Este tópico descreve as principais interfaces e os parâmetros de solicitação para chamar os modelos da série Qwen-TTS-Realtime com o DashScope Python SDK.
Pré-requisitos
Requer o DashScope Python SDK 2.0.1 ou posterior.
Início rápido
import os
import base64
import time
from concurrent.futures import ThreadPoolExecutor
import dashscope
text_to_synthesize = [
'Right? I love supermarkets like this.',
'Especially during Chinese New Year,',
'I go shopping at supermarkets.',
'And I feel',
'absolutely thrilled!',
'I want to buy so many things!'
]
# As API Keys das regiões Singapura e China (Pequim) não são intercambiáveis. Obtenha sua 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 por: api_key = "sk-xxx"
client = dashscope.Client(
api_key=os.getenv("DASHSCOPE_API_KEY"),
# A configuração abaixo refere-se à região Pequim (China). Substitua {WorkspaceId} pelo ID real do seu workspace. O valor de region varia conforme a região.
workspace="{WorkspaceId}",
region="cn-beijing",
)
# Thread de recebimento: itera sobre os eventos do servidor e grava o áudio no arquivo de forma incremental
def receive_events(session):
with open('result_24k.pcm', 'wb') as f:
for event in session.events():
event_type = event.get('type')
if event_type == 'session.created':
print('start session: {}'.format(event['session']['id']))
elif event_type == 'response.audio.delta':
f.write(base64.b64decode(event['delta']))
elif event_type == 'response.done':
print(f'response {session.last_response_id} done')
elif event_type == 'session.finished':
print('session finished')
if __name__ == '__main__':
print('Initializing ...')
# Cria uma sessão de síntese de fala em tempo real: entrar no contexto with estabelece a conexão automaticamente
with client.audio.realtime.connect(
model='qwen3-tts-flash-realtime',
) as session:
session.update_session(
output_modalities=['audio'],
voice='Cherry',
response_format='pcm',
sample_rate=24000,
mode='server_commit'
)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_events, session)
for text_chunk in text_to_synthesize:
print(f'send text: {text_chunk}')
session.send_event({'type': 'input_text_buffer.append', 'text': text_chunk})
time.sleep(0.1)
# Notifica o servidor de que a entrada foi concluída (no modo server_commit o servidor decide quando sintetizar)
session.end_session()
receiver.result()
print('[Metric] session: {}, first audio delay: {}'.format(
session.session_id,
session.last_first_audio_delay,
))
import os
import base64
import time
from concurrent.futures import ThreadPoolExecutor
import dashscope
text_to_synthesize = [
'This is the first sentence.',
'This is the second sentence.',
'This is the third sentence.',
]
# As API Keys das regiões Singapura e China (Pequim) não são intercambiáveis. Obtenha sua 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 por: api_key = "sk-xxx"
client = dashscope.Client(
api_key=os.getenv("DASHSCOPE_API_KEY"),
# A configuração abaixo refere-se à região Pequim (China). Substitua {WorkspaceId} pelo ID real do seu workspace. O valor de region varia conforme a região.
workspace="{WorkspaceId}",
region="cn-beijing",
)
# Thread de recebimento: itera sobre os eventos do servidor e grava o áudio no arquivo de forma incremental
def receive_events(session):
with open('result_24k.pcm', 'wb') as f:
for event in session.events():
event_type = event.get('type')
if event_type == 'session.created':
print('start session: {}'.format(event['session']['id']))
elif event_type == 'response.audio.delta':
f.write(base64.b64decode(event['delta']))
elif event_type == 'response.done':
print(f'response {session.last_response_id} done')
elif event_type == 'session.finished':
print('session finished')
if __name__ == '__main__':
print('Initializing ...')
# Cria uma sessão de síntese de fala em tempo real: entrar no contexto with estabelece a conexão automaticamente
with client.audio.realtime.connect(
model='qwen3-tts-flash-realtime',
) as session:
session.update_session(
output_modalities=['audio'],
voice='Cherry',
response_format='pcm',
sample_rate=24000,
mode='commit'
)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_events, session)
for text in text_to_synthesize:
print(f'send text: {text}')
session.send_event({'type': 'input_text_buffer.append', 'text': text})
# No modo commit o cliente aciona a síntese
session.send_event({'type': 'input_text_buffer.commit'})
time.sleep(0.1)
session.end_session()
receiver.result()
print('[Metric] session: {}, first audio delay: {}'.format(
session.session_id,
session.last_first_audio_delay,
))
import os
import base64
import time
from concurrent.futures import ThreadPoolExecutor
import dashscope
text_to_synthesize = [
'Right? I love supermarkets like this.',
'Especially during Chinese New Year,',
'I go shopping at supermarkets.',
'And I feel',
'absolutely thrilled!',
'I want to buy so many things!'
]
# As API Keys das regiões Singapura e China (Pequim) não são intercambiáveis. Obtenha sua 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 por: api_key = "sk-xxx"
client = dashscope.Client(
api_key=os.getenv("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",
)
# Thread de recebimento: itera sobre os eventos do servidor e grava o áudio no arquivo de forma incremental
def receive_events(session):
with open('result_24k.pcm', 'wb') as f:
for event in session.events():
event_type = event.get('type')
if event_type == 'session.created':
print('start session: {}'.format(event['session']['id']))
elif event_type == 'response.audio.delta':
f.write(base64.b64decode(event['delta']))
elif event_type == 'response.done':
print(f'response {session.last_response_id} done')
elif event_type == 'session.finished':
print('session finished')
if __name__ == '__main__':
print('Initializing ...')
# Cria uma sessão de síntese de fala em tempo real: entrar no contexto with estabelece a conexão automaticamente
with client.audio.realtime.connect(
model='qwen3-tts-flash-realtime',
) as session:
session.update_session(
output_modalities=['audio'],
voice='Cherry',
response_format='pcm',
sample_rate=24000,
mode='server_commit'
)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_events, session)
for text_chunk in text_to_synthesize:
print(f'send text: {text_chunk}')
session.send_event({'type': 'input_text_buffer.append', 'text': text_chunk})
time.sleep(0.1)
# Notifica o servidor de que a entrada foi concluída (no modo server_commit o servidor decide quando sintetizar)
session.end_session()
receiver.result()
print('[Metric] session: {}, first audio delay: {}'.format(
session.session_id,
session.last_first_audio_delay,
))
import os
import base64
import time
from concurrent.futures import ThreadPoolExecutor
import dashscope
text_to_synthesize = [
'This is the first sentence.',
'This is the second sentence.',
'This is the third sentence.',
]
# As API Keys das regiões Singapura e China (Pequim) não são intercambiáveis. Obtenha sua 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 por: api_key = "sk-xxx"
client = dashscope.Client(
api_key=os.getenv("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",
)
# Thread de recebimento: itera sobre os eventos do servidor e grava o áudio no arquivo de forma incremental
def receive_events(session):
with open('result_24k.pcm', 'wb') as f:
for event in session.events():
event_type = event.get('type')
if event_type == 'session.created':
print('start session: {}'.format(event['session']['id']))
elif event_type == 'response.audio.delta':
f.write(base64.b64decode(event['delta']))
elif event_type == 'response.done':
print(f'response {session.last_response_id} done')
elif event_type == 'session.finished':
print('session finished')
if __name__ == '__main__':
print('Initializing ...')
# Cria uma sessão de síntese de fala em tempo real: entrar no contexto with estabelece a conexão automaticamente
with client.audio.realtime.connect(
model='qwen3-tts-flash-realtime',
) as session:
session.update_session(
output_modalities=['audio'],
voice='Cherry',
response_format='pcm',
sample_rate=24000,
mode='commit'
)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_events, session)
for text in text_to_synthesize:
print(f'send text: {text}')
session.send_event({'type': 'input_text_buffer.append', 'text': text})
# No modo commit o cliente aciona a síntese
session.send_event({'type': 'input_text_buffer.commit'})
time.sleep(0.1)
session.end_session()
receiver.result()
print('[Metric] session: {}, first audio delay: {}'.format(
session.session_id,
session.last_first_audio_delay,
))
Acesse o GitHub para baixar mais códigos de exemplo.
Parâmetros da solicitação
Os parâmetros de solicitação a seguir podem ser definidos no método connect de client.audio.realtime:
Parâmetro | Tipo | Obrigatório | Descrição |
|---|---|---|---|
model | str | Sim | Nome do modelo (consulte Modelos compatíveis). |
ws_url | str | Não | Endpoint da sessão. Quando omitido, é derivado automaticamente dos parâmetros de construção |
Os parâmetros de solicitação a seguir podem ser configurados por meio do método update_session da sessão (os parâmetros nomeados são passados diretamente e os demais são repassados ao objeto session do evento session.update):
Parâmetro | Tipo | Obrigatório | Descrição |
|---|---|---|---|
voice | str | Sim | Voz usada na síntese de fala. Para mais informações, consulte Lista de vozes do Qwen-TTS. |
language_type | str | Não | Define o idioma do áudio sintetizado. O valor padrão é
|
mode | str | Não | Modo de interação. Valores válidos:
|
response_format | str | Não | Formato da saída de áudio do modelo. Formatos compatíveis:
|
sample_rate | int | Não | Taxa de amostragem da saída de áudio do modelo, em Hz. Taxas de amostragem compatíveis:
|
speech_rate | float | Não | Velocidade da fala do áudio. O valor 1,0 representa a velocidade normal. Valores menores que 1,0 tornam a fala mais lenta; valores maiores que 1,0 a tornam mais rápida. Valor padrão: 1,0. Intervalo válido: [0,5, 2,0]. |
volume | int | Não | Volume do áudio. Intervalo válido: [0, 100]. |
pitch_rate | float | Não | Tom do áudio sintetizado. Valor padrão: 1,0. Intervalo válido: [0,5, 2,0]. |
bit_rate | int | Não | Define a taxa de bits do áudio em kbps. Uma taxa de bits maior resulta em melhor qualidade de áudio e tamanho de arquivo maior. Este parâmetro está disponível apenas quando o formato de áudio ( Valor padrão: 128. Intervalo válido: [6, 510]. |
Referência da API
Sessão (RealtimeSession)
A sessão de síntese de fala em tempo real é criada por meio de client.audio.realtime.connect(model=...); a conexão é estabelecida automaticamente ao entrar no contexto with (também é possível chamar o método connect() da sessão para estabelecê-la manualmente).
Assinatura do método | Eventos de resposta do servidor (entregues por iteração via | Descrição |
|---|---|---|
|
| Cria a conexão com o servidor. Chamado automaticamente ao entrar no contexto |
|
| Atualiza as configurações padrão desta sessão. Para detalhes dos parâmetros, consulte Parâmetros de solicitação. Ao estabelecer a conexão, o servidor retorna prontamente as configurações padrão de entrada e saída desta sessão. Se você precisar atualizar as configurações padrão, recomendamos chamar este método imediatamente após estabelecer a conexão. Ao receber um evento session.update, o servidor valida os parâmetros; se forem inválidos, retorna um erro; caso contrário, atualiza a configuração da sessão no lado do servidor. |
| Nenhum | Envia um evento bruto. A entrada de texto é feita por meio da série de eventos
|
|
| Envia o evento |
|
| Envia o evento
|
|
| Envia o evento session.finish para encerrar a tarefa. Em seguida, continue consumindo |
| None | Fecha a conexão. Chamado automaticamente ao sair do contexto |
| Nenhum | Obtém o session_id da tarefa atual. |
| Nenhum | Obtém o response_id da resposta mais recente. |
| Nenhum | Obtém o atraso do primeiro pacote de áudio. |
Iteração de eventos (events())
O servidor retorna os eventos e dados de resposta ao cliente por meio de eventos. Na thread de recebimento, itere sobre events() da sessão para processar os eventos do servidor; a iteração termina após o evento session.finished; eventos de error são lançados como exceções DashScopeError e podem ser capturados com try/except.
Método | Parâmetros | Valor de retorno | Descrição |
|---|---|---|---|
| event: evento de resposta do servidor ( | Iterador | Inclui as respostas às chamadas de interface e o texto e o áudio gerados pelo modelo; a iteração termina após o evento |
| event: evento de resposta do servidor ( | Evento ou | Lê um evento do servidor; retorna |