cartesia 1.3.1__tar.gz → 1.4.0__tar.gz

{cartesia-1.3.1 → cartesia-1.4.0}/PKG-INFO

@@ -1,11 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: cartesia
-Version: 1.3.1
+Version: 1.4.0
 Summary: The official Python library for the Cartesia API.
+License-File: LICENSE.md
 Requires-Python: >=3.9
 Requires-Dist: aiohttp>=3.10.10
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: iterators>=0.2.0
+Requires-Dist: pydub>=0.25.1
 Requires-Dist: requests>=2.31.0
 Requires-Dist: websockets>=10.4
 Description-Content-Type: text/markdown

{cartesia-1.3.1 → cartesia-1.4.0}/cartesia/_types.py

@@ -36,7 +36,6 @@ class VoiceMetadata(TypedDict):
     user_id: str
     created_at: str
     language: str
-    base_voice_id: Optional[str] = None
 
 
 class VoiceControls(TypedDict):
@@ -62,6 +61,7 @@ class OutputFormat(TypedDict):
     container: str
     encoding: str
     sample_rate: int
+    bit_rate: Optional[int] = None
 
 
 class EventType:

{cartesia-1.3.1 → cartesia-1.4.0}/cartesia/_websocket.py

@@ -121,7 +121,7 @@ class _TTSContext:
                         raise RuntimeError(f"Error generating audio:\n{response['error']}")
                     if response["done"]:
                         break
-                    if response["data"]:
+                    if "data" in response and response["data"]:
                         yield self._websocket._convert_response(
                             response=response, include_context_id=True
                         )
@@ -138,7 +138,7 @@ class _TTSContext:
                             raise RuntimeError(f"Error generating audio:\n{response['error']}")
                         if response["done"]:
                             break
-                        if response["data"]:
+                        if "data" in response and response["data"]:
                             yield self._websocket._convert_response(
                                 response=response, include_context_id=True
                             )

cartesia-1.4.0/cartesia/async_tts.py

@@ -0,0 +1,176 @@
+from typing import Iterator, List, Optional, Tuple
+
+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
+
+    async def infill(
+        self,
+        *,
+        model_id: str,
+        language: str,
+        transcript: str,
+        voice_id: str,
+        output_format: OutputFormat,
+        left_audio_path: Optional[str] = None,
+        right_audio_path: Optional[str] = None,
+        experimental_voice_controls: Optional[VoiceControls] = None,
+    ) -> Tuple[bytes, bytes]:
+        """Generate infill audio between two existing audio segments.
+
+        Args:
+            model_id: The ID of the model to use for generating audio
+            language: The language of the transcript
+            transcript: The text to synthesize
+            voice_id: The ID of the voice to use for generating audio
+            output_format: The desired audio output format
+            left_audio_path: Path to the audio file that comes before the infill
+            right_audio_path: Path to the audio file that comes after the infill
+            experimental_voice_controls: Optional voice control parameters
+
+        Returns:
+            A tuple containing:
+            - The generated infill audio (bytes)
+            - The complete concatenated audio (bytes)
+        """
+        if not left_audio_path and not right_audio_path:
+            raise ValueError("Must specify at least one of left_audio_path or right_audio_path")
+
+        headers = self.headers.copy()
+        headers.pop("Content-Type", None)
+
+        left_audio_file = None
+        right_audio_file = None
+        try:
+            files = {}
+            if left_audio_path:
+                left_audio_file = open(left_audio_path, "rb")
+                files["left_audio"] = left_audio_file
+            if right_audio_path:
+                right_audio_file = open(right_audio_path, "rb")
+                files["right_audio"] = right_audio_file
+
+            # Construct form data with output_format fields directly
+            data = {
+                "model_id": model_id,
+                "language": language,
+                "transcript": transcript,
+                "voice_id": voice_id,
+                "output_format[container]": output_format["container"],
+                "output_format[encoding]": output_format["encoding"],
+                "output_format[sample_rate]": output_format["sample_rate"],
+            }
+
+            # Add bit_rate for mp3 container
+            if "bit_rate" in output_format:
+                data["output_format[bit_rate]"] = output_format["bit_rate"]
+
+            # Add voice controls if specified
+            if experimental_voice_controls:
+                if "speed" in experimental_voice_controls:
+                    data["voice[__experimental_controls][speed]"] = experimental_voice_controls[
+                        "speed"
+                    ]
+                if "emotion" in experimental_voice_controls:
+                    # Pass emotions as a list instead of individual values
+                    data["voice[__experimental_controls][emotion][]"] = experimental_voice_controls[
+                        "emotion"
+                    ]
+
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self._http_url()}/infill/bytes",
+                    headers=headers,
+                    timeout=self.timeout,
+                    files=files,
+                    data=data,
+                )
+
+            if not response.is_success:
+                raise ValueError(
+                    f"Failed to infill audio. Status Code: {response.status_code}\n"
+                    f"Error: {response.text}"
+                )
+
+            if left_audio_file:
+                left_audio_file.seek(0)
+                left_audio = left_audio_file.read()
+            else:
+                left_audio = None
+
+            if right_audio_file:
+                right_audio_file.seek(0)
+                right_audio = right_audio_file.read()
+            else:
+                right_audio = None
+
+            infill_audio = response.content
+            format = output_format["container"].lower()
+            total_audio = self._concat_audio_segments(
+                left_audio, infill_audio, right_audio, format=format
+            )
+            return infill_audio, total_audio
+
+        finally:
+            if left_audio_file:
+                left_audio_file.close()
+            if right_audio_file:
+                right_audio_file.close()

