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

audiopod/__init__.py

@@ -1,34 +1,33 @@
 """
 AudioPod SDK for Python
 Professional Audio Processing powered by AI
-
-Example:
-    from audiopod import AudioPod
-
-    client = AudioPod(api_key="ap_...")
-
-    # Transcribe audio
-    job = client.transcription.create(url="https://...")
-    result = client.transcription.wait_for_completion(job.id)
 """
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
-from .client import AudioPod
+from .client import Client, AsyncClient
 from .exceptions import (
     AudioPodError,
     AuthenticationError,
     APIError,
     RateLimitError,
+    ValidationError,
     InsufficientBalanceError,
 )
 
+# Alias for consistency with documentation and Node.js SDK
+AudioPod = Client
+
 __all__ = [
-    "AudioPod",
+    "Client",
+    "AsyncClient",
+    "AudioPod",  # Alias for Client
     "AudioPodError",
-    "AuthenticationError",
+    "AuthenticationError", 
     "APIError",
     "RateLimitError",
+    "ValidationError",
     "InsufficientBalanceError",
     "__version__",
 ]
+

audiopod/client.py

@@ -1,102 +1,84 @@
 """
 AudioPod API Client
-
-Clean, minimal API inspired by OpenAI's SDK design.
 """
 
 import os
