Prérequis
Qwen-Audio-TTS
Endpoint du service
L'endpoint du service du SDK est déterminé par les paramètres workspace/region du constructeur de Client (ils correspondent aux adresses ci-dessous, qui incluent le WorkspaceId). Pour basculer vers une autre région, modifiez les paramètres du constructeur de Client avec les valeurs de la région de destination.
Singapore
wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference
Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.
China (Beijing)
wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference
Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.
ImportantAlibaba Cloud Model Studio a publié des domaines spécifiques aux espaces de travail pour les régions Chine (Pékin) et Singapour. Ces nouveaux domaines dédiés offrent des performances supérieures et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer vers ces nouveaux domaines :
- Chine (Pékin) : passez de
dashscope.aliyuncs.comà{WorkspaceId}.cn-beijing.maas.aliyuncs.com - Singapour : passez de
dashscope-intl.aliyuncs.comà{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com
CosyVoice
Endpoint du service
L'endpoint du SDK est déterminé par les paramètres workspace et region du constructeur de Client (ils correspondent aux adresses ci-dessous, qui incluent le WorkspaceId). Pour basculer vers une autre région, modifiez les paramètres du constructeur de Client avec les valeurs de la région concernée.
Singapore
wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference
Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.
China (Beijing)
wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference
Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.
CLI dashscope
Appel via la ligne de commande dashscope.
export DASHSCOPE_API_KEY="your-api-key"
# Replace {WorkspaceId} with your Beijing workspace ID.
export DASHSCOPE_HTTP_BASE_URL="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"
dashscope speech-synthesis create -m cosyvoice-v3-plus -t "Hello world" --voice longanyang
ImportantL'assistant interactif SDK Expert permet d'effectuer les mêmes tâches de développement et de dépannage en langage naturel ; consultez
DashScope SDK Expert.Pour le tableau complet des régions, consultez Présentation des URL de base.
ImportantAlibaba Cloud Model Studio a publié des domaines spécifiques aux espaces de travail pour les régions Chine (Pékin) et Singapour. Ces nouveaux domaines dédiés offrent des performances supérieures et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer vers ces nouveaux domaines :
- Chine (Pékin) : passez de
dashscope.aliyuncs.comà{WorkspaceId}.cn-beijing.maas.aliyuncs.com - Singapour : passez de
dashscope-intl.aliyuncs.comà{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com
Démarrage rapide
Qwen-Audio-TTS / CosyVoice
Le SDK prend en charge les modes de synthèse suivants :
- Sans streaming : appel bloquant qui envoie l'intégralité du texte en une fois et renvoie directement l'audio complet. Idéal pour la synthèse vocale de textes courts.
- Streaming unidirectionnel : appel non bloquant qui envoie l'intégralité du texte en une fois et reçoit les données en itérant sur les chunks audio délivrés par
stream. Idéal pour la synthèse vocale de textes courts exigeant une forte réactivité temps réel. - Streaming bidirectionnel : appel non bloquant qui envoie le texte en plusieurs segments et reçoit en temps réel le flux audio synthétisé de manière incrémentale en itérant sur les méthodes
audio_chunks()/events()de la session. Idéal pour la synthèse vocale de textes longs exigeant une forte réactivité temps réel.
Sans streaming
Le texte envoyé en un seul appel ne doit pas dépasser 20 000 caractères. Dépasser cette limite déclenche une erreur.
ImportantChaque appel à synthesize ou stream crée sa propre session ; il n'est pas nécessaire de réutiliser les instances.
# coding=utf-8
import os
import dashscope
# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
# Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
client = dashscope.Client(
api_key=os.environ.get('DASHSCOPE_API_KEY'),
workspace="{WorkspaceId}",
region="ap-southeast-1",
)
# Modèle
model = "qwen-audio-3.0-tts-flash"
# Voix
voice = "longanhuan_v3.6"
# Envoyez le texte à synthétiser et récupérez l'audio binaire
audio = client.audio.tts.synthesize("How is the weather today?", model=model, voice=voice)
# Enregistrez l'audio dans un fichier local
with open('output.mp3', 'wb') as f:
f.write(audio)
CLI dashscope
Appel via la ligne de commande dashscope.
export DASHSCOPE_API_KEY="your-api-key"
# Replace {WorkspaceId} with your workspace ID, ap-southeast-1 with your region (e.g., us-east-1, eu-central-1)
export DASHSCOPE_HTTP_BASE_URL="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1"
dashscope speech-synthesis create -m qwen-audio-3.0-tts-flash -t "Hello world" --voice longanhuan_v3.6
ImportantL'assistant interactif SDK Expert permet d'effectuer les mêmes tâches de développement et de dépannage en langage naturel ; consultez
DashScope SDK Expert.Pour le tableau complet des régions, consultez Présentation des URL de base.
Streaming unidirectionnel
Le texte envoyé en un seul appel ne doit pas dépasser 20 000 caractères. Dépasser cette limite déclenche une erreur.
ImportantChaque appel à synthesize ou stream crée sa propre session ; il n'est pas nécessaire de réutiliser les instances.
# coding=utf-8
import os
from datetime import datetime
import dashscope
def get_timestamp():
now = datetime.now()
formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
return formatted_timestamp
# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
# Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
client = dashscope.Client(
api_key=os.environ.get('DASHSCOPE_API_KEY'),
workspace="{WorkspaceId}",
region="ap-southeast-1",
)
# Modèle
model = "qwen-audio-3.0-tts-flash"
# Voix
voice = "longanhuan_v3.6"
# Envoyez l'intégralité du texte en une fois et recevez l'audio binaire chunk par chunk
with open("output.mp3", "wb") as f:
for chunk in client.audio.tts.stream("How is the weather today?", model=model, voice=voice):
print(get_timestamp() + " Binary audio length: " + str(len(chunk)))
f.write(chunk)
print("Speech synthesis completed, all results received: " + get_timestamp())
Streaming bidirectionnel
Le texte envoyé par appel ne doit pas dépasser 20 000 caractères. Le texte cumulé ne doit pas dépasser 200 000 caractères.
-
Pendant la saisie en flux, appelez le
send_textde la session plusieurs fois pour envoyer des segments de texte successifs. Le serveur segmente automatiquement en phrases le texte reçu :- Les phrases complètes sont synthétisées immédiatement
- Les phrases incomplètes sont mises en mémoire tampon jusqu'à complétion
Lorsque
stopest appelé, le serveur force la synthèse de tout le texte reçu mais non traité (y compris les phrases incomplètes). -
L'intervalle entre segments de texte ne doit pas dépasser 23 secondes. Sinon, une exception « request timeout after 23 seconds » est levée.
S'il n'y a plus de texte à envoyer, appelez rapidement
stoppour terminer la tâche.ImportantAppelez toujours
stop. Ne pas le faire peut empêcher le dernier texte d'être converti en parole.Le serveur applique un délai d'attente de 23 secondes. Cette valeur ne peut pas être modifiée côté client.
# coding=utf-8
#
# pyaudio installation instructions:
# For macOS, run the following commands:
# brew install portaudio
# pip install pyaudio
# For Debian/Ubuntu, run the following commands:
# sudo apt-get install python-pyaudio python3-pyaudio
# or
# pip install pyaudio
# For CentOS, run the following commands:
# sudo yum install -y portaudio portaudio-devel && pip install pyaudio
# For Microsoft Windows, run the following command:
# python -m pip install pyaudio
import os
import time
import pyaudio
from concurrent.futures import ThreadPoolExecutor
import dashscope
from datetime import datetime
def get_timestamp():
now = datetime.now()
formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
return formatted_timestamp
# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
# Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
client = dashscope.Client(
api_key=os.environ.get('DASHSCOPE_API_KEY'),
workspace="{WorkspaceId}",
region="ap-southeast-1",
)
# Modèle
model = "qwen-audio-3.0-tts-flash"
# Voix
voice = "longanhuan_v3.6"
test_text = [
"Streaming text-to-speech SDK,",
"converts input text",
"into binary audio data.",
"Compared with non-streaming speech synthesis,",
"streaming synthesis offers better real-time performance.",
"Users hear near-synchronous audio output while typing,",
"greatly improving interaction experience",
"and reducing wait time.",
"Ideal for large language model (LLM) integration,",
"where text is streamed for speech synthesis.",
]
# Créez une session de diffusion bidirectionnelle : la connexion est établie automatiquement à l'entrée dans le contexte with
with client.audio.tts.connect(
model=model,
voice=voice,
format="pcm",
sample_rate=22050,
) as session:
# Initialisez le lecteur
player = pyaudio.PyAudio()
stream = player.open(format=pyaudio.paInt16, channels=1, rate=22050, output=True)
# Thread de réception : itérez sur les données audio et lisez-les en temps réel
def receive_audio():
for chunk in session.audio_chunks():
print(get_timestamp() + " Binary audio length: " + str(len(chunk)))
stream.write(chunk)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_audio)
# Envoyez le texte à synthétiser en mode streaming
for text in test_text:
session.send_text(text)
time.sleep(0.1)
# Terminez la synthèse en flux
session.stop()
receiver.result()
print("Speech synthesis completed, all results received: " + get_timestamp())
# Arrêtez le lecteur
stream.stop_stream()
stream.close()
player.terminate()
# La première connexion WebSocket est établie lors de l'envoi du premier texte, la latence du premier paquet inclut donc le temps d'établissement de la connexion
print('[Metric] first packet latency: {} ms'.format(session.first_package_delay))
CosyVoice
Le SDK fournit les interfaces clés de la synthèse vocale et prend en charge les modes d'appel suivants :
- Sans streaming : appel bloquant qui envoie l'intégralité du texte en une fois et renvoie directement l'audio complet. Idéal pour la synthèse vocale de textes courts.
- Streaming unidirectionnel : appel non bloquant qui envoie l'intégralité du texte en une fois et reçoit les données en itérant sur les chunks audio délivrés par
stream. Idéal pour la synthèse vocale de textes courts exigeant une forte réactivité temps réel. - Streaming bidirectionnel : appel non bloquant qui envoie le texte en plusieurs segments et reçoit en temps réel le flux audio synthétisé de manière incrémentale en itérant sur les méthodes
audio_chunks()/events()de la session. Idéal pour la synthèse vocale de textes longs exigeant une forte réactivité temps réel.
Sans streaming
Le texte envoyé en un seul appel ne doit pas dépasser 20 000 caractères. Dépasser cette limite déclenche une exception DashScopeError.
Importantsynthesize et stream créent une nouvelle session à chaque appel ; il n'est pas nécessaire de réutiliser les instances.
Dans les exemples de code communs, choisissez le même mode d’appel. Définissez model sur cosyvoice-v3-plus et voice sur longanyang.
Streaming unidirectionnel
Le texte envoyé en un seul appel ne doit pas dépasser 20 000 caractères. Dépasser cette limite déclenche une exception DashScopeError.
Importantsynthesize et stream créent une nouvelle session à chaque appel ; il n'est pas nécessaire de réutiliser les instances.
Dans les exemples de code communs, choisissez le même mode d’appel. Définissez model sur cosyvoice-v3-plus et voice sur longanyang.
Streaming bidirectionnel
Le texte envoyé par appel ne doit pas dépasser 20 000 caractères. Le texte cumulé ne doit pas dépasser 200 000 caractères.
-
Pendant la saisie en flux, appelez le
send_textde la session plusieurs fois pour envoyer des segments de texte successifs. Le serveur segmente automatiquement en phrases le texte reçu :- Les phrases complètes sont synthétisées immédiatement
- Les phrases incomplètes sont mises en mémoire tampon jusqu'à complétion
Lorsque
stopest appelé, le serveur force la synthèse de tout le texte reçu mais non traité (y compris les phrases incomplètes). -
L'intervalle entre segments de texte ne doit pas dépasser 23 secondes. Sinon, une exception « request timeout after 23 seconds » est levée.
S'il n'y a plus de texte à envoyer, appelez rapidement
stoppour terminer la tâche.ImportantAppelez toujours
stop. Ne pas le faire peut empêcher le dernier texte d'être converti en parole.Le serveur applique un délai d'attente de 23 secondes. Cette valeur ne peut pas être modifiée côté client.
# coding=utf-8
#
# pyaudio installation instructions:
# For macOS, run the following commands:
# brew install portaudio
# pip install pyaudio
# For Debian/Ubuntu, run the following commands:
# sudo apt-get install python-pyaudio python3-pyaudio
# or
# pip install pyaudio
# For CentOS, run the following commands:
# sudo yum install -y portaudio portaudio-devel && pip install pyaudio
# For Microsoft Windows, run the following command:
# python -m pip install pyaudio
import os
import time
import pyaudio
from concurrent.futures import ThreadPoolExecutor
import dashscope
from datetime import datetime
def get_timestamp():
now = datetime.now()
formatted_timestamp = now.strftime("[%Y-%m-%d %H:%M:%S.%f]")
return formatted_timestamp
# Les API Key des régions Singapour et Pékin sont différentes. Obtenez votre API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, remplacez la ligne suivante par votre API Key de Model Studio : api_key="sk-xxx"
# Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
client = dashscope.Client(
api_key=os.environ.get('DASHSCOPE_API_KEY'),
workspace="{WorkspaceId}",
region="ap-southeast-1",
)
# Modèle
model = "cosyvoice-v3-plus"
# Voix
voice = "longanyang"
test_text = [
"Streaming text-to-speech SDK,",
"converts input text",
"into binary audio data.",
"Compared with non-streaming speech synthesis,",
"streaming synthesis offers better real-time performance.",
"Users hear near-synchronous audio output while typing,",
"greatly improving interaction experience",
"and reducing wait time.",
"Ideal for large language model (LLM) integration,",
"where text is streamed for speech synthesis.",
]
# Créez une session de diffusion bidirectionnelle : la connexion est établie automatiquement à l'entrée dans le contexte with
with client.audio.tts.connect(
model=model,
voice=voice,
format="pcm",
sample_rate=22050,
) as session:
# Initialisez le lecteur
player = pyaudio.PyAudio()
stream = player.open(format=pyaudio.paInt16, channels=1, rate=22050, output=True)
# Thread de réception : itérez sur les données audio et lisez-les en temps réel
def receive_audio():
for chunk in session.audio_chunks():
print(get_timestamp() + " Binary audio length: " + str(len(chunk)))
stream.write(chunk)
with ThreadPoolExecutor(max_workers=1) as pool:
receiver = pool.submit(receive_audio)
# Envoyez le texte à synthétiser en mode streaming
for text in test_text:
session.send_text(text)
time.sleep(0.1)
# Terminez la synthèse en flux
session.stop()
receiver.result()
print("Speech synthesis completed, all results received: " + get_timestamp())
# Arrêtez le lecteur
stream.stop_stream()
stream.close()
player.terminate()
# La première connexion WebSocket est établie lors de l'envoi du premier texte, la latence du premier paquet inclut donc le temps d'établissement de la connexion
print('[Metric] first package delay: {} ms'.format(session.first_package_delay))
Paramètres de requête
Qwen-Audio-TTS
Les paramètres suivants se configurent via les méthodes synthesize/stream/connect de client.audio.tts pour contrôler le modèle, la voix, le format et les caractéristiques audio (model, voice, format, sample_rate, volume, rate, pitch, language_hints et enable_ssml sont des paramètres nommés ; les autres paramètres se transmettent via le dictionnaire parameters).
| Paramètre | Type | Requis | Description |
|---|---|---|---|
model | str | Oui | Le nom du modèle. |
voice | str | Oui | La voix utilisée pour la synthèse vocale.
|
format | str | Non | Format d'encodage audio. Valeur par défaut : mp3. Prend en charge mp3, wav, pcm et d'autres formats. Le taux d'échantillonnage se définit via le paramètre |
volume | int | Non | Le niveau de volume. Valeur par défaut : 50. Valeurs valides : [0, 100]. |
rate | float | Non | La vitesse de la parole. Valeur par défaut : 1.0. Valeurs valides : [0.5, 2.0]. |
pitch | float | Non | Le ton. Valeur par défaut : 1.0. Valeurs valides : [0.5, 2.0]. |
bit_rate | int | Non | Le débit binaire audio en kbps. Lorsque le format audio est mp3 ou opus, utilisez bit_rate pour ajuster le débit.Valeur par défaut : 32. Valeurs valides : [6, 510]. Configurez |
word_timestamp_enabled | bool | Non | Indique s'il faut activer les horodatages au niveau du mot. Valeur par défaut : false. Disponible uniquement en mode de sortie en flux. Les voix clonées sont prises en charge. Pour les voix système compatibles, consultez la liste des voix de Qwen-Audio-TTS. Configurez |
seed | int | Non | Une graine aléatoire pour contrôler la variation de la sortie de synthèse. Lorsque la version du modèle, le texte, la voix et les autres paramètres ne changent pas, l'utilisation de la même graine produit des résultats identiques. Valeur par défaut : 0. Valeurs valides : [0, 65535]. |
language_hints | list[str] | Non | RemarquePour les voix multilingues et dialectales de qwen-audio-3.1-tts-flash, ce paramètre permet de spécifier la langue ou le dialecte. Consultez les paramètres des voix multilingues et dialectales pour en savoir plus. Spécifie la langue cible de la synthèse vocale afin d'améliorer la qualité de sortie. Lorsque la prononciation des chiffres, le développement des abréviations, la lecture des symboles ou la synthèse en langues minoritaires ne répondent pas aux attentes, utilisez ce paramètre. Par exemple :
Valeurs valides
Remarque
|
instruction | str | Non | Contrôle les caractéristiques de la synthèse, telles que le dialecte, l'émotion ou le style de parole. Pour les détails d'utilisation, consultez Contrôle par instructions. |
enable_aigc_tag | bool | Non | Indique s'il faut intégrer un filigrane AIGC dans l'audio généré. Lorsque la valeur est true, le filigrane est intégré dans les fichiers audio aux formats compatibles (wav/mp3/opus). Valeur par défaut : false. Configurez |
aigc_propagator | str | Non | Définit le champ ContentPropagator du filigrane AIGC, identifiant le propagateur du contenu. Ne prend effet que si enable_aigc_tag vaut true.Valeur par défaut : l'UID Alibaba Cloud. Se configure via le dictionnaire |
aigc_propagate_id | str | Non | Définit le champ PropagateID du filigrane AIGC, identifiant de manière unique une action de propagation donnée. Ne prend effet que si enable_aigc_tag vaut true.Valeur par défaut : l'ID de requête de la requête de synthèse vocale en cours. Se configure via le dictionnaire |
hot_fix | dict | Non | Configure des corrections de prononciation et des remplacements de texte appliqués avant la synthèse. Paramètres :
Exemple : |
|
| Non | Indique s’il faut activer le filtrage Markdown. Lorsque l’option est activée, le service convertit le Markdown en texte adapté à la lecture à voix haute avant la synthèse. Valeur par défaut : Utilisez |
CosyVoice
Les paramètres suivants se configurent via les méthodes synthesize/stream/connect de client.audio.tts pour contrôler le modèle, la voix, le format et les caractéristiques audio (model, voice, format, sample_rate, volume, rate, pitch, language_hints et enable_ssml sont des paramètres nommés ; les autres paramètres se transmettent via le dictionnaire parameters).
| Paramètre | Type | Requis | Description |
|---|---|---|---|
model | str | Oui | Le nom du modèle. |
voice | str | Oui | La voix utilisée pour la synthèse vocale.
|
format | str | Non | Format d'encodage audio. Valeur par défaut : mp3. Prend en charge mp3, wav, pcm et d'autres formats. Le taux d'échantillonnage se définit via le paramètre |
volume | int | Non | Le niveau de volume. Valeur par défaut : 50. Valeurs valides : [0, 100]. |
rate | float | Non | La vitesse de la parole. Valeur par défaut : 1.0. Valeurs valides : [0.5, 2.0]. |
pitch | float | Non | Le ton. Valeur par défaut : 1.0. Valeurs valides : [0.5, 2.0]. |
bit_rate | int | Non | Le débit binaire audio en kbps. Lorsque le format audio est mp3 ou opus, utilisez bit_rate pour ajuster le débit.Valeur par défaut : 32. Valeurs valides : [6, 510]. Configurez |
word_timestamp_enabled | bool | Non | Indique s'il faut activer les horodatages au niveau du mot. Valeur par défaut : false. Disponible uniquement en mode de sortie en flux. Voix compatibles : voix clonées de cosyvoice-v3.5-plus, cosyvoice-v3.5-flash, cosyvoice-v3-flash, cosyvoice-v3-plus, cosyvoice-v2 et voix système marquées comme compatibles dans la liste des voix CosyVoice. Les voix clonées d'autres modèles ne prennent pas en charge cette fonction. Configurez |
seed | int | Non | Une graine aléatoire pour contrôler la variation de la sortie de synthèse. Lorsque la version du modèle, le texte, la voix et les autres paramètres ne changent pas, l'utilisation de la même graine produit des résultats identiques. Valeur par défaut : 0. Valeurs valides : [0, 65535]. |
language_hints | list[str] | Non | Important
Spécifie la langue cible de la synthèse vocale afin d'améliorer la qualité de sortie. Lorsque la prononciation des chiffres, le développement des abréviations, la lecture des symboles ou la synthèse en langues minoritaires ne répondent pas aux attentes, utilisez ce paramètre. Par exemple :
Valeurs valides
|
instruction | str | Non | Contrôle les caractéristiques de la synthèse, telles que le dialecte, l'émotion ou le style de parole. Pour les détails d'utilisation, consultez Contrôle par instructions. |
enable_aigc_tag | bool | Non | Indique s'il faut intégrer un filigrane AIGC dans l'audio généré. Lorsque la valeur est true, le filigrane est intégré dans les fichiers audio aux formats compatibles (wav/mp3/opus). Valeur par défaut : false. RemarqueSeuls cosyvoice-v3-flash, cosyvoice-v3-plus et cosyvoice-v2 prennent en charge cette fonction. Configurez |
aigc_propagator | str | Non | Définit le champ ContentPropagator du filigrane AIGC, identifiant le propagateur du contenu. Ne prend effet que si enable_aigc_tag vaut true.Valeur par défaut : l'UID Alibaba Cloud. RemarqueSeuls cosyvoice-v3-flash, cosyvoice-v3-plus et cosyvoice-v2 prennent en charge cette fonction. Se configure via le dictionnaire |
aigc_propagate_id | str | Non | Définit le champ PropagateID du filigrane AIGC, identifiant de manière unique une action de propagation donnée. Ne prend effet que si enable_aigc_tag vaut true.Valeur par défaut : l'ID de requête de la requête de synthèse vocale en cours. RemarqueSeuls cosyvoice-v3-flash, cosyvoice-v3-plus et cosyvoice-v2 prennent en charge cette fonction. Se configure via le dictionnaire |
hot_fix | dict | Non | Configure des corrections de prononciation et des remplacements de texte appliqués avant la synthèse. RemarqueCette fonction n'est pas compatible avec cosyvoice-v2. Paramètres :
Exemple : |
enable_markdown_filter | bool | Non | Remarquecosyvoice-v2 ne prend pas en charge cette fonctionnalité. Indique s’il faut activer le filtrage Markdown. Lorsque l’option est activée, le service convertit le Markdown en texte adapté à la lecture à voix haute avant la synthèse. Valeur par défaut : false. Valeurs valides :
Configurez |
Référence de l’API
stream() - streaming
Signature de la méthode :
def stream(self, text: str, *, model: str, voice: str,
format: str = "mp3", sample_rate: int = 22050, ...) -> Iterator[bytes]
Paramètres :
| Paramètre | Type | Requis | Description |
|---|---|---|---|
text | str | Oui | Le texte complet à synthétiser. Longueur maximale: 20 000 caractères. |
Valeur de retour : Iterator[bytes], les données audio délivrées chunk par chunk.
Description : Synthèse en flux qui envoie l'intégralité du texte en une fois et délivre l'audio chunk par chunk (Iterator[bytes]). Elle convient particulièrement aux scénarios de synthèse vocale de textes courts exigeant une forte réactivité temps réel. Pour envoyer le texte par segments, utilisez la session de diffusion bidirectionnelle (connect).
send_text() - saisie en flux (méthode de session)
Envoie le texte par segments dans une session de diffusion bidirectionnelle (client.audio.tts.connect(...)).
Signature de la méthode :
def send_text(self, text: str) -> None
Paramètres : text est le segment de texte à synthétiser en cours. Appelez send_text plusieurs fois pour ajouter du texte. Maximum par appel: 20 000 caractères ; maximum cumulé: 200 000 caractères. L'envoi de texte et la réception d'audio doivent s'exécuter de manière concurrente (à utiliser avec audio_chunks()/events() et stop).
stop() - terminer la saisie en flux (méthode de session)
Signature de la méthode :
def stop(self) -> None
Description : Notifie au serveur que tout le texte a été envoyé. Cet appel ne bloque pas le thread courant ; le thread de réception doit continuer à consommer audio_chunks()/events() jusqu'à ce que le texte restant soit synthétisé et que toutes les données audio soient renvoyées. Si cette méthode n'est pas appelée, il est possible que le dernier texte ne soit pas converti en parole.
Métriques et réponses de la session (attributs de session)
session.first_package_delay
session.usage
session.last_response
first_package_delay:float, la latence en millisecondes entre l'envoi du texte et la réception du premier chunk audio. À lire après la fin de la synthèse.usage:dict, les informations d'utilisation de la tâche de synthèse la plus récente.last_response:dict, le message de réponse de la tâche de synthèse la plus récente (avec les clésheader/payload). Le request_id de la requête la plus récente peut être obtenu depuis leheaderdesession.last_response, utile pour le dépannage et la corrélation de logs.
audio_chunks() - itérer les données audio
Signature de la méthode :
def audio_chunks(self) -> Iterator[bytes]
Valeur de retour : Iterator[bytes], les données binaires audio délivrées chunk par chunk, dans le format spécifié par le paramètre format.
Description : Itérez dans le thread de réception pour recevoir les données audio chunk par chunk ; pendant la synthèse, plusieurs chunks sont délivrés. Écrivez les données dans un fichier ou envoyez-les à un dispositif de lecture. Une session n'autorise qu'un seul lecteur de events() ou audio_chunks().
events() - itérer les événements du serveur
Signature de la méthode :
def events(self) -> Generator[Union[Dict, bytes], None, None]
Valeur de retour : Renvoie à la fois des événements de réponse du serveur (dict, contenant header (informations de la requête) et payload (informations de sortie)) et des bytes audio. Le champ payload.output contient le type d'événement, le texte original et d'autres informations. Consultez champ output dans les messages de events().
Description : Itérez sur les réponses du serveur dans le thread de réception. Les réponses contiennent les informations de sortie des événements de synthèse (type d'événement, texte original, informations de phrase, etc.) ; accédez directement à payload.output pour plus de détails.
Gestion des erreurs
Lorsqu'une erreur survient pendant la synthèse, la couche WebSocket lève une exception DashScopeError et la connexion se ferme automatiquement après la levée de l'exception. Utilisez try/except côté envoi/réception pour capturer et consigner les erreurs à des fins de dépannage :
from dashscope import DashScopeError
try:
...
except DashScopeError as e:
print(e.code, e.message, e.request_id)
Cycle de vie de la session
- La connexion est établie automatiquement à l'entrée dans le contexte
with(vous pouvez initialiser des flux de sortie audio ou ouvrir des ressources fichier en amont). - Une fois tout le texte synthétisé et toutes les données audio délivrées, l'itération de
events()/audio_chunks()se termine ; vous pouvez ensuite lire des métriques de performance commefirst_package_delay. - La connexion se ferme automatiquement à la sortie du contexte
with(vous pouvez ensuite libérer les dispositifs de lecture audio et d'autres ressources).
Champ output dans les messages de events()
Le dict d'événement délivré par l'itérateur events() de la session contient un champ payload.output avec les informations de l'événement de synthèse. Utilisez ce champ pour suivre la progression de la synthèse et récupérer les détails par phrase. La structure du champ output est la suivante :
| Champ | Type | Description |
|---|---|---|
type | str | Type d'événement. Valeurs: sentence-begin (début de synthèse de phrase), sentence-synthesis (synthèse de phrase en cours) ou sentence-end (fin de synthèse de phrase). |
original_text | str | Le texte original de la phrase en cours. Renvoyé dans les événements sentence-begin et sentence-end. |
sentence | dict | Informations de la phrase. Contient index (numéro de séquence de la phrase) et words (liste de mots avec informations d'horodatage lorsque word_timestamp_enabled est activé). |
Exemple de message :
{
"header": {
"task_id": "xxx",
"event": "result-generated",
"attributes": {}
},
"payload": {
"output": {
"type": "sentence-begin",
"original_text": "How is the weather today?",
"sentence": {
"index": 0,
"words": []
}
}
}
}
Exemple d'analyse :
def handle_event(event):
output = (event.get('payload') or {}).get('output') or {}
event_type = output.get('type', '')
original_text = output.get('original_text', '')
if event_type:
print(f'Event type: {event_type}, original text: {original_text}')
Qwen-Audio-TTS
Référence commune
- stream() - streaming
- send_text() - saisie en flux (méthode de session)
- stop() - terminer la saisie en flux (méthode de session)
- Métriques et réponses de la session (attributs de session)
- audio_chunks() - itérer les données audio
- events() - itérer les événements du serveur
- Gestion des erreurs
- Cycle de vie de la session
- Champ output dans les messages de events()
Consultez la documentation Qwen-Audio-TTS Python SDK actuelle.
Ressource principale (client.audio.tts)
Chemin de la ressource : client.audio.tts
Fonction : Synthèse vocale basée sur WebSocket, proposant trois formes d'appel : synthèse en un seul appel (synthesize), synthèse en flux (stream) et session de diffusion bidirectionnelle (connect).
Point d'entrée d'appel
# Synthèse en un seul appel : renvoie l'ensemble des octets audio
audio = client.audio.tts.synthesize(
text, # text est obligatoire (argument positionnel)
model="qwen-audio-3.0-tts-flash", # le modèle auquel appartient la voix
voice="longanhuan_v3.6", # la voix
format="mp3", # Format d'encodage audio, valeur par défaut "mp3"
sample_rate=22050, # Taux d'échantillonnage, valeur par défaut 22050
)
# Synthèse en flux : délivre les octets audio chunk par chunk (écrivez/lisez pendant la réception)
for chunk in client.audio.tts.stream(text, model=..., voice=...):
...
# Session de diffusion bidirectionnelle : envoyez le texte par segments ; la connexion est établie automatiquement à l'entrée dans le contexte with
with client.audio.tts.connect(model=..., voice=...) as session:
session.send_text(text) # Peut être appelée plusieurs fois pour ajouter du texte
session.stop() # Notifie le serveur que la saisie est terminée
for chunk in session.audio_chunks():
...
synthesize() - sans streaming
Signature de la méthode :
def synthesize(self, text: str, *, model: str,
voice: str, format: str = "mp3",
sample_rate: int = 22050, volume: int = None,
rate: float = None, pitch: float = None,
language_hints: list = None, enable_ssml: bool = None,
parameters: Dict = None, ...) -> bytes
Paramètres :
| Paramètre | Type | Requis | Description |
|---|---|---|---|
text | str | Oui | Le texte complet à synthétiser. Longueur maximale: 20 000 caractères. |
Valeur de retour : bytes contenant l'ensemble des données audio.
Description : Cet appel bloquant attend et renvoie l'intégralité des données audio en une seule fois. Il convient particulièrement aux textes courts n'exigeant pas de performance temps réel stricte. Chaque appel à synthesize ou stream crée sa propre session ; il n'est pas nécessaire de réutiliser les instances.
cancel() - annuler la synthèse en flux (méthode de session)
Signature de la méthode :
def cancel(self) -> None
Description : Annule le tour courant de synthèse vocale en flux. Après cet appel, le SDK met immédiatement fin à la tâche courante. Une fois annulée, la session ne peut plus envoyer de texte ; créez une nouvelle session pour poursuivre la synthèse.
Itération de session et événements
La synthèse en flux n'utilise plus d'interfaces de callback : l'audio et les événements du serveur se reçoivent via les méthodes d'itération de la session. stream()/synthesize() ne nécessitent aucune gestion de session ; le cycle de vie d'une session de diffusion bidirectionnelle (client.audio.tts.connect(...)) est : entrée dans le contexte with qui établit automatiquement la connexion → appels multiples à send_text() → stop() → lecture de tous les résultats → sortie du contexte qui ferme automatiquement la connexion.
CosyVoice
Référence commune
- stream() - streaming
- send_text() - saisie en flux (méthode de session)
- stop() - terminer la saisie en flux (méthode de session)
- Métriques et réponses de la session (attributs de session)
- audio_chunks() - itérer les données audio
- events() - itérer les événements du serveur
- Gestion des erreurs
- Cycle de vie de la session
- Champ output dans les messages de events()
Consultez la documentation CosyVoice Python SDK actuelle.
Ressource principale (client.audio.tts)
Chemin de la ressource : client.audio.tts
Description : Synthèse vocale basée sur WebSocket, proposant trois formes d'appel : synthèse en un seul appel (synthesize), synthèse en flux (stream) et session de diffusion bidirectionnelle (connect).
Point d'entrée d'appel
# Synthèse en un seul appel : renvoie l'ensemble des octets audio
audio = client.audio.tts.synthesize(
text, # text est un paramètre obligatoire (argument positionnel)
model="cosyvoice-v3-plus", # Le modèle auquel appartient la voix
voice="longanyang", # La voix
format="mp3", # Format d'encodage audio, valeur par défaut "mp3"
sample_rate=22050, # Taux d'échantillonnage, valeur par défaut 22050
)
# Synthèse en flux : délivre les octets audio chunk par chunk (écrivez/lisez pendant la réception)
for chunk in client.audio.tts.stream(text, model=..., voice=...):
...
# Session de diffusion bidirectionnelle : envoyez le texte par segments ; la connexion est établie automatiquement à l'entrée dans le contexte with
with client.audio.tts.connect(model=..., voice=...) as session:
session.send_text(text) # Peut être appelée plusieurs fois pour ajouter du texte
session.stop() # Notifie le serveur que la saisie est terminée
for chunk in session.audio_chunks():
...
synthesize() - sans streaming
Signature de la méthode :
def synthesize(self, text: str, *, model: str = "cosyvoice-v1",
voice: str = "longxiaochun", format: str = "mp3",
sample_rate: int = 22050, volume: int = None,
rate: float = None, pitch: float = None,
language_hints: list = None, enable_ssml: bool = None,
parameters: Dict = None, ...) -> bytes
Paramètres :
| Paramètre | Type | Requis | Description |
|---|---|---|---|
text | str | Oui | Le texte complet à synthétiser. Longueur maximale: 20 000 caractères. |
Valeur de retour : bytes contenant l'ensemble des données audio.
Description : Cet appel bloquant attend et renvoie l'intégralité des données audio en une seule fois. Il convient particulièrement aux textes courts n'exigeant pas de performance temps réel stricte. synthesize et stream créent une nouvelle session à chaque appel ; il n'est pas nécessaire de réutiliser les instances.
cancel() - annuler la synthèse en flux (méthode de session)
Signature de la méthode :
def cancel(self) -> None
Description : Annule la tâche de synthèse vocale en flux en cours. Après cet appel, le SDK met immédiatement fin à la tâche courante. Une fois annulée, la session ne peut plus envoyer de texte ; créez une nouvelle session pour poursuivre la synthèse.
ImportantLimitations du modèle :
- Chine (Pékin) : les modèles CosyVoice requièrent la version v2 ou ultérieure.
- Singapour : les modèles CosyVoice ne prennent pas en charge cette fonction.
Itération de session et événements
La synthèse en flux n'utilise plus d'interfaces de callback : l'audio et les événements du serveur se reçoivent via les méthodes d'itération de la session. stream()/synthesize() ne nécessitent aucune gestion de session ; le cycle de vie d'une session de diffusion bidirectionnelle (client.audio.tts.connect(...)) est : entrée dans le contexte with qui établit automatiquement la connexion → appels multiples à send_text() → stop() → lecture de tous les résultats → sortie du contexte qui ferme automatiquement la connexion.