audiopod 1.0.0__py3-none-any.whl

audiopod/config.py

@@ -0,0 +1,63 @@
+"""
+AudioPod Client Configuration
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ClientConfig:
+    """Configuration for AudioPod API client"""
+    
+    # API 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

audiopod/exceptions.py

@@ -0,0 +1,96 @@
+"""
+AudioPod API Client 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
+
+
+class AuthenticationError(AudioPodError):
+    """Raised when API key authentication fails"""
+    pass
+
+
+class APIError(AudioPodError):
+    """Raised when API returns an error response"""
+    
+    def __init__(
+        self, 
+        message: str, 
+        status_code: Optional[int] = None,
+        details: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, details)
+        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 ValidationError(AudioPodError):
+    """Raised when input validation fails"""
+    pass
+
+
+class ProcessingError(APIError):
+    """Raised when audio processing fails"""
+    
+    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
+
+
+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/models.py

@@ -0,0 +1,235 @@
+"""
+AudioPod API Client Models
+Data structures for API responses
+"""
+
+from datetime import datetime
+from typing import Optional, Dict, Any, List, Union
+from dataclasses import dataclass
+from enum import Enum
+
+
+class JobStatus(str, Enum):
+    """Job processing status"""
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class VoiceType(str, Enum):
+    """Voice profile types"""
+    CUSTOM = "custom"
+    STANDARD = "standard"
+
+
+class TTSProvider(str, Enum):
+    """Text-to-speech providers"""
+    AUDIOPOD_SONIC = "audiopod_sonic"
+    OPENAI = "openai"
+    GOOGLE_GEMINI = "google_gemini"
+
+
+@dataclass
+class Job:
+    """Base job information"""
+    id: int
+    status: JobStatus
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    progress: float = 0.0
+    error_message: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+    result: Optional[Dict[str, Any]] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Job':
+        """Create Job from API response data"""
+        return cls(
+            id=data['id'],
+            status=JobStatus(data['status']),
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')),
+            updated_at=datetime.fromisoformat(data['updated_at'].replace('Z', '+00:00')) if data.get('updated_at') else None,
+            completed_at=datetime.fromisoformat(data['completed_at'].replace('Z', '+00:00')) if data.get('completed_at') else None,
+            progress=data.get('progress', 0.0),
+            error_message=data.get('error_message'),
+            parameters=data.get('parameters'),
+            result=data.get('result')
+        )
+
+
+@dataclass
+class VoiceProfile:
+    """Voice profile information"""
+    id: int
+    uuid: str
+    name: str
+    display_name: Optional[str]
+    description: Optional[str]
+    voice_type: VoiceType
+    provider: TTSProvider
+    is_public: bool
+    language_code: Optional[str] = None
+    language_name: Optional[str] = None
+    gender: Optional[str] = None
+    accent: Optional[str] = None
+    created_at: Optional[datetime] = None
+    status: Optional[JobStatus] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'VoiceProfile':
+        """Create VoiceProfile from API response data"""
+        return cls(
+            id=data['id'],
+            uuid=data['uuid'],
+            name=data['name'],
+            display_name=data.get('display_name'),
+            description=data.get('description'),
+            voice_type=VoiceType(data['voice_type']),
+            provider=TTSProvider(data['provider']),
+            is_public=data['is_public'],
+            language_code=data.get('language_code'),
+            language_name=data.get('language_name'),
+            gender=data.get('gender'),
+            accent=data.get('accent'),
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None,
+            status=JobStatus(data['status']) if data.get('status') else None
+        )
+
+
+@dataclass
+class TranscriptionResult:
+    """Transcription job result"""
+    job: Job
+    transcript: Optional[str] = None
+    detected_language: Optional[str] = None
+    confidence_score: Optional[float] = None
+    segments: Optional[List[Dict[str, Any]]] = None
+    audio_duration: Optional[float] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'TranscriptionResult':
+        """Create TranscriptionResult from API response data"""
+        return cls(
+            job=Job.from_dict(data),
+            transcript=data.get('transcript'),
+            detected_language=data.get('detected_language'),
+            confidence_score=data.get('confidence_score'),
+            segments=data.get('segments'),
+            audio_duration=data.get('total_duration')
+        )
+
+
+@dataclass
+class MusicGenerationResult:
+    """Music generation job result"""
+    job: Job
+    output_url: Optional[str] = None
+    output_urls: Optional[Dict[str, str]] = None  # Format -> URL mapping
+    audio_duration: Optional[float] = None
+    actual_seeds: Optional[List[int]] = None
+    share_token: Optional[str] = None
+    share_url: Optional[str] = None
+    is_shared: bool = False
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'MusicGenerationResult':
+        """Create MusicGenerationResult from API response data"""
+        return cls(
+            job=Job.from_dict(data),
+            output_url=data.get('output_url'),
+            output_urls=data.get('output_urls'),
+            audio_duration=data.get('audio_duration'),
+            actual_seeds=data.get('actual_seeds'),
+            share_token=data.get('share_token'),
+            share_url=data.get('share_url'),
+            is_shared=data.get('is_shared', False)
+        )
+
+
+@dataclass
+class TranslationResult:
+    """Translation job result"""
+    job: Job
+    source_language: Optional[str] = None
+    target_language: Optional[str] = None
+    audio_output_url: Optional[str] = None
+    video_output_url: Optional[str] = None
+    transcript_path: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'TranslationResult':
+        """Create TranslationResult from API response data"""
+        return cls(
+            job=Job.from_dict(data),
+            source_language=data.get('source_language'),
+            target_language=data.get('target_language'),
+            audio_output_url=data.get('audio_output_path'),
+            video_output_url=data.get('video_output_path'),
+            transcript_path=data.get('transcript_path')
+        )
+
+
+@dataclass
+class SpeakerAnalysisResult:
+    """Speaker analysis job result"""
+    job: Job
+    num_speakers: Optional[int] = None
+    speaker_segments: Optional[List[Dict[str, Any]]] = None
+    output_paths: Optional[Dict[str, str]] = None
+    rttm_path: Optional[str] = None
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SpeakerAnalysisResult':
+        """Create SpeakerAnalysisResult from API response data"""
+        return cls(
+            job=Job.from_dict(data),
+            num_speakers=data.get('num_speakers'),
+            speaker_segments=data.get('speaker_segments'),
+            output_paths=data.get('output_paths'),
+            rttm_path=data.get('rttm_path')
+        )
+
+
+@dataclass
+class DenoiseResult:
+    """Audio denoising job result"""
+    job: Job
+    output_url: Optional[str] = None
+    video_output_url: Optional[str] = None
+    stats: Optional[Dict[str, Any]] = None
+    is_video: bool = False
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'DenoiseResult':
+        """Create DenoiseResult from API response data"""
+        return cls(
+            job=Job.from_dict(data),
+            output_url=data.get('output_path'),
+            video_output_url=data.get('video_output_path'),
+            stats=data.get('stats'),
+            is_video=data.get('is_video', False)
+        )
+
+
+@dataclass
+class CreditInfo:
+    """User credit information"""
+    balance: int
+    payg_balance: int
+    total_available_credits: int
+    next_reset_date: Optional[datetime] = None
+    total_credits_used: int = 0
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'CreditInfo':
+        """Create CreditInfo from API response data"""
+        return cls(
+            balance=data['balance'],
+            payg_balance=data['payg_balance'],
+            total_available_credits=data['total_available_credits'],
+            next_reset_date=datetime.fromisoformat(data['next_reset_date'].replace('Z', '+00:00')) if data.get('next_reset_date') else None,
+            total_credits_used=data.get('total_credits_used', 0)
+        )

