audiopod 1.0.0__py3-none-any.whl

audiopod/__init__.py

@@ -0,0 +1,83 @@
+"""
+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
+"""
+
+from .client import Client, AsyncClient
+from .exceptions import (
+    AudioPodError,
+    AuthenticationError, 
+    APIError,
+    RateLimitError,
+    ValidationError,
+    ProcessingError
+)
+from .models import (
+    Job,
+    VoiceProfile,
+    TranscriptionResult,
+    MusicGenerationResult,
+    TranslationResult
+)
+
+__version__ = "1.0.0"
+__author__ = "AudioPod AI"
+__email__ = "support@audiopod.ai"
+__license__ = "MIT"
+
+# Public API
+__all__ = [
+    # Main clients
+    "Client",
+    "AsyncClient",
+    
+    # Exceptions
+    "AudioPodError",
+    "AuthenticationError",
+    "APIError", 
+    "RateLimitError",
+    "ValidationError",
+    "ProcessingError",
+    
+    # Models
+    "Job",
+    "VoiceProfile",
+    "TranscriptionResult", 
+    "MusicGenerationResult",
+    "TranslationResult",
+]
+
+# Package metadata
+__all__.extend([
+    "__version__",
+    "__author__", 
+    "__email__",
+    "__license__"
+])

audiopod/cli.py

