typecast-python 0.3.9__tar.gz → 0.3.11__tar.gz

{typecast_python-0.3.9 → typecast_python-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typecast-python
-Version: 0.3.9
+Version: 0.3.11
 Summary: Official Typecast Python SDK - Convert text to lifelike speech using AI-powered voices
 Project-URL: Homepage, https://typecast.ai
 Project-URL: Documentation, https://typecast.ai/docs/overview
@@ -227,20 +227,22 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.8
-Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: aiohttp>=3.14.1; python_version >= '3.10'
+Requires-Dist: httpx<1,>=0.28.1; python_version < '3.10'
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: requests>=2.28.0
+Requires-Dist: requests>=2.33.0; python_version >= '3.10'
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: aioresponses>=0.7.6; extra == 'dev'
-Requires-Dist: black<25.0.0,>=23.0.0; extra == 'dev'
+Requires-Dist: black<27.0.0,>=26.3.1; extra == 'dev'
 Requires-Dist: flake8<6.0.0,>=5.0.0; extra == 'dev'
+Requires-Dist: httpx<1.0.0,>=0.28.1; extra == 'dev'
 Requires-Dist: isort>=5.0.0; extra == 'dev'
 Requires-Dist: mypy<1.11.0,>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-asyncio<1.0.0,>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-asyncio<2.0.0,>=1.4.0; extra == 'dev'
 Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == 'dev'
 Requires-Dist: pytest-mock>=3.14.0; extra == 'dev'
-Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'dev'
+Requires-Dist: pytest<10.0.0,>=9.0.3; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <div align="center">

{typecast_python-0.3.9 → typecast_python-0.3.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "typecast-python"
-version = "0.3.9"
+version = "0.3.11"
 description = "Official Typecast Python SDK - Convert text to lifelike speech using AI-powered voices"
 authors = [
     {name = "Neosapience", email = "help@typecast.ai"}
@@ -33,20 +33,22 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "aiohttp>=3.9.0",
-    "requests>=2.28.0",
+    "aiohttp>=3.14.1; python_version >= '3.10'",
+    "requests>=2.33.0; python_version >= '3.10'",
+    "httpx>=0.28.1,<1; python_version < '3.10'",
     "pydantic>=2.0.0",
     "typing-extensions>=4.0.0",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=7.0.0,<9.0.0",
+    "pytest>=9.0.3,<10.0.0",
     "pytest-cov>=5.0.0,<6.0.0",
     "pytest-mock>=3.14.0",
-    "pytest-asyncio>=0.21.0,<1.0.0",
+    "pytest-asyncio>=1.4.0,<2.0.0",
     "aioresponses>=0.7.6",
-    "black>=23.0.0,<25.0.0",
+    "httpx>=0.28.1,<1.0.0",
+    "black>=26.3.1,<27.0.0",
     "flake8>=5.0.0,<6.0.0",
     "mypy>=1.0.0,<1.11.0",
     "isort>=5.0.0",
@@ -90,15 +92,19 @@ multi_line_output = 3
 
 [dependency-groups]
 dev = [
-    "pytest>=7.0.0,<9.0.0",
+    "pytest>=9.0.3,<10.0.0",
     "pytest-cov>=5.0.0,<6.0.0",
     "pytest-mock>=3.14.0",
-    "pytest-asyncio>=0.21.0,<1.0.0",
+    "pytest-asyncio>=1.4.0,<2.0.0",
     "aioresponses>=0.7.6",
-    "python-dotenv>=1.0.0,<2.0.0",
+    "httpx>=0.28.1,<1.0.0",
+    "python-dotenv>=1.2.2,<2.0.0",
     "ruff>=0.14.0",
 ]
 
+[tool.uv]
+environments = ["python_version >= '3.10'"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

typecast_python-0.3.11/src/typecast/_httpx_compat.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple
+
+import httpx
+
+
+def _timeout(value: Any) -> Any:
+    if isinstance(value, ClientTimeout):
+        total = value.total or value.sock_read or 5.0
+        return httpx.Timeout(
+            total, connect=value.connect or value.sock_connect or total
+        )
+    if isinstance(value, tuple):
+        return httpx.Timeout(value[1], connect=value[0])
+    return value
+
+
+def _headers(defaults: Dict[str, str], supplied: Optional[dict]) -> Dict[str, str]:
+    headers = dict(defaults)
+    for key, value in (supplied or {}).items():
+        if value is None:
+            headers.pop(key, None)
+        else:
+            headers[key] = value
+    return headers
+
+
+class RequestsCompatResponse:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    def iter_content(self, chunk_size: int) -> Iterator[bytes]:
+        return self._response.iter_bytes(chunk_size)
+
+    def close(self) -> None:
+        self._response.close()
+
+
+class RequestsCompatSession:
+    def __init__(self, client: Optional[httpx.Client] = None):
+        self._client = client or httpx.Client(timeout=None)
+        self.headers: Dict[str, str] = {}
+
+    def _request(self, method: str, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        stream = kwargs.pop("stream", False)
+        kwargs["headers"] = _headers(self.headers, kwargs.get("headers"))
+        if "timeout" in kwargs:
+            kwargs["timeout"] = _timeout(kwargs["timeout"])
+        if stream:
+            request = self._client.build_request(method, url, **kwargs)
+            response = self._client.send(request, stream=True)
+        else:
+            response = self._client.request(method, url, **kwargs)
+        return RequestsCompatResponse(response)
+
+    def get(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("POST", url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("DELETE", url, **kwargs)
+
+    def close(self) -> None:
+        self._client.close()
+
+
+class ClientTimeout:
+    def __init__(
+        self,
+        *,
+        total: Optional[float] = None,
+        connect: Optional[float] = None,
+        sock_connect: Optional[float] = None,
+        sock_read: Optional[float] = None,
+    ):
+        self.total = total
+        self.connect = connect
+        self.sock_connect = sock_connect
+        self.sock_read = sock_read
+
+
+class FormData:
+    def __init__(self):
+        self.fields: List[Tuple[str, Any, Optional[str], Optional[str]]] = []
+
+    def add_field(
+        self,
+        name: str,
+        value: Any,
+        *,
+        filename: Optional[str] = None,
+        content_type: Optional[str] = None,
+    ) -> None:
+        self.fields.append((name, value, filename, content_type))
+
+
+class _AsyncContent:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    async def iter_chunked(self, chunk_size: int) -> AsyncIterator[bytes]:
+        async for chunk in self._response.aiter_bytes(chunk_size):
+            yield chunk
+
+
+class AiohttpCompatResponse:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self.status = response.status_code
+        self.headers = response.headers
+        self.content = _AsyncContent(response)
+
+    async def read(self) -> bytes:
+        return await self._response.aread()
+
+    async def text(self) -> str:
+        await self._response.aread()
+        return self._response.text
+
+    async def json(self) -> Any:
+        await self._response.aread()
+        return self._response.json()
+
+    async def close(self) -> None:
+        await self._response.aclose()
+
+
+class _AsyncRequestContext:
+    def __init__(self, request: Any):
+        self._request = request
+        self._response: Optional[AiohttpCompatResponse] = None
+
+    async def __aenter__(self) -> AiohttpCompatResponse:
+        response = await self._request
+        self._response = response
+        return response
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        if self._response:
+            await self._response.close()
+
+
+class AiohttpCompatSession:
+    def __init__(
+        self,
+        headers: Optional[dict] = None,
+        client: Optional[httpx.AsyncClient] = None,
+    ):
+        self._client = client or httpx.AsyncClient(timeout=300)
+        self.headers = dict(headers or {})
+
+    async def _request(
+        self, method: str, url: str, **kwargs: Any
+    ) -> AiohttpCompatResponse:
+        kwargs["headers"] = _headers(self.headers, kwargs.get("headers"))
+        if "timeout" in kwargs:
+            kwargs["timeout"] = _timeout(kwargs["timeout"])
+        form = kwargs.get("data")
+        if isinstance(form, FormData):
+            kwargs.pop("data")
+            kwargs["data"] = {
+                name: value
+                for name, value, filename, _ in form.fields
+                if filename is None
+            }
+            kwargs["files"] = [
+                (name, (filename, value, content_type))
+                for name, value, filename, content_type in form.fields
+                if filename is not None
+            ]
+        request = self._client.build_request(method, url, **kwargs)
+        response = await self._client.send(request, stream=True)
+        return AiohttpCompatResponse(response)
+
+    def get(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("GET", url, **kwargs))
+
+    def post(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("POST", url, **kwargs))
+
+    def delete(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("DELETE", url, **kwargs))
+
+    async def close(self) -> None:
+        await self._client.aclose()

{typecast_python-0.3.9 → typecast_python-0.3.11}/src/typecast/_user_agent.py

@@ -2,9 +2,6 @@ import platform
 import sys
 from importlib import metadata
 
-import aiohttp
-import requests
-
 from . import conf
 
 
@@ -55,7 +52,7 @@ def build_user_agent(
 def requests_user_agent(host: str, transport: str = "rest") -> str:
     return build_user_agent(
         mode="sync",
-        http_library=f"requests/{requests.__version__}",
+        http_library=f"requests/{_package_version('requests')}",
         host=host,
         transport=transport,
     )
@@ -64,7 +61,16 @@ def requests_user_agent(host: str, transport: str = "rest") -> str:
 def aiohttp_user_agent(host: str, transport: str = "rest") -> str:
     return build_user_agent(
         mode="async",
-        http_library=f"aiohttp/{aiohttp.__version__}",
+        http_library=f"aiohttp/{_package_version('aiohttp')}",
+        host=host,
+        transport=transport,
+    )
+
+
+def httpx_user_agent(host: str, mode: str, transport: str = "rest") -> str:
+    return build_user_agent(
+        mode=mode,
+        http_library=f"httpx/{_package_version('httpx')}",
         host=host,
         transport=transport,
     )

{typecast_python-0.3.9 → typecast_python-0.3.11}/src/typecast/async_client.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from pathlib import Path
-from typing import AsyncIterator, BinaryIO, Optional, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, BinaryIO, Optional, Union
 from urllib.parse import quote
 
-import aiohttp
+if sys.version_info >= (3, 10):  # pragma: no cover - version-specific import
+    import aiohttp
+else:  # pragma: no cover
+    aiohttp = None  # type: ignore[assignment]
 
 from . import conf
 from ._voice_clone import (
@@ -13,7 +17,10 @@ from ._voice_clone import (
     validate_clone_inputs,
     validate_custom_voice_id,
 )
-from ._user_agent import aiohttp_user_agent
+from ._user_agent import aiohttp_user_agent, httpx_user_agent
+
+if TYPE_CHECKING or sys.version_info < (3, 10):  # pragma: no cover
+    from ._httpx_compat import AiohttpCompatSession, ClientTimeout, FormData
 from .client import _guess_audio_mime
 from .client import _output_with_inferred_format
 from .client import _validate_output_path
@@ -69,7 +76,7 @@ class AsyncTypecast:
         self,
         host: Optional[str] = None,
         api_key: Optional[str] = None,
-        session: Optional[aiohttp.ClientSession] = None,
+        session: Optional[Any] = None,
     ):
         """Initialize the async Typecast client.
 
@@ -91,16 +98,26 @@ class AsyncTypecast:
         if not self.api_key and conf.is_default_host(self.host):
             raise ValueError("API key is required for the default Typecast API host")
         self._owns_session = session is None
-        self.session: Optional[aiohttp.ClientSession] = session
+        self.session: Optional[Any] = session
 
     async def __aenter__(self):
         # When an external session is injected, do not create a new one.
         # Per-request auth headers are attached via _request_headers() on each call.
         if self.session is None:
-            headers = {"User-Agent": aiohttp_user_agent(self.host)}
+            headers = {
+                "User-Agent": (
+                    aiohttp_user_agent(self.host)
+                    if aiohttp
+                    else httpx_user_agent(self.host, "async")
+                )
+            }
             if self.api_key:
                 headers["X-API-KEY"] = self.api_key
-            self.session = aiohttp.ClientSession(headers=headers)
+            self.session = (
+                aiohttp.ClientSession(headers=headers)
+                if aiohttp
+                else AiohttpCompatSession(headers=headers)
+            )
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -247,7 +264,11 @@ class AsyncTypecast:
         if not self.session:
             raise TypecastError("Client session not initialized. Use async with.")
         endpoint = "/v1/text-to-speech/stream"
-        stream_timeout = aiohttp.ClientTimeout(sock_connect=10, sock_read=300)
+        stream_timeout = (
+            aiohttp.ClientTimeout(sock_connect=10, sock_read=300)
+            if aiohttp
+            else ClientTimeout(sock_connect=10, sock_read=300)
+        )
         async with self.session.post(
             f"{self.host}{endpoint}",
             json=request.model_dump(exclude_none=True),
@@ -258,7 +279,9 @@ class AsyncTypecast:
                 error_text = await response.text()
                 self._handle_error(response.status, error_text)
 
-            async for chunk in response.content.iter_chunked(chunk_size):  # pragma: no branch
+            async for chunk in response.content.iter_chunked(
+                chunk_size
+            ):  # pragma: no branch
                 yield chunk
 
     async def text_to_speech_with_timestamps(
@@ -332,7 +355,7 @@ class AsyncTypecast:
         audio_bytes, filename = validate_clone_inputs(audio, name)
         model_str = normalize_clone_model(model)
 
-        form = aiohttp.FormData()
+        form: Any = aiohttp.FormData() if aiohttp else FormData()
         form.add_field("name", name)
         form.add_field("model", model_str)
         form.add_field(
@@ -341,7 +364,11 @@ class AsyncTypecast:
             filename=filename,
             content_type=_guess_audio_mime(filename),
         )
-        timeout = aiohttp.ClientTimeout(total=300, connect=10)
+        timeout = (
+            aiohttp.ClientTimeout(total=300, connect=10)
+            if aiohttp
+            else ClientTimeout(total=300, connect=10)
+        )
         async with self.session.post(
             f"{self.host}/v1/voices/clone",
             data=form,
@@ -367,7 +394,11 @@ class AsyncTypecast:
             raise TypecastError("Client session not initialized; use 'async with'.")
 
         validate_custom_voice_id(voice_id)
-        timeout = aiohttp.ClientTimeout(total=60, connect=10)
+        timeout = (
+            aiohttp.ClientTimeout(total=60, connect=10)
+            if aiohttp
+            else ClientTimeout(total=60, connect=10)
+        )
         async with self.session.delete(
             f"{self.host}/v1/voices/{quote(voice_id, safe='')}",
             timeout=timeout,

{typecast_python-0.3.9 → typecast_python-0.3.11}/src/typecast/client.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import sys
 from pathlib import Path
-from typing import BinaryIO, Iterator, Optional, Union
+from typing import TYPE_CHECKING, Any, BinaryIO, Iterator, Optional, Union
 from urllib.parse import quote
 
-import requests
+if sys.version_info >= (3, 10):  # pragma: no cover - version-specific import
+    import requests
+else:  # pragma: no cover
+    requests = None  # type: ignore[assignment]
 
 from . import conf
 from ._voice_clone import (
@@ -12,7 +16,10 @@ from ._voice_clone import (
     validate_clone_inputs,
     validate_custom_voice_id,
 )
-from ._user_agent import requests_user_agent
+from ._user_agent import httpx_user_agent, requests_user_agent
+
+if TYPE_CHECKING or sys.version_info < (3, 10):  # pragma: no cover
+    from ._httpx_compat import RequestsCompatSession
 from .composer import SpeechComposer
 from .exceptions import (
     BadRequestError,
@@ -103,7 +110,7 @@ class Typecast:
         self,
         host: Optional[str] = None,
         api_key: Optional[str] = None,
-        session: Optional[requests.Session] = None,
+        session: Optional[Any] = None,
     ):
         """Initialize the Typecast client.
 
@@ -124,13 +131,18 @@ class Typecast:
         if not self.api_key and conf.is_default_host(self.host):
             raise ValueError("API key is required for the default Typecast API host")
         self._owns_session = session is None
+        self.session: Any
         if session is not None:
             self.session = session
         else:
-            self.session = requests.Session()
+            self.session = requests.Session() if requests else RequestsCompatSession()
             headers = {
                 "Content-Type": "application/json",
-                "User-Agent": requests_user_agent(self.host),
+                "User-Agent": (
+                    requests_user_agent(self.host)
+                    if requests
+                    else httpx_user_agent(self.host, "sync")
+                ),
             }
             if self.api_key:
                 headers["X-API-KEY"] = self.api_key
@@ -197,10 +209,11 @@ class Typecast:
         if response.status_code != 200:
             self._handle_error(response.status_code, response.text)
 
+        content_type = response.headers.get("Content-Type", "audio/wav").lower()
         return TTSResponse(
             audio_data=response.content,
             duration=response.headers.get("X-Audio-Duration", 0),
-            format=response.headers.get("Content-Type", "audio/wav").split("/")[-1],
+            format="mp3" if "mp3" in content_type or "mpeg" in content_type else "wav",
         )
 
     def compose_speech(self) -> SpeechComposer:
@@ -209,7 +222,23 @@ class Typecast:
         Text passed to ``say()`` may include pause markup such as ``<|0.3s|>``.
         ``pause(seconds)`` also uses seconds, e.g. ``0.3`` for 300 ms.
         """
-        return SpeechComposer(self.text_to_speech)
+        return SpeechComposer(self.compose_text_to_speech)
+
+    def compose_text_to_speech(self, segments: list[dict]) -> TTSResponse:
+        response = self.session.post(
+            f"{self.host}/v1/text-to-speech/compose",
+            json={"segments": segments},
+            headers=self._request_headers(),
+            timeout=(10, 300),
+        )
+        if response.status_code != 200:
+            self._handle_error(response.status_code, response.text)
+        content_type = response.headers.get("Content-Type", "audio/wav").lower()
+        return TTSResponse(
+            audio_data=response.content,
+            duration=response.headers.get("X-Audio-Duration", 0),
+            format="mp3" if "mp3" in content_type or "mpeg" in content_type else "wav",
+        )
 
     def generate_to_file(
         self,

{typecast_python-0.3.9 → typecast_python-0.3.11}/src/typecast/composer.py

@@ -1,10 +1,7 @@
 from __future__ import annotations
 
-import io
 import math
 import re
-import struct
-import wave
 from dataclasses import dataclass
 from typing import Callable, Literal, Optional, Union
 
@@ -31,19 +28,6 @@ class _SpeechPart:
     settings: "_ComposerSettings"
 
 
-@dataclass(frozen=True)
-class _WavSpec:
-    sample_rate: int
-    channels: int
-    sample_width: int
-
-
-@dataclass(frozen=True)
-class _ParsedWav:
-    spec: _WavSpec
-    samples: list[int]
-
-
 @dataclass(frozen=True)
 class _ComposerSettings:
     voice_id: Optional[str] = None
@@ -55,8 +39,8 @@ class _ComposerSettings:
 
 
 class SpeechComposer:
-    def __init__(self, text_to_speech: Callable[[TTSRequest], TTSResponse]):
-        self._text_to_speech = text_to_speech
+    def __init__(self, compose: Callable[[list[dict]], TTSResponse]):
+        self._compose = compose
         self._defaults = _ComposerSettings()
         self._parts: list[Union[_SpeechPart, _PausePart]] = []
 
@@ -124,41 +108,29 @@ class SpeechComposer:
         if not any(isinstance(part, _SpeechPart) for part in plan):
             raise ValueError("at least one speech segment is required")
 
-        output_format = (
-            self._defaults.output.audio_format if self._defaults.output else "wav"
-        )
+        formats = {
+            part.settings.output.audio_format
+            for part in plan
+            if isinstance(part, _SpeechPart)
+            and part.settings.output
+            and part.settings.output.audio_format
+        }
+        if len(formats) > 1:
+            raise ValueError("composed speech segments must use one audio format")
+        output_format = next(iter(formats), "wav")
         if output_format not in ("wav", "mp3"):
-            raise ValueError(f"unsupported composed speech output format: {output_format}")
+            raise ValueError(
+                f"unsupported composed speech output format: {output_format}"
+            )
 
-        wav_spec: Optional[_WavSpec] = None
-        output_samples: list[int] = []
+        segments: list[dict] = []
         for part in plan:
             if isinstance(part, _PausePart):
-                if wav_spec is None:
-                    raise ValueError("pause cannot be the first composed part")
-                output_samples.extend(
-                    [0] * _seconds_to_samples(part.seconds, wav_spec.sample_rate)
-                )
+                segments.append({"type": "pause", "duration_seconds": part.seconds})
                 continue
-
-            request = _settings_to_request(part.text, part.settings)
-            response = self._text_to_speech(request)
-            wav = _parse_wav(response.audio_data)
-            if wav_spec is not None and wav.spec != wav_spec:
-                raise ValueError("all composed WAV segments must use the same PCM format")
-            wav_spec = wav.spec
-            output_samples.extend(_trim_silence(wav.samples))
-
-        final_spec = wav_spec
-        assert final_spec is not None
-        wav_bytes = _encode_wav(output_samples, final_spec)
-        if output_format == "mp3":
-            raise ValueError("ffmpeg is required to encode composed speech as mp3")
-        return TTSResponse(
-            audio_data=wav_bytes,
-            duration=len(output_samples) / final_spec.sample_rate,
-            format="wav",
-        )
+            request = _settings_to_request(part.text, part.settings, output_format)
+            segments.append({"type": "tts", **request.model_dump(exclude_none=True)})
+        return self._compose(segments)
 
     def _build_plan(self) -> list[Union[_SpeechPart, _PausePart]]:
         plan: list[Union[_SpeechPart, _PausePart]] = []
@@ -173,7 +145,9 @@ class SpeechComposer:
                 if not parsed.text.strip():
                     continue
                 if not part.settings.voice_id:
-                    raise ValueError("voice_id is required for composed speech segments")
+                    raise ValueError(
+                        "voice_id is required for composed speech segments"
+                    )
                 if not part.settings.model:
                     raise ValueError("model is required for composed speech segments")
                 plan.append(_SpeechPart(text=parsed.text, settings=part.settings))
@@ -184,10 +158,14 @@ def parse_pause_markup(text: str) -> list[Union[_TextPart, _PausePart]]:
     parts: list[Union[_TextPart, _PausePart]] = []
     last_index = 0
     for match in _PAUSE_TOKEN.finditer(text):
-        if match.start() > last_index:
-            parts.append(_TextPart(kind="text", text=text[last_index : match.start()]))
-        parts.append(_PausePart(kind="pause", seconds=float(match.group(1))))
-        last_index = match.end()
+        seconds = float(match.group(1))
+        if math.isfinite(seconds) and seconds > 0:
+            if match.start() > last_index:
+                parts.append(
+                    _TextPart(kind="text", text=text[last_index : match.start()])
+                )
+            parts.append(_PausePart(kind="pause", seconds=seconds))
+            last_index = match.end()
     if last_index < len(text):
         parts.append(_TextPart(kind="text", text=text[last_index:]))
     return parts
@@ -207,69 +185,33 @@ def _merge_settings(
     )
 
 
-def _merge_output(base: Optional[Output], override: Optional[Output]) -> Optional[Output]:
+def _merge_output(
+    base: Optional[Output], override: Optional[Output]
+) -> Optional[Output]:
     if base is None and override is None:
         return None
-    data = base.model_dump(exclude_none=True, exclude_unset=True) if base is not None else {}
+    data = (
+        base.model_dump(exclude_none=True, exclude_unset=True)
+        if base is not None
+        else {}
+    )
     if override is not None:
         data.update(override.model_dump(exclude_none=True, exclude_unset=True))
     return Output(**data)
 
 
-def _settings_to_request(text: str, settings: _ComposerSettings) -> TTSRequest:
-    output = _merge_output(settings.output, Output(audio_format="wav"))
+def _settings_to_request(
+    text: str, settings: _ComposerSettings, output_format: str
+) -> TTSRequest:
+    output = _merge_output(settings.output, Output(audio_format=output_format))
     return TTSRequest(
         text=text,
         voice_id=settings.voice_id or "",
-        model=settings.model if isinstance(settings.model, TTSModel) else TTSModel(settings.model),
+        model=settings.model
+        if isinstance(settings.model, TTSModel)
+        else TTSModel(settings.model),
         language=settings.language,
         prompt=settings.prompt,
         output=output,
         seed=settings.seed,
     )
-
-
-def _parse_wav(data: bytes) -> _ParsedWav:
-    try:
-        with wave.open(io.BytesIO(data), "rb") as reader:
-            channels = reader.getnchannels()
-            sample_width = reader.getsampwidth()
-            sample_rate = reader.getframerate()
-            if channels != 1 or sample_width != 2:
-                raise ValueError("only mono 16-bit PCM WAV is supported for composed speech")
-            frames = reader.readframes(reader.getnframes())
-    except (EOFError, wave.Error) as exc:
-        raise ValueError("unsupported WAV data") from exc
-    samples = [
-        struct.unpack("<h", frames[offset : offset + 2])[0]
-        for offset in range(0, len(frames), 2)
-    ]
-    return _ParsedWav(
-        spec=_WavSpec(sample_rate=sample_rate, channels=channels, sample_width=sample_width),
-        samples=samples,
-    )
-
-
-def _encode_wav(samples: list[int], spec: _WavSpec) -> bytes:
-    payload = b"".join(struct.pack("<h", sample) for sample in samples)
-    out = io.BytesIO()
-    with wave.open(out, "wb") as writer:
-        writer.setnchannels(spec.channels)
-        writer.setsampwidth(spec.sample_width)
-        writer.setframerate(spec.sample_rate)
-        writer.writeframes(payload)
-    return out.getvalue()
-
-
-def _trim_silence(samples: list[int]) -> list[int]:
-    start = 0
-    end = len(samples)
-    while start < end and samples[start] == 0:
-        start += 1
-    while end > start and samples[end - 1] == 0:
-        end -= 1
-    return samples[start:end]
-
-
-def _seconds_to_samples(seconds: float, sample_rate: int) -> int:
-    return round(seconds * sample_rate)