runapi-gemini-tts 0.1.0__tar.gz

runapi_gemini_tts-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: runapi-gemini-tts
+Version: 0.1.0
+Summary: RunAPI Gemini TTS SDK for multi-speaker speech generation in JavaScript, Python, Ruby, Go, Java, and PHP
+Project-URL: Homepage, https://runapi.ai/models/gemini-tts
+Project-URL: Documentation, https://runapi.ai/docs#sdk-gemini-tts
+Project-URL: Source, https://github.com/runapi-ai/gemini-tts-sdk
+Project-URL: Issues, https://github.com/runapi-ai/gemini-tts-sdk/issues
+Project-URL: Changelog, https://github.com/runapi-ai/gemini-tts-sdk/blob/main/CHANGELOG.md
+Project-URL: Release Notes, https://github.com/runapi-ai/gemini-tts-sdk/releases/tag/python%2Fv0.1.0
+Author-email: RunAPI <contact@runapi.ai>
+License-Expression: Apache-2.0
+Keywords: api,audio,gemini,gemini-tts,golang,google,gradle,java,maven,python,ruby,runapi,runapi-ai,sdk,speech,text-to-speech,typescript
+Requires-Python: >=3.9
+Requires-Dist: runapi-core>=0.2.0
+Description-Content-Type: text/markdown
+
+# Gemini TTS Python SDK for RunAPI
+
+Install `runapi-gemini-tts` for keyword-based multi-speaker speech requests and normalized task responses.
+
+```bash
+pip install runapi-gemini-tts
+```
+
+```python
+from runapi.gemini_tts import GeminiTtsClient
+
+client = GeminiTtsClient()
+result = client.text_to_speech.run(
+    model="gemini-2.5-pro-tts",
+    speakers=[{"speaker_id": "Speaker 1", "voice_name": "Fenrir", "accent": "British (RP)", "style": "Deadpan", "pace": "Natural"}],
+    dialogue_turns=[{"speaker_id": "Speaker 1", "text": "Welcome."}],
+)
+```
+
+See the [model page](https://runapi.ai/models/gemini-tts) and [API reference](https://runapi.ai/docs#gemini-tts). Licensed under Apache-2.0.

runapi_gemini_tts-0.1.0/README.md

@@ -0,0 +1,20 @@
+# Gemini TTS Python SDK for RunAPI
+
+Install `runapi-gemini-tts` for keyword-based multi-speaker speech requests and normalized task responses.
+
+```bash
+pip install runapi-gemini-tts
+```
+
+```python
+from runapi.gemini_tts import GeminiTtsClient
+
+client = GeminiTtsClient()
+result = client.text_to_speech.run(
+    model="gemini-2.5-pro-tts",
+    speakers=[{"speaker_id": "Speaker 1", "voice_name": "Fenrir", "accent": "British (RP)", "style": "Deadpan", "pace": "Natural"}],
+    dialogue_turns=[{"speaker_id": "Speaker 1", "text": "Welcome."}],
+)
+```
+
+See the [model page](https://runapi.ai/models/gemini-tts) and [API reference](https://runapi.ai/docs#gemini-tts). Licensed under Apache-2.0.

runapi_gemini_tts-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runapi-gemini-tts"
+version = "0.1.0"
+description = "RunAPI Gemini TTS SDK for multi-speaker speech generation in JavaScript, Python, Ruby, Go, Java, and PHP"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "RunAPI", email = "contact@runapi.ai" }]
+keywords = ["runapi", "runapi-ai", "gemini-tts", "gemini", "google", "text-to-speech", "speech", "audio", "api", "sdk", "typescript", "python", "ruby", "golang", "java", "maven", "gradle"]
+dependencies = ["runapi-core>=0.2.0"]
+
+[project.urls]
+Homepage = "https://runapi.ai/models/gemini-tts"
+Documentation = "https://runapi.ai/docs#sdk-gemini-tts"
+Source = "https://github.com/runapi-ai/gemini-tts-sdk"
+Issues = "https://github.com/runapi-ai/gemini-tts-sdk/issues"
+Changelog = "https://github.com/runapi-ai/gemini-tts-sdk/blob/main/CHANGELOG.md"
+"Release Notes" = "https://github.com/runapi-ai/gemini-tts-sdk/releases/tag/python%2Fv0.1.0"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runapi"]
+
+[tool.uv]
+package = true
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.runapi]
+slug = "gemini-tts"

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/__init__.py