@@ -0,0 +1,285 @@
+"""
+AudioPod CLI - Command Line Interface
+"""
+
+import os
+import sys
+import json
+import click
+from typing import Optional
+
+from .client import Client
+from .exceptions import AudioPodError
+
+
+@click.group()
+@click.option('--api-key', envvar='AUDIOPOD_API_KEY', help='AudioPod API key')
+@click.option('--base-url', default='https://api.audiopod.ai', help='API base URL')
+@click.option('--debug', is_flag=True, help='Enable debug logging')
+@click.pass_context
+def cli(ctx, api_key: str, base_url: str, debug: bool):
+    """AudioPod CLI - Professional Audio Processing powered by AI"""
+    ctx.ensure_object(dict)
+    
+    if not api_key:
+        click.echo("Error: API key is required. Set AUDIOPOD_API_KEY environment variable or use --api-key option.")
+        sys.exit(1)
+    
+    try:
+        ctx.obj['client'] = Client(
+            api_key=api_key,
+            base_url=base_url,
+            debug=debug
+        )
+    except AudioPodError as e:
+        click.echo(f"Error: {e.message}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.pass_context
+def health(ctx):
+    """Check API health status"""
+    try:
+        client = ctx.obj['client']
+        status = client.check_health()
+        click.echo(f"API Status: {status.get('status', 'Unknown')}")
+    except AudioPodError as e:
+        click.echo(f"Health check failed: {e.message}")
+        sys.exit(1)
+
+
+@cli.group()
+def credits():
+    """Credit management commands"""
+    pass
+
+
+@credits.command('balance')
+@click.pass_context
+def credits_balance(ctx):
+    """Get current credit balance"""
+    try:
+        client = ctx.obj['client']
+        credits = client.credits.get_credit_balance()
+        
+        click.echo("Credit Balance:")
+        click.echo(f"  Subscription Credits: {credits.balance:,}")
+        click.echo(f"  Pay-as-you-go Credits: {credits.payg_balance:,}")
+        click.echo(f"  Total Available: {credits.total_available_credits:,}")
+        click.echo(f"  Total Used: {credits.total_credits_used:,}")
+        if credits.next_reset_date:
+            click.echo(f"  Next Reset: {credits.next_reset_date}")
+            
+    except AudioPodError as e:
+        click.echo(f"Failed to get credit balance: {e.message}")
+        sys.exit(1)
+
+
+@credits.command('usage')
+@click.pass_context
+def credits_usage(ctx):
+    """Get credit usage history"""
+    try:
+        client = ctx.obj['client']
+        usage = client.credits.get_usage_history()
+        
+        if not usage:
+            click.echo("No usage history found.")
+            return
+            
+        click.echo("Recent Credit Usage:")
+        for record in usage[:10]:  # Show last 10 records
+            click.echo(f"  {record['created_at']}: {record['service_type']} - {record['credits_used']} credits")
+            
+    except AudioPodError as e:
+        click.echo(f"Failed to get usage history: {e.message}")
+        sys.exit(1)
+
+
+@cli.group()
+def voice():
+    """Voice cloning and TTS commands"""
+    pass
+
+
+@voice.command('clone')
+@click.argument('voice_file', type=click.Path(exists=True))
+@click.argument('text')
+@click.option('--language', '-l', help='Target language code (e.g., en, es)')
+@click.option('--speed', '-s', default=1.0, help='Speech speed (0.5-2.0)')
+@click.option('--wait', is_flag=True, help='Wait for completion')
+@click.option('--output', '-o', help='Output file path')
+@click.pass_context
+def voice_clone(ctx, voice_file: str, text: str, language: Optional[str], 
+               speed: float, wait: bool, output: Optional[str]):
+    """Clone a voice from audio file"""
+    try:
+        client = ctx.obj['client']
+        
+        click.echo(f"Cloning voice from {voice_file}...")
+        
+        job = client.voice.clone_voice(
+            voice_file=voice_file,
+            text=text,
+            language=language,
+            speed=speed,
+            wait_for_completion=wait
+        )
+        
+        if wait:
+            click.echo(f"Voice cloning completed!")
+            if 'output_url' in job:
+                click.echo(f"Generated audio URL: {job['output_url']}")
+            if output:
+                # Here you could add download functionality
+                click.echo(f"To download: curl -o {output} '{job['output_url']}'")
+        else:
+            click.echo(f"Voice cloning job started with ID: {job.id}")
+            click.echo(f"Check status with: audiopod voice status {job.id}")
+            
+    except AudioPodError as e:
+        click.echo(f"Voice cloning failed: {e.message}")
+        sys.exit(1)
+
+
+@voice.command('list')
+@click.option('--limit', default=20, help='Maximum number of voices to show')
+@click.pass_context  
+def voice_list(ctx, limit: int):
+    """List available voice profiles"""
+    try:
+        client = ctx.obj['client']
+        voices = client.voice.list_voice_profiles(limit=limit)
+        
+        if not voices:
+            click.echo("No voice profiles found.")
+            return
+            
+        click.echo("Available Voice Profiles:")
+        for voice in voices:
+            status_icon = "✓" if voice.status == "completed" else "⏳"
+            visibility = "Public" if voice.is_public else "Private"
+            click.echo(f"  {status_icon} {voice.name} (ID: {voice.id}) - {visibility}")
+            if voice.description:
+                click.echo(f"    {voice.description}")
+                
+    except AudioPodError as e:
+        click.echo(f"Failed to list voices: {e.message}")
+        sys.exit(1)
+
+
+@cli.group()
+def music():
+    """Music generation commands"""
+    pass
+
+
+@music.command('generate')
+@click.argument('prompt')
+@click.option('--duration', '-d', default=120.0, help='Duration in seconds')
+@click.option('--wait', is_flag=True, help='Wait for completion')
+@click.option('--output', '-o', help='Output file path')
+@click.pass_context
+def music_generate(ctx, prompt: str, duration: float, wait: bool, output: Optional[str]):
+    """Generate music from text prompt"""
+    try:
+        client = ctx.obj['client']
+        
+        click.echo(f"Generating music: '{prompt}'...")
+        
+        job = client.music.generate_music(
+            prompt=prompt,
+            duration=duration,
+            wait_for_completion=wait
+        )
+        
+        if wait:
+            click.echo("Music generation completed!")
+            if hasattr(job, 'output_url') and job.output_url:
+                click.echo(f"Generated music URL: {job.output_url}")
+            if output:
+                click.echo(f"To download: curl -o {output} '{job.output_url}'")
+        else:
+            click.echo(f"Music generation job started with ID: {job.id}")
+            click.echo(f"Check status with: audiopod music status {job.id}")
+            
+    except AudioPodError as e:
+        click.echo(f"Music generation failed: {e.message}")
+        sys.exit(1)
+
+
+@music.command('list')
+@click.option('--limit', default=20, help='Maximum number of tracks to show')
+@click.pass_context
+def music_list(ctx, limit: int):
+    """List generated music tracks"""
+    try:
+        client = ctx.obj['client']
+        tracks = client.music.list_music_jobs(limit=limit)
+        
+        if not tracks:
+            click.echo("No music tracks found.")
+            return
+            
+        click.echo("Generated Music Tracks:")
+        for track in tracks:
+            status_icon = "✓" if track.job.status == "completed" else "⏳"
+            prompt = track.job.parameters.get('prompt', 'N/A') if track.job.parameters else 'N/A'
+            click.echo(f"  {status_icon} Job {track.job.id}: '{prompt[:50]}...'")
+            
+    except AudioPodError as e:
+        click.echo(f"Failed to list music tracks: {e.message}")
+        sys.exit(1)
+
+
+@cli.group()
+def transcription():
+    """Transcription commands"""
+    pass
+
+
+@transcription.command('transcribe')
+@click.argument('audio_file', type=click.Path(exists=True))
+@click.option('--language', '-l', help='Language code (auto-detect if not specified)')
+@click.option('--speakers', is_flag=True, help='Enable speaker diarization')
+@click.option('--wait', is_flag=True, help='Wait for completion')
+@click.option('--format', '-f', default='txt', help='Output format (txt, json, srt)')
+@click.pass_context
+def transcription_transcribe(ctx, audio_file: str, language: Optional[str], 
+                           speakers: bool, wait: bool, format: str):
+    """Transcribe audio to text"""
+    try:
+        client = ctx.obj['client']
+        
+        click.echo(f"Transcribing {audio_file}...")
+        
+        job = client.transcription.transcribe_audio(
+            audio_file=audio_file,
+            language=language,
+            enable_speaker_diarization=speakers,
+            wait_for_completion=wait
+        )
+        
+        if wait:
+            click.echo("Transcription completed!")
+            if hasattr(job, 'transcript') and job.transcript:
+                click.echo("Transcript:")
+                click.echo(job.transcript)
+            if speakers and hasattr(job, 'segments') and job.segments:
+                click.echo(f"\nFound {len(job.segments)} speaker segments")
+        else:
+            click.echo(f"Transcription job started with ID: {job.id}")
+            
+    except AudioPodError as e:
+        click.echo(f"Transcription failed: {e.message}")
+        sys.exit(1)
+
+
+def main():
+    """Main CLI entry point"""
+    cli()
+
+
+if __name__ == '__main__':
+    main()

audiopod/client.py

@@ -0,0 +1,332 @@
+"""
+AudioPod API Client
+Main client classes for synchronous and asynchronous API access
+"""
+
+import os
+import logging
+from typing import Optional, Dict, Any, Union
+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
+from .services import (
+    VoiceService,
+    MusicService, 
+    TranscriptionService,
+    TranslationService,
+    SpeakerService,
+    DenoiserService,
+    KaraokeService,
+    CreditService
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BaseClient:
+    """Base client with common functionality"""
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        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, 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
+        """
+        # 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."
+            )
+            
+        # Validate API key format
+        if not self.api_key.startswith("ap_"):
+            raise AuthenticationError("Invalid API key format. AudioPod API keys start with 'ap_'")
+            
+        # Configuration
+        self.config = ClientConfig(
+            base_url=base_url or "https://api.audiopod.ai",
+            timeout=timeout,
+            max_retries=max_retries,
+            verify_ssl=verify_ssl,
+            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"
+        }
+        
+    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
+        """Handle API response and raise appropriate exceptions"""
+        try:
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            if response.status_code == 401:
+                raise AuthenticationError("Invalid API key or authentication failed")
+            elif response.status_code == 429:
+                raise RateLimitError("Rate limit exceeded. Please try again later.")
+            elif response.status_code >= 400:
+                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}")
+
+
+class Client(BaseClient):
+    """
+    Synchronous AudioPod API Client
+    
+    Provides access to all AudioPod services through a simple Python interface.
+    """
+    
+    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
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+        
+        # Initialize 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)
+        
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        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
+        """
+        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
+            
+    def get_user_info(self) -> Dict[str, Any]:
+        """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"""
+        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.
+    """
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._session: Optional[aiohttp.ClientSession] = None
+        
+        # Initialize async 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)
+        
+    @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)
+            self._session = aiohttp.ClientSession(
+                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,
+        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
+        """
+        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 def _handle_async_response(self, response: aiohttp.ClientResponse) -> Dict[str, Any]:
+        """Handle async API response and raise appropriate exceptions"""
+        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:
+                try:
+                    error_data = await response.json()
+                    message = error_data.get("detail", str(e))
+                except:
+                    message = str(e)
+                raise APIError(f"API request failed: {message}", status_code=response.status)
+            else:
+                raise APIError(f"Unexpected HTTP error: {e}")
+        except aiohttp.ClientError as e:
+            raise APIError(f"Request failed: {e}")
+            
+    async def get_user_info(self) -> Dict[str, Any]:
+        """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"""
+        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()