cartesia 1.0.14__tar.gz → 1.1.0.dev0__tar.gz

{cartesia-1.0.14/cartesia.egg-info → cartesia-1.1.0.dev0}/PKG-INFO

@@ -1,19 +1,15 @@
 Metadata-Version: 2.1
 Name: cartesia
-Version: 1.0.14
+Version: 1.1.0.dev0
 Summary: The official Python library for the Cartesia API.
-Home-page: 
-Author: Cartesia, Inc.
-Author-email: support@cartesia.ai
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8.0
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: all
 License-File: LICENSE.md
-
+Requires-Dist: aiohttp>=3.10.10
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: iterators>=0.2.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: websockets>=13.1
 
 # Cartesia Python API Library
 
@@ -30,6 +26,7 @@ The official Cartesia Python library which provides convenient access to the Car
   - [Installation](#installation)
   - [Voices](#voices)
   - [Text-to-Speech](#text-to-speech)
+    - [Bytes](#bytes)
     - [Server-Sent Events (SSE)](#server-sent-events-sse)
     - [WebSocket](#websocket)
       - [Conditioning speech on previous generations using WebSocket](#conditioning-speech-on-previous-generations-using-websocket)
@@ -88,6 +85,30 @@ new_voice = client.voices.create(
 
 ## Text-to-Speech
 
+### Bytes
+
+```python
+from cartesia import Cartesia
+import os
+
+client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
+
+data = client.tts.bytes(
+    model_id="sonic-english",
+    transcript="Hello, world! I'm generating audio on Cartesia.",
+    voice_id="a0e99841-438c-4a64-b679-ae501e7d6091",  # Barbershop Man
+    # You can find the supported `output_format`s at https://docs.cartesia.ai/api-reference/tts/bytes
+    output_format={
+        "container": "wav",
+        "encoding": "pcm_f32le",
+        "sample_rate": 44100,
+    },
+)
+
+with open("output.wav", "wb") as f:
+    f.write(data)
+```
+
 ### Server-Sent Events (SSE)
 
 ```python
@@ -96,7 +117,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 
@@ -149,7 +169,6 @@ import os
 
 async def write_stream():
     client = AsyncCartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-    voice_name = "Barbershop Man"
     voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
     voice = client.voices.get(id=voice_id)
     transcript = "Hello! Welcome to Cartesia"
@@ -203,7 +222,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 transcript = "Hello! Welcome to Cartesia"
@@ -460,7 +478,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 

cartesia-1.0.14/PKG-INFO → cartesia-1.1.0.dev0/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.1
-Name: cartesia
-Version: 1.0.14
-Summary: The official Python library for the Cartesia API.
-Home-page: 
-Author: Cartesia, Inc.
-Author-email: support@cartesia.ai
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8.0
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Provides-Extra: all
-License-File: LICENSE.md
-
-
 # Cartesia Python API Library
 
 ![PyPI - Version](https://img.shields.io/pypi/v/cartesia)
@@ -30,6 +13,7 @@ The official Cartesia Python library which provides convenient access to the Car
   - [Installation](#installation)
   - [Voices](#voices)
   - [Text-to-Speech](#text-to-speech)
+    - [Bytes](#bytes)
     - [Server-Sent Events (SSE)](#server-sent-events-sse)
     - [WebSocket](#websocket)
       - [Conditioning speech on previous generations using WebSocket](#conditioning-speech-on-previous-generations-using-websocket)
@@ -88,6 +72,30 @@ new_voice = client.voices.create(
 
 ## Text-to-Speech
 
+### Bytes
+
+```python
+from cartesia import Cartesia
+import os
+
+client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
+
+data = client.tts.bytes(
+    model_id="sonic-english",
+    transcript="Hello, world! I'm generating audio on Cartesia.",
+    voice_id="a0e99841-438c-4a64-b679-ae501e7d6091",  # Barbershop Man
+    # You can find the supported `output_format`s at https://docs.cartesia.ai/api-reference/tts/bytes
+    output_format={
+        "container": "wav",
+        "encoding": "pcm_f32le",
+        "sample_rate": 44100,
+    },
+)
+
+with open("output.wav", "wb") as f:
+    f.write(data)
+```
+
 ### Server-Sent Events (SSE)
 
 ```python
@@ -96,7 +104,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 
@@ -149,7 +156,6 @@ import os
 
 async def write_stream():
     client = AsyncCartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-    voice_name = "Barbershop Man"
     voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
     voice = client.voices.get(id=voice_id)
     transcript = "Hello! Welcome to Cartesia"
@@ -203,7 +209,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 transcript = "Hello! Welcome to Cartesia"
@@ -460,7 +465,6 @@ import pyaudio
 import os
 
 client = Cartesia(api_key=os.environ.get("CARTESIA_API_KEY"))
-voice_name = "Barbershop Man"
 voice_id = "a0e99841-438c-4a64-b679-ae501e7d6091"
 voice = client.voices.get(id=voice_id)
 

{cartesia-1.0.14 → cartesia-1.1.0.dev0}/cartesia/_async_sse.py

@@ -8,8 +8,8 @@ from cartesia._constants import BACKOFF_FACTOR, MAX_RETRIES
 from cartesia._logger import logger
 from cartesia._sse import _SSE
 from cartesia._types import OutputFormat, VoiceControls
-from cartesia.tts import TTS
 from cartesia.utils.retry import retry_on_connection_error_async
+from cartesia.utils.tts import _construct_tts_request
 
 
 class _AsyncSSE(_SSE):
@@ -37,27 +37,17 @@ class _AsyncSSE(_SSE):
         stream: bool = True,
         _experimental_voice_controls: Optional[VoiceControls] = None,
     ) -> Union[bytes, AsyncGenerator[bytes, None]]:
-        voice = TTS._validate_and_construct_voice(
-            voice_id,
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
             voice_embedding=voice_embedding,
-            experimental_voice_controls=_experimental_voice_controls,
+            duration=duration,
+            language=language,
+            _experimental_voice_controls=_experimental_voice_controls,
         )
 
-        request_body = {
-            "model_id": model_id,
-            "transcript": transcript,
-            "voice": voice,
-            "output_format": {
-                "container": output_format["container"],
-                "encoding": output_format["encoding"],
-                "sample_rate": output_format["sample_rate"],
-            },
-            "language": language,
-        }
-
-        if duration is not None:
-            request_body["duration"] = duration
-
         generator = self._sse_generator_wrapper(request_body)
 
         if stream:

{cartesia-1.0.14 → cartesia-1.1.0.dev0}/cartesia/_async_websocket.py

@@ -10,6 +10,7 @@ from cartesia._constants import DEFAULT_MODEL_ID, DEFAULT_VOICE_EMBEDDING
 from cartesia._types import OutputFormat, VoiceControls
 from cartesia._websocket import _WebSocket
 from cartesia.tts import TTS
+from cartesia.utils.tts import _construct_tts_request
 
 
 class _AsyncTTSContext:
@@ -75,30 +76,20 @@ class _AsyncTTSContext:
 
         await self._websocket.connect()
 
-        voice = TTS._validate_and_construct_voice(
-            voice_id,
-            voice_embedding,
-            experimental_voice_controls=_experimental_voice_controls,
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
+            voice_embedding=voice_embedding,
+            duration=duration,
+            language=language,
+            context_id=self._context_id,
+            add_timestamps=add_timestamps,
+            continue_=continue_,
+            _experimental_voice_controls=_experimental_voice_controls,
         )
 
-        request_body = {
-            "model_id": model_id,
-            "transcript": transcript,
-            "voice": voice,
-            "output_format": {
-                "container": output_format["container"],
-                "encoding": output_format["encoding"],
-                "sample_rate": output_format["sample_rate"],
-            },
-            "context_id": self._context_id,
-            "continue": continue_,
-            "language": language,
-            "add_timestamps": add_timestamps,
-        }
-
-        if duration is not None:
-            request_body["duration"] = duration
-
         await self._websocket.websocket.send_json(request_body)
 
         # Start listening for responses on the WebSocket
@@ -202,12 +193,11 @@ class _AsyncWebSocket(_WebSocket):
         if self.websocket is None or self._is_websocket_closed():
             route = "tts/websocket"
             session = await self._get_session()
+            url = f"{self.ws_url}/{route}?api_key={self.api_key}&cartesia_version={self.cartesia_version}"
             try:
-                self.websocket = await session.ws_connect(
-                    f"{self.ws_url}/{route}?api_key={self.api_key}&cartesia_version={self.cartesia_version}"
-                )
+                self.websocket = await session.ws_connect(url)
             except Exception as e:
-                raise RuntimeError(f"Failed to connect to WebSocket. {e}")
+                raise RuntimeError(f"Failed to connect to WebSocket at {url}. {e}")
 
     def _is_websocket_closed(self):
         return self.websocket.closed

{cartesia-1.0.14 → cartesia-1.1.0.dev0}/cartesia/_sse.py

@@ -8,7 +8,7 @@ from cartesia._constants import BACKOFF_FACTOR, MAX_RETRIES
 from cartesia._logger import logger
 from cartesia._types import OutputFormat, VoiceControls
 from cartesia.utils.retry import retry_on_connection_error
-from cartesia.utils.tts import _validate_and_construct_voice
+from cartesia.utils.tts import _construct_tts_request, _validate_and_construct_voice
 
 
 class _SSE:
@@ -84,25 +84,16 @@ class _SSE:
             Both the generator and the dictionary contain the following key(s):
             - audio: The audio as bytes.
         """
-        voice = _validate_and_construct_voice(
-            voice_id,
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
             voice_embedding=voice_embedding,
-            experimental_voice_controls=_experimental_voice_controls,
+            duration=duration,
+            language=language,
+            _experimental_voice_controls=_experimental_voice_controls,
         )
-        request_body = {
-            "model_id": model_id,
-            "transcript": transcript,
-            "voice": voice,
-            "output_format": {
-                "container": output_format["container"],
-                "encoding": output_format["encoding"],
-                "sample_rate": output_format["sample_rate"],
-            },
-            "language": language,
-        }
-
-        if duration is not None:
-            request_body["duration"] = duration
 
         generator = self._sse_generator_wrapper(request_body)
 

{cartesia-1.0.14 → cartesia-1.1.0.dev0}/cartesia/_websocket.py

@@ -14,7 +14,7 @@ except ImportError:
 from iterators import TimeoutIterator
 
 from cartesia._types import EventType, OutputFormat, VoiceControls
-from cartesia.utils.tts import _validate_and_construct_voice
+from cartesia.utils.tts import _construct_tts_request
 
 
 class _TTSContext:
@@ -81,29 +81,20 @@ class _TTSContext:
 
         self._websocket.connect()
 
-        voice = _validate_and_construct_voice(
-            voice_id,
+        # Create the initial request body
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
             voice_embedding=voice_embedding,
-            experimental_voice_controls=_experimental_voice_controls,
+            duration=duration,
+            language=language,
+            context_id=self._context_id,
+            add_timestamps=add_timestamps,
+            _experimental_voice_controls=_experimental_voice_controls,
         )
 
-        # Create the initial request body
-        request_body = {
-            "model_id": model_id,
-            "voice": voice,
-            "output_format": {
-                "container": output_format["container"],
-                "encoding": output_format["encoding"],
-                "sample_rate": output_format["sample_rate"],
-            },
-            "context_id": self._context_id,
-            "language": language,
-            "add_timestamps": add_timestamps,
-        }
-
-        if duration is not None:
-            request_body["duration"] = duration
-
         try:
             # Create an iterator with a timeout to get text chunks
             text_iterator = TimeoutIterator(
@@ -303,29 +294,19 @@ class _WebSocket:
         if context_id is None:
             context_id = str(uuid.uuid4())
 
-        voice = _validate_and_construct_voice(
-            voice_id,
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
             voice_embedding=voice_embedding,
-            experimental_voice_controls=_experimental_voice_controls,
+            context_id=context_id,
+            duration=duration,
+            language=language,
+            add_timestamps=add_timestamps,
+            _experimental_voice_controls=_experimental_voice_controls,
         )
 
-        request_body = {
-            "model_id": model_id,
-            "transcript": transcript,
-            "voice": voice,
-            "output_format": {
-                "container": output_format["container"],
-                "encoding": output_format["encoding"],
-                "sample_rate": output_format["sample_rate"],
-            },
-            "context_id": context_id,
-            "language": language,
-            "add_timestamps": add_timestamps,
-        }
-
-        if duration is not None:
-            request_body["duration"] = duration
-
         generator = self._websocket_generator(request_body)
 
         if stream:

cartesia-1.1.0.dev0/cartesia/async_tts.py

@@ -0,0 +1,63 @@
+from typing import Iterator, List, Optional
+
+import httpx
+from cartesia._async_sse import _AsyncSSE
+from cartesia._async_websocket import _AsyncWebSocket
+from cartesia._types import OutputFormat, VoiceControls
+from cartesia.tts import TTS
+from cartesia.utils.tts import _construct_tts_request
+
+
+class AsyncTTS(TTS):
+    def __init__(self, api_key, base_url, timeout, get_session):
+        super().__init__(api_key, base_url, timeout)
+        self._get_session = get_session
+        self._sse_class = _AsyncSSE(self._http_url(), self.headers, self.timeout, get_session)
+        self.sse = self._sse_class.send
+
+    async def websocket(self) -> _AsyncWebSocket:
+        ws = _AsyncWebSocket(
+            self._ws_url(),
+            self.api_key,
+            self.cartesia_version,
+            self.timeout,
+            self._get_session,
+        )
+        await ws.connect()
+        return ws
+
+    async def bytes(
+        self,
+        *,
+        model_id: str,
+        transcript: str,
+        output_format: OutputFormat,
+        voice_id: Optional[str] = None,
+        voice_embedding: Optional[List[float]] = None,
+        duration: Optional[int] = None,
+        language: Optional[str] = None,
+        _experimental_voice_controls: Optional[VoiceControls] = None,
+    ) -> bytes:
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
+            voice_embedding=voice_embedding,
+            duration=duration,
+            language=language,
+            _experimental_voice_controls=_experimental_voice_controls,
+        )
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self._http_url()}/tts/bytes",
+                headers=self.headers,
+                timeout=self.timeout,
+                json=request_body,
+            )
+
+        if not response.is_success:
+            raise ValueError(f"Failed to generate audio. Error: {response.text}")
+
+        return response.content

{cartesia-1.0.14 → cartesia-1.1.0.dev0}/cartesia/tts.py

@@ -1,4 +1,6 @@
-from typing import List, Optional
+from typing import Iterator, List, Optional
+
+import httpx
 
 from cartesia._sse import _SSE
 from cartesia._types import (
@@ -9,7 +11,7 @@ from cartesia._types import (
 )
 from cartesia._websocket import _WebSocket
 from cartesia.resource import Resource
-from cartesia.utils.tts import _validate_and_construct_voice
+from cartesia.utils.tts import _construct_tts_request, _validate_and_construct_voice
 
 
 class TTS(Resource):
@@ -34,6 +36,41 @@ class TTS(Resource):
         ws.connect()
         return ws
 
+    def bytes(
+        self,
+        *,
+        model_id: str,
+        transcript: str,
+        output_format: OutputFormat,
+        voice_id: Optional[str] = None,
+        voice_embedding: Optional[List[float]] = None,
+        duration: Optional[int] = None,
+        language: Optional[str] = None,
+        _experimental_voice_controls: Optional[VoiceControls] = None,
+    ) -> bytes:
+        request_body = _construct_tts_request(
+            model_id=model_id,
+            transcript=transcript,
+            output_format=output_format,
+            voice_id=voice_id,
+            voice_embedding=voice_embedding,
+            duration=duration,
+            language=language,
+            _experimental_voice_controls=_experimental_voice_controls,
+        )
+
+        response = httpx.post(
+            f"{self._http_url()}/tts/bytes",
+            headers=self.headers,
+            timeout=self.timeout,
+            json=request_body,
+        )
+
+        if not response.is_success:
+            raise ValueError(f"Failed to generate audio. Error: {response.text}")
+
+        return response.content
+
     @staticmethod
     def get_output_format(output_format_name: str) -> OutputFormat:
         """Convenience method to get the output_format dictionary from a given output format name.

cartesia-1.1.0.dev0/cartesia/utils/tts.py

@@ -0,0 +1,74 @@
+from typing import List, Optional
+
+from cartesia._types import OutputFormat, VoiceControls
+
+
+def _validate_and_construct_voice(
+    voice_id: Optional[str] = None,
+    voice_embedding: Optional[List[float]] = None,
+    experimental_voice_controls: Optional[VoiceControls] = None,
+) -> dict:
+    if voice_id is None and voice_embedding is None:
+        raise ValueError("Either voice_id or voice_embedding must be specified.")
+
+    voice = {}
+
+    if voice_id is not None:
+        voice["id"] = voice_id
+
+    if voice_embedding is not None:
+        voice["embedding"] = voice_embedding
+
+    if experimental_voice_controls is not None:
+        voice["__experimental_controls"] = experimental_voice_controls
+
+    return voice
+
+
+def _construct_tts_request(
+    *,
+    model_id: str,
+    output_format: OutputFormat,
+    transcript: Optional[str] = None,
+    voice_id: Optional[str] = None,
+    voice_embedding: Optional[List[float]] = None,
+    duration: Optional[int] = None,
+    language: Optional[str] = None,
+    add_timestamps: bool = False,
+    context_id: Optional[str] = None,
+    continue_: bool = False,
+    _experimental_voice_controls: Optional[VoiceControls] = None,
+):
+    tts_request = {
+        "model_id": model_id,
+        "voice": _validate_and_construct_voice(
+            voice_id,
+            voice_embedding=voice_embedding,
+            experimental_voice_controls=_experimental_voice_controls,
+        ),
+        "output_format": {
+            "container": output_format["container"],
+            "encoding": output_format["encoding"],
+            "sample_rate": output_format["sample_rate"],
+        },
+    }
+
+    if language is not None:
+        tts_request["language"] = language
+
+    if transcript is not None:
+        tts_request["transcript"] = transcript
+
+    if duration is not None:
+        tts_request["duration"] = duration
+
+    if add_timestamps:
+        tts_request["add_timestamps"] = add_timestamps
+
+    if context_id is not None:
+        tts_request["context_id"] = context_id
+
+    if continue_:
+        tts_request["continue"] = continue_
+
+    return tts_request

cartesia-1.1.0.dev0/cartesia/version.py

@@ -0,0 +1 @@
+__version__ = "1.1.0-dev0"