-from typing import Optional, Dict, Any, BinaryIO
+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 .exceptions import (
-    AuthenticationError,
-    APIError,
-    RateLimitError,
-    InsufficientBalanceError,
+from .config import ClientConfig
+from .exceptions import AuthenticationError, APIError, RateLimitError, InsufficientBalanceError
+from .services import (
+    VoiceService,
+    MusicService,
+    TranscriptionService,
+    TranslationService,
+    SpeakerService,
+    DenoiserService,
+    CreditService,
+    StemExtractionService,
+    WalletService,
+    VideoService,
 )
-from .resources.transcription import Transcription
-from .resources.voice import Voice
-from .resources.music import Music
-from .resources.stems import StemExtraction
-from .resources.denoiser import Denoiser
-from .resources.speaker import Speaker
-from .resources.wallet import Wallet
-
-VERSION = "2.1.0"
-DEFAULT_BASE_URL = "https://api.audiopod.ai"
-DEFAULT_TIMEOUT = 60
-
 
-class AudioPod:
-    """
-    AudioPod API Client.
+logger = logging.getLogger(__name__)
 
-    Args:
-        api_key: Your AudioPod API key (starts with 'ap_').
-                 If not provided, reads from AUDIOPOD_API_KEY env var.
-        base_url: Base URL for the API (default: https://api.audiopod.ai)
-        timeout: Request timeout in seconds (default: 60)
-        max_retries: Maximum retries for failed requests (default: 3)
 
-    Example:
-        >>> from audiopod import AudioPod
-        >>> client = AudioPod(api_key="ap_...")
-        >>> result = client.transcription.transcribe(url="https://...")
-    """
+class BaseClient:
+    """Base client with common functionality"""
 
     def __init__(
         self,
         api_key: Optional[str] = None,
         base_url: Optional[str] = None,
-        timeout: int = DEFAULT_TIMEOUT,
+        timeout: int = 30,
         max_retries: int = 3,
+        verify_ssl: bool = True,
+        debug: bool = False,
     ):
-        self.api_key = api_key or os.getenv("AUDIOPOD_API_KEY")
+        """
+        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 is required. Pass api_key or set AUDIOPOD_API_KEY environment variable."
+                "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. AudioPod API keys start with 'ap_'"
-            )
+            raise AuthenticationError("Invalid API key format. Keys start with 'ap_'")
 
-        self.base_url = base_url or DEFAULT_BASE_URL
-        self.timeout = timeout
-
-        # Configure session with retries
-        self._session = requests.Session()
-        retry_strategy = Retry(
-            total=max_retries,
-            status_forcelist=[429, 500, 502, 503, 504],
-            allowed_methods=["HEAD", "GET", "OPTIONS", "POST", "DELETE"],
-            backoff_factor=1,
+        self.config = ClientConfig(
+            base_url=base_url or "https://api.audiopod.ai",
+            timeout=timeout,
+            max_retries=max_retries,
+            verify_ssl=verify_ssl,
+            debug=debug,
         )
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        self._session.mount("http://", adapter)
-        self._session.mount("https://", adapter)
-
-        # Initialize services
-        self.transcription = Transcription(self)
-        self.voice = Voice(self)
-        self.music = Music(self)
-        self.stems = StemExtraction(self)
-        self.denoiser = Denoiser(self)
-        self.speaker = Speaker(self)
-        self.wallet = Wallet(self)
 
     def _get_headers(self) -> Dict[str, str]:
         return {
             "Authorization": f"Bearer {self.api_key}",
             "X-API-Key": self.api_key,
             "Content-Type": "application/json",
-            "User-Agent": f"audiopod-python/{VERSION}",
+            "User-Agent": f"audiopod-python/{self.config.version}",
             "Accept": "application/json",
         }
 
@@ -106,93 +88,225 @@ class AudioPod:
             if response.status_code == 204:
                 return {}
             return response.json()
-        except requests.exceptions.HTTPError:
-            status = response.status_code
-            try:
-                data = response.json()
-                message = data.get("detail") or data.get("message") or str(data)
-            except Exception:
-                message = response.text or f"HTTP {status}"
-
-            if status == 401:
-                raise AuthenticationError(message)
-            elif status == 402:
+        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(
-                        message,
+                        data.get("message", "Insufficient balance"),
                         required_cents=data.get("required_cents"),
                         available_cents=data.get("available_cents"),
                     )
                 except (ValueError, KeyError):
-                    raise InsufficientBalanceError(message)
-            elif status == 429:
-                raise RateLimitError(message)
+                    raise InsufficientBalanceError("Insufficient wallet balance")
+            elif response.status_code == 429:
+                raise RateLimitError("Rate limit exceeded")
             else:
-                raise APIError(message, status_code=status)
+                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)
 
-    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Make a GET request."""
-        url = urljoin(self.base_url, endpoint)
-        headers = self._get_headers()
-        response = self._session.get(
-            url, headers=headers, params=params, timeout=self.timeout
+
+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"]
         )
-        return self._handle_response(response)
+        ```
+    """
+
+    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)
 
-    def post(
+        # 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.stems = self.stem_extraction  # Alias for consistency with Node.js SDK
+        self.wallet = WalletService(self)
+        self.video = VideoService(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 a POST request."""
-        url = urljoin(self.base_url, endpoint)
+        """Make API request."""
+        url = urljoin(self.config.base_url, endpoint)
         headers = self._get_headers()
-        response = self._session.post(
-            url, headers=headers, data=data, json=json_data, timeout=self.timeout
+
+        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 delete(self, endpoint: str) -> Dict[str, Any]:
-        """Make a DELETE request."""
-        url = urljoin(self.base_url, endpoint)
-        headers = self._get_headers()
-        response = self._session.delete(url, headers=headers, timeout=self.timeout)
-        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 upload(
+    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.stems = self.stem_extraction  # Alias for consistency with Node.js SDK
+        self.wallet = WalletService(self, async_mode=True)
+        self.video = VideoService(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,
-        file_path: str,
-        field_name: str = "file",
-        additional_fields: Optional[Dict[str, Any]] = None,
+        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]:
-        """Upload a file."""
-        url = urljoin(self.base_url, endpoint)
-        headers = self._get_headers()
-        headers.pop("Content-Type", None)  # Let requests set multipart boundary
-
-        with open(file_path, "rb") as f:
-            files = {field_name: f}
-            data = {}
-            if additional_fields:
-                for key, value in additional_fields.items():
-                    if value is not None:
-                        data[key] = str(value) if not isinstance(value, str) else value
-
-            response = self._session.post(
-                url, headers=headers, files=files, data=data, timeout=self.timeout
-            )
+        """Make async API request."""
+        url = urljoin(self.config.base_url, endpoint)
 
-        return self._handle_response(response)
+        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)
 
-    def close(self):
-        """Close the client session."""
-        self._session.close()
+    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)
 
-    def __enter__(self):
+    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
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+

audiopod/config.py

@@ -0,0 +1,17 @@
+"""
+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"
+

audiopod/exceptions.py

@@ -2,48 +2,40 @@
 AudioPod SDK Exceptions
 """
 
-from typing import Optional
-
 
 class AudioPodError(Exception):
-    """Base exception for AudioPod SDK."""
-
-    def __init__(self, message: str = "An error occurred"):
-        self.message = message
-        super().__init__(self.message)
+    """Base exception for AudioPod SDK"""
+    pass
 
 
 class AuthenticationError(AudioPodError):
-    """Raised when authentication fails."""
-
-    def __init__(self, message: str = "Authentication failed"):
-        super().__init__(message)
+    """Raised when authentication fails"""
+    pass
 
 
 class APIError(AudioPodError):
-    """Raised when an API request fails."""
-
-    def __init__(self, message: str = "API request failed", status_code: Optional[int] = None):
-        self.status_code = status_code
+    """Raised when API returns an error"""
+    
+    def __init__(self, message: str, status_code: int = None):
         super().__init__(message)
+        self.status_code = status_code
 
 
 class RateLimitError(AudioPodError):
-    """Raised when rate limit is exceeded."""
+    """Raised when rate limit is exceeded"""
+    pass
 
-    def __init__(self, message: str = "Rate limit exceeded"):
-        super().__init__(message)
+
+class ValidationError(AudioPodError):
+    """Raised when input validation fails"""
+    pass
 
 
 class InsufficientBalanceError(AudioPodError):
-    """Raised when wallet balance is insufficient."""
-
-    def __init__(
-        self,
-        message: str = "Insufficient wallet balance",
-        required_cents: Optional[int] = None,
-        available_cents: Optional[int] = None,
-    ):
+    """Raised when wallet balance is insufficient"""
+    
+    def __init__(self, message: str, required_cents: int = None, available_cents: int = None):
+        super().__init__(message)
         self.required_cents = required_cents
         self.available_cents = available_cents
-        super().__init__(message)
+

audiopod/services/__init__.py

@@ -0,0 +1,30 @@
+"""
+AudioPod SDK Services
+"""
+
+from .base import BaseService
+from .voice import VoiceService
+from .music import MusicService
+from .transcription import TranscriptionService
+from .translation import TranslationService
+from .speaker import SpeakerService
+from .denoiser import DenoiserService
+from .credits import CreditService
+from .stem_extraction import StemExtractionService
+from .wallet import WalletService
+from .video import VideoService
+
+__all__ = [
+    "BaseService",
+    "VoiceService",
+    "MusicService",
+    "TranscriptionService",
+    "TranslationService",
+    "SpeakerService",
+    "DenoiserService",
+    "CreditService",
+    "StemExtractionService",
+    "WalletService",
+    "VideoService",
+]
+

audiopod/services/base.py

@@ -0,0 +1,69 @@
+"""
+Base Service Class
+"""
+
+import time
+from typing import Any, Dict, Optional, Tuple, BinaryIO
+
+
+class BaseService:
+    """Base class for all services"""
+
+    def __init__(self, client: Any, async_mode: bool = False):
+        self.client = client
+        self.async_mode = async_mode
+
+    def _prepare_file_upload(
+        self, file_path: str, field_name: str = "file"
+    ) -> Dict[str, Tuple[str, BinaryIO, str]]:
+        """Prepare file for upload."""
+        import mimetypes
+
+        mime_type, _ = mimetypes.guess_type(file_path)
+        mime_type = mime_type or "application/octet-stream"
+
+        file_handle = open(file_path, "rb")
+        filename = file_path.split("/")[-1]
+
+        return {field_name: (filename, file_handle, mime_type)}
+
+    def _wait_for_completion(
+        self, job_id: int, timeout: int = 900, poll_interval: int = 5
+    ) -> Dict[str, Any]:
+        """Wait for job completion."""
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            response = self.client.request("GET", f"/api/v1/jobs/{job_id}")
+
+            status = response.get("status", "").upper()
+            if status == "COMPLETED":
+                return response
+            elif status in ["FAILED", "ERROR"]:
+                raise Exception(f"Job failed: {response.get('error_message', 'Unknown error')}")
+
+            time.sleep(poll_interval)
+
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+
+    async def _async_wait_for_completion(
+        self, job_id: int, timeout: int = 900, poll_interval: int = 5
+    ) -> Dict[str, Any]:
+        """Async wait for job completion."""
+        import asyncio
+
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            response = await self.client.request("GET", f"/api/v1/jobs/{job_id}")
+
+            status = response.get("status", "").upper()
+            if status == "COMPLETED":
+                return response
+            elif status in ["FAILED", "ERROR"]:
+                raise Exception(f"Job failed: {response.get('error_message', 'Unknown error')}")
+
+            await asyncio.sleep(poll_interval)
+
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+