cartesia-1.4.0/cartesia/tts.py

@@ -0,0 +1,292 @@
+import json
+from typing import Iterator, List, Optional, Tuple
+
+import httpx
+import io
+from pydub import AudioSegment
+
+from cartesia._sse import _SSE
+from cartesia._types import (
+    OutputFormat,
+    OutputFormatMapping,
+    VoiceControls,
+)
+from cartesia._websocket import _WebSocket
+from cartesia.resource import Resource
+from cartesia.utils.tts import _construct_tts_request, _validate_and_construct_voice
+
+
+class TTS(Resource):
+    """This resource contains methods to generate audio using Cartesia's text-to-speech API."""
+
+    def __init__(self, api_key: str, base_url: str, timeout: float):
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+        )
+        self._sse_class = _SSE(self._http_url(), self.headers, self.timeout)
+        self.sse = self._sse_class.send
+
+    def websocket(self) -> _WebSocket:
+        """This method returns a WebSocket object that can be used to generate audio using WebSocket.
+
+        Returns:
+            _WebSocket: A WebSocket object that can be used to generate audio using WebSocket.
+        """
+        ws = _WebSocket(self._ws_url(), self.api_key, self.cartesia_version)
+        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.
+
+        Args:
+            output_format_name (str): The name of the output format.
+
+        Returns:
+            OutputFormat: A dictionary containing the details of the output format to be passed into tts.sse() or tts.websocket().send()
+
+        Raises:
+            ValueError: If the output_format name is not supported
+        """
+        if output_format_name in OutputFormatMapping._format_mapping:
+            output_format_obj = OutputFormatMapping.get_format(output_format_name)
+        else:
+            raise ValueError(f"Unsupported format: {output_format_name}")
+
+        return OutputFormat(
+            container=output_format_obj["container"],
+            encoding=output_format_obj["encoding"],
+            sample_rate=output_format_obj["sample_rate"],
+        )
+
+    @staticmethod
+    def get_sample_rate(output_format_name: str) -> int:
+        """Convenience method to get the sample rate for a given output format.
+
+        Args:
+            output_format_name (str): The name of the output format.
+
+        Returns:
+            int: The sample rate for the output format.
+
+        Raises:
+            ValueError: If the output_format name is not supported
+        """
+        if output_format_name in OutputFormatMapping._format_mapping:
+            output_format_obj = OutputFormatMapping.get_format(output_format_name)
+        else:
+            raise ValueError(f"Unsupported format: {output_format_name}")
+
+        return output_format_obj["sample_rate"]
+
+    @staticmethod
+    def _validate_and_construct_voice(
+        voice_id: Optional[str] = None,
+        voice_embedding: Optional[List[float]] = None,
+        experimental_voice_controls: Optional[VoiceControls] = None,
+    ) -> dict:
+        """Validate and construct the voice dictionary for the request.
+
+        Args:
+            voice_id: The ID of the voice to use for generating audio.
+            voice_embedding: The embedding of the voice to use for generating audio.
+            experimental_voice_controls: Voice controls for emotion and speed.
+                Note: This is an experimental feature and may rapidly change in the future.
+
+        Returns:
+            A dictionary representing the voice configuration.
+
+        Raises:
+            ValueError: If neither or both voice_id and voice_embedding are specified.
+        """
+        return _validate_and_construct_voice(voice_id, voice_embedding, experimental_voice_controls)
+
+    def infill(
+        self,
+        *,
+        model_id: str,
+        language: str,
+        transcript: str,
+        voice_id: str,
+        output_format: OutputFormat,
+        left_audio_path: Optional[str] = None,
+        right_audio_path: Optional[str] = None,
+        experimental_voice_controls: Optional[VoiceControls] = None,
+    ) -> Tuple[bytes, bytes]:
+        """Generate infill audio between two existing audio segments.
+
+        Args:
+            model_id: The ID of the model to use for generating audio
+            language: The language of the transcript
+            transcript: The text to synthesize
+            voice_id: The ID of the voice to use for generating audio
+            output_format: The desired audio output format
+            left_audio_path: Path to the audio file that comes before the infill
+            right_audio_path: Path to the audio file that comes after the infill
+            experimental_voice_controls: Optional voice control parameters
+
+        Returns:
+            A tuple containing:
+            - The generated infill audio (bytes)
+            - The complete concatenated audio (bytes)
+        """
+        if not left_audio_path and not right_audio_path:
+            raise ValueError("Must specify at least one of left_audio_path or right_audio_path")
+
+        headers = self.headers.copy()
+        headers.pop("Content-Type", None)
+
+        left_audio_file = None
+        right_audio_file = None
+        try:
+            files = {}
+            if left_audio_path:
+                left_audio_file = open(left_audio_path, "rb")
+                files["left_audio"] = left_audio_file
+            if right_audio_path:
+                right_audio_file = open(right_audio_path, "rb")
+                files["right_audio"] = right_audio_file
+
+            # Construct form data with output_format fields directly
+            data = {
+                "model_id": model_id,
+                "language": language,
+                "transcript": transcript,
+                "voice_id": voice_id,
+                "output_format[container]": output_format["container"],
+                "output_format[encoding]": output_format["encoding"],
+                "output_format[sample_rate]": output_format["sample_rate"],
+            }
+
+            # Add bit_rate for mp3 container
+            if "bit_rate" in output_format:
+                data["output_format[bit_rate]"] = output_format["bit_rate"]
+
+            # Add voice controls if specified
+            if experimental_voice_controls:
+                if "speed" in experimental_voice_controls:
+                    data["voice[__experimental_controls][speed]"] = experimental_voice_controls[
+                        "speed"
+                    ]
+                if "emotion" in experimental_voice_controls:
+                    # Pass emotions as a list instead of individual values
+                    data["voice[__experimental_controls][emotion][]"] = experimental_voice_controls[
+                        "emotion"
+                    ]
+
+            response = httpx.post(
+                f"{self._http_url()}/infill/bytes",
+                headers=headers,
+                timeout=self.timeout,
+                files=files,
+                data=data,
+            )
+
+            if not response.is_success:
+                raise ValueError(
+                    f"Failed to infill audio. Status Code: {response.status_code}\n"
+                    f"Error: {response.text}"
+                )
+
+            if left_audio_file:
+                left_audio_file.seek(0)
+                left_audio = left_audio_file.read()
+            else:
+                left_audio = None
+
+            if right_audio_file:
+                right_audio_file.seek(0)
+                right_audio = right_audio_file.read()
+            else:
+                right_audio = None
+
+            infill_audio = response.content
+            format = output_format["container"].lower()
+            total_audio = self._concat_audio_segments(
+                left_audio, infill_audio, right_audio, format=format
+            )
+            return infill_audio, total_audio
+
+        finally:
+            if left_audio_file:
+                left_audio_file.close()
+            if right_audio_file:
+                right_audio_file.close()
+
+    @staticmethod
+    def _concat_audio_segments(
+        left_audio: Optional[bytes],
+        infill_audio: bytes,
+        right_audio: Optional[bytes],
+        format: str = "wav",
+    ) -> bytes:
+        """Helper method to concatenate three audio segments while preserving audio format and headers.
+
+        Args:
+            left_audio: The audio segment that comes before the infill
+            infill_audio: The generated infill audio segment
+            right_audio: The audio segment that comes after the infill
+            format: The audio format (e.g., 'wav', 'mp3'). Defaults to 'wav'
+
+        Returns:
+            bytes: The concatenated audio as bytes
+
+        Raises:
+            ValueError: If the audio segments cannot be loaded or concatenated
+        """
+        try:
+            # Convert bytes to AudioSegment objects
+            combined = AudioSegment.empty()
+            if left_audio:
+                combined += AudioSegment.from_file(io.BytesIO(left_audio), format=format)
+
+            combined += AudioSegment.from_file(io.BytesIO(infill_audio), format=format)
+
+            if right_audio:
+                combined += AudioSegment.from_file(io.BytesIO(right_audio), format=format)
+
+            # Export to bytes
+            output = io.BytesIO()
+            combined.export(output, format=format)
+            return output.getvalue()
+
+        except Exception as e:
+            raise ValueError(f"Failed to concatenate audio segments: {str(e)}")

cartesia-1.4.0/cartesia/version.py

@@ -0,0 +1 @@
+__version__ = "1.4.0"

{cartesia-1.3.1 → cartesia-1.4.0}/cartesia/voices.py

@@ -52,8 +52,7 @@ class Voices(Resource):
 
         if not response.is_success:
             raise ValueError(
-                f"Failed to get voice. Status Code: {response.status_code}\n"
-                f"Error: {response.text}"
+                f"Failed to get voice. Status Code: {response.status_code}\nError: {response.text}"
             )
 
         return response.json()
@@ -123,7 +122,6 @@ class Voices(Resource):
         name: str,
         description: str,
         embedding: List[float],
-        base_voice_id: Optional[str] = None,
         language: str = "en",
     ) -> VoiceMetadata:
         """Create a new voice.