@@ -0,0 +1,24 @@
+"""Gemini TTS client for RunAPI."""
+
+from runapi.core import (
+    AuthenticationError,
+    InsufficientCreditsError,
+    NotFoundError,
+    RateLimitError,
+    TaskFailedError,
+    TaskTimeoutError,
+    ValidationError,
+)
+
+from .client import GeminiTtsClient
+
+__all__ = [
+    "GeminiTtsClient",
+    "AuthenticationError",
+    "RateLimitError",
+    "InsufficientCreditsError",
+    "NotFoundError",
+    "ValidationError",
+    "TaskFailedError",
+    "TaskTimeoutError",
+]

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/client.py

@@ -0,0 +1,19 @@
+"""Gemini TTS client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import ClientOptions, HttpClient, resolve_api_key
+
+from .resources.text_to_speech import TextToSpeech
+
+
+class GeminiTtsClient:
+    """Client for multi-speaker Gemini TTS generation."""
+
+    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+        resolved_api_key = resolve_api_key(api_key)
+        client_options = ClientOptions(api_key=resolved_api_key, **options)
+        http = client_options.http_client or HttpClient(client_options)
+        self.text_to_speech = TextToSpeech(http)

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/contract_gen.py

@@ -0,0 +1,37 @@
+CONTRACT = {
+    "text-to-speech": {
+        "models": ["gemini-2.5-pro-tts", "gemini-3.1-flash-tts"],
+        "fields_by_model": {
+            "gemini-2.5-pro-tts": {
+                "dialogue_turns": {
+                    "required": True
+                },
+                "model": {
+                    "required": True
+                },
+                "speakers": {
+                    "required": True
+                },
+                "temperature": {
+                    "min": 0,
+                    "max": 2
+                }
+            },
+            "gemini-3.1-flash-tts": {
+                "dialogue_turns": {
+                    "required": True
+                },
+                "model": {
+                    "required": True
+                },
+                "speakers": {
+                    "required": True
+                },
+                "temperature": {
+                    "min": 0,
+                    "max": 2
+                }
+            }
+        }
+    }
+}

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/py.typed

@@ -0,0 +1 @@
+

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/resources/__init__.py

@@ -0,0 +1,5 @@
+"""Gemini TTS resources."""
+
+from .text_to_speech import TextToSpeech
+
+__all__ = ["TextToSpeech"]

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/resources/text_to_speech.py

@@ -0,0 +1,30 @@
+"""Gemini TTS text-to-speech resource."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import Resource, RequestOptions
+
+from ..contract_gen import CONTRACT
+from ..types import AudioTaskResponse, CompletedAudioTaskResponse
+
+
+class TextToSpeech(Resource):
+    """Generate multi-speaker speech from ordered dialogue turns."""
+
+    ENDPOINT = "/api/v1/gemini_tts/text_to_speech"
+    RESPONSE_CLASS = AudioTaskResponse
+    COMPLETED_RESPONSE_CLASS = CompletedAudioTaskResponse
+
+    def run(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        task = self.create(options=options, **params)
+        return self._poll_until_complete(lambda: self.get(task.id, options=options))
+
+    def create(self, options: Optional[RequestOptions] = None, **params: Any) -> Any:
+        compacted = self._compact_params(params)
+        self._validate_contract(CONTRACT["text-to-speech"], compacted)
+        return self._request("post", self.ENDPOINT, body=compacted, options=options)
+
+    def get(self, id: str, options: Optional[RequestOptions] = None) -> Any:
+        return self._request("get", f"{self.ENDPOINT}/{id}", options=options)

runapi_gemini_tts-0.1.0/src/runapi/gemini_tts/types.py

@@ -0,0 +1,18 @@
+"""Gemini TTS response models."""
+
+from runapi.core import BaseModel, TaskResponse, optional, required
+
+
+class Audio(BaseModel):
+    url = required(str)
+
+
+class AudioTaskResponse(TaskResponse):
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+    audios = optional([lambda: Audio])
+    error = optional(str)
+
+
+class CompletedAudioTaskResponse(AudioTaskResponse):
+    audios = required([lambda: Audio])

runapi_gemini_tts-0.1.0/tests/test_client.py

@@ -0,0 +1,91 @@
+import pytest
+
+from runapi.core import config
+from runapi.core.errors import AuthenticationError, ValidationError
+from runapi.gemini_tts import GeminiTtsClient
+from runapi.gemini_tts.resources.text_to_speech import TextToSpeech
+from runapi.gemini_tts.types import CompletedAudioTaskResponse
+
+
+class FakeHttp:
+    def __init__(self, *responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body))
+        return self._responses.pop(0) if self._responses else {"id": "task_1", "status": "processing"}
+
+
+@pytest.fixture(autouse=True)
+def reset_config(monkeypatch):
+    monkeypatch.delenv("RUNAPI_API_KEY", raising=False)
+    monkeypatch.setattr(config, "api_key", None)
+    yield
+
+
+def valid_params():
+    return {
+        "model": "gemini-2.5-pro-tts",
+        "temperature": 0.8,
+        "speakers": [{
+            "speaker_id": "Speaker 1",
+            "voice_name": "Fenrir",
+            "accent": "British (RP)",
+            "style": "Deadpan",
+            "pace": "Natural",
+        }],
+        "dialogue_turns": [{"speaker_id": "Speaker 1", "text": "Welcome."}],
+    }
+
+
+def test_raises_without_api_key():
+    with pytest.raises(AuthenticationError, match="API key is required"):
+        GeminiTtsClient()
+
+
+def test_exposes_text_to_speech_resource():
+    client = GeminiTtsClient(api_key="k", http_client=FakeHttp())
+    assert isinstance(client.text_to_speech, TextToSpeech)
+
+
+def test_create_posts_flat_nested_body():
+    fake = FakeHttp({"id": "task_1", "status": "processing"})
+    client = GeminiTtsClient(api_key="k", http_client=fake)
+    result = client.text_to_speech.create(**valid_params())
+
+    assert fake.calls == [("post", "/api/v1/gemini_tts/text_to_speech", valid_params())]
+    assert result.id == "task_1"
+
+
+def test_get_decodes_audio_results():
+    fake = FakeHttp({
+        "id": "task_1",
+        "status": "completed",
+        "audios": [{"url": "https://tempfile.runapi.ai/dialogue.mp3"}],
+    })
+    client = GeminiTtsClient(api_key="k", http_client=fake)
+    result = client.text_to_speech.get("task_1")
+
+    assert fake.calls == [("get", "/api/v1/gemini_tts/text_to_speech/task_1", None)]
+    assert result.audios[0].url == "https://tempfile.runapi.ai/dialogue.mp3"
+
+
+def test_run_returns_completed_response():
+    fake = FakeHttp(
+        {"id": "task_1", "status": "processing"},
+        {"id": "task_1", "status": "completed", "audios": [{"url": "https://tempfile.runapi.ai/dialogue.mp3"}]},
+    )
+    client = GeminiTtsClient(api_key="k", http_client=fake)
+    result = client.text_to_speech.run(**valid_params())
+
+    assert isinstance(result, CompletedAudioTaskResponse)
+
+
+def test_contract_requires_nested_collections():
+    client = GeminiTtsClient(api_key="k", http_client=FakeHttp())
+    params = valid_params()
+    params.pop("speakers")
+
+    with pytest.raises(ValidationError, match="speakers is required"):
+        client.text_to_speech.create(**params)