audiopod 1.4.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

audiopod/resources/transcription.py

@@ -0,0 +1,205 @@
+"""
+Transcription Service - Speech-to-Text
+"""
+
+import time
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+POLL_INTERVAL = 3  # seconds
+DEFAULT_TIMEOUT = 600  # 10 minutes
+
+
+class Transcription:
+    """Speech-to-text transcription service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        url: Optional[str] = None,
+        urls: Optional[List[str]] = None,
+        language: Optional[str] = None,
+        speaker_diarization: bool = False,
+        min_speakers: Optional[int] = None,
+        max_speakers: Optional[int] = None,
+        word_timestamps: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Create a transcription job from URL(s).
+
+        Args:
+            url: Single URL to transcribe
+            urls: List of URLs to transcribe
+            language: Language code (ISO 639-1). Auto-detected if not specified
+            speaker_diarization: Enable speaker diarization
+            min_speakers: Minimum number of speakers (hint for diarization)
+            max_speakers: Maximum number of speakers (hint for diarization)
+            word_timestamps: Enable word-level timestamps
+
+        Returns:
+            Job object with id and status
+
+        Example:
+            >>> job = client.transcription.create(
+            ...     url="https://youtube.com/watch?v=...",
+            ...     speaker_diarization=True,
+            ... )
+        """
+        source_urls = urls or ([url] if url else [])
+        if not source_urls:
+            raise ValueError("At least one URL is required")
+
+        return self._client.post(
+            "/api/v1/transcribe/transcribe",
+            json_data={
+                "source_urls": source_urls,
+                "language": language,
+                "enable_speaker_diarization": speaker_diarization,
+                "min_speakers": min_speakers,
+                "max_speakers": max_speakers,
+                "enable_word_timestamps": word_timestamps,
+            },
+        )
+
+    def upload(
+        self,
+        file_path: str,
+        *,
+        language: Optional[str] = None,
+        speaker_diarization: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Upload a file for transcription.
+
+        Args:
+            file_path: Path to the audio file
+            language: Language code (ISO 639-1)
+            speaker_diarization: Enable speaker diarization
+
+        Returns:
+            Job object with id and status
+        """
+        return self._client.upload(
+            "/api/v1/transcribe/transcribe-upload",
+            file_path,
+            field_name="files",
+            additional_fields={
+                "language": language,
+                "enable_speaker_diarization": speaker_diarization,
+            },
+        )
+
+    def get(self, job_id: int) -> Dict[str, Any]:
+        """Get a transcription job by ID."""
+        return self._client.get(f"/api/v1/transcribe/jobs/{job_id}")
+
+    def list(
+        self,
+        *,
+        skip: int = 0,
+        limit: int = 50,
+        status: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List transcription jobs."""
+        return self._client.get(
+            "/api/v1/transcribe/jobs",
+            params={"offset": skip, "limit": limit, "status": status},
+        )
+
+    def delete(self, job_id: int) -> None:
+        """Delete a transcription job."""
+        self._client.delete(f"/api/v1/transcribe/jobs/{job_id}")
+
+    def get_transcript(
+        self, job_id: int, format: str = "json"
+    ) -> Any:
+        """
+        Get transcript content.
+
+        Args:
+            job_id: Job ID
+            format: Output format ('json', 'txt', 'srt', 'vtt')
+        """
+        return self._client.get(
+            f"/api/v1/transcribe/jobs/{job_id}/transcript",
+            params={"format": format},
+        )
+
+    def wait_for_completion(
+        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
+    ) -> Dict[str, Any]:
+        """
+        Wait for a transcription job to complete.
+
+        Args:
+            job_id: Job ID to wait for
+            timeout: Maximum time to wait in seconds
+
+        Returns:
+            Completed job object
+
+        Raises:
+            TimeoutError: If job doesn't complete within timeout
+            RuntimeError: If job fails
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get(job_id)
+            status = job.get("status", "")
+
+            if status == "COMPLETED":
+                return job
+            if status == "FAILED":
+                raise RuntimeError(
+                    f"Transcription failed: {job.get('error_message', 'Unknown error')}"
+                )
+            if status == "CANCELLED":
+                raise RuntimeError("Transcription was cancelled")
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"Transcription timed out after {timeout}s")
+
+    def transcribe(
+        self,
+        *,
+        url: Optional[str] = None,
+        urls: Optional[List[str]] = None,
+        language: Optional[str] = None,
+        speaker_diarization: bool = False,
+        min_speakers: Optional[int] = None,
+        max_speakers: Optional[int] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Create and wait for transcription to complete.
+
+        This is a convenience method that combines create() and wait_for_completion().
+
+        Example:
+            >>> result = client.transcription.transcribe(
+            ...     url="https://youtube.com/watch?v=...",
+            ...     speaker_diarization=True,
+            ... )
+            >>> print(result["detected_language"])
+        """
+        job = self.create(
+            url=url,
+            urls=urls,
+            language=language,
+            speaker_diarization=speaker_diarization,
+            min_speakers=min_speakers,
+            max_speakers=max_speakers,
+        )
+        job_id = job.get("id") or job.get("job_id")
+        return self.wait_for_completion(job_id, timeout=timeout)
+
+
+
+

audiopod/resources/voice.py

@@ -0,0 +1,139 @@
+"""
+Voice Service - Voice Cloning & Text-to-Speech
+"""
+
+import time
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+POLL_INTERVAL = 2  # seconds
+DEFAULT_TIMEOUT = 300  # 5 minutes
+
+
+class Voice:
+    """Voice cloning and text-to-speech service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def list(self) -> List[Dict[str, Any]]:
+        """List all available voices."""
+        return self._client.get("/api/v1/voice/voices")
+
+    def get(self, voice_id: int) -> Dict[str, Any]:
+        """Get a voice by ID."""
+        return self._client.get(f"/api/v1/voice/voices/{voice_id}")
+
+    def create(
+        self,
+        name: str,
+        audio_file: str,
+        *,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new voice clone.
+
+        Args:
+            name: Name for the voice
+            audio_file: Path to audio sample file
+            description: Optional description
+
+        Returns:
+            Created voice object
+
+        Example:
+            >>> voice = client.voice.create(
+            ...     name="My Voice",
+            ...     audio_file="./sample.mp3",
+            ... )
+        """
+        return self._client.upload(
+            "/api/v1/voice/voices",
+            audio_file,
+            field_name="audio_file",
+            additional_fields={"name": name, "description": description},
+        )
+
+    def delete(self, voice_id: int) -> None:
+        """Delete a voice."""
+        self._client.delete(f"/api/v1/voice/voices/{voice_id}")
+
+    def speak(
+        self,
+        text: str,
+        voice_id: int,
+        *,
+        speed: float = 1.0,
+    ) -> Dict[str, Any]:
+        """
+        Generate speech from text.
+
+        Args:
+            text: Text to convert to speech
+            voice_id: Voice ID to use
+            speed: Speech speed (0.5 to 2.0)
+
+        Returns:
+            TTS job object
+        """
+        return self._client.post(
+            "/api/v1/voice/tts/generate",
+            json_data={
+                "text": text,
+                "voice_id": voice_id,
+                "speed": speed,
+            },
+        )
+
+    def get_job(self, job_id: int) -> Dict[str, Any]:
+        """Get TTS job status."""
+        return self._client.get(f"/api/v1/voice/tts/status/{job_id}")
+
+    def wait_for_completion(
+        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
+    ) -> Dict[str, Any]:
+        """Wait for TTS job to complete."""
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get_job(job_id)
+            status = job.get("status", "")
+
+            if status == "COMPLETED":
+                return job
+            if status == "FAILED":
+                raise RuntimeError(
+                    f"TTS generation failed: {job.get('error_message', 'Unknown error')}"
+                )
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"TTS generation timed out after {timeout}s")
+
+    def generate(
+        self,
+        text: str,
+        voice_id: int,
+        *,
+        speed: float = 1.0,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Generate speech and wait for completion.
+
+        Example:
+            >>> result = client.voice.generate(
+            ...     text="Hello, world!",
+            ...     voice_id=123,
+            ... )
+            >>> print(result["output_url"])
+        """
+        job = self.speak(text, voice_id, speed=speed)
+        return self.wait_for_completion(job["id"], timeout=timeout)
+
+
+
+

audiopod/resources/wallet.py

@@ -0,0 +1,110 @@
+"""
+Wallet Service - API Wallet & Billing
+"""
+
+from typing import Optional, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+
+class Wallet:
+    """API wallet and billing service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def get_balance(self) -> Dict[str, Any]:
+        """
+        Get current wallet balance.
+
+        Returns:
+            Balance information including balance_cents, balance_usd, etc.
+
+        Example:
+            >>> balance = client.wallet.get_balance()
+            >>> print(f"Balance: {balance['balance_usd']}")
+        """
+        return self._client.get("/api/v1/api-wallet/balance")
+
+    def get_usage(
+        self,
+        *,
+        page: int = 1,
+        limit: int = 50,
+        api_key_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get usage history.
+
+        Args:
+            page: Page number
+            limit: Items per page
+            api_key_id: Filter by specific API key
+        """
+        return self._client.get(
+            "/api/v1/api-wallet/usage",
+            params={"page": page, "limit": limit, "api_key_id": api_key_id},
+        )
+
+    def get_pricing(self) -> Dict[str, Any]:
+        """
+        Get pricing information for all services.
+
+        Returns:
+            Pricing table with rates per service
+        """
+        return self._client.get("/api/v1/api-wallet/pricing")
+
+    def estimate_cost(
+        self, service_type: str, duration_seconds: int
+    ) -> Dict[str, Any]:
+        """
+        Estimate cost for an operation.
+
+        Args:
+            service_type: Service type (e.g., 'transcription', 'stem_extraction')
+            duration_seconds: Duration in seconds
+
+        Returns:
+            Cost estimate with cost_cents and cost_usd
+
+        Example:
+            >>> estimate = client.wallet.estimate_cost(
+            ...     service_type="transcription",
+            ...     duration_seconds=3600,
+            ... )
+            >>> print(f"Estimated cost: {estimate['cost_usd']}")
+        """
+        return self._client.post(
+            "/api/v1/api-wallet/estimate",
+            json_data={
+                "service_type": service_type,
+                "duration_seconds": duration_seconds,
+            },
+        )
+
+    def check_balance(
+        self, service_type: str, duration_seconds: int
+    ) -> Dict[str, Any]:
+        """
+        Check if balance is sufficient for an operation.
+
+        Args:
+            service_type: Service type
+            duration_seconds: Duration in seconds
+
+        Returns:
+            Object with 'sufficient' boolean and cost details
+        """
+        return self._client.post(
+            "/api/v1/api-wallet/check-balance",
+            json_data={
+                "service_type": service_type,
+                "duration_seconds": duration_seconds,
+            },
+        )
+
+
+
+

audiopod-2.1.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: audiopod
+Version: 2.1.0
+Summary: Official AudioPod SDK for Python - Professional Audio Processing powered by AI
+Author-email: AudioPod AI <support@audiopod.ai>
+License: MIT
+Project-URL: Homepage, https://audiopod.ai
+Project-URL: Documentation, https://docs.audiopod.ai
+Project-URL: Repository, https://github.com/AudiopodAI/audiopod-sdk-python
+Project-URL: Issues, https://github.com/AudiopodAI/audiopod-sdk-python/issues
+Keywords: audiopod,audio,ai,speech-to-text,transcription,text-to-speech,tts,voice-cloning,music-generation,stem-separation,denoiser,speaker-diarization
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.28.0; extra == "dev"
+Dynamic: license-file
+
+# AudioPod Python SDK
+
+Official Python SDK for [AudioPod AI](https://audiopod.ai) - Professional Audio Processing powered by AI.
+
+[![PyPI version](https://badge.fury.io/py/audiopod.svg)](https://pypi.org/project/audiopod/)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install audiopod
+```
+
+## Quick Start
+
+```python
+from audiopod import AudioPod
+
+# Initialize client
+client = AudioPod(api_key="ap_your_api_key")
+
+# Separate audio into 6 stems
+result = client.stems.separate(
+    url="https://youtube.com/watch?v=VIDEO_ID",
+    mode="six"
+)
+
+# Download stems
+for stem, url in result["download_urls"].items():
+    print(f"{stem}: {url}")
+```
+
+## Stem Separation
+
+Extract individual audio components from mixed recordings.
+
+### Available Modes
+
+| Mode | Stems | Output |
+|------|-------|--------|
+| `single` | 1 | Specified stem only (vocals, drums, bass, guitar, piano, other) |
+| `two` | 2 | Vocals + Instrumental |
+| `four` | 4 | Vocals, Drums, Bass, Other |
+| `six` | 6 | Vocals, Drums, Bass, Guitar, Piano, Other |
+| `producer` | 8 | + Kick, Snare, Hihat |
+| `studio` | 12 | Full production toolkit |
+| `mastering` | 16 | Maximum detail |
+
+### Examples
+
+```python
+from audiopod import AudioPod
+
+client = AudioPod(api_key="ap_your_api_key")
+
+# Six-stem separation from YouTube
+job = client.stems.extract(
+    url="https://youtube.com/watch?v=VIDEO_ID",
+    mode="six"
+)
+print(f"Job ID: {job['id']}")
+
+# Wait for completion
+result = client.stems.wait_for_completion(job["id"])
+print(result["download_urls"])
+
+# Or use the convenience method (extract + wait)
+result = client.stems.separate(
+    url="https://youtube.com/watch?v=VIDEO_ID",
+    mode="six"
+)
+
+# From local file
+result = client.stems.separate(
+    file="./song.mp3",
+    mode="four"
+)
+
+# Extract only vocals
+result = client.stems.separate(
+    url="https://youtube.com/watch?v=VIDEO_ID",
+    mode="single",
+    stem="vocals"
+)
+
+# Get available modes
+modes = client.stems.modes()
+for m in modes["modes"]:
+    print(f"{m['mode']}: {m['description']}")
+```
+
+## API Wallet
+
+Check balance and manage your wallet.
+
+```python
+# Check balance
+balance = client.wallet.balance()
+print(f"Balance: {balance['balance_usd']}")
+
+# Estimate cost
+estimate = client.wallet.estimate("stem_extraction", duration_seconds=180)
+print(f"Estimated cost: {estimate['cost_usd']}")
+
+# Get usage history
+usage = client.wallet.usage()
+for log in usage["logs"]:
+    print(f"{log['service_type']}: {log['amount_usd']}")
+```
+
+## Other Services
+
+```python
+# Transcription
+job = client.transcription.create(url="https://...")
+result = client.transcription.wait_for_completion(job["id"])
+
+# Voice cloning
+voice = client.voice.clone(file="./sample.wav", name="My Voice")
+
+# Music generation
+song = client.music.generate(prompt="upbeat electronic dance music")
+
+# Noise reduction
+clean = client.denoiser.denoise(file="./noisy.wav")
+
+# Speaker diarization
+speakers = client.speaker.diarize(url="https://...")
+```
+
+## Error Handling
+
+```python
+from audiopod import AudioPod, InsufficientBalanceError, AuthenticationError
+
+try:
+    client = AudioPod(api_key="ap_...")
+    result = client.stems.separate(url="...", mode="six")
+except AuthenticationError:
+    print("Invalid API key")
+except InsufficientBalanceError as e:
+    print(f"Need more credits. Required: {e.required_cents} cents")
+```
+
+## Environment Variables
+
+```bash
+export AUDIOPOD_API_KEY="ap_your_api_key"
+```
+
+```python
+# Client reads from env automatically
+client = AudioPod()
+```
+
+## Documentation
+
+- [API Documentation](https://docs.audiopod.ai)
+- [API Reference](https://docs.audiopod.ai/api-reference/stem-splitter)
+- [Get API Key](https://www.audiopod.ai/dashboard/account/api-keys)
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

audiopod-2.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+audiopod/__init__.py,sha256=UacaYDOzZMyFlXUtfNBnIZZPC5wjePjhYgxClJ31wio,661
+audiopod/client.py,sha256=mt9rYyxecSnODywkW7xuPQ9SZqhPO560VFLY7c-4f84,6632
+audiopod/exceptions.py,sha256=Xg3tNIwb0MoVyLZFqg5ifLIhh3mHgt-poneUB_a--Ag,1301
+audiopod/resources/__init__.py,sha256=I4R-sJmLwLCDbliAmhHwfjqVILCo2RnxjxYaI6PYDTs,375
+audiopod/resources/denoiser.py,sha256=n6-vyAor7FZnbEDZxgAtpnWIlMmHAIyoZsV5hY9xryQ,2996
+audiopod/resources/music.py,sha256=pXScN9DXNXYgFtvgjhiDShJpGNx5A0r_HsqTFiweBZ8,4742
+audiopod/resources/speaker.py,sha256=uEGbfuIUNGof6FJe9vODKwQ8NG-3Tz293ZUYEfd96NA,3612
+audiopod/resources/stems.py,sha256=kaYvJq84rJOH8wFDzVhN9kECzr2LeCseoa7_dXV4dsc,8524
+audiopod/resources/transcription.py,sha256=p-X5l8mbXrcUnsjqcdvN4SiZtM4EOitAg9Ipf_ubjkQ,6142
+audiopod/resources/voice.py,sha256=CCsRA23r3IMjVrU6sM2uiSMDs-D4Vi2pcu_nUGp9iAk,3646
+audiopod/resources/wallet.py,sha256=PksHlUv8jPcjwIpH0s2uYvr2y_g8BQWBhwyPwFr6Qco,2898
+audiopod-2.1.0.dist-info/licenses/LICENSE,sha256=hqEjnOaGNbnLSBxbtbC7WQVREU2vQI8FmwecCiZlMfA,1068
+audiopod-2.1.0.dist-info/METADATA,sha256=MIJ9npAwwfraOMxfrrN1LZtOC7y1VQw363t-5EbFoTk,5769
+audiopod-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+audiopod-2.1.0.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
+audiopod-2.1.0.dist-info/RECORD,,

{audiopod-1.4.0.dist-info → audiopod-2.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

audiopod/config.py

@@ -1,17 +0,0 @@
-"""
-AudioPod SDK Configuration
-"""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class ClientConfig:
-    """Client configuration settings"""
-    base_url: str = "https://api.audiopod.ai"
-    timeout: int = 30
-    max_retries: int = 3
-    verify_ssl: bool = True
-    debug: bool = False
-    version: str = "1.3.0"
-