@@ -132,7 +130,6 @@ class Voices(Resource):
             name: The name of the voice.
             description: The description of the voice.
             embedding: The embedding of the voice. This should be generated with :meth:`clone`.
-            base_voice_id: The ID of the base voice. This should be a valid voice ID if specified.
 
         Returns:
             A dictionary containing the voice metadata.
@@ -144,7 +141,6 @@ class Voices(Resource):
                 "name": name,
                 "description": description,
                 "embedding": embedding,
-                "base_voice_id": base_voice_id,
                 "language": language,
             },
             timeout=self.timeout,

{cartesia-1.3.1 → cartesia-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cartesia"
-version = "1.3.1"
+version = "1.4.0"
 description = "The official Python library for the Cartesia API."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -10,6 +10,7 @@ dependencies = [
     "iterators>=0.2.0",
     "requests>=2.31.0",
     "websockets>=10.4",
+    "pydub>=0.25.1",
 ]
 
 [build-system]

{cartesia-1.3.1 → cartesia-1.4.0}/tests/test_tts.py

@@ -126,24 +126,6 @@ def test_create_voice(client: Cartesia):
     client.voices.delete(voice["id"])
 
 
-@pytest.mark.skip(reason="Enable after https://github.com/cartesia-ai/bifrost/pull/847 is deployed")
-def test_create_voice_with_parent(client: Cartesia):
-    logger.info("Testing voices.create with parent")
-    voice = client.voices.create(
-        name="Test Base voice",
-        description="Test base voice description",
-        embedding=np.ones(192).tolist(),
-        base_voice_id=SAMPLE_VOICE_ID,
-    )
-    assert isinstance(voice, dict)
-    assert voice["base_voice_id"] == SAMPLE_VOICE_ID
-
-    get_voice = client.voices.get(voice["id"])
-    assert get_voice["base_voice_id"] == SAMPLE_VOICE_ID
-
-    client.voices.delete(voice["id"])
-
-
 def test_mix_voice(client: Cartesia):
     logger.info("Testing voices.mix")
     output = client.voices.mix(

{cartesia-1.3.1 → cartesia-1.4.0}/uv.lock

@@ -162,12 +162,13 @@ wheels = [
 
 [[package]]
 name = "cartesia"
-version = "1.3.1"
+version = "1.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },
     { name = "httpx" },
     { name = "iterators" },
+    { name = "pydub" },
     { name = "requests" },
     { name = "websockets" },
 ]
@@ -191,6 +192,7 @@ requires-dist = [
     { name = "aiohttp", specifier = ">=3.10.10" },
     { name = "httpx", specifier = ">=0.27.0" },
     { name = "iterators", specifier = ">=0.2.0" },
+    { name = "pydub", specifier = ">=0.25.1" },
     { name = "requests", specifier = ">=2.31.0" },
     { name = "websockets", specifier = ">=10.4" },
 ]
@@ -1029,6 +1031,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
 ]
 
+[[package]]
+name = "pydub"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327 },
+]
+
 [[package]]
 name = "pygments"
 version = "2.18.0"

