livekit-plugins-cartesia 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

livekit/plugins/cartesia/__init__.py

@@ -28,3 +28,12 @@ class CartesiaPlugin(Plugin):
 
 
 Plugin.register_plugin(CartesiaPlugin())
+
+# Cleanup docs of unexported modules
+_module = dir()
+NOT_IN_ALL = [m for m in _module if m not in __all__]
+
+__pdoc__ = {}
+
+for n in NOT_IN_ALL:
+    __pdoc__[n] = False

livekit/plugins/cartesia/models.py

@@ -8,7 +8,34 @@ TTSEncoding = Literal[
     # "pcm_alaw",
 ]
 
-
 TTSModels = Literal["sonic-english", "sonic-multilingual"]
 TTSLanguages = Literal["en", "es", "fr", "de", "pt", "zh", "ja"]
 TTSDefaultVoiceId = "c2ac25f9-ecc4-4f56-9095-651354df60c0"
+TTSVoiceSpeed = Literal["fastest", "fast", "normal", "slow", "slowest"]
+TTSVoiceEmotion = Literal[
+    "anger:lowest",
+    "anger:low",
+    "anger",
+    "anger:high",
+    "anger:highest",
+    "positivity:lowest",
+    "positivity:low",
+    "positivity",
+    "positivity:high",
+    "positivity:highest",
+    "surprise:lowest",
+    "surprise:low",
+    "surprise",
+    "surprise:high",
+    "surprise:highest",
+    "sadness:lowest",
+    "sadness:low",
+    "sadness",
+    "sadness:high",
+    "sadness:highest",
+    "curiosity:lowest",
+    "curiosity:low",
+    "curiosity",
+    "curiosity:high",
+    "curiosity:highest",
+]

livekit/plugins/cartesia/tts.py

@@ -22,10 +22,24 @@ from dataclasses import dataclass
 from typing import Any
 
 import aiohttp
-from livekit.agents import tokenize, tts, utils
+from livekit import rtc
+from livekit.agents import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    tokenize,
+    tts,
+    utils,
+)
 
 from .log import logger
-from .models import TTSDefaultVoiceId, TTSEncoding, TTSModels
+from .models import (
+    TTSDefaultVoiceId,
+    TTSEncoding,
+    TTSModels,
+    TTSVoiceEmotion,
+    TTSVoiceSpeed,
+)
 
 API_AUTH_HEADER = "X-API-Key"
 API_VERSION_HEADER = "Cartesia-Version"
@@ -37,10 +51,12 @@ BUFFERED_WORDS_COUNT = 8
 
 @dataclass
 class _TTSOptions:
-    model: TTSModels
+    model: TTSModels | str
     encoding: TTSEncoding
     sample_rate: int
     voice: str | list[float]
+    speed: TTSVoiceSpeed | float | None
+    emotion: list[TTSVoiceEmotion | str] | None
     api_key: str
     language: str
 
@@ -49,14 +65,33 @@ class TTS(tts.TTS):
     def __init__(
         self,
         *,
-        model: TTSModels = "sonic-english",
+        model: TTSModels | str = "sonic-english",
         language: str = "en",
         encoding: TTSEncoding = "pcm_s16le",
         voice: str | list[float] = TTSDefaultVoiceId,
+        speed: TTSVoiceSpeed | float | None = None,
+        emotion: list[TTSVoiceEmotion | str] | None = None,
         sample_rate: int = 24000,
         api_key: str | None = None,
         http_session: aiohttp.ClientSession | None = None,
     ) -> None:
