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

audiopod/__init__.py

@@ -1,83 +1,29 @@
 """
-AudioPod API Client
-Professional Audio Processing SDK for Python
-
-This package provides a comprehensive Python SDK for the AudioPod API,
-enabling developers to integrate advanced audio processing capabilities
-into their applications.
-
-Basic Usage:
-    >>> import audiopod
-    >>> client = audiopod.Client(api_key="your-api-key")
-    >>> 
-    >>> # Voice cloning
-    >>> job = client.voice.clone_voice(
-    ...     voice_file="path/to/voice.wav",
-    ...     text="Hello, this is a cloned voice!"
-    ... )
-    >>> 
-    >>> # Music generation
-    >>> music = client.music.generate(
-    ...     prompt="upbeat electronic dance music"
-    ... )
-    >>> 
-    >>> # Audio transcription
-    >>> transcript = client.transcription.transcribe(
-    ...     audio_file="path/to/audio.mp3",
-    ...     language="en"
-    ... )
-
-For more examples and documentation, visit: https://docs.audiopod.ai
+AudioPod SDK for Python
+Professional Audio Processing powered by AI
 """
 
+__version__ = "1.3.0"
+
 from .client import Client, AsyncClient
 from .exceptions import (
     AudioPodError,
-    AuthenticationError, 
+    AuthenticationError,
     APIError,
     RateLimitError,
     ValidationError,
-    ProcessingError
+    InsufficientBalanceError,
 )
-from .models import (
-    Job,
-    VoiceProfile,
-    TranscriptionResult,
-    MusicGenerationResult,
-    TranslationResult
-)
-
-__version__ = "1.2.0"
-__author__ = "AudioPod AI"
-__email__ = "support@audiopod.ai"
-__license__ = "MIT"
 
-# Public API
 __all__ = [
-    # Main clients
     "Client",
     "AsyncClient",
-    
-    # Exceptions
     "AudioPodError",
-    "AuthenticationError",
-    "APIError", 
+    "AuthenticationError", 
+    "APIError",
     "RateLimitError",
     "ValidationError",
-    "ProcessingError",
-    
-    # Models
-    "Job",
-    "VoiceProfile",
-    "TranscriptionResult", 
-    "MusicGenerationResult",
-    "TranslationResult",
+    "InsufficientBalanceError",
+    "__version__",
 ]
 
-# Package metadata
-__all__.extend([
-    "__version__",
-    "__author__", 
-    "__email__",
-    "__license__"
-])

audiopod/client.py

@@ -1,11 +1,10 @@
 """
 AudioPod API Client
-Main client classes for synchronous and asynchronous API access
 """
 
 import os
 import logging
-from typing import Optional, Dict, Any, Union
+from typing import Optional, Dict, Any
 from urllib.parse import urljoin
 
 import requests
@@ -14,17 +13,17 @@ from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
 from .config import ClientConfig
-from .exceptions import AuthenticationError, APIError, RateLimitError
+from .exceptions import AuthenticationError, APIError, RateLimitError, InsufficientBalanceError
 from .services import (
     VoiceService,
-    MusicService, 
+    MusicService,
     TranscriptionService,
     TranslationService,
     SpeakerService,
     DenoiserService,
-    KaraokeService,
     CreditService,
-    StemExtractionService
+    StemExtractionService,
+    WalletService,
 )
 
 logger = logging.getLogger(__name__)
@@ -32,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 class BaseClient:
     """Base client with common functionality"""
-    
+
     def __init__(
         self,
         api_key: Optional[str] = None,
@@ -40,296 +39,268 @@ class BaseClient:
         timeout: int = 30,
         max_retries: int = 3,
         verify_ssl: bool = True,
-        debug: bool = False
+        debug: bool = False,
     ):
         """
-        Initialize the AudioPod API client
-        
+        Initialize the AudioPod API client.
+
         Args:
-            api_key: Your AudioPod API key. If None, will try to read from AUDIOPOD_API_KEY env var
-            base_url: API base URL. Defaults to production endpoint
-            timeout: Request timeout in seconds
-            max_retries: Maximum number of retries for failed requests
-            verify_ssl: Whether to verify SSL certificates
-            debug: Enable debug logging
+            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.
         """
