audiopod 1.2.0__tar.gz → 1.4.0__tar.gz

audiopod-1.4.0/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: audiopod
+Version: 1.4.0
+Summary: 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-python
+Keywords: audiopod,audio,ai,voice,cloning,transcription,stem-separation,music,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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 :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# AudioPod Python SDK
+
+Official Python SDK for [AudioPod AI](https://audiopod.ai) - Professional Audio Processing powered by AI.
+
+## Installation
+
+```bash
+pip install audiopod
+```
+
+## Quick Start
+
+```python
+from audiopod import Client
+
+# Initialize client
+client = Client(api_key="ap_your_api_key")
+# Or set AUDIOPOD_API_KEY environment variable
+
+# Check wallet balance
+balance = client.wallet.get_balance()
+print(f"Balance: {balance['balance_usd']}")
+
+# Extract stems from audio
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# Download stems
+for stem, url in job["download_urls"].items():
+    print(f"{stem}: {url}")
+```
+
+## Services
+
+### Wallet (API Billing)
+
+```python
+# Get balance
+balance = client.wallet.get_balance()
+
+# Get pricing
+pricing = client.wallet.get_pricing()
+
+# Estimate cost
+estimate = client.wallet.estimate_cost("stem_extraction", duration_seconds=300)
+
+# Top up wallet
+checkout = client.wallet.create_topup_checkout(amount_cents=2500)  # $25
+print(f"Pay at: {checkout['url']}")
+
+# Usage history
+usage = client.wallet.get_usage_history(page=1, limit=50)
+```
+
+### Stem Extraction
+
+```python
+# Extract all stems
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# From URL
+job = client.stem_extraction.extract_stems(
+    url="https://example.com/song.mp3",
+    stem_types=["vocals", "other"]
+)
+
+# Check status
+status = client.stem_extraction.get_job(job_id=123)
+```
+
+### Transcription
+
+```python
+# Transcribe audio
+result = client.transcription.transcribe(
+    audio_file="podcast.mp3",
+    speaker_diarization=True,
+    wait_for_completion=True
+)
+print(result["transcript"])
+```
+
+### Voice Cloning & TTS
+
+```python
+# List voices
+voices = client.voice.list_voices()
+
+# Generate speech
+audio = client.voice.generate_speech(
+    text="Hello, world!",
+    voice_id=123,
+    wait_for_completion=True
+)
+```
+
+### Music Generation
+
+```python
+# Generate music
+result = client.music.generate(
+    prompt="upbeat electronic dance music",
+    duration=30,
+    wait_for_completion=True
+)
+```
+
+### Noise Reduction
+
+```python
+# Denoise audio
+result = client.denoiser.denoise(
+    audio_file="noisy.mp3",
+    mode="studio",
+    wait_for_completion=True
+)
+```
+
+## Async Support
+
+```python
+import asyncio
+from audiopod import AsyncClient
+
+async def main():
+    async with AsyncClient() as client:
+        balance = await client.wallet.get_balance()
+        print(f"Balance: {balance['balance_usd']}")
+
+asyncio.run(main())
+```
+
+## Error Handling
+
+```python
+from audiopod import Client
+from audiopod.exceptions import (
+    AuthenticationError,
+    InsufficientBalanceError,
+    RateLimitError,
+    APIError
+)
+
+try:
+    client = Client()
+    job = client.stem_extraction.extract_stems(audio_file="song.mp3")
+except AuthenticationError:
+    print("Invalid API key")
+except InsufficientBalanceError as e:
+    print(f"Need to top up: required {e.required_cents} cents")
+except RateLimitError:
+    print("Rate limit exceeded, try again later")
+except APIError as e:
+    print(f"API error ({e.status_code}): {e}")
+```
+
+## Documentation
+
+- [API Reference](https://docs.audiopod.ai)
+- [API Wallet](https://docs.audiopod.ai/account/api-wallet)
+- [Stem Separation](https://docs.audiopod.ai/api-reference/stem-splitter)
+
+## License
+
+MIT
+

audiopod-1.4.0/README.md

@@ -0,0 +1,173 @@
+# AudioPod Python SDK
+
+Official Python SDK for [AudioPod AI](https://audiopod.ai) - Professional Audio Processing powered by AI.
+
+## Installation
+
+```bash
+pip install audiopod
+```
+
+## Quick Start
+
+```python
+from audiopod import Client
+
+# Initialize client
+client = Client(api_key="ap_your_api_key")
+# Or set AUDIOPOD_API_KEY environment variable
+
+# Check wallet balance
+balance = client.wallet.get_balance()
+print(f"Balance: {balance['balance_usd']}")
+
+# Extract stems from audio
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# Download stems
+for stem, url in job["download_urls"].items():
+    print(f"{stem}: {url}")
+```
+
+## Services
+
+### Wallet (API Billing)
+
+```python
+# Get balance
+balance = client.wallet.get_balance()
+
+# Get pricing
+pricing = client.wallet.get_pricing()
+
+# Estimate cost
+estimate = client.wallet.estimate_cost("stem_extraction", duration_seconds=300)
+
+# Top up wallet
+checkout = client.wallet.create_topup_checkout(amount_cents=2500)  # $25
+print(f"Pay at: {checkout['url']}")
+
+# Usage history
+usage = client.wallet.get_usage_history(page=1, limit=50)
+```
+
+### Stem Extraction
+
+```python
+# Extract all stems
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# From URL
+job = client.stem_extraction.extract_stems(
+    url="https://example.com/song.mp3",
+    stem_types=["vocals", "other"]
+)
+
+# Check status
+status = client.stem_extraction.get_job(job_id=123)
+```
+
+### Transcription
+
+```python
+# Transcribe audio
+result = client.transcription.transcribe(
+    audio_file="podcast.mp3",
+    speaker_diarization=True,
+    wait_for_completion=True
+)
+print(result["transcript"])
+```
+
+### Voice Cloning & TTS
+
+```python
+# List voices
+voices = client.voice.list_voices()
+
+# Generate speech
+audio = client.voice.generate_speech(
+    text="Hello, world!",
+    voice_id=123,
+    wait_for_completion=True
+)
+```
+
+### Music Generation
+
+```python
+# Generate music
+result = client.music.generate(
+    prompt="upbeat electronic dance music",
+    duration=30,
+    wait_for_completion=True
+)
+```
+
+### Noise Reduction
+
+```python
+# Denoise audio
+result = client.denoiser.denoise(
+    audio_file="noisy.mp3",
+    mode="studio",
+    wait_for_completion=True
+)
+```
+
+## Async Support
+
+```python
+import asyncio
+from audiopod import AsyncClient
+
+async def main():
+    async with AsyncClient() as client:
+        balance = await client.wallet.get_balance()
+        print(f"Balance: {balance['balance_usd']}")
+
+asyncio.run(main())
+```
+
+## Error Handling
+
+```python
+from audiopod import Client
+from audiopod.exceptions import (
+    AuthenticationError,
+    InsufficientBalanceError,
+    RateLimitError,
+    APIError
+)
+
+try:
+    client = Client()
+    job = client.stem_extraction.extract_stems(audio_file="song.mp3")
+except AuthenticationError:
+    print("Invalid API key")
+except InsufficientBalanceError as e:
+    print(f"Need to top up: required {e.required_cents} cents")
+except RateLimitError:
+    print("Rate limit exceeded, try again later")
+except APIError as e:
+    print(f"API error ({e.status_code}): {e}")
+```
+
+## Documentation
+
+- [API Reference](https://docs.audiopod.ai)
+- [API Wallet](https://docs.audiopod.ai/account/api-wallet)
+- [Stem Separation](https://docs.audiopod.ai/api-reference/stem-splitter)
+
+## License
+
+MIT
+

audiopod-1.4.0/audiopod/__init__.py

@@ -0,0 +1,29 @@
+"""
+AudioPod SDK for Python
+Professional Audio Processing powered by AI
+"""
+
+__version__ = "1.3.0"
+
+from .client import Client, AsyncClient
+from .exceptions import (
+    AudioPodError,
+    AuthenticationError,
+    APIError,
+    RateLimitError,
+    ValidationError,
+    InsufficientBalanceError,
+)
+
+__all__ = [
+    "Client",
+    "AsyncClient",
+    "AudioPodError",
+    "AuthenticationError", 
+    "APIError",
+    "RateLimitError",
+    "ValidationError",
+    "InsufficientBalanceError",
+    "__version__",
+]
+

audiopod-1.4.0/audiopod/client.py

@@ -0,0 +1,306 @@
+"""
+AudioPod API Client
+"""
+
+import os
+import logging
+from typing import Optional, Dict, Any
+from urllib.parse import urljoin
+
+import requests
+import aiohttp
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from .config import ClientConfig
+from .exceptions import AuthenticationError, APIError, RateLimitError, InsufficientBalanceError
+from .services import (
+    VoiceService,
+    MusicService,
+    TranscriptionService,
+    TranslationService,
+    SpeakerService,
+    DenoiserService,
+    CreditService,
+    StemExtractionService,
+    WalletService,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BaseClient:
+    """Base client with common functionality"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        max_retries: int = 3,
+        verify_ssl: bool = True,
+        debug: bool = False,
+    ):
+        """
+        Initialize the AudioPod API client.
+
+        Args:
+            api_key: Your AudioPod API key. If None, reads from AUDIOPOD_API_KEY env var.
+            base_url: API base URL. Defaults to https://api.audiopod.ai
+            timeout: Request timeout in seconds.
+            max_retries: Maximum retries for failed requests.
+            verify_ssl: Whether to verify SSL certificates.
+            debug: Enable debug logging.
+        """
+        if debug:
+            logging.basicConfig(level=logging.DEBUG)
+
+        self.api_key = api_key or os.getenv("AUDIOPOD_API_KEY")
+        if not self.api_key:
+            raise AuthenticationError(
+                "API key required. Pass api_key or set AUDIOPOD_API_KEY environment variable."
+            )
+
+        if not self.api_key.startswith("ap_"):
+            raise AuthenticationError("Invalid API key format. Keys start with 'ap_'")
+
+        self.config = ClientConfig(
+            base_url=base_url or "https://api.audiopod.ai",
+            timeout=timeout,
+            max_retries=max_retries,
+            verify_ssl=verify_ssl,
+            debug=debug,
+        )
+
+    def _get_headers(self) -> Dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": f"audiopod-python/{self.config.version}",
+            "Accept": "application/json",
+        }
+
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        try:
+            response.raise_for_status()
+            if response.status_code == 204:
+                return {}
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid API key")
+            elif response.status_code == 402:
+                try:
+                    data = response.json()
+                    raise InsufficientBalanceError(
+                        data.get("message", "Insufficient balance"),
+                        required_cents=data.get("required_cents"),
+                        available_cents=data.get("available_cents"),
+                    )
+                except (ValueError, KeyError):
+                    raise InsufficientBalanceError("Insufficient wallet balance")
+            elif response.status_code == 429:
+                raise RateLimitError("Rate limit exceeded")
+            else:
+                try:
+                    error_data = response.json()
+                    message = error_data.get("detail", str(e))
+                except:
+                    message = str(e)
+                raise APIError(f"API error: {message}", status_code=response.status_code)
+
+
+class Client(BaseClient):
+    """
+    Synchronous AudioPod API Client.
+
+    Example:
+        ```python
+        from audiopod import Client
+
+        client = Client(api_key="ap_your_key")
+
+        # Check wallet balance
+        balance = client.wallet.get_balance()
+        print(f"Balance: {balance['balance_usd']}")
+
+        # Extract stems
+        job = client.stem_extraction.extract_stems(
+            audio_file="song.mp3",
+            stem_types=["vocals", "drums", "bass", "other"]
+        )
+        ```
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=self.config.max_retries,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["HEAD", "GET", "OPTIONS", "POST", "DELETE"],
+            backoff_factor=1,
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+        # Services
+        self.voice = VoiceService(self)
+        self.music = MusicService(self)
+        self.transcription = TranscriptionService(self)
+        self.translation = TranslationService(self)
+        self.speaker = SpeakerService(self)
+        self.denoiser = DenoiserService(self)
+        self.credits = CreditService(self)
+        self.stem_extraction = StemExtractionService(self)
+        self.wallet = WalletService(self)
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make API request."""
+        url = urljoin(self.config.base_url, endpoint)
+        headers = self._get_headers()
+
+        if files:
+            headers.pop("Content-Type", None)
+
+        response = self.session.request(
+            method=method,
+            url=url,
+            headers=headers,
+            data=data,
+            json=json_data,
+            files=files,
+            params=params,
+            timeout=self.config.timeout,
+            verify=self.config.verify_ssl,
+        )
+        return self._handle_response(response)
+
+    def get_user_info(self) -> Dict[str, Any]:
+        """Get current user information."""
+        return self.request("GET", "/api/v1/auth/me")
+
+    def close(self):
+        """Close client session."""
+        self.session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class AsyncClient(BaseClient):
+    """
+    Asynchronous AudioPod API Client.
+
+    Example:
+        ```python
+        import asyncio
+        from audiopod import AsyncClient
+
+        async def main():
+            async with AsyncClient(api_key="ap_your_key") as client:
+                balance = await client.wallet.get_balance()
+                print(f"Balance: {balance['balance_usd']}")
+
+        asyncio.run(main())
+        ```
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._session: Optional[aiohttp.ClientSession] = None
+
+        # Services
+        self.voice = VoiceService(self, async_mode=True)
+        self.music = MusicService(self, async_mode=True)
+        self.transcription = TranscriptionService(self, async_mode=True)
+        self.translation = TranslationService(self, async_mode=True)
+        self.speaker = SpeakerService(self, async_mode=True)
+        self.denoiser = DenoiserService(self, async_mode=True)
+        self.credits = CreditService(self, async_mode=True)
+        self.stem_extraction = StemExtractionService(self, async_mode=True)
+        self.wallet = WalletService(self, async_mode=True)
+
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=self.config.timeout)
+            connector = aiohttp.TCPConnector(ssl=self.config.verify_ssl)
+            self._session = aiohttp.ClientSession(
+                timeout=timeout, connector=connector, headers=self._get_headers()
+            )
+        return self._session
+
+    async def request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make async API request."""
+        url = urljoin(self.config.base_url, endpoint)
+
+        async with self.session.request(
+            method=method,
+            url=url,
+            json=json_data,
+            data=data,
+            params=params,
+        ) as response:
+            return await self._handle_async_response(response)
+
+    async def _handle_async_response(self, response: aiohttp.ClientResponse) -> Dict[str, Any]:
+        if response.status == 204:
+            return {}
+        try:
+            response.raise_for_status()
+            return await response.json()
+        except aiohttp.ClientResponseError as e:
+            if response.status == 401:
+                raise AuthenticationError("Invalid API key")
+            elif response.status == 402:
+                try:
+                    data = await response.json()
+                    raise InsufficientBalanceError(
+                        data.get("message", "Insufficient balance"),
+                        required_cents=data.get("required_cents"),
+                        available_cents=data.get("available_cents"),
+                    )
+                except:
+                    raise InsufficientBalanceError("Insufficient wallet balance")
+            elif response.status == 429:
+                raise RateLimitError("Rate limit exceeded")
+            else:
+                raise APIError(f"API error: {e}", status_code=response.status)
+
+    async def get_user_info(self) -> Dict[str, Any]:
+        """Get current user information."""
+        return await self.request("GET", "/api/v1/auth/me")
+
+    async def close(self):
+        """Close async client session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+