Alibaba Cloud Model Studio:Fun-ASR-Realtime Python SDK

import os
import signal  # for keyboard events handling (press "Ctrl+C" to terminate recording)
import sys

import dashscope
import pyaudio
from concurrent.futures import ThreadPoolExecutor

mic = None
stream = None

# Defina os parâmetros de gravação
sample_rate = 16000  # taxa de amostragem (Hz)
channels = 1  # canal mono
dtype = 'int16'  # tipo de dados
format_pcm = 'pcm'  # o formato dos dados de áudio
block_size = 3200  # número de quadros por buffer

# Receptor de eventos do reconhecimento de fala em tempo real
def receive_events(rec):
    for event in rec.events():
        payload = event.get('payload') or {}
        sentence = (payload.get('output') or {}).get('sentence') or {}
        if sentence.get('text') and not sentence.get('heartbeat'):
            print('Texto reconhecido: ', sentence['text'])
            if sentence.get('sentence_end'):
                print(
                    'Fim da frase, request_id:%s, usage:%s'
                    % (rec.request_id, rec.usage))

def signal_handler(sig, frame):
    print('Ctrl+C pressionado, interrompendo o reconhecimento ...')
    # Interrompa o reconhecimento
    recognition.stop()
    print('Reconhecimento interrompido.')
    print(
        '[Métrica] requestId: {}, atraso do primeiro pacote ms: {}, atraso do último pacote ms: {}'
        .format(
            recognition.request_id,
            recognition.first_package_delay,
            recognition.last_package_delay,
        ))
    # Force a saída do programa
    sys.exit(0)

# função principal
if __name__ == '__main__':
    # A API Key difere entre as regiões Singapura e Beijing. Obtenha uma API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
    # Se a variável de ambiente não estiver configurada, substitua a linha abaixo pela sua API Key do Model Studio: api_key="sk-xxx"
    client = dashscope.Client(
        api_key=os.environ.get('DASHSCOPE_API_KEY'),
        # A configuração abaixo refere-se à região Singapura. Substitua {WorkspaceId} pelo ID real do seu workspace. O valor de region varia conforme a região.
        workspace="{WorkspaceId}",
        region="ap-southeast-1",
    )

    # Chame o service de reconhecimento; você pode personalizar os parâmetros de reconhecimento, como model, format,
    # sample_rate
    with client.audio.asr.recognize(
            model='fun-asr-realtime',
            format=format_pcm,
            # 'pcm'、'wav'、'opus'、'speex'、'aac'、'amr'; consulte os formatos suportados na documentação
            sample_rate=sample_rate,
            # suporta 8000, 16000
    ) as recognition:
        # Abra o microfone
        mic = pyaudio.PyAudio()
        stream = mic.open(format=pyaudio.paInt16,
                          channels=1,
                          rate=16000,
                          input=True)
        with ThreadPoolExecutor(max_workers=1) as pool:
            receiver = pool.submit(receive_events, recognition)
            try:
                # Envie o áudio do microfone até que "Ctrl+C" seja pressionado
                while stream:
                    data = stream.read(3200, exception_on_overflow=False)
                    recognition.send_audio_frame(data)
                recognition.stop()
                receiver.result()
            finally:
                # close deve ser executado dentro do contexto do pool para desbloquear o receptor
                recognition.close()
        stream.stop_stream()
        stream.close()
        mic.terminate()
        stream = None
        mic = None

import os
import time
import dashscope
from concurrent.futures import ThreadPoolExecutor

# A API Key difere entre as regiões Singapura e Beijing. Obtenha uma API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
# Se a variável de ambiente não estiver configurada, substitua a linha abaixo pela sua API Key do Model Studio: api_key="sk-xxx"
client = dashscope.Client(
    api_key=os.environ.get('DASHSCOPE_API_KEY'),
    # A configuração abaixo refere-se à região Singapura. Substitua {WorkspaceId} pelo ID real do seu workspace. O valor de region varia conforme a região.
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

from datetime import datetime

def get_timestamp():
    now = datetime.now()
    formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
    return formatted_timestamp

# Receptor de eventos do reconhecimento de fala em tempo real
def receive_events(rec):
    for event in rec.events():
        payload = event.get('payload') or {}
        sentence = (payload.get('output') or {}).get('sentence') or {}
        if sentence.get('text') and not sentence.get('heartbeat'):
            print(get_timestamp() + ' Texto reconhecido: ', sentence['text'])
        if sentence.get('sentence_end'):
            print(get_timestamp() +
                  'Fim da frase, request_id:%s, usage:%s'
                  % (rec.request_id, rec.usage))

with client.audio.asr.recognize(
        model='fun-asr-realtime',
        format='wav',
        sample_rate=16000,
) as recognition:
    with ThreadPoolExecutor(max_workers=1) as pool:
        receiver = pool.submit(receive_events, recognition)
        try:
            audio_data: bytes = None
            f = open("{YOUR_AUDIO_FILE}", 'rb')
            if os.path.getsize("{YOUR_AUDIO_FILE}"):
                # Leia todos os dados do arquivo para o buffer de uma só vez
                file_buffer = f.read()
                f.close()
                print("Iniciar reconhecimento")

                # Envie 3200 bytes do buffer por vez
                buffer_size = len(file_buffer)
                offset = 0
                chunk_size = 3200

                while offset < buffer_size:
                    # Calcule o tamanho do bloco de dados a enviar desta vez
                    remaining_bytes = buffer_size - offset
                    current_chunk_size = min(chunk_size, remaining_bytes)

                    # Extraia o bloco de dados atual do buffer
                    audio_data = file_buffer[offset:offset + current_chunk_size]

                    # Envie o quadro de dados de áudio
                    recognition.send_audio_frame(audio_data)
                    # Atualize o offset
                    offset += current_chunk_size

                    # Adicione um atraso para simular a transmissão em tempo real
                    time.sleep(0.1)

                recognition.stop()
                receiver.result()
            else:
                raise Exception(
                    'The supplied file was empty (zero bytes long)')
        finally:
            # close deve ser executado dentro do contexto do pool para desbloquear o receptor
            recognition.close()

print(
    '[Métrica] requestId: {}, atraso do primeiro pacote ms: {}, atraso do último pacote ms: {}'
    .format(
        recognition.request_id,
        recognition.first_package_delay,
        recognition.last_package_delay,
    ))