-        # Set up logging
         if debug:
             logging.basicConfig(level=logging.DEBUG)
-            
-        # Get API key
+
         self.api_key = api_key or os.getenv("AUDIOPOD_API_KEY")
         if not self.api_key:
             raise AuthenticationError(
-                "API key is required. Pass it as 'api_key' parameter or set AUDIOPOD_API_KEY environment variable."
+                "API key required. Pass api_key or set AUDIOPOD_API_KEY environment variable."
             )
-            
-        # Validate API key format
+
         if not self.api_key.startswith("ap_"):
-            raise AuthenticationError("Invalid API key format. AudioPod API keys start with 'ap_'")
-            
-        # Configuration
+            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
+            debug=debug,
         )
-        
+
     def _get_headers(self) -> Dict[str, str]:
-        """Get standard headers for API requests"""
         return {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
             "User-Agent": f"audiopod-python/{self.config.version}",
-            "Accept": "application/json"
+            "Accept": "application/json",
         }
-        
+
     def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
-        """Handle API response and raise appropriate exceptions"""
         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 or authentication failed")
+                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. Please try again later.")
-            elif response.status_code >= 400:
+                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 request failed: {message}", status_code=response.status_code)
-            else:
-                raise APIError(f"Unexpected HTTP error: {e}")
-        except requests.exceptions.RequestException as e:
-            raise APIError(f"Request failed: {e}")
+                raise APIError(f"API error: {message}", status_code=response.status_code)
 
 
 class Client(BaseClient):
     """
-    Synchronous AudioPod API Client
-    
-    Provides access to all AudioPod services through a simple Python interface.
+    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)
-        
-        # Configure session with retries
+
         self.session = requests.Session()
         retry_strategy = Retry(
             total=self.config.max_retries,
             status_forcelist=[429, 500, 502, 503, 504],
-            method_whitelist=["HEAD", "GET", "OPTIONS", "POST"],
-            backoff_factor=1
+            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
+
+        # 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.karaoke = KaraokeService(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,
-        **kwargs
     ) -> Dict[str, Any]:
-        """
-        Make a request to the AudioPod API
-        
-        Args:
-            method: HTTP method (GET, POST, etc.)
-            endpoint: API endpoint path
-            data: JSON data to send
-            files: Files to upload
-            params: URL parameters
-            **kwargs: Additional requests parameters
-            
-        Returns:
-            API response data
-        """
+        """Make API request."""
         url = urljoin(self.config.base_url, endpoint)
         headers = self._get_headers()
-        
-        # Handle file uploads (don't set Content-Type for multipart)
+
         if files:
             headers.pop("Content-Type", None)
-            
-        try:
-            response = self.session.request(
-                method=method,
-                url=url,
-                headers=headers,
-                json=data,
-                files=files,
-                params=params,
-                timeout=self.config.timeout,
-                verify=self.config.verify_ssl,
-                **kwargs
-            )
-            return self._handle_response(response)
-            
-        except Exception as e:
-            logger.error(f"Request failed: {method} {url} - {e}")
-            raise
-            
+
+        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"""
+        """Get current user information."""
         return self.request("GET", "/api/v1/auth/me")
-        
-    def check_health(self) -> Dict[str, Any]:
-        """Check API health status"""
-        return self.request("GET", "/api/v1/health")
-        
+
     def close(self):