+        """
+        Create a new instance of Cartesia TTS.
+
+        See https://docs.cartesia.ai/reference/web-socket/stream-speech/stream-speech for more details on the the Cartesia API.
+
+        Args:
+            model (TTSModels, optional): The Cartesia TTS model to use. Defaults to "sonic-english".
+            language (str, optional): The language code for synthesis. Defaults to "en".
+            encoding (TTSEncoding, optional): The audio encoding format. Defaults to "pcm_s16le".
+            voice (str | list[float], optional): The voice ID or embedding array.
+            speed (TTSVoiceSpeed | float, optional): Voice Control - Speed (https://docs.cartesia.ai/user-guides/voice-control)
+            emotion (list[TTSVoiceEmotion], optional): Voice Control - Emotion (https://docs.cartesia.ai/user-guides/voice-control)
+            sample_rate (int, optional): The audio sample rate in Hz. Defaults to 24000.
+            api_key (str, optional): The Cartesia API key. If not provided, it will be read from the CARTESIA_API_KEY environment variable.
+            http_session (aiohttp.ClientSession | None, optional): An existing aiohttp ClientSession to use. If not provided, a new session will be created.
+        """
+
         super().__init__(
             capabilities=tts.TTSCapabilities(streaming=True),
             sample_rate=sample_rate,
@@ -73,6 +108,8 @@ class TTS(tts.TTS):
             encoding=encoding,
             sample_rate=sample_rate,
             voice=voice,
+            speed=speed,
+            emotion=emotion,
             api_key=api_key,
         )
         self._session = http_session
@@ -83,63 +120,106 @@ class TTS(tts.TTS):
 
         return self._session
 
+    def update_options(
+        self,
+        *,
+        model: TTSModels | None = None,
+        language: str | None = None,
+        voice: str | list[float] | None = None,
+        speed: TTSVoiceSpeed | float | None = None,
+        emotion: list[TTSVoiceEmotion | str] | None = None,
+    ) -> None:
+        """
+        Update the Text-to-Speech (TTS) configuration options.
+
+        This method allows updating the TTS settings, including model type, language, voice, speed,
+        and emotion. If any parameter is not provided, the existing value will be retained.
+
+        Args:
+            model (TTSModels, optional): The Cartesia TTS model to use. Defaults to "sonic-english".
+            language (str, optional): The language code for synthesis. Defaults to "en".
+            voice (str | list[float], optional): The voice ID or embedding array.
+            speed (TTSVoiceSpeed | float, optional): Voice Control - Speed (https://docs.cartesia.ai/user-guides/voice-control)
+            emotion (list[TTSVoiceEmotion], optional): Voice Control - Emotion (https://docs.cartesia.ai/user-guides/voice-control)
+        """
+        self._opts.model = model or self._opts.model
+        self._opts.language = language or self._opts.language
+        self._opts.voice = voice or self._opts.voice
+        self._opts.speed = speed or self._opts.speed
+        if emotion is not None:
+            self._opts.emotion = emotion
+
     def synthesize(self, text: str) -> "ChunkedStream":
-        return ChunkedStream(text, self._opts, self._ensure_session())
+        return ChunkedStream(self, text, self._opts, self._ensure_session())
 
     def stream(self) -> "SynthesizeStream":
-        return SynthesizeStream(self._opts, self._ensure_session())
+        return SynthesizeStream(self, self._opts, self._ensure_session())
 
 
 class ChunkedStream(tts.ChunkedStream):
     """Synthesize chunked text using the bytes endpoint"""
 
     def __init__(
-        self, text: str, opts: _TTSOptions, session: aiohttp.ClientSession
+        self, tts: TTS, text: str, opts: _TTSOptions, session: aiohttp.ClientSession
     ) -> None:
-        super().__init__()
-        self._text, self._opts, self._session = text, opts, session
+        super().__init__(tts, text)
+        self._opts, self._session = opts, session
 
-    @utils.log_exceptions(logger=logger)
-    async def _main_task(self):
+    async def _main_task(self) -> None:
+        request_id = utils.shortuuid()
         bstream = utils.audio.AudioByteStream(
             sample_rate=self._opts.sample_rate, num_channels=NUM_CHANNELS
         )