cartesia-1.3.1/cartesia/async_tts.py

@@ -1,63 +0,0 @@
-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.3.1/cartesia/tts.py

@@ -1,137 +0,0 @@
-from typing import Iterator, List, Optional
-
-import httpx
-
-from cartesia._sse import _SSE
-from cartesia._types import (
-    OutputFormat,
-    OutputFormatMapping,
-    VoiceControls,
-)
-from cartesia._websocket import _WebSocket
-from cartesia.resource import Resource
-from cartesia.utils.tts import _construct_tts_request, _validate_and_construct_voice
-
-
-class TTS(Resource):
-    """This resource contains methods to generate audio using Cartesia's text-to-speech API."""
-
-    def __init__(self, api_key: str, base_url: str, timeout: float):
-        super().__init__(
-            api_key=api_key,
-            base_url=base_url,
-            timeout=timeout,
-        )
-        self._sse_class = _SSE(self._http_url(), self.headers, self.timeout)
-        self.sse = self._sse_class.send
-
-    def websocket(self) -> _WebSocket:
-        """This method returns a WebSocket object that can be used to generate audio using WebSocket.
-
-        Returns:
-            _WebSocket: A WebSocket object that can be used to generate audio using WebSocket.
-        """
-        ws = _WebSocket(self._ws_url(), self.api_key, self.cartesia_version)
-        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.
-
-        Args:
-            output_format_name (str): The name of the output format.
-
-        Returns:
-            OutputFormat: A dictionary containing the details of the output format to be passed into tts.sse() or tts.websocket().send()
-
-        Raises:
-            ValueError: If the output_format name is not supported
-        """
-        if output_format_name in OutputFormatMapping._format_mapping:
-            output_format_obj = OutputFormatMapping.get_format(output_format_name)
-        else:
-            raise ValueError(f"Unsupported format: {output_format_name}")
-
-        return OutputFormat(
-            container=output_format_obj["container"],
-            encoding=output_format_obj["encoding"],
-            sample_rate=output_format_obj["sample_rate"],
-        )
-
-    @staticmethod
-    def get_sample_rate(output_format_name: str) -> int:
-        """Convenience method to get the sample rate for a given output format.
-
-        Args:
-            output_format_name (str): The name of the output format.
-
-        Returns:
-            int: The sample rate for the output format.
-
-        Raises:
-            ValueError: If the output_format name is not supported
-        """
-        if output_format_name in OutputFormatMapping._format_mapping:
-            output_format_obj = OutputFormatMapping.get_format(output_format_name)
-        else:
-            raise ValueError(f"Unsupported format: {output_format_name}")
-
-        return output_format_obj["sample_rate"]
-
-    @staticmethod
-    def _validate_and_construct_voice(
-        voice_id: Optional[str] = None,
-        voice_embedding: Optional[List[float]] = None,
-        experimental_voice_controls: Optional[VoiceControls] = None,
-    ) -> dict:
-        """Validate and construct the voice dictionary for the request.
-
-        Args:
-            voice_id: The ID of the voice to use for generating audio.
-            voice_embedding: The embedding of the voice to use for generating audio.
-            experimental_voice_controls: Voice controls for emotion and speed.
-                Note: This is an experimental feature and may rapidly change in the future.
-
-        Returns:
-            A dictionary representing the voice configuration.
-
-        Raises:
-            ValueError: If neither or both voice_id and voice_embedding are specified.
-        """
-        return _validate_and_construct_voice(voice_id, voice_embedding, experimental_voice_controls)

cartesia-1.3.1/cartesia/version.py

@@ -1 +0,0 @@
-__version__ = "1.3.1"