-        """Close the client session"""
+        """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
-    
-    Provides async/await support for better performance in async applications.
+    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
-        
-        # Initialize async services
+
+        # 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.karaoke = KaraokeService(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:
-        """Get or create aiohttp session"""
         if self._session is None or self._session.closed:
             timeout = aiohttp.ClientTimeout(total=self.config.timeout)
-            connector = aiohttp.TCPConnector(verify_ssl=self.config.verify_ssl)
+            connector = aiohttp.TCPConnector(ssl=self.config.verify_ssl)
             self._session = aiohttp.ClientSession(
-                timeout=timeout,
-                connector=connector,
-                headers=self._get_headers()
+                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,
-        **kwargs
     ) -> Dict[str, Any]:
-        """
-        Make an async request to the AudioPod API
-        
-        Args:
-            method: HTTP method (GET, POST, etc.)
-            endpoint: API endpoint path
-            data: JSON data to send
-            files: Files to upload
-            params: URL parameters
-            **kwargs: Additional aiohttp parameters
-            
-        Returns:
-            API response data
-        """
+        """Make async API request."""
         url = urljoin(self.config.base_url, endpoint)
-        
-        try:
-            if files:
-                # Handle file uploads
-                form_data = aiohttp.FormData()
-                for key, value in (data or {}).items():
-                    form_data.add_field(key, str(value))
-                for key, file_data in files.items():
-                    form_data.add_field(key, file_data)
-                data = form_data
-                
-            async with self.session.request(
-                method=method,
-                url=url,
-                json=data if not files else None,
-                data=data if files else None,
-                params=params,
-                **kwargs
-            ) as response:
-                return await self._handle_async_response(response)
-                
-        except Exception as e:
-            logger.error(f"Async request failed: {method} {url} - {e}")
-            raise
-            
+
+        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]:
-        """Handle async API response and raise appropriate exceptions"""
+        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 or authentication failed")
-            elif response.status == 429:
-                raise RateLimitError("Rate limit exceeded. Please try again later.")
-            elif response.status >= 400:
+                raise AuthenticationError("Invalid API key")
+            elif response.status == 402:
                 try:
-                    error_data = await response.json()
-                    message = error_data.get("detail", str(e))
+                    data = await response.json()
+                    raise InsufficientBalanceError(
+                        data.get("message", "Insufficient balance"),
+                        required_cents=data.get("required_cents"),
+                        available_cents=data.get("available_cents"),
+                    )
                 except:
-                    message = str(e)
-                raise APIError(f"API request failed: {message}", status_code=response.status)
+                    raise InsufficientBalanceError("Insufficient wallet balance")
+            elif response.status == 429:
+                raise RateLimitError("Rate limit exceeded")
             else:
-                raise APIError(f"Unexpected HTTP error: {e}")
-        except aiohttp.ClientError as e:
-            raise APIError(f"Request failed: {e}")
-            
+                raise APIError(f"API error: {e}", status_code=response.status)
+
     async def get_user_info(self) -> Dict[str, Any]:
-        """Get current user information"""
+        """Get current user information."""
         return await self.request("GET", "/api/v1/auth/me")
-        
-    async def check_health(self) -> Dict[str, Any]:
-        """Check API health status"""
-        return await self.request("GET", "/api/v1/health")
-        
+
     async def close(self):
-        """Close the async client session"""
+        """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()
+

audiopod/config.py

@@ -1,63 +1,17 @@
 """
-AudioPod Client Configuration
+AudioPod SDK Configuration
 """
 
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class ClientConfig:
-    """Configuration for AudioPod API client"""
-    
-    # API settings
+    """Client configuration settings"""
     base_url: str = "https://api.audiopod.ai"
-    api_version: str = "v1"
-    
-    # Request settings
     timeout: int = 30
     max_retries: int = 3
     verify_ssl: bool = True
-    
-    # Client settings
     debug: bool = False
-    version: str = "1.0.0"
-    
-    # Rate limiting
-    rate_limit_per_minute: int = 600
-    
-    # File upload limits
-    max_file_size_mb: int = 100
-    supported_audio_formats: tuple = (
-        ".mp3", ".wav", ".m4a", ".flac", ".ogg", 
-        ".aac", ".wma", ".aiff", ".au"
-    )
-    supported_video_formats: tuple = (
-        ".mp4", ".avi", ".mov", ".mkv", ".wmv", 
-        ".flv", ".webm", ".m4v"
-    )
-    
-    @property
-    def api_base_url(self) -> str:
-        """Get full API base URL with version"""
-        return f"{self.base_url}/api/{self.api_version}"
-        
-    def validate_file_format(self, filename: str, file_type: str = "audio") -> bool:
-        """
-        Validate if file format is supported
-        
-        Args:
-            filename: Name of the file
-            file_type: Type of file ('audio' or 'video')
-            
-        Returns:
-            True if format is supported
-        """
-        filename = filename.lower()
-        
-        if file_type == "audio":
-            return any(filename.endswith(fmt) for fmt in self.supported_audio_formats)
-        elif file_type == "video":
-            return any(filename.endswith(fmt) for fmt in self.supported_video_formats)
-        else:
-            return False
+    version: str = "1.3.0"
+