-        request_id, segment_id = utils.shortuuid(), utils.shortuuid()
-
-        data = _to_cartesia_options(self._opts)
-        data["transcript"] = self._text
-
-        async with self._session.post(
-            "https://api.cartesia.ai/tts/bytes",
-            headers={
-                API_AUTH_HEADER: self._opts.api_key,
-                API_VERSION_HEADER: API_VERSION,
-            },
-            json=data,
-        ) as resp:
-            async for data, _ in resp.content.iter_chunks():
-                for frame in bstream.write(data):
-                    self._event_ch.send_nowait(
-                        tts.SynthesizedAudio(
-                            request_id=request_id, segment_id=segment_id, frame=frame
+
+        json = _to_cartesia_options(self._opts)
+        json["transcript"] = self._input_text
+
+        headers = {
+            API_AUTH_HEADER: self._opts.api_key,
+            API_VERSION_HEADER: API_VERSION,
+        }
+
+        try:
+            async with self._session.post(
+                "https://api.cartesia.ai/tts/bytes",
+                headers=headers,
+                json=json,
+            ) as resp:
+                resp.raise_for_status()
+                async for data, _ in resp.content.iter_chunks():
+                    for frame in bstream.write(data):
+                        self._event_ch.send_nowait(
+                            tts.SynthesizedAudio(
+                                request_id=request_id,
+                                frame=frame,
+                            )
                         )
-                    )
 
-            for frame in bstream.flush():
-                self._event_ch.send_nowait(
-                    tts.SynthesizedAudio(
-                        request_id=request_id, segment_id=segment_id, frame=frame
+                for frame in bstream.flush():
+                    self._event_ch.send_nowait(
+                        tts.SynthesizedAudio(request_id=request_id, frame=frame)
                     )
-                )
+        except asyncio.TimeoutError as e:
+            raise APITimeoutError() from e
+        except aiohttp.ClientResponseError as e:
+            raise APIStatusError(
+                message=e.message,
+                status_code=e.status,
+                request_id=None,
+                body=None,
+            ) from e
+        except Exception as e:
+            raise APIConnectionError() from e
 
 
 class SynthesizeStream(tts.SynthesizeStream):
     def __init__(
         self,
+        tts: TTS,
         opts: _TTSOptions,
         session: aiohttp.ClientSession,
     ):
-        super().__init__()
+        super().__init__(tts)
         self._opts, self._session = opts, session
         self._sent_tokenizer_stream = tokenize.basic.SentenceTokenizer(
             min_sentence_len=BUFFERED_WORDS_COUNT
@@ -204,6 +284,22 @@ class SynthesizeStream(tts.SynthesizeStream):
                 num_channels=NUM_CHANNELS,
             )
 
+            last_frame: rtc.AudioFrame | None = None
+
+            def _send_last_frame(*, segment_id: str, is_final: bool) -> None:
+                nonlocal last_frame
+                if last_frame is not None:
+                    self._event_ch.send_nowait(
+                        tts.SynthesizedAudio(
+                            request_id=request_id,
+                            segment_id=segment_id,
+                            frame=last_frame,
+                            is_final=is_final,
+                        )
+                    )
+
+                    last_frame = None
+
             while True:
                 msg = await ws.receive()
                 if msg.type in (
@@ -219,26 +315,18 @@ class SynthesizeStream(tts.SynthesizeStream):
 
                 data = json.loads(msg.data)
                 segment_id = data.get("context_id")
-                # Once we receive audio for a segment, we can start a new segment
+
                 if data.get("data"):
                     b64data = base64.b64decode(data["data"])
                     for frame in audio_bstream.write(b64data):
-                        self._event_ch.send_nowait(
-                            tts.SynthesizedAudio(
-                                request_id=request_id,
-                                segment_id=segment_id,
-                                frame=frame,
-                            )
-                        )
+                        _send_last_frame(segment_id=segment_id, is_final=False)
+                        last_frame = frame
                 elif data.get("done"):
                     for frame in audio_bstream.flush():
-                        self._event_ch.send_nowait(
-                            tts.SynthesizedAudio(
-                                request_id=request_id,
-                                segment_id=segment_id,
-                                frame=frame,
-                            )
-                        )
+                        _send_last_frame(segment_id=segment_id, is_final=False)
+                        last_frame = frame
+
+                    _send_last_frame(segment_id=segment_id, is_final=True)
 
                     if segment_id == request_id:
                         # we're not going to receive more frames, close the connection
@@ -268,6 +356,15 @@ def _to_cartesia_options(opts: _TTSOptions) -> dict[str, Any]:
         voice["mode"] = "embedding"
         voice["embedding"] = opts.voice
 
+    voice_controls: dict = {}
+    if opts.speed is not None:
+        voice_controls["speed"] = opts.speed
+    if opts.emotion is not None:
+        voice_controls["emotion"] = opts.emotion
+
+    if voice_controls:
+        voice["__experimental_controls"] = voice_controls
+
     return {
         "model_id": opts.model,
         "voice": voice,

livekit/plugins/cartesia/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.4.1"
+__version__ = "0.4.3"

{livekit_plugins_cartesia-0.4.1.dist-info → livekit_plugins_cartesia-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-plugins-cartesia
-Version: 0.4.1
+Version: 0.4.3
 Summary: LiveKit Agents Plugin for Cartesia
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
-Requires-Dist: livekit-agents >=0.8.0.dev0
+Requires-Dist: livekit-agents >=0.11
 
 # LiveKit Plugins Cartesia
 

livekit_plugins_cartesia-0.4.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+livekit/plugins/cartesia/__init__.py,sha256=UTa6Q7IxhRBCwPftowHEUDvmBg99J_UjGS_yxTzKD7g,1095
+livekit/plugins/cartesia/log.py,sha256=4Mnhjng_DU1dIWP9IWjIQGZ67EV3LnQhWMWCHVudJbo,71
+livekit/plugins/cartesia/models.py,sha256=fOO276Vzw3OkDUWUVcw7PH95ctFy38rj3q9I6_mYQ7M,950
+livekit/plugins/cartesia/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/cartesia/tts.py,sha256=2xwWOIjwLDOF4TbHlDibrZpUju9If8WrNpHQ2JMuBC0,13533
+livekit/plugins/cartesia/version.py,sha256=u7PSD5TBbPRIhE8vJkBVJzq_eGqYfg6RP5c3VKNlKGk,600
+livekit_plugins_cartesia-0.4.3.dist-info/METADATA,sha256=w5q0oz6rdHDL5cxAyT5hWbHqhZnOPnZYGl3aUKsr3z4,1246
+livekit_plugins_cartesia-0.4.3.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+livekit_plugins_cartesia-0.4.3.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
+livekit_plugins_cartesia-0.4.3.dist-info/RECORD,,

{livekit_plugins_cartesia-0.4.1.dist-info → livekit_plugins_cartesia-0.4.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

livekit_plugins_cartesia-0.4.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-livekit/plugins/cartesia/__init__.py,sha256=BUfWY_evL5dUHn9hBDQVor6ssctDKQfbQfZy5SWndN8,926
-livekit/plugins/cartesia/log.py,sha256=4Mnhjng_DU1dIWP9IWjIQGZ67EV3LnQhWMWCHVudJbo,71
-livekit/plugins/cartesia/models.py,sha256=ZoSyV2ap_LqAIgvBvkmukkPxQR9DfKb3Z3oHtWxMiVg,335
-livekit/plugins/cartesia/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/cartesia/tts.py,sha256=sdiiWinOZR5EBkQFwa3GZAGrkgzXY1-aSRiDZ34K8ww,9527
-livekit/plugins/cartesia/version.py,sha256=GSGiYNpxiJSu-Mwsw7PqdHsxkwAqS-5ceh44QLp4ovU,600
-livekit_plugins_cartesia-0.4.1.dist-info/METADATA,sha256=B1B0c8a2ik7feImTl3nQHul9bqMhKebkmO880BCwF7Y,1252
-livekit_plugins_cartesia-0.4.1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-livekit_plugins_cartesia-0.4.1.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
-livekit_plugins_cartesia-0.4.1.dist-info/RECORD,,