o êi_@sdZddlZddlmZddlmZmZmZmZm Z m Z ddl Z ddl m Z mZmZmZddlmZmZdd lmZmZmZmZdd lmZmZdd lmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'd e&d e(de'fddZ)de e(e%efde e%effddZ*GdddZ+GdddZ,dS)z&TTS (Text-to-Speech) namespace client.N)ThreadPoolExecutor) AsyncIterableIterableIteratorListOptionalUnion)AsyncWebSocketSessionWebSocketSession aconnect_ws connect_ws)aiter_websocket_audioiter_websocket_audio)AsyncClientWrapper ClientWrapperRequestOptionsWebSocketOptions)AsyncAudioStream AudioStream) AudioFormat CloseEvent FlushEvent LatencyModeModelProsodyReferenceAudio StartEvent TextEvent TTSConfig TTSRequestconfigtextreturncCstdid|d|jd|jd|jd|jd|jd|jd|jd |jd |j d |j d |j d |j d|j d|jd|jd|jd|jS)z*Convert TTSConfig to TTSRequest with text.r# chunk_lengthformat sample_rate mp3_bitrate opus_bitrate references reference_id normalizelatencyprosodytop_p temperaturemax_new_tokensrepetition_penaltymin_chunk_lengthcondition_on_previous_chunksearly_stop_thresholdN)r!r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5)r"r#r6r6K/home/ubuntu/.local/lib/python3.10/site-packages/fishaudio/resources/tts.py_config_to_tts_requestsJ     r8itemcCst|ttfr |St|dS)zHNormalize string input to TextEvent, pass through event types unchanged.r#) isinstancerr)r9r6r6r7_normalize_to_event4s r<c@sbeZdZdZdefddZdddddedddded eed ee e d ee d ee d ee dededeedefddZdddddedddded eed ee e d ee d ee d ee dededeedefddZdddddedddd deeeeefd eed ee e d ee d ee d ee dedededeedeefddZdS) TTSClientzSynchronous TTS operations.client_wrappercC ||_dSN_clientselfr>r6r6r7__init__@ zTTSClient.__init__Ns1r+r*r&r-speedr"modelrequest_optionsr#r+r*r&r-rIr"rJrKr$c st||} |dur || _|dur|| _|dur|| _|dur!|| _|dur.tj||jd| _| jdd} |j j ddd|dt | | d fd d } t | S) a Stream text-to-speech audio chunks. Args: text: Text to synthesize reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use request_options: Request-level overrides Returns: AudioStream object that can be iterated for audio chunks Example: ```python from fishaudio import FishAudio client = FishAudio(api_key="...") # Stream and process chunks for chunk in client.tts.stream(text="Hello world"): process_audio_chunk(chunk) # Or collect all at once audio = client.tts.stream(text="Hello world").collect() ``` NbaseT exclude_nonePOST/v1/ttsapplication/msgpackz Content-TyperJheaderscontentrKc3sD]}|r |VqdSr@) iter_byteschunkresponser6r7_streams  z!TTSClient.stream.._stream)r8r+r*r&r-rfrom_speed_overrider. model_dumprBrequest ormsgpackpackbr rDr#r+r*r&r-rIr"rJrKr_payloadr\r6rZr7streamCs* -  zTTSClient.streamc Cs |j||||||||| d S)as Convert text to speech and return complete audio as bytes. This is a convenience method that streams all audio chunks and combines them. For chunk-by-chunk processing, use stream() instead. Args: text: Text to synthesize reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use request_options: Request-level overrides Returns: Complete audio as bytes Example: ```python from fishaudio import FishAudio from fishaudio.utils import play, save client = FishAudio(api_key="...") # Get complete audio audio = client.tts.convert(text="Hello world") # Play it play(audio) # Or save it save(audio, "output.mp3") ``` r#r+r*r&r-rIr"rJrKrdcollect) rDr#r+r*r&r-rIr"rJrKr6r6r7converts2 zTTSClient.convert ) r+r*r&r-rIr"rJ max_workers ws_options text_streamrjrkc  #s*t|dd|dur|_|dur|_|dur|_|dur#|_|dur0tj||jd_| r6| ni} t | d} zPt d |j j |j d|id| #fd d } | | }tD]}|Vqc|Wdn1swwYW| jd d dSW| jd d dS| jd d w)a Stream text and receive audio in real-time via WebSocket. Perfect for conversational AI, live captioning, and streaming applications. Args: text_stream: Iterator of text chunks to stream reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use max_workers: ThreadPoolExecutor workers for concurrent sender ws_options: WebSocket connection options for configuring timeouts, message size limits, etc. Useful for long-running generations that may exceed default timeout values. See WebSocketOptions class for available parameters. Returns: Iterator of audio bytes Example: ```python from fishaudio import FishAudio, TTSConfig, ReferenceAudio, WebSocketOptions client = FishAudio(api_key="...") def text_generator(): yield "Hello, " yield "this is " yield "streaming text!" # Simple usage with defaults with open("output.mp3", "wb") as f: for audio_chunk in client.tts.stream_websocket(text_generator()): f.write(audio_chunk) # With format and speed parameters with open("output.wav", "wb") as f: for audio_chunk in client.tts.stream_websocket( text_generator(), format="wav", speed=1.3 ): f.write(audio_chunk) # With reference_id parameter with open("output.mp3", "wb") as f: for audio_chunk in client.tts.stream_websocket(text_generator(), reference_id="your_model_id"): f.write(audio_chunk) # With references parameter with open("output.mp3", "wb") as f: for audio_chunk in client.tts.stream_websocket( text_generator(), references=[ReferenceAudio(audio=audio_bytes, text="sample")] ): f.write(audio_chunk) # With WebSocket options for long-running generations # Useful if you're generating very long responses that may take >20 seconds ws_options = WebSocketOptions(keepalive_ping_timeout_seconds=60.0) with open("output.mp3", "wb") as f: for audio_chunk in client.tts.stream_websocket( text_generator(), ws_options=ws_options ): f.write(audio_chunk) # Parameters override config values config = TTSConfig(format="mp3", latency="balanced") with open("output.wav", "wb") as f: for audio_chunk in client.tts.stream_websocket( text_generator(), format="wav", # Parameter wins config=config ): f.write(audio_chunk) ``` r:NrL)rj /v1/tts/liverJclientrUcsZttdD]}t|}t|qttdSN)r_ send_bytesr`rarr^r<rr9eventrl tts_requestwsr6r7senderUsz*TTSClient.stream_websocket..senderF)waitrn)r8r+r*r&r-rr]r.to_httpx_ws_kwargsrr rBrp get_headerssubmitrresultshutdown)rDrlr+r*r&r-rIr"rJrjrk ws_kwargsexecutorry sender_future audio_chunkr6rvr7stream_websocketsF `   zTTSClient.stream_websocket)__name__ __module__ __qualname____doc__rrEr strrrrrrfloatrrrrdbytesrhrrrrintrrrr6r6r6r7r==s     V     B      r=c@sTeZdZdZdefddZdddddedddded eed ee e d ee d ee d ee dededeedefddZdddddedddded eed ee e d ee d ee d ee dededeedefddZdddddeddddeeeeefd eed ee e d ee d ee d ee dededeefddZdS)AsyncTTSClientzAsynchronous TTS operations.r>cCr?r@rArCr6r6r7rEmrFzAsyncTTSClient.__init__NrGrHr#r+r*r&r-rIr"rJrKr$c st||} |dur || _|dur|| _|dur|| _|dur"|| _|dur/tj||jd| _| jdd} |j j ddd|dt | | d IdHfd d } t | S) a9 Stream text-to-speech audio chunks (async). Args: text: Text to synthesize reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use request_options: Request-level overrides Returns: AsyncAudioStream object that can be iterated for audio chunks Example: ```python from fishaudio import AsyncFishAudio client = AsyncFishAudio(api_key="...") # Stream and process chunks async for chunk in await client.tts.stream(text="Hello world"): await process_audio_chunk(chunk) # Or collect all at once stream = await client.tts.stream(text="Hello world") audio = await stream.collect() ``` NrLTrNrPrQrRrSrTcs(2z 3dHW}|r|Vq6dSr@) aiter_bytesrXrZr6r7r\s z&AsyncTTSClient.stream.._stream)r8r+r*r&r-rr]r.r^rBr_r`rarrbr6rZr7rdps, .  zAsyncTTSClient.streamc s2|j||||||||| d IdH} | IdHS)a Convert text to speech and return complete audio as bytes (async). This is a convenience method that streams all audio chunks and combines them. For chunk-by-chunk processing, use stream() instead. Args: text: Text to synthesize reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use request_options: Request-level overrides Returns: Complete audio as bytes Example: ```python from fishaudio import AsyncFishAudio from fishaudio.utils import play, save client = AsyncFishAudio(api_key="...") # Get complete audio audio = await client.tts.convert(text="Hello world") # Play it play(audio) # Or save it save(audio, "output.mp3") ``` reNrf) rDr#r+r*r&r-rIr"rJrKrdr6r6r7rhs2  zAsyncTTSClient.convert)r+r*r&r-rIr"rJrkrlrkc st|dd|dur|_|dur|_|dur|_|dur#|_|dur0tj||jd_| r6| ni} t d |j j |j d|id| 4IdH.fdd } t | } t2z 3dHW} | Vqb6| IdHWdIdHdS1IdHswYdS) aw Stream text and receive audio in real-time via WebSocket (async). Perfect for conversational AI, live captioning, and streaming applications. Args: text_stream: Async iterator of text chunks to stream reference_id: Voice reference ID (overrides config.reference_id if provided) references: Reference audio samples (overrides config.references if provided) format: Audio format - "mp3", "wav", "pcm", or "opus" (overrides config.format if provided) latency: Latency mode - "normal" or "balanced" (overrides config.latency if provided) speed: Speech speed multiplier, e.g. 1.5 for 1.5x speed (overrides config.prosody.speed if provided) config: TTS configuration (audio settings, voice, model parameters) model: TTS model to use ws_options: WebSocket connection options for configuring timeouts, message size limits, etc. Useful for long-running generations that may exceed default timeout values. See WebSocketOptions class for available parameters. Returns: Async iterator of audio bytes Example: ```python from fishaudio import AsyncFishAudio, TTSConfig, ReferenceAudio, WebSocketOptions client = AsyncFishAudio(api_key="...") async def text_generator(): yield "Hello, " yield "this is " yield "async streaming!" # Simple usage with defaults async with aiofiles.open("output.mp3", "wb") as f: async for audio_chunk in client.tts.stream_websocket(text_generator()): await f.write(audio_chunk) # With format and speed parameters async with aiofiles.open("output.wav", "wb") as f: async for audio_chunk in client.tts.stream_websocket( text_generator(), format="wav", speed=1.3 ): await f.write(audio_chunk) # With reference_id parameter async with aiofiles.open("output.mp3", "wb") as f: async for audio_chunk in client.tts.stream_websocket(text_generator(), reference_id="your_model_id"): await f.write(audio_chunk) # With references parameter async with aiofiles.open("output.mp3", "wb") as f: async for audio_chunk in client.tts.stream_websocket( text_generator(), references=[ReferenceAudio(audio=audio_bytes, text="sample")] ): await f.write(audio_chunk) # With WebSocket options for long-running generations # Useful if you're generating very long responses that may take >20 seconds ws_options = WebSocketOptions(keepalive_ping_timeout_seconds=60.0) async with aiofiles.open("output.mp3", "wb") as f: async for audio_chunk in client.tts.stream_websocket( text_generator(), ws_options=ws_options ): await f.write(audio_chunk) # Parameters override config values config = TTSConfig(format="mp3", latency="balanced") async with aiofiles.open("output.wav", "wb") as f: async for audio_chunk in client.tts.stream_websocket( text_generator(), format="wav", # Parameter wins config=config ): await f.write(audio_chunk) ``` rmr:NrLrnrJrocsxttdIdH2z3dHW}t|}t|IdHq6ttIdHdSrqrrrtrvr6r7rys  z/AsyncTTSClient.stream_websocket..senderr{)r8r+r*r&r-rr]r.r|r rBrpr}asyncio create_taskr)rDrlr+r*r&r-rIr"rJrkrry sender_taskrr6rvr7rs> ^  .zAsyncTTSClient.stream_websocket)rrrrrrEr rrrrrrrrrrrdrrhrrrrrrr6r6r6r7rjs     W     C    r)-rrconcurrent.futuresrtypingrrrrrrr`httpx_wsr r r r realtimerrcorerrrrcore.iteratorsrrtypesrrrrrrrrrr r!rr8r<r=rr6r6r6r7s(  4    /