audiopod/services/__init__.py

@@ -0,0 +1,24 @@
+"""
+AudioPod API Services
+Service classes for different API endpoints
+"""
+
+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
+
+__all__ = [
+    "VoiceService",
+    "MusicService", 
+    "TranscriptionService",
+    "TranslationService",
+    "SpeakerService",
+    "DenoiserService",
+    "KaraokeService",
+    "CreditService"
+]

audiopod/services/base.py

@@ -0,0 +1,213 @@
+"""
+Base service class for AudioPod API services
+"""
+
+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
+
+
+class BaseService:
+    """Base class for all AudioPod API services"""
+    
+    def __init__(self, client: Union["Client", "AsyncClient"], 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 _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
+        """
+        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)
+                )
+                
+            time.sleep(poll_interval)
+            
+        raise ProcessingError(
+            f"Job {job_id} timed out after {timeout} seconds",
+            job_id=str(job_id)
+        )
+        
+    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
+        """
+        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)
+                )
+                
+            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()

audiopod/services/credits.py

@@ -0,0 +1,46 @@
+"""
+Credits Service - User credits and usage tracking
+"""
+
+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"""
+        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)
+        
+    def get_usage_history(self) -> List[Dict[str, Any]]:
+        """Get credit usage history"""
+        if self.async_mode:
+            return self._async_get_usage_history()
+        else:
+            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"""
+        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 await self.client.request("GET", "/api/v1/credits/multipliers")