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

audiopod/cli.py

@@ -1,285 +0,0 @@
-"""
-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/models.py

@@ -1,250 +0,0 @@
-"""
-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:
-    """Speech translation job result"""
-    job: Job
-    source_language: Optional[str] = None
-    target_language: Optional[str] = None
-    display_name: Optional[str] = None
-    audio_output_path: Optional[str] = None
-    video_output_path: Optional[str] = None
-    transcript_path: Optional[str] = None
-    translated_audio_url: Optional[str] = None
-    video_output_url: Optional[str] = None
-    transcript_urls: Optional[Dict[str, str]] = None
-    is_video: bool = False
-    
-    @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'),
-            display_name=data.get('display_name'),
-            audio_output_path=data.get('audio_output_path'),
-            video_output_path=data.get('video_output_path'),
-            transcript_path=data.get('transcript_path'),
-            translated_audio_url=data.get('translated_audio_url'),
-            video_output_url=data.get('video_output_url'),
-            transcript_urls=data.get('transcript_urls'),
-            is_video=data.get('is_video', False)
-        )
-    
-    @property
-    def audio_output_url(self) -> Optional[str]:
-        """Backward compatibility property - returns translated_audio_url"""
-        return self.translated_audio_url
-
-
-@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/py.typed

@@ -1,2 +0,0 @@
-# Marker file for PEP 561
-# This package supports type checking

audiopod/services/karaoke.py

@@ -1,61 +0,0 @@
-"""
-Karaoke Service - Karaoke video generation
-"""
-
-from typing import Optional, Union
-from .base import BaseService
-from ..models import Job
-
-
-class KaraokeService(BaseService):
-    """Service for karaoke video generation"""
-    
-    def generate_karaoke(
-        self,
-        audio_file: Optional[str] = None,
-        youtube_url: Optional[str] = None,
-        custom_lyrics: Optional[str] = None,
-        video_style: str = "modern",
-        wait_for_completion: bool = False,
-        timeout: int = 1200
-    ) -> Job:
-        """Generate karaoke video"""
-        if not audio_file and not youtube_url:
-            raise ValueError("Either audio_file or youtube_url must be provided")
-            
-        data = {"video_style": video_style}
-        files = {}
-        
-        if audio_file:
-            files = self._prepare_file_upload(audio_file, "file")
-        if youtube_url:
-            data["youtube_url"] = youtube_url
-        if custom_lyrics:
-            data["custom_lyrics"] = custom_lyrics
-            
-        if self.async_mode:
-            return self._async_generate_karaoke(files, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request(
-                "POST", "/api/v1/karaoke/generate",
-                data=data, files=files if files else None
-            )
-            job = Job.from_dict(response)
-            
-            if wait_for_completion:
-                return self._wait_for_completion(job.id, timeout)
-                
-            return job
-            
-    async def _async_generate_karaoke(self, files, data, wait_for_completion, timeout):
-        """Async version of generate_karaoke"""
-        response = await self.client.request(
-            "POST", "/api/v1/karaoke/generate",
-            data=data, files=files if files else None
-        )
-        job = Job.from_dict(response)
-        
-        if wait_for_completion:
-            return await self._async_wait_for_completion(job.id, timeout)
-            
-        return job