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

audiopod/exceptions.py

@@ -1,51 +1,29 @@
 """
-AudioPod API Client Exceptions
+AudioPod SDK Exceptions
 """
 
-from typing import Optional, Dict, Any
-
 
 class AudioPodError(Exception):
-    """Base exception for AudioPod API client"""
-    
-    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
-        super().__init__(message)
-        self.message = message
-        self.details = details or {}
-        
-    def __str__(self) -> str:
-        return self.message
+    """Base exception for AudioPod SDK"""
+    pass
 
 
 class AuthenticationError(AudioPodError):
-    """Raised when API key authentication fails"""
+    """Raised when authentication fails"""
     pass
 
 
 class APIError(AudioPodError):
-    """Raised when API returns an error response"""
+    """Raised when API returns an error"""
     
-    def __init__(
-        self, 
-        message: str, 
-        status_code: Optional[int] = None,
-        details: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(message, details)
+    def __init__(self, message: str, status_code: int = None):
+        super().__init__(message)
         self.status_code = status_code
 
 
-class RateLimitError(APIError):
-    """Raised when API rate limit is exceeded"""
-    
-    def __init__(
-        self,
-        message: str = "Rate limit exceeded",
-        retry_after: Optional[int] = None,
-        details: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(message, status_code=429, details=details)
-        self.retry_after = retry_after
+class RateLimitError(AudioPodError):
+    """Raised when rate limit is exceeded"""
+    pass
 
 
 class ValidationError(AudioPodError):
@@ -53,44 +31,11 @@ class ValidationError(AudioPodError):
     pass
 
 
-class ProcessingError(APIError):
-    """Raised when audio processing fails"""
+class InsufficientBalanceError(AudioPodError):
+    """Raised when wallet balance is insufficient"""
     
-    def __init__(
-        self,
-        message: str,
-        job_id: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(message, details=details)
-        self.job_id = job_id
-
-
-class FileError(AudioPodError):
-    """Raised when file operations fail"""
-    pass
-
-
-class NetworkError(AudioPodError):
-    """Raised when network operations fail"""
-    pass
-
-
-class TimeoutError(AudioPodError):
-    """Raised when operations timeout"""
-    pass
-
+    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
 
-class InsufficientCreditsError(APIError):
-    """Raised when user has insufficient credits"""
-    
-    def __init__(
-        self,
-        message: str = "Insufficient credits",
-        credits_needed: Optional[int] = None,
-        credits_available: Optional[int] = None,
-        details: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(message, status_code=402, details=details)
-        self.credits_needed = credits_needed
-        self.credits_available = credits_available

audiopod/services/__init__.py

@@ -1,26 +1,30 @@
 """
-AudioPod API Services
-Service classes for different API endpoints
+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 .karaoke import KaraokeService
 from .credits import CreditService
 from .stem_extraction import StemExtractionService
+from .wallet import WalletService
+from .video import VideoService
 
 __all__ = [
+    "BaseService",
     "VoiceService",
-    "MusicService", 
+    "MusicService",
     "TranscriptionService",
     "TranslationService",
     "SpeakerService",
     "DenoiserService",
-    "KaraokeService",
     "CreditService",
-    "StemExtractionService"
+    "StemExtractionService",
+    "WalletService",
+    "VideoService",
 ]
+

audiopod/services/base.py

@@ -1,213 +1,69 @@
 """
-Base service class for AudioPod API services
+Base Service Class
 """
 
-import os
 import time
-from typing import TYPE_CHECKING, Optional, Dict, Any, Union, BinaryIO
-from pathlib import Path
-
-from ..exceptions import ValidationError, FileError, ProcessingError
-from ..models import Job, JobStatus
-
-if TYPE_CHECKING:
-    from ..client import Client, AsyncClient
+from typing import Any, Dict, Optional, Tuple, BinaryIO
 
 
 class BaseService:
-    """Base class for all AudioPod API services"""
-    
-    def __init__(self, client: Union["Client", "AsyncClient"], async_mode: bool = False):
+    """Base class for all services"""
+
+    def __init__(self, client: Any, async_mode: bool = False):
         self.client = client
         self.async_mode = async_mode
-        
-    def _validate_file(self, file_path: str, file_type: str = "audio") -> str:
-        """
-        Validate file exists and format is supported
-        
-        Args:
-            file_path: Path to the file
-            file_type: Type of file ('audio' or 'video')
-            
-        Returns:
-            Absolute path to the file
-            
-        Raises:
-            FileError: If file doesn't exist or format not supported
-        """
-        path = Path(file_path)
-        
-        if not path.exists():
-            raise FileError(f"File not found: {file_path}")
-            
-        if not self.client.config.validate_file_format(path.name, file_type):
-            supported_formats = (
-                self.client.config.supported_audio_formats 
-                if file_type == "audio" 
-                else self.client.config.supported_video_formats
-            )
-            raise FileError(
-                f"Unsupported {file_type} format. "
-                f"Supported formats: {', '.join(supported_formats)}"
-            )
-            
-        # Check file size
-        file_size_mb = path.stat().st_size / (1024 * 1024)
-        if file_size_mb > self.client.config.max_file_size_mb:
-            raise FileError(
-                f"File too large: {file_size_mb:.1f}MB. "
-                f"Maximum size: {self.client.config.max_file_size_mb}MB"
-            )
-            
-        return str(path.absolute())
-        
-    def _prepare_file_upload(self, file_path: str, field_name: str = "file") -> Dict[str, Any]:
-        """
-        Prepare file for upload
-        
-        Args:
-            file_path: Path to the file
-            field_name: Form field name for the file
-            
-        Returns:
-            Files dict for requests
-        """
-        validated_path = self._validate_file(file_path)
-        
-        with open(validated_path, 'rb') as f:
-            return {field_name: (Path(validated_path).name, f.read())}
-            
+
+    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 = 300,
-        poll_interval: int = 5
-    ) -> Job:
-        """
-        Wait for job completion with polling
-        
-        Args:
-            job_id: Job ID to wait for
-            timeout: Maximum time to wait in seconds
-            poll_interval: How often to check status in seconds
-            
-        Returns:
-            Completed job
-            
-        Raises:
-            ProcessingError: If job fails or times out
-        """
+        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:
-            job_data = self.client.request("GET", f"/api/v1/jobs/{job_id}")
-            job = Job.from_dict(job_data)
-            
-            if job.status == JobStatus.COMPLETED:
-                return job
-            elif job.status == JobStatus.FAILED:
-                raise ProcessingError(
-                    f"Job {job_id} failed: {job.error_message}",
-                    job_id=str(job_id)
-                )
-            elif job.status == JobStatus.CANCELLED:
-                raise ProcessingError(
-                    f"Job {job_id} was cancelled",
-                    job_id=str(job_id)
-                )
-                
+            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 ProcessingError(
-            f"Job {job_id} timed out after {timeout} seconds",
-            job_id=str(job_id)
-        )
-        
+
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+
     async def _async_wait_for_completion(
-        self,
-        job_id: int,
-        timeout: int = 300,
-        poll_interval: int = 5
-    ) -> Job:
-        """
-        Async version of wait_for_completion
-        
-        Args:
-            job_id: Job ID to wait for
-            timeout: Maximum time to wait in seconds
-            poll_interval: How often to check status in seconds
-            
-        Returns:
-            Completed job
-            
-        Raises:
-            ProcessingError: If job fails or times out
-        """
+        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:
-            job_data = await self.client.request("GET", f"/api/v1/jobs/{job_id}")
-            job = Job.from_dict(job_data)
-            
-            if job.status == JobStatus.COMPLETED:
-                return job
-            elif job.status == JobStatus.FAILED:
-                raise ProcessingError(
-                    f"Job {job_id} failed: {job.error_message}",
-                    job_id=str(job_id)
-                )
-            elif job.status == JobStatus.CANCELLED:
-                raise ProcessingError(
-                    f"Job {job_id} was cancelled",
-                    job_id=str(job_id)
-                )
-                
+            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 ProcessingError(
-            f"Job {job_id} timed out after {timeout} seconds",
-            job_id=str(job_id)
-        )
-        
-    def _validate_language_code(self, language: str) -> str:
-        """
-        Validate language code format
-        
-        Args:
-            language: Language code to validate
-            
-        Returns:
-            Validated language code
-            
-        Raises:
-            ValidationError: If language code is invalid
-        """
-        if not language or len(language) < 2:
-            raise ValidationError("Language code must be at least 2 characters")
-            
-        # Convert to lowercase for consistency
-        return language.lower()
-        
-    def _validate_text_input(self, text: str, max_length: int = 5000) -> str:
-        """
-        Validate text input
-        
-        Args:
-            text: Text to validate
-            max_length: Maximum allowed length
-            
-        Returns:
-            Validated text
-            
-        Raises:
-            ValidationError: If text is invalid
-        """
-        if not text or not text.strip():
-            raise ValidationError("Text input cannot be empty")
-            
-        if len(text) > max_length:
-            raise ValidationError(f"Text too long. Maximum length: {max_length} characters")
-            
-        return text.strip()
+
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+

audiopod/services/credits.py

@@ -1,46 +1,42 @@
 """
-Credits Service - User credits and usage tracking
+Credits Service - User credits and usage (subscription credits)
 """
 
 from typing import List, Dict, Any
 from .base import BaseService
-from ..models import CreditInfo
 
 
 class CreditService(BaseService):
-    """Service for managing user credits and usage"""
-    
-    def get_credit_balance(self) -> CreditInfo:
-        """Get current credit balance and info"""
+    """
+    Service for managing subscription credits.
+
+    Note: For API wallet (USD-based billing), use client.wallet instead.
+    """
+
+    def get_balance(self) -> Dict[str, Any]:
+        """Get subscription credit balance."""
         if self.async_mode:
-            return self._async_get_credit_balance()
-        else:
-            response = self.client.request("GET", "/api/v1/credits")
-            return CreditInfo.from_dict(response)
-            
-    async def _async_get_credit_balance(self) -> CreditInfo:
-        """Async version of get_credit_balance"""
-        response = await self.client.request("GET", "/api/v1/credits")
-        return CreditInfo.from_dict(response)
-        
+            return self._async_get_balance()
+        return self.client.request("GET", "/api/v1/credits")
+
+    async def _async_get_balance(self) -> Dict[str, Any]:
+        return await self.client.request("GET", "/api/v1/credits")
+
     def get_usage_history(self) -> List[Dict[str, Any]]:
-        """Get credit usage history"""
+        """Get credit usage history."""
         if self.async_mode:
             return self._async_get_usage_history()
-        else:
-            return self.client.request("GET", "/api/v1/credits/usage")
-            
+        return self.client.request("GET", "/api/v1/credits/usage")
+
     async def _async_get_usage_history(self) -> List[Dict[str, Any]]:
-        """Async version of get_usage_history"""
         return await self.client.request("GET", "/api/v1/credits/usage")
-        
-    def get_credit_multipliers(self) -> Dict[str, float]:
-        """Get credit multipliers for different services"""
+
+    def get_multipliers(self) -> Dict[str, float]:
+        """Get credit multipliers for services."""
         if self.async_mode:
-            return self._async_get_credit_multipliers()
-        else:
-            return self.client.request("GET", "/api/v1/credits/multipliers")
-            
-    async def _async_get_credit_multipliers(self) -> Dict[str, float]:
-        """Async version of get_credit_multipliers"""
+            return self._async_get_multipliers()
+        return self.client.request("GET", "/api/v1/credits/multipliers")
+
+    async def _async_get_multipliers(self) -> Dict[str, float]:
         return await self.client.request("GET", "/api/v1/credits/multipliers")
+

audiopod/services/denoiser.py

@@ -1,51 +1,136 @@
 """
-Denoiser Service - Audio denoising operations
+Denoiser Service - Audio noise reduction
+
+API Routes:
+- POST /api/v1/denoiser/denoise      - Denoise audio
+- GET  /api/v1/denoiser/jobs/{id}    - Get job details
+- GET  /api/v1/denoiser/jobs         - List jobs
+- DELETE /api/v1/denoiser/jobs/{id}  - Delete job
 """
 
-from typing import Optional, Union
+from typing import Optional, Dict, Any, List
 from .base import BaseService
-from ..models import Job, DenoiseResult
 
 
 class DenoiserService(BaseService):
-    """Service for audio denoising operations"""
-    
-    def denoise_audio(
+    """Service for audio noise reduction."""
+
+    def denoise(
         self,
-        audio_file: str,
-        quality_mode: str = "balanced",
-        wait_for_completion: bool = False,
-        timeout: int = 600
-    ) -> Union[Job, DenoiseResult]:
-        """Remove noise from audio"""
-        files = self._prepare_file_upload(audio_file, "file")
-        data = {"quality_mode": quality_mode}
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        mode: str = "balanced",
+        wait_for_completion: bool = True,
+        timeout: int = 300,
+        # Legacy parameter name
+        audio_file: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Remove noise from audio.
+
+        Args:
+            file: Path to local audio file
+            url: URL of audio file
+            mode: Denoise mode ("balanced", "studio", or "ultra")
+            wait_for_completion: Wait for completion (default: True)
+            timeout: Max wait time in seconds
+
+        Returns:
+            Job dict with denoised audio URL when completed
+        """
+        # Support both 'file' and legacy 'audio_file' parameter names
+        audio_file = file or audio_file
         
+        data = {"mode": mode}
+        if url:
+            data["url"] = url
+
+        files = self._prepare_file_upload(audio_file, "file") if audio_file else None
+
         if self.async_mode:
-            return self._async_denoise(files, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request(
-                "POST", "/api/v1/denoiser/denoise",
-                data=data, files=files
-            )
-            job = Job.from_dict(response)
-            
-            if wait_for_completion:
-                completed_job = self._wait_for_completion(job.id, timeout)
-                return DenoiseResult.from_dict(completed_job.result or completed_job.__dict__)
-                
-            return job
-            
-    async def _async_denoise(self, files, data, wait_for_completion, timeout):
-        """Async version of denoise_audio"""
-        response = await self.client.request(
-            "POST", "/api/v1/denoiser/denoise",
-            data=data, files=files
-        )
-        job = Job.from_dict(response)
-        
+            return self._async_denoise(data, files, wait_for_completion, timeout)
+
+        response = self.client.request("POST", "/api/v1/denoiser/denoise", data=data, files=files)
+
+        if wait_for_completion:
+            job_id = response.get("id") or response.get("job_id")
+            return self._wait_for_denoise(job_id, timeout)
+        return response
+
+    async def _async_denoise(
+        self, data: Dict, files: Optional[Dict], wait_for_completion: bool, timeout: int
+    ) -> Dict[str, Any]:
+        response = await self.client.request("POST", "/api/v1/denoiser/denoise", data=data, files=files)
         if wait_for_completion:
-            completed_job = await self._async_wait_for_completion(job.id, timeout)
-            return DenoiseResult.from_dict(completed_job.result or completed_job.__dict__)
-            
-        return job
+            job_id = response.get("id") or response.get("job_id")
+            return await self._async_wait_for_denoise(job_id, timeout)
+        return response
+
+    def get_job(self, job_id: int) -> Dict[str, Any]:
+        """Get denoise job details and status."""
+        if self.async_mode:
+            return self._async_get_job(job_id)
+        return self.client.request("GET", f"/api/v1/denoiser/jobs/{job_id}")
+
+    async def _async_get_job(self, job_id: int) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v1/denoiser/jobs/{job_id}")
+
+    def list_jobs(self, skip: int = 0, limit: int = 50) -> List[Dict[str, Any]]:
+        """List denoiser jobs."""
+        if self.async_mode:
+            return self._async_list_jobs(skip, limit)
+        return self.client.request(
+            "GET", "/api/v1/denoiser/jobs", params={"skip": skip, "limit": limit}
+        )
+
+    async def _async_list_jobs(self, skip: int, limit: int) -> List[Dict[str, Any]]:
+        return await self.client.request(
+            "GET", "/api/v1/denoiser/jobs", params={"skip": skip, "limit": limit}
+        )
+
+    def delete_job(self, job_id: int) -> Dict[str, str]:
+        """Delete a denoiser job."""
+        if self.async_mode:
+            return self._async_delete_job(job_id)
+        return self.client.request("DELETE", f"/api/v1/denoiser/jobs/{job_id}")
+
+    async def _async_delete_job(self, job_id: int) -> Dict[str, str]:
+        return await self.client.request("DELETE", f"/api/v1/denoiser/jobs/{job_id}")
+
+    def _wait_for_denoise(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Wait for denoise job completion."""
+        import time
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get_job(job_id)
+            status = job.get("status", "").upper()
+
+            if status == "COMPLETED":
+                return job
+            elif status in ("FAILED", "ERROR"):
+                raise Exception(f"Denoising failed: {job.get('error_message', 'Unknown error')}")
+
+            time.sleep(3)
+
+        raise TimeoutError(f"Denoising {job_id} did not complete within {timeout} seconds")
+
+    async def _async_wait_for_denoise(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Async wait for denoise job completion."""
+        import asyncio
+        import time
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = await self.get_job(job_id)
+            status = job.get("status", "").upper()
+
+            if status == "COMPLETED":
+                return job
+            elif status in ("FAILED", "ERROR"):
+                raise Exception(f"Denoising failed: {job.get('error_message', 'Unknown error')}")
+
+            await asyncio.sleep(3)
+
+        raise TimeoutError(f"Denoising {job_id} did not complete within {timeout} seconds")
+