cartesia 0.0.0__tar.gz → 0.0.3__tar.gz

cartesia-0.0.3/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cartesia
+Version: 0.0.3
+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
+Requires-Dist: websockets
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: docformatter; extra == "dev"
+Requires-Dist: black==24.1.1; extra == "dev"
+Requires-Dist: isort==5.13.2; extra == "dev"
+Requires-Dist: flake8==7.0.0; extra == "dev"
+Requires-Dist: flake8-bugbear==24.2.6; extra == "dev"
+Requires-Dist: pytest>=8.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pre-commit; extra == "all"
+Requires-Dist: docformatter; extra == "all"
+Requires-Dist: black==24.1.1; extra == "all"
+Requires-Dist: isort==5.13.2; extra == "all"
+Requires-Dist: flake8==7.0.0; extra == "all"
+Requires-Dist: flake8-bugbear==24.2.6; extra == "all"
+Requires-Dist: pytest>=8.0.2; extra == "all"
+Requires-Dist: pytest-cov>=4.1.0; extra == "all"
+
+
+# Cartesia Python API Library
+The official Cartesia Python library which provides convenient access to the Cartesia REST and Websocket API from any Python 3.8+ application.
+
+**Note:** This API is still in alpha. Please expect breaking changes and report any issues you encounter.
+
+## Installation
+```bash
+pip install cartesia
+
+# pip install in editable mode w/ dev dependencies
+pip install -e '.[dev]'
+```
+
+## Usage
+```python
+from cartesia.tts import CartesiaTTS
+import pyaudio
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+p = pyaudio.PyAudio()
+
+stream = None
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    rate = output["sampling_rate"]
+
+    if not stream:
+        stream = p.open(format=pyaudio.paFloat32,
+                        channels=1,
+                        rate=rate,
+                        output=True)
+
+    # Write the audio data to the stream
+    stream.write(buffer)
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+```
+
+If you are using Jupyter Notebook or JupyterLab, you can use IPython.display.Audio to play the generated audio directly in the notebook. Here's an example:
+
+```python
+from cartesia.tts import CartesiaTTS
+from IPython.display import Audio
+import io
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+# Create a BytesIO object to store the audio data
+audio_data = io.BytesIO()
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    audio_data.write(buffer)
+
+# Set the cursor position to the beginning of the BytesIO object
+audio_data.seek(0)
+
+# Create an Audio object from the BytesIO data
+audio = Audio(audio_data, rate=output["sampling_rate"])
+
+# Display the Audio object
+display(audio)
+```
+
+We recommend using [`python-dotenv`](https://pypi.org/project/python-dotenv/) to add `CARTESIA_API_KEY="my-api-key"` to your .env file so that your API Key is not stored in the source code.

cartesia-0.0.3/README.md

@@ -0,0 +1,79 @@
+# Cartesia Python API Library
+The official Cartesia Python library which provides convenient access to the Cartesia REST and Websocket API from any Python 3.8+ application.
+
+**Note:** This API is still in alpha. Please expect breaking changes and report any issues you encounter.
+
+## Installation
+```bash
+pip install cartesia
+
+# pip install in editable mode w/ dev dependencies
+pip install -e '.[dev]'
+```
+
+## Usage
+```python
+from cartesia.tts import CartesiaTTS
+import pyaudio
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+p = pyaudio.PyAudio()
+
+stream = None
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    rate = output["sampling_rate"]
+
+    if not stream:
+        stream = p.open(format=pyaudio.paFloat32,
+                        channels=1,
+                        rate=rate,
+                        output=True)
+
+    # Write the audio data to the stream
+    stream.write(buffer)
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+```
+
+If you are using Jupyter Notebook or JupyterLab, you can use IPython.display.Audio to play the generated audio directly in the notebook. Here's an example:
+
+```python
+from cartesia.tts import CartesiaTTS
+from IPython.display import Audio
+import io
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+# Create a BytesIO object to store the audio data
+audio_data = io.BytesIO()
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    audio_data.write(buffer)
+
+# Set the cursor position to the beginning of the BytesIO object
+audio_data.seek(0)
+
+# Create an Audio object from the BytesIO data
+audio = Audio(audio_data, rate=output["sampling_rate"])
+
+# Display the Audio object
+display(audio)
+```
+
+We recommend using [`python-dotenv`](https://pypi.org/project/python-dotenv/) to add `CARTESIA_API_KEY="my-api-key"` to your .env file so that your API Key is not stored in the source code.

cartesia-0.0.3/cartesia/__init__.py

@@ -0,0 +1,3 @@
+from cartesia.tts import CartesiaTTS
+
+__all__ = ["CartesiaTTS"]

cartesia-0.0.3/cartesia/tts.py

@@ -0,0 +1,309 @@
+import base64
+import json
+import os
+import uuid
+from typing import Any, Dict, Generator, List, Optional, TypedDict, Union
+
+import requests
+from websockets.sync.client import connect
+
+DEFAULT_MODEL_ID = "genial-planet-1346"
+DEFAULT_BASE_URL = "api.cartesia.ai"
+DEFAULT_API_VERSION = "v0"
+
+
+class AudioOutput(TypedDict):
+    audio: bytes
+    sampling_rate: int
+
+
+Embedding = List[float]
+
+
+class VoiceMetadata(TypedDict):
+    id: str
+    name: str
+    description: str
+    embedding: Optional[Embedding]
+
+
+class CartesiaTTS:
+    """The client for Cartesia's text-to-speech library.
+
+    This client contains methods to interact with the Cartesia text-to-speech API.
+    The API offers
+
+    Examples:
+
+        >>> client = CartesiaTTS()
+
+        # Load available voices and their metadata (excluding the embeddings).
+        # Embeddings are fetched with `get_voice_embedding`. This avoids preloading
+        # all of the embeddings, which can be expensive if there are a lot of voices.
+        >>> voices = client.get_voices()
+        >>> embedding = client.get_voice_embedding(voice_id=voices["Milo"]["id"])
+        >>> audio = client.generate(transcript="Hello world!", voice=embedding)
+
+        # Preload all available voices and their embeddings if you plan on reusing
+        # all of the embeddings often.
+        >>> voices = client.get_voices(skip_embeddings=False)
+        >>> embedding = voices["Milo"]["embedding"]
+        >>> audio = client.generate(transcript="Hello world!", voice=embedding)
+
+        # Generate audio stream
+        >>> for audio_chunk in client.generate(transcript="Hello world!", voice=embedding, stream=True):
+        ...     audio, sr = audio_chunk["audio"], audio_chunk["sampling_rate"]
+    """
+
+    def __init__(self, *, api_key: str = None):
+        """
+        Args:
+            api_key: The API key to use for authorization.
+                If not specified, the API key will be read from the environment variable
+                `CARTESIA_API_KEY`.
+        """
+        self.base_url = os.environ.get("CARTESIA_BASE_URL", DEFAULT_BASE_URL)
+        self.api_key = api_key or os.environ.get("CARTESIA_API_KEY")
+        self.api_version = os.environ.get("CARTESIA_API_VERSION", DEFAULT_API_VERSION)
+        self.headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
+        self.websocket = None
+        self.refresh_websocket()
+
+    def get_voices(self, skip_embeddings: bool = True) -> Dict[str, VoiceMetadata]:
+        """Returns a mapping from voice name -> voice metadata.
+
+        Args:
+            skip_embeddings: Whether to skip returning the embeddings.
+                It is recommended to skip if you only want to see what
+                voices are available, since loading embeddings for all your voices can be expensive.
+                You can then use ``get_voice_embedding`` to get the embeddings for the voices you are
+                interested in.
+
+        Returns:
+            A mapping from voice name -> voice metadata.
+
+        Note:
+            If the voice name is not unique, there is undefined behavior as to which
+            voice will correspond to the name. To be more thorough, look at the web
+            client to find the `voice_id` for the voice you are looking for.
+
+        Usage:
+            >>> client = CartesiaTTS()
+            >>> voices = client.get_voices()
+            >>> voices
+                {
+                    "Jane": {
+                        "id": "c1d1d3a8-6f4e-4b3f-8b3e-2e1b3e1b3e1b",
+                        "name": "Jane",
+                }
+            >>> embedding = client.get_voice_embedding(voice_id=voices["Jane"]["id"])
+            >>> audio = client.generate(transcript="Hello world!", voice=embedding)
+        """
+        params = {"select": "id, name, description"} if skip_embeddings else None
+        response = requests.get(f"{self._http_url()}/voices", headers=self.headers, params=params)
+
+        if response.status_code != 200:
+            raise ValueError(f"Failed to get voices. Error: {response.text}")
+
+        voices = response.json()
+        # TODO: Update the API to return the embedding as a list of floats rather than string.
+        if not skip_embeddings:
+            for voice in voices:
+                voice["embedding"] = json.loads(voice["embedding"])
+        return {voice["name"]: voice for voice in voices}
+
+    def get_voice_embedding(
+        self, *, voice_id: str = None, filepath: str = None, link: str = None
+    ) -> Embedding:
+        """Get a voice embedding from voice_id, a filepath or YouTube url.
+
+        Args:
+            voice_id: The voice id.
+            filepath: Path to audio file from which to get the audio.
+            link: The url to get the audio from. Currently only supports youtube shared urls.
+
+        Returns:
+            The voice embedding.
+
+        Raises:
+            ValueError: If more than one of `voice_id`, `filepath` or `link` is specified.
+                Only one should be specified.
+        """
+        if sum(bool(x) for x in (voice_id, filepath, link)) != 1:
+            raise ValueError("Exactly one of `voice_id`, `filepath` or `url` should be specified.")
+
+        if voice_id:
+            url = f"{self._http_url()}/voices/embedding/{voice_id}"
+            response = requests.get(url, headers=self.headers)
+        elif filepath:
+            url = f"{self._http_url()}/voices/clone/clip"
+            files = {"clip": open(filepath, "rb")}
+            headers = self.headers.copy()
+            # The default content type of JSON is incorrect for file uploads
+            headers.pop("Content-Type")
+            response = requests.post(url, headers=headers, files=files)
+        elif link:
+            url = f"{self._http_url()}/voices/clone/url"
+            params = {"link": link}
+            response = requests.post(url, headers=self.headers, params=params)
+
+        if response.status_code != 200:
+            raise ValueError(
+                f"Failed to clone voice. Status Code: {response.status_code}\n"
+                f"Error: {response.text}"
+            )
+
+        # Handle successful response
+        out = response.json()
+        if isinstance(out["embedding"], str):
+            out["embedding"] = json.loads(out["embedding"])
+        return out["embedding"]
+
+    def refresh_websocket(self):
+        """Refresh the websocket connection.
+
+        Note:
+            The connection is synchronous.
+        """
+        if self.websocket and not self._is_websocket_closed():
+            self.websocket.close()
+        self.websocket = connect(
+            f"{self._ws_url()}/audio/websocket?api_key={self.api_key}",
+            close_timeout=None,
+        )
+
+    def _is_websocket_closed(self):
+        return self.websocket.socket.fileno() == -1
+
+    def _check_inputs(
+        self, transcript: str, duration: Optional[float], chunk_time: Optional[float]
+    ):
+        if chunk_time is not None:
+            if chunk_time < 0.1 or chunk_time > 0.5:
+                raise ValueError("`chunk_time` must be between 0.1 and 0.5")
+
+        if chunk_time is not None and duration is not None:
+            if duration < chunk_time:
+                raise ValueError("`duration` must be greater than chunk_time")
+
+        if transcript.strip() == "":
+            raise ValueError("`transcript` must be non empty")
+
+    def generate(
+        self,
+        *,
+        transcript: str,
+        duration: int = None,
+        chunk_time: float = None,
+        voice: Embedding = None,
+        stream: bool = False,
+        websocket: bool = True,
+    ) -> Union[AudioOutput, Generator[AudioOutput, None, None]]:
+        """Generate audio from a transcript.
+
+        Args:
+            transcript: The text to generate audio for.
+            duration: The maximum duration of the audio in seconds.
+            chunk_time: How long each audio segment should be in seconds.
+                This should not need to be adjusted.
+            voice: The voice to use for generating audio.
+                This can either be a voice id (string) or an embedding vector (List[float]).
+            stream: Whether to stream the audio or not.
+                If ``True`` this function returns a generator.
+            websocket: Whether to use a websocket for streaming audio.
+                Using the websocket reduces latency by pre-poning the handshake.
+
+        Returns:
+            A generator if `stream` is True, otherwise a dictionary.
+            Dictionary from both generator and non-generator return types have the following keys:
+                * "audio": The audio as a bytes buffer.
+                * "sampling_rate": The sampling rate of the audio.
+        """
+        self._check_inputs(transcript, duration, chunk_time)
+
+        body = dict(transcript=transcript, model_id=DEFAULT_MODEL_ID)
+
+        optional_body = dict(
+            duration=duration,
+            chunk_time=chunk_time,
+            voice=voice,
+        )
+        body.update({k: v for k, v in optional_body.items() if v is not None})
+
+        if websocket:
+            generator = self._generate_ws(body)
+        else:
+            generator = self._generate_http(body)
+
+        if stream:
+            return generator
+
+        chunks = []
+        sampling_rate = None
+        for chunk in generator:
+            if sampling_rate is None:
+                sampling_rate = chunk["sampling_rate"]
+            chunks.append(chunk["audio"])
+
+        return {"audio": b"".join(chunks), "sampling_rate": sampling_rate}
+
+    def _generate_http(self, body: Dict[str, Any]):
+        response = requests.post(
+            f"{self._http_url()}/audio/stream",
+            stream=True,
+            data=json.dumps(body),
+            headers=self.headers,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to generate audio. {response.text}")
+
+        buffer = ""
+        for chunk_bytes in response.iter_content(chunk_size=None):
+            buffer += chunk_bytes.decode("utf-8")
+            while "{" in buffer and "}" in buffer:
+                start_index = buffer.find("{")
+                end_index = buffer.find("}", start_index)
+                if start_index != -1 and end_index != -1:
+                    try:
+                        chunk_json = json.loads(buffer[start_index : end_index + 1])
+                        audio = base64.b64decode(chunk_json["data"])
+                        yield {"audio": audio, "sampling_rate": chunk_json["sampling_rate"]}
+                        buffer = buffer[end_index + 1 :]
+                    except json.JSONDecodeError:
+                        break
+
+        if buffer:
+            try:
+                chunk_json = json.loads(buffer)
+                audio = base64.b64decode(chunk_json["data"])
+                yield {"audio": audio, "sampling_rate": chunk_json["sampling_rate"]}
+            except json.JSONDecodeError:
+                pass
+
+    def _generate_ws(self, body: Dict[str, Any]):
+        if not self.websocket or self._is_websocket_closed():
+            self.refresh_websocket()
+
+        self.websocket.send(json.dumps({"data": body, "context_id": uuid.uuid4().hex}))
+        try:
+            response = json.loads(self.websocket.recv())
+            while not response["done"]:
+                audio = base64.b64decode(response["data"])
+                # print("timing", time.perf_counter() - start)
+                yield {"audio": audio, "sampling_rate": response["sampling_rate"]}
+
+                response = json.loads(self.websocket.recv())
+        except Exception:
+            raise RuntimeError(f"Failed to generate audio. {response}")
+
+    def _http_url(self):
+        prefix = "http" if "localhost" in self.base_url else "https"
+        return f"{prefix}://{self.base_url}/{self.api_version}"
+
+    def _ws_url(self):
+        prefix = "ws" if "localhost" in self.base_url else "wss"
+        return f"{prefix}://{self.base_url}/{self.api_version}"
+
+    def __del__(self):
+        if self.websocket.socket.fileno() > -1:
+            self.websocket.close()

cartesia-0.0.3/cartesia/version.py

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

cartesia-0.0.3/cartesia.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cartesia
+Version: 0.0.3
+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
+Requires-Dist: websockets
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: docformatter; extra == "dev"
+Requires-Dist: black==24.1.1; extra == "dev"
+Requires-Dist: isort==5.13.2; extra == "dev"
+Requires-Dist: flake8==7.0.0; extra == "dev"
+Requires-Dist: flake8-bugbear==24.2.6; extra == "dev"
+Requires-Dist: pytest>=8.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Provides-Extra: all
+Requires-Dist: pre-commit; extra == "all"
+Requires-Dist: docformatter; extra == "all"
+Requires-Dist: black==24.1.1; extra == "all"
+Requires-Dist: isort==5.13.2; extra == "all"
+Requires-Dist: flake8==7.0.0; extra == "all"
+Requires-Dist: flake8-bugbear==24.2.6; extra == "all"
+Requires-Dist: pytest>=8.0.2; extra == "all"
+Requires-Dist: pytest-cov>=4.1.0; extra == "all"
+
+
+# Cartesia Python API Library
+The official Cartesia Python library which provides convenient access to the Cartesia REST and Websocket API from any Python 3.8+ application.
+
+**Note:** This API is still in alpha. Please expect breaking changes and report any issues you encounter.
+
+## Installation
+```bash
+pip install cartesia
+
+# pip install in editable mode w/ dev dependencies
+pip install -e '.[dev]'
+```
+
+## Usage
+```python
+from cartesia.tts import CartesiaTTS
+import pyaudio
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+p = pyaudio.PyAudio()
+
+stream = None
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    rate = output["sampling_rate"]
+
+    if not stream:
+        stream = p.open(format=pyaudio.paFloat32,
+                        channels=1,
+                        rate=rate,
+                        output=True)
+
+    # Write the audio data to the stream
+    stream.write(buffer)
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+```
+
+If you are using Jupyter Notebook or JupyterLab, you can use IPython.display.Audio to play the generated audio directly in the notebook. Here's an example:
+
+```python
+from cartesia.tts import CartesiaTTS
+from IPython.display import Audio
+import io
+import os
+
+client = CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+voices = client.get_voices()
+voice = client.get_voice_embedding(voice_id=voices["Graham"]["id"])
+transcript = "Hello! Welcome to Cartesia"
+
+# Create a BytesIO object to store the audio data
+audio_data = io.BytesIO()
+
+# Generate and stream audio
+for output in client.generate(transcript=transcript, voice=voice, stream=True):
+    buffer = output["audio"]
+    audio_data.write(buffer)
+
+# Set the cursor position to the beginning of the BytesIO object
+audio_data.seek(0)
+
+# Create an Audio object from the BytesIO data
+audio = Audio(audio_data, rate=output["sampling_rate"])
+
+# Display the Audio object
+display(audio)
+```
+
+We recommend using [`python-dotenv`](https://pypi.org/project/python-dotenv/) to add `CARTESIA_API_KEY="my-api-key"` to your .env file so that your API Key is not stored in the source code.

cartesia-0.0.3/cartesia.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.py
+cartesia/__init__.py
+cartesia/tts.py
+cartesia/version.py
+cartesia.egg-info/PKG-INFO
+cartesia.egg-info/SOURCES.txt
+cartesia.egg-info/dependency_links.txt
+cartesia.egg-info/requires.txt
+cartesia.egg-info/top_level.txt
+tests/test_tts.py

cartesia-0.0.3/cartesia.egg-info/requires.txt

@@ -0,0 +1,22 @@
+websockets
+requests
+
+[all]
+pre-commit
+docformatter
+black==24.1.1
+isort==5.13.2
+flake8==7.0.0
+flake8-bugbear==24.2.6
+pytest>=8.0.2
+pytest-cov>=4.1.0
+
+[dev]
+pre-commit
+docformatter
+black==24.1.1
+isort==5.13.2
+flake8==7.0.0
+flake8-bugbear==24.2.6
+pytest>=8.0.2
+pytest-cov>=4.1.0

cartesia-0.0.3/cartesia.egg-info/top_level.txt

@@ -0,0 +1 @@
+cartesia

cartesia-0.0.3/pyproject.toml

@@ -0,0 +1,11 @@
+[tool.black]
+line-length = 100
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+line_length = 100

cartesia-0.0.3/setup.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import io
+import os
+
+# Note: To use the 'upload' functionality of this file, you must:
+#   $ pipenv install twine --dev
+import shutil
+import subprocess
+import sys
+from distutils.util import convert_path
+from shutil import rmtree
+
+from setuptools import Command, find_packages, setup
+
+PACKAGE_DIR = "cartesia"
+main_ns = {}
+ver_path = convert_path(os.path.join(PACKAGE_DIR, "version.py"))
+with open(ver_path) as ver_file:
+    exec(ver_file.read(), main_ns)
+
+
+# Package meta-data.
+NAME = "cartesia"
+DESCRIPTION = "The official Python library for the Cartesia API."
+URL = ""
+EMAIL = "support@cartesia.ai"
+AUTHOR = "Cartesia, Inc."
+REQUIRES_PYTHON = ">=3.8.0"
+VERSION = main_ns["__version__"]
+
+
+# What packages are required for this module to be executed?
+def get_requirements(path):
+    with open(path, "r") as f:
+        out = f.read().splitlines()
+
+    out = [line.strip() for line in out]
+    return out
+
+
+REQUIRED = get_requirements("requirements.txt")
+REQUIRED_DEV = get_requirements("requirements-dev.txt")
+
+# What packages are optional?
+EXTRAS = {
+    "dev": REQUIRED_DEV,
+}
+EXTRAS["all"] = [pkg for group in EXTRAS.values() for pkg in group]
+
+# The rest you shouldn't have to touch too much :)
+# ------------------------------------------------
+# Except, perhaps the License and Trove Classifiers!
+# If you do change the License, remember to change the Trove Classifier for that!
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+# Import the README and use it as the long-description.
+# Note: this will only work if 'README.md' is present in your MANIFEST.in file!
+try:
+    with io.open(os.path.join(here, "README.md"), encoding="utf-8") as f:
+        long_description = "\n" + f.read()
+except FileNotFoundError:
+    long_description = DESCRIPTION
+
+# Load the package's __version__.py module as a dictionary.
+about = {}
+if not VERSION:
+    project_slug = NAME.lower().replace("-", "_").replace(" ", "_")
+    with open(os.path.join(here, project_slug, "__version__.py")) as f:
+        exec(f.read(), about)
+else:
+    about["__version__"] = VERSION
+
+
+class UploadCommand(Command):
+    """Support setup.py upload."""
+
+    description = "Build and publish the package."
+    user_options = []
+
+    @staticmethod
+    def status(s):
+        """Prints things in bold."""
+        print("\033[1m{0}\033[0m".format(s))
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        try:
+            self.status("Removing previous builds…")
+            rmtree(os.path.join(here, "dist"))
+        except OSError:
+            pass
+
+        self.status("Building Source and Wheel (universal) distribution…")
+        os.system("{0} setup.py sdist bdist_wheel --universal".format(sys.executable))
+
+        self.status("Uploading the package to PyPI via Twine…")
+        os.system("twine upload dist/*")
+
+        self.status("Pushing git tags…")
+        os.system("git tag v{0}".format(about["__version__"]))
+        os.system("git push --tags")
+
+        sys.exit()
+
+
+class BumpVersionCommand(Command):
+    """
+    To use: python setup.py bumpversion -v <version>
+
+    This command will push the new version directly and tag it.
+    """
+
+    description = "Installs the foo."
+    user_options = [
+        ("version=", "v", "the new version number"),
+    ]
+
+    @staticmethod
+    def status(s):
+        """Prints things in bold."""
+        print("\033[1m{0}\033[0m".format(s))
+
+    def initialize_options(self):
+        self.version = None
+
+    def finalize_options(self):
+        # This package cannot be imported at top level because it
+        # is not recognized by Github Actions.
+        from packaging import version
+
+        if self.version is None:
+            raise ValueError("Please specify a version number.")
+
+        current_version = about["__version__"]
+        if not version.Version(self.version) > version.Version(current_version):
+            raise ValueError(
+                f"New version ({self.version}) must be greater than "
+                f"current version ({current_version})."
+            )
+
+    def _undo(self):
+        os.system(f"git restore --staged {PACKAGE_DIR}/__init__.py")
+        os.system(f"git checkout -- {PACKAGE_DIR}/__init__.py")
+
+    def run(self):
+        current_version = about["__version__"]
+
+        self.status("Checking current branch is 'main'")
+        current_branch = get_git_branch()
+        if current_branch != "main":
+            raise RuntimeError(
+                "You can only bump the version from the 'main' branch. "
+                "You are currently on the '{}' branch.".format(current_branch)
+            )
+
+        self.status("Pulling latest changes from origin")
+        err_code = os.system("git pull")
+        if err_code != 0:
+            raise RuntimeError("Failed to pull from origin.")
+
+        self.status("Checking working directory is clean")
+        err_code = os.system("git diff --exit-code")
+        err_code += os.system("git diff --cached --exit-code")
+        if err_code != 0:
+            raise RuntimeError("Working directory is not clean.")
+
+        # TODO: Add check to see if all tests are passing on main.
+
+        # Change the version in __init__.py
+        self.status(f"Updating version {current_version} -> {self.version}")
+        update_version(self.version)
+        if current_version != self.version:
+            self._undo()
+            raise RuntimeError("Failed to update version.")
+
+        self.status(f"Adding {PACKAGE_DIR}/__init__.py to git")
+        err_code = os.system(f"git add {PACKAGE_DIR}/__init__.py")
+        if err_code != 0:
+            self._undo()
+            raise RuntimeError("Failed to add file to git.")
+
+        # Commit the file with a message '[bumpversion] v<version>'.
+        self.status(f"Commit with message '[bumpversion] v{self.version}'")
+        err_code = os.system("git commit -m '[bumpversion] v{}'".format(current_version))
+        if err_code != 0:
+            self._undo()
+            raise RuntimeError("Failed to commit file to git.")
+
+        # Push the commit to origin.
+        # self.status("Pushing commit to origin")
+        # err_code = os.system("git push")
+        # if err_code != 0:
+        #     # TODO: undo the commit automatically.
+        #     raise RuntimeError("Failed to push commit to origin.")
+
+        sys.exit()
+
+
+def update_version(version):
+    import json
+
+    # Update python.
+    init_py = [
+        line if not line.startswith("__version__") else f'__version__ = "{version}"\n'
+        for line in open(ver_path, "r").readlines()
+    ]
+    with open(ver_path, "w") as f:
+        f.writelines(init_py)
+
+
+def get_git_branch():
+    """Return the name of the current branch."""
+    proc = subprocess.Popen(["git branch"], stdout=subprocess.PIPE, shell=True)
+    (out, err) = proc.communicate()
+    if err is not None:
+        raise RuntimeError(f"Error finding git branch: {err}")
+    out = out.decode("utf-8").split("\n")
+    current_branch = [line for line in out if line.startswith("*")][0]
+    current_branch = current_branch.replace("*", "").strip()
+    return current_branch
+
+
+# Where the magic happens:
+setup(
+    name=NAME,
+    version=about["__version__"],
+    description=DESCRIPTION,
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author=AUTHOR,
+    author_email=EMAIL,
+    python_requires=REQUIRES_PYTHON,
+    url=URL,
+    packages=[PACKAGE_DIR],
+    install_requires=REQUIRED,
+    extras_require=EXTRAS,
+    include_package_data=True,
+    classifiers=[
+        # Trove classifiers
+        # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    # $ setup.py publish support.
+    cmdclass={"upload": UploadCommand, "bumpversion": BumpVersionCommand},
+)

cartesia-0.0.3/tests/test_tts.py

@@ -0,0 +1,133 @@
+"""Test against the production Cartesia TTS API.
+
+This test suite tries to be as general as possible because different keys
+will lead to different results. Therefore, we cannot test for complete correctness
+but rather for general correctness.
+"""
+
+import os
+from typing import Dict, Generator
+
+import pytest
+
+from cartesia.tts import CartesiaTTS, VoiceMetadata
+
+SAMPLE_VOICE = "Milo"
+
+
+class _Resources:
+    def __init__(self, *, client: CartesiaTTS, voices: Dict[str, VoiceMetadata]):
+        self.client = client
+        self.voices = voices
+
+
+@pytest.fixture(scope="session")
+def client():
+    return CartesiaTTS(api_key=os.environ.get("CARTESIA_API_KEY"))
+
+
+@pytest.fixture(scope="session")
+def resources(client: CartesiaTTS):
+    voices = client.get_voices()
+    voice_id = voices[SAMPLE_VOICE]["id"]
+    voices[SAMPLE_VOICE]["embedding"] = client.get_voice_embedding(voice_id=voice_id)
+
+    return _Resources(
+        client=client,
+        voices=voices,
+    )
+
+
+def test_get_voices(client: CartesiaTTS):
+    voices = client.get_voices()
+
+    assert isinstance(voices, dict)
+    assert all(isinstance(key, str) for key in voices.keys())
+    ids = [voice["id"] for voice in voices.values()]
+    assert len(ids) == len(set(ids)), "All ids must be unique"
+    assert all(
+        key == voice["name"] for key, voice in voices.items()
+    ), "The key must be the same as the name"
+
+
+def test_get_voice_embedding_from_id(client: CartesiaTTS):
+    voices = client.get_voices()
+    voice_id = voices[SAMPLE_VOICE]["id"]
+
+    client.get_voice_embedding(voice_id=voice_id)
+
+
+def test_get_voice_embedding_from_url(client: CartesiaTTS):
+    url = "https://youtu.be/g2Z7Ddd573M?si=P8BM_hBqt5P8Ft6I&t=69"
+    _ = client.get_voice_embedding(link=url)
+
+
+@pytest.mark.parametrize("websocket", [True, False])
+def test_generate(resources: _Resources, websocket: bool):
+    client = resources.client
+    voices = resources.voices
+    embedding = voices[SAMPLE_VOICE]["embedding"]
+    transcript = "Hello, world!"
+
+    output = client.generate(transcript=transcript, voice=embedding, websocket=websocket)
+    assert output.keys() == {"audio", "sampling_rate"}
+    assert isinstance(output["audio"], bytes)
+    assert isinstance(output["sampling_rate"], int)
+
+
+@pytest.mark.parametrize("websocket", [True, False])
+def test_generate_stream(resources: _Resources, websocket: bool):
+    client = resources.client
+    voices = resources.voices
+    embedding = voices[SAMPLE_VOICE]["embedding"]
+    transcript = "Hello, world!"
+
+    generator = client.generate(
+        transcript=transcript, voice=embedding, websocket=websocket, stream=True
+    )
+    assert isinstance(generator, Generator)
+
+    for output in generator:
+        assert output.keys() == {"audio", "sampling_rate"}
+        assert isinstance(output["audio"], bytes)
+        assert isinstance(output["sampling_rate"], int)
+
+
+@pytest.mark.parametrize("chunk_time", [0.05, 0.6])
+def test_check_inputs_invalid_chunk_time(client: CartesiaTTS, chunk_time):
+    with pytest.raises(ValueError, match="`chunk_time` must be between 0.1 and 0.5"):
+        client._check_inputs("Test", None, chunk_time)
+
+
+@pytest.mark.parametrize("chunk_time", [0.1, 0.3, 0.5])
+def test_check_inputs_valid_chunk_time(client, chunk_time):
+    try:
+        client._check_inputs("Test", None, chunk_time)
+    except ValueError:
+        pytest.fail("Unexpected ValueError raised")
+
+
+def test_check_inputs_duration_less_than_chunk_time(client: CartesiaTTS):
+    with pytest.raises(ValueError, match="`duration` must be greater than chunk_time"):
+        client._check_inputs("Test", 0.2, 0.3)
+
+
+@pytest.mark.parametrize("duration,chunk_time", [(0.5, 0.2), (1.0, 0.5), (2.0, 0.1)])
+def test_check_inputs_valid_duration_and_chunk_time(client: CartesiaTTS, duration, chunk_time):
+    try:
+        client._check_inputs("Test", duration, chunk_time)
+    except ValueError:
+        pytest.fail("Unexpected ValueError raised")
+
+
+def test_check_inputs_empty_transcript(client: CartesiaTTS):
+    with pytest.raises(ValueError, match="`transcript` must be non empty"):
+        client._check_inputs("", None, None)
+
+
+@pytest.mark.parametrize("transcript", ["Hello", "Test transcript", "Lorem ipsum dolor sit amet"])
+def test_check_inputs_valid_transcript(client: CartesiaTTS, transcript):
+    try:
+        client._check_inputs(transcript, None, None)
+    except ValueError:
+        pytest.fail("Unexpected ValueError raised")

cartesia-0.0.0/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.1
-Name: cartesia
-Version: 0.0.0
-Summary: Library for the Cartesia API.
-Author: Kabir Goel
-Author-email: kabir@cartesia.ai
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6

cartesia-0.0.0/cartesia.egg-info/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.1
-Name: cartesia
-Version: 0.0.0
-Summary: Library for the Cartesia API.
-Author: Kabir Goel
-Author-email: kabir@cartesia.ai
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6

cartesia-0.0.0/cartesia.egg-info/SOURCES.txt

@@ -1,5 +0,0 @@
-setup.py
-cartesia.egg-info/PKG-INFO
-cartesia.egg-info/SOURCES.txt
-cartesia.egg-info/dependency_links.txt
-cartesia.egg-info/top_level.txt

cartesia-0.0.0/cartesia.egg-info/top_level.txt

@@ -1 +0,0 @@
-

cartesia-0.0.0/setup.py

@@ -1,17 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='cartesia',
-    version='0.0.0',
-    author='Kabir Goel',
-    author_email='kabir@cartesia.ai',
-    description='Library for the Cartesia API.',
-    packages=find_packages(),
-    classifiers=[
-    'Programming Language :: Python :: 3',
-    'License :: OSI Approved :: MIT License',
-    'Operating System :: OS Independent',
-    ],
-    python_requires='>=3.6',
-)
-