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

audiopod/__init__.py

@@ -1,29 +1,34 @@
 """
 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__ = "1.3.0"
+__version__ = "2.1.0"
 
-from .client import Client, AsyncClient
+from .client import AudioPod
 from .exceptions import (
     AudioPodError,
     AuthenticationError,
     APIError,
     RateLimitError,
-    ValidationError,
     InsufficientBalanceError,
 )
 
 __all__ = [
-    "Client",
-    "AsyncClient",
+    "AudioPod",
     "AudioPodError",
-    "AuthenticationError", 
+    "AuthenticationError",
     "APIError",
     "RateLimitError",
-    "ValidationError",
     "InsufficientBalanceError",
     "__version__",
 ]
-

audiopod/client.py

@@ -1,82 +1,102 @@
 """
 AudioPod API Client
+
+Clean, minimal API inspired by OpenAI's SDK design.
 """
 
 import os
-import logging
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, BinaryIO
 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,
+from .exceptions import (
+    AuthenticationError,
+    APIError,
+    RateLimitError,
+    InsufficientBalanceError,
 )
+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
+
 
-logger = logging.getLogger(__name__)
+class AudioPod:
+    """
+    AudioPod API Client.
 
+    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)
 
-class BaseClient:
-    """Base client with common functionality"""
+    Example:
+        >>> from audiopod import AudioPod
+        >>> client = AudioPod(api_key="ap_...")
+        >>> result = client.transcription.transcribe(url="https://...")
+    """
 
     def __init__(
         self,
         api_key: Optional[str] = None,
         base_url: Optional[str] = None,
-        timeout: int = 30,
+        timeout: int = DEFAULT_TIMEOUT,
         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."
+                "API key is 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_'")
+            raise AuthenticationError(
+                "Invalid API key format. AudioPod API 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,
+        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,
         )
+        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/{self.config.version}",
+            "User-Agent": f"audiopod-python/{VERSION}",
             "Accept": "application/json",
         }
 
@@ -86,221 +106,93 @@ class BaseClient:
             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:
+        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:
                 try:
                     data = response.json()
                     raise InsufficientBalanceError(
-                        data.get("message", "Insufficient balance"),
+                        message,
                         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")
+                    raise InsufficientBalanceError(message)
+            elif status == 429:
+                raise RateLimitError(message)
             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.
+                raise APIError(message, status_code=status)
 
-    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,
+    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
         )
-        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)
+        return self._handle_response(response)
 
-    def request(
+    def post(
         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)
+        """Make a POST request."""
+        url = urljoin(self.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,
+        response = self._session.post(
+            url, headers=headers, data=data, json=json_data, 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 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
+    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)
 
-    async def request(
+    def upload(
         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,
+        file_path: str,
+        field_name: str = "file",
+        additional_fields: 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)
+        """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
+            )
 
-    async def get_user_info(self) -> Dict[str, Any]:
-        """Get current user information."""
-        return await self.request("GET", "/api/v1/auth/me")
+        return self._handle_response(response)
 
-    async def close(self):
-        """Close async client session."""
-        if self._session and not self._session.closed:
-            await self._session.close()
+    def close(self):
+        """Close the client session."""
+        self._session.close()
 
-    async def __aenter__(self):
+    def __enter__(self):
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

audiopod/exceptions.py

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

audiopod/resources/__init__.py

@@ -0,0 +1,23 @@
+"""AudioPod SDK Resources"""
+
+from .transcription import Transcription
+from .voice import Voice
+from .music import Music
+from .stems import StemExtraction
+from .denoiser import Denoiser
+from .speaker import Speaker
+from .wallet import Wallet
+
+__all__ = [
+    "Transcription",
+    "Voice",
+    "Music",
+    "StemExtraction",
+    "Denoiser",
+    "Speaker",
+    "Wallet",
+]
+
+
+
+

audiopod/resources/denoiser.py

@@ -0,0 +1,116 @@
+"""
+Denoiser Service - Audio Noise Reduction
+"""
+
+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 Denoiser:
+    """Audio noise reduction service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a denoise job.
+
+        Args:
+            file: Path to audio file
+            url: URL of audio/video
+
+        Returns:
+            Denoise job object
+
+        Example:
+            >>> job = client.denoiser.create(file="./noisy-audio.mp3")
+        """
+        if file:
+            return self._client.upload(
+                "/api/v1/denoiser/denoise",
+                file,
+                field_name="file",
+            )
+
+        if url:
+            return self._client.post(
+                "/api/v1/denoiser/denoise",
+                json_data={"url": url},
+            )
+
+        raise ValueError("Either file or url must be provided")
+
+    def get(self, job_id: int) -> Dict[str, Any]:
+        """Get a denoise job by ID."""
+        return self._client.get(f"/api/v1/denoiser/jobs/{job_id}")
+
+    def list(
+        self,
+        *,
+        skip: int = 0,
+        limit: int = 50,
+        status: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List denoise jobs."""
+        return self._client.get(
+            "/api/v1/denoiser/jobs",
+            params={"skip": skip, "limit": limit, "status": status},
+        )
+
+    def delete(self, job_id: int) -> None:
+        """Delete a denoise job."""
+        self._client.delete(f"/api/v1/denoiser/jobs/{job_id}")
+
+    def wait_for_completion(
+        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
+    ) -> Dict[str, Any]:
+        """Wait for denoising to complete."""
+        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"Denoising failed: {job.get('error_message', 'Unknown error')}"
+                )
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"Denoising timed out after {timeout}s")
+
+    def denoise(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Denoise audio and wait for completion.
+
+        Example:
+            >>> result = client.denoiser.denoise(file="./noisy-audio.mp3")
+            >>> print(result["output_url"])
+        """
+        job = self.create(file=file, url=url)
+        return self.wait_for_completion(job["id"], timeout=timeout)
+
+
+
+