audiopod 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

audiopod/__init__.py

@@ -47,7 +47,7 @@ from .models import (
     TranslationResult
 )
 
-__version__ = "1.0.0"
+__version__ = "1.1.1"
 __author__ = "AudioPod AI"
 __email__ = "support@audiopod.ai"
 __license__ = "MIT"

audiopod/client.py

@@ -23,7 +23,8 @@ from .services import (
     SpeakerService,
     DenoiserService,
     KaraokeService,
-    CreditService
+    CreditService,
+    StemExtractionService
 )
 
 logger = logging.getLogger(__name__)
@@ -139,6 +140,7 @@ class Client(BaseClient):
         self.denoiser = DenoiserService(self)
         self.karaoke = KaraokeService(self)
         self.credits = CreditService(self)
+        self.stem_extraction = StemExtractionService(self)
         
     def request(
         self,
@@ -227,6 +229,7 @@ class AsyncClient(BaseClient):
         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)
         
     @property
     def session(self) -> aiohttp.ClientSession:

audiopod/models.py

@@ -151,13 +151,18 @@ class MusicGenerationResult:
 
 @dataclass
 class TranslationResult:
-    """Translation job result"""
+    """Speech 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
+    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':
@@ -166,10 +171,20 @@ class TranslationResult:
             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')
+            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

audiopod/py.typed

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

audiopod/services/__init__.py

@@ -11,6 +11,7 @@ from .speaker import SpeakerService
 from .denoiser import DenoiserService
 from .karaoke import KaraokeService
 from .credits import CreditService
+from .stem_extraction import StemExtractionService
 
 __all__ = [
     "VoiceService",
@@ -20,5 +21,6 @@ __all__ = [
     "SpeakerService",
     "DenoiserService",
     "KaraokeService",
-    "CreditService"
+    "CreditService",
+    "StemExtractionService"
 ]

audiopod/services/music.py

@@ -51,15 +51,15 @@ class MusicService(BaseService):
         if seed is not None and (seed < 0 or seed > 2**32 - 1):
             raise ValidationError("Seed must be between 0 and 2^32 - 1")
             
-        # Prepare request data
+        # Prepare request data - FIXED: Use correct parameter names matching API schema
         data = {
             "prompt": prompt,
-            "duration": duration,
+            "audio_duration": duration,  # FIXED: API expects "audio_duration" not "duration"
             "guidance_scale": guidance_scale,
-            "num_inference_steps": num_inference_steps
+            "infer_step": num_inference_steps  # FIXED: API expects "infer_step" not "num_inference_steps"
         }
         if seed is not None:
-            data["seed"] = seed
+            data["manual_seeds"] = [seed]  # FIXED: API expects "manual_seeds" list not "seed"
         if display_name:
             data["display_name"] = display_name.strip()
             
@@ -68,7 +68,9 @@ class MusicService(BaseService):
             return self._async_generate_music(data, wait_for_completion, timeout)
         else:
             response = self.client.request("POST", "/api/v1/music/text2music", data=data)
-            job = Job.from_dict(response)
+            # FIXED: Handle response format correctly - API returns {"job": {...}, "message": "..."}
+            job_data = response.get("job", response)
+            job = Job.from_dict(job_data)
             
             if wait_for_completion:
                 completed_job = self._wait_for_completion(job.id, timeout)
@@ -84,7 +86,9 @@ class MusicService(BaseService):
     ) -> Union[Job, MusicGenerationResult]:
         """Async version of generate_music"""
         response = await self.client.request("POST", "/api/v1/music/text2music", data=data)
-        job = Job.from_dict(response)
+        # FIXED: Handle response format correctly
+        job_data = response.get("job", response)
+        job = Job.from_dict(job_data)
         
         if wait_for_completion:
             completed_job = await self._async_wait_for_completion(job.id, timeout)
@@ -122,11 +126,14 @@ class MusicService(BaseService):
         if style not in ["modern", "classic", "trap"]:
             raise ValidationError("Style must be 'modern', 'classic', or 'trap'")
             
-        # Prepare request data
+        # Prepare request data - FIXED: Match API schema for text2rap
         data = {
+            "prompt": f"rap music, {style} style",  # FIXED: API expects "prompt" field
             "lyrics": lyrics,
-            "style": style,
-            "tempo": tempo
+            "audio_duration": 120.0,  # Default duration
+            "guidance_scale": 7.5,
+            "infer_step": 50,
+            "lora_name_or_path": "ACE-Step/ACE-Step-v1-chinese-rap-LoRA"  # Rap-specific LoRA
         }
         if display_name:
             data["display_name"] = display_name.strip()
@@ -136,7 +143,9 @@ class MusicService(BaseService):
             return self._async_generate_rap(data, wait_for_completion, timeout)
         else:
             response = self.client.request("POST", "/api/v1/music/text2rap", data=data)
-            job = Job.from_dict(response)
+            # FIXED: Handle response format correctly
+            job_data = response.get("job", response)
+            job = Job.from_dict(job_data)
             
             if wait_for_completion:
                 completed_job = self._wait_for_completion(job.id, timeout)
@@ -152,7 +161,9 @@ class MusicService(BaseService):
     ) -> Union[Job, MusicGenerationResult]:
         """Async version of generate_rap"""
         response = await self.client.request("POST", "/api/v1/music/text2rap", data=data)
-        job = Job.from_dict(response)
+        # FIXED: Handle response format correctly
+        job_data = response.get("job", response)
+        job = Job.from_dict(job_data)
         
         if wait_for_completion:
             completed_job = await self._async_wait_for_completion(job.id, timeout)
@@ -194,10 +205,12 @@ class MusicService(BaseService):
         if tempo is not None and not 60 <= tempo <= 200:
             raise ValidationError("Tempo must be between 60 and 200 BPM")
             
-        # Prepare request data
+        # Prepare request data - FIXED: Match API schema for prompt2instrumental
         data = {
             "prompt": prompt,
-            "duration": duration
+            "audio_duration": duration,  # FIXED: API expects "audio_duration"
+            "guidance_scale": 7.5,
+            "infer_step": 50
         }
         if instruments:
             data["instruments"] = instruments
@@ -213,7 +226,9 @@ class MusicService(BaseService):
             return self._async_generate_instrumental(data, wait_for_completion, timeout)
         else:
             response = self.client.request("POST", "/api/v1/music/prompt2instrumental", data=data)
-            job = Job.from_dict(response)
+            # FIXED: Handle response format correctly
+            job_data = response.get("job", response)
+            job = Job.from_dict(job_data)
             
             if wait_for_completion:
                 completed_job = self._wait_for_completion(job.id, timeout)
@@ -229,7 +244,80 @@ class MusicService(BaseService):
     ) -> Union[Job, MusicGenerationResult]:
         """Async version of generate_instrumental"""
         response = await self.client.request("POST", "/api/v1/music/prompt2instrumental", data=data)
-        job = Job.from_dict(response)
+        # FIXED: Handle response format correctly
+        job_data = response.get("job", response)
+        job = Job.from_dict(job_data)
+        
+        if wait_for_completion:
+            completed_job = await self._async_wait_for_completion(job.id, timeout)
+            return MusicGenerationResult.from_dict(completed_job.result or completed_job.__dict__)
+            
+        return job
+    
+    def generate_vocals(
+        self,
+        lyrics: str,
+        prompt: str = "vocals",
+        duration: float = 120.0,
+        display_name: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 600
+    ) -> Union[Job, MusicGenerationResult]:
+        """
+        Generate vocals from lyrics - NEW METHOD matching API lyric2vocals endpoint
+        
+        Args:
+            lyrics: Song lyrics
+            prompt: Vocal style description
+            duration: Duration in seconds
+            display_name: Custom name for the track
+            wait_for_completion: Whether to wait for completion
+            timeout: Maximum time to wait
+            
+        Returns:
+            Job object or generation result
+        """
+        # Validate inputs
+        lyrics = self._validate_text_input(lyrics, max_length=10000)
+        prompt = self._validate_text_input(prompt, max_length=2000)
+        if not 10.0 <= duration <= 600.0:
+            raise ValidationError("Duration must be between 10 and 600 seconds")
+            
+        # Prepare request data - Match API schema for lyric2vocals
+        data = {
+            "prompt": prompt,
+            "lyrics": lyrics,
+            "audio_duration": duration,
+            "guidance_scale": 7.5,
+            "infer_step": 50
+        }
+        if display_name:
+            data["display_name"] = display_name.strip()
+            
+        # Make request
+        if self.async_mode:
+            return self._async_generate_vocals(data, wait_for_completion, timeout)
+        else:
+            response = self.client.request("POST", "/api/v1/music/lyric2vocals", data=data)
+            job_data = response.get("job", response)
+            job = Job.from_dict(job_data)
+            
+            if wait_for_completion:
+                completed_job = self._wait_for_completion(job.id, timeout)
+                return MusicGenerationResult.from_dict(completed_job.result or completed_job.__dict__)
+                
+            return job
+    
+    async def _async_generate_vocals(
+        self,
+        data: Dict[str, Any],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Union[Job, MusicGenerationResult]:
+        """Async version of generate_vocals"""
+        response = await self.client.request("POST", "/api/v1/music/lyric2vocals", data=data)
+        job_data = response.get("job", response)
+        job = Job.from_dict(job_data)
         
         if wait_for_completion:
             completed_job = await self._async_wait_for_completion(job.id, timeout)
@@ -322,7 +410,7 @@ class MusicService(BaseService):
         """
         params = {
             "limit": limit,
-            "skip": offset
+            "skip": offset  # FIXED: API uses "skip" parameter for offset
         }
         if status:
             params["status"] = status

audiopod/services/stem_extraction.py

@@ -0,0 +1,180 @@
+"""
+Stem Extraction Service - Audio stem separation operations
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from .base import BaseService
+from ..models import Job
+from ..exceptions import ValidationError
+
+
+class StemExtractionService(BaseService):
+    """Service for audio stem extraction operations"""
+    
+    def extract_stems(
+        self,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        stem_types: List[str] = None,
+        model_name: str = "htdemucs",
+        two_stems_mode: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 900
+    ) -> Job:
+        """
+        Extract stems from audio file
+        
+        Args:
+            audio_file: Path to audio file to process
+            url: URL of audio file to process (alternative to audio_file)
+            stem_types: List of stems to extract (e.g., ['vocals', 'drums', 'bass', 'other'])
+            model_name: Model to use for separation ('htdemucs' or 'htdemucs_6s')
+            two_stems_mode: Two-stem mode for vocals/instrumental separation
+            wait_for_completion: Whether to wait for completion
+            timeout: Maximum time to wait
+            
+        Returns:
+            Job object with stem extraction details
+        """
+        if not audio_file and not url:
+            raise ValidationError("Either audio_file or url must be provided")
+        
+        if audio_file and url:
+            raise ValidationError("Provide either audio_file or url, not both")
+        
+        # Set default stem types based on model
+        if stem_types is None:
+            if model_name == "htdemucs_6s":
+                stem_types = ["vocals", "drums", "bass", "other", "piano", "guitar"]
+            else:
+                stem_types = ["vocals", "drums", "bass", "other"]
+        
+        # Validate model name
+        if model_name not in ["htdemucs", "htdemucs_6s"]:
+            raise ValidationError("Model name must be 'htdemucs' or 'htdemucs_6s'")
+        
+        # Prepare request
+        files = {}
+        data = {
+            "stem_types": str(stem_types),  # API expects string representation
+            "model_name": model_name
+        }
+        
+        if audio_file:
+            files = self._prepare_file_upload(audio_file, "file")
+        
+        if url:
+            data["url"] = url
+        
+        if two_stems_mode:
+            data["two_stems_mode"] = two_stems_mode
+        
+        if self.async_mode:
+            return self._async_extract_stems(files, data, wait_for_completion, timeout)
+        else:
+            response = self.client.request(
+                "POST", 
+                "/api/v1/stem-extraction/extract",
+                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_extract_stems(
+        self,
+        files: Dict[str, Any],
+        data: Dict[str, Any],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Job:
+        """Async version of extract_stems"""
+        response = await self.client.request(
+            "POST",
+            "/api/v1/stem-extraction/extract",
+            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
+    
+    def get_stem_job(self, job_id: int) -> Job:
+        """
+        Get stem extraction job status
+        
+        Args:
+            job_id: ID of the stem extraction job
+            
+        Returns:
+            Job object with current status
+        """
+        if self.async_mode:
+            return self._async_get_stem_job(job_id)
+        else:
+            response = self.client.request("GET", f"/api/v1/stem-extraction/status/{job_id}")
+            return Job.from_dict(response)
+    
+    async def _async_get_stem_job(self, job_id: int) -> Job:
+        """Async version of get_stem_job"""
+        response = await self.client.request("GET", f"/api/v1/stem-extraction/status/{job_id}")
+        return Job.from_dict(response)
+    
+    def list_stem_jobs(
+        self,
+        skip: int = 0,
+        limit: int = 50
+    ) -> List[Job]:
+        """
+        List stem extraction jobs
+        
+        Args:
+            skip: Number of jobs to skip
+            limit: Maximum number of jobs to return
+            
+        Returns:
+            List of stem extraction jobs
+        """
+        params = {
+            "skip": skip,
+            "limit": limit
+        }
+        
+        if self.async_mode:
+            return self._async_list_stem_jobs(params)
+        else:
+            response = self.client.request("GET", "/api/v1/stem-extraction/jobs", params=params)
+            return [Job.from_dict(job_data) for job_data in response]
+    
+    async def _async_list_stem_jobs(self, params: Dict[str, Any]) -> List[Job]:
+        """Async version of list_stem_jobs"""
+        response = await self.client.request("GET", "/api/v1/stem-extraction/jobs", params=params)
+        return [Job.from_dict(job_data) for job_data in response]
+    
+    def delete_stem_job(self, job_id: int) -> Dict[str, str]:
+        """
+        Delete a stem extraction job
+        
+        Args:
+            job_id: ID of the job to delete
+            
+        Returns:
+            Deletion confirmation
+        """
+        if self.async_mode:
+            return self._async_delete_stem_job(job_id)
+        else:
+            return self.client.request("DELETE", f"/api/v1/stem-extraction/jobs/{job_id}")
+    
+    async def _async_delete_stem_job(self, job_id: int) -> Dict[str, str]:
+        """Async version of delete_stem_job"""
+        return await self.client.request("DELETE", f"/api/v1/stem-extraction/jobs/{job_id}")

audiopod/services/translation.py

@@ -1,42 +1,59 @@
 """
-Translation Service - Audio/video translation operations
+Translation Service - Speech-to-speech translation operations
 """
 
 from typing import Optional, Union
 from .base import BaseService
 from ..models import Job, TranslationResult
+from ..exceptions import ValidationError
 
 
 class TranslationService(BaseService):
-    """Service for audio and video translation operations"""
+    """Service for speech-to-speech translation operations"""
     
     def translate_audio(
         self,
-        audio_file: str,
-        target_language: str,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        target_language: str = "en",
         source_language: Optional[str] = None,
         wait_for_completion: bool = False,
         timeout: int = 900
     ) -> Union[Job, TranslationResult]:
         """
-        Translate audio to another language
+        Translate speech from audio/video file to another language while preserving voice characteristics
         
         Args:
-            audio_file: Path to audio file
-            target_language: Target language code
-            source_language: Source language (auto-detect if None)
+            audio_file: Path to audio/video file (required if no URL)
+            url: Direct media URL (required if no file)
+            target_language: Target language code (ISO 639-1, e.g., 'es' for Spanish)
+            source_language: Source language code (auto-detect if None)
             wait_for_completion: Whether to wait for completion
             timeout: Maximum time to wait
             
         Returns:
             Job object or translation result
         """
+        if not audio_file and not url:
+            raise ValidationError("Either audio_file or url must be provided")
+        
+        if audio_file and url:
+            raise ValidationError("Provide either audio_file or url, not both")
+            
         target_language = self._validate_language_code(target_language)
         if source_language:
             source_language = self._validate_language_code(source_language)
             
-        files = self._prepare_file_upload(audio_file, "file")
+        # Prepare request data
+        files = {}
         data = {"target_language": target_language}
+        
+        if audio_file:
+            files = self._prepare_file_upload(audio_file, "file")
+        
+        if url:
+            data["url"] = url
+            
         if source_language:
             data["source_language"] = source_language
             
@@ -44,7 +61,10 @@ class TranslationService(BaseService):
             return self._async_translate_audio(files, data, wait_for_completion, timeout)
         else:
             response = self.client.request(
-                "POST", "/api/v1/translation/translate", data=data, files=files
+                "POST", 
+                "/api/v1/translation/translate/speech",  # FIXED: Use correct speech-to-speech endpoint
+                data=data, 
+                files=files if files else None
             )
             job = Job.from_dict(response)
             
@@ -53,11 +73,35 @@ class TranslationService(BaseService):
                 return TranslationResult.from_dict(completed_job.result or completed_job.__dict__)
                 
             return job
+    
+    def translate_speech(
+        self,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        target_language: str = "en",
+        source_language: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 900
+    ) -> Union[Job, TranslationResult]:
+        """
+        Alias for translate_audio - more descriptive method name for speech translation
+        """
+        return self.translate_audio(
+            audio_file=audio_file,
+            url=url,
+            target_language=target_language,
+            source_language=source_language,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout
+        )
             
     async def _async_translate_audio(self, files, data, wait_for_completion, timeout):
         """Async version of translate_audio"""
         response = await self.client.request(
-            "POST", "/api/v1/translation/translate", data=data, files=files
+            "POST", 
+            "/api/v1/translation/translate/speech",  # FIXED: Use correct speech-to-speech endpoint
+            data=data, 
+            files=files if files else None
         )
         job = Job.from_dict(response)
         
@@ -79,3 +123,74 @@ class TranslationService(BaseService):
         """Async version of get_translation_job"""
         response = await self.client.request("GET", f"/api/v1/translation/translations/{job_id}")
         return TranslationResult.from_dict(response)
+    
+    def list_translation_jobs(
+        self,
+        skip: int = 0,
+        limit: int = 50
+    ) -> list:
+        """
+        List translation jobs
+        
+        Args:
+            skip: Number of jobs to skip (pagination offset)
+            limit: Maximum number of jobs to return (max 100)
+            
+        Returns:
+            List of translation jobs
+        """
+        params = {
+            "skip": skip,
+            "limit": min(limit, 100)  # API max is 100
+        }
+        
+        if self.async_mode:
+            return self._async_list_translation_jobs(params)
+        else:
+            response = self.client.request("GET", "/api/v1/translation/translations", params=params)
+            return [TranslationResult.from_dict(job_data) for job_data in response]
+    
+    async def _async_list_translation_jobs(self, params: dict) -> list:
+        """Async version of list_translation_jobs"""
+        response = await self.client.request("GET", "/api/v1/translation/translations", params=params)
+        return [TranslationResult.from_dict(job_data) for job_data in response]
+    
+    def retry_translation(self, job_id: int) -> Job:
+        """
+        Retry a failed translation job
+        
+        Args:
+            job_id: ID of the failed translation job to retry
+            
+        Returns:
+            New job object for the retry attempt
+        """
+        if self.async_mode:
+            return self._async_retry_translation(job_id)
+        else:
+            response = self.client.request("POST", f"/api/v1/translation/translations/{job_id}/retry")
+            return Job.from_dict(response)
+    
+    async def _async_retry_translation(self, job_id: int) -> Job:
+        """Async version of retry_translation"""
+        response = await self.client.request("POST", f"/api/v1/translation/translations/{job_id}/retry")
+        return Job.from_dict(response)
+    
+    def delete_translation_job(self, job_id: int) -> dict:
+        """
+        Delete a translation job
+        
+        Args:
+            job_id: ID of the translation job to delete
+            
+        Returns:
+            Deletion confirmation
+        """
+        if self.async_mode:
+            return self._async_delete_translation_job(job_id)
+        else:
+            return self.client.request("DELETE", f"/api/v1/translation/translations/{job_id}")
+    
+    async def _async_delete_translation_job(self, job_id: int) -> dict:
+        """Async version of delete_translation_job"""
+        return await self.client.request("DELETE", f"/api/v1/translation/translations/{job_id}")

{audiopod-1.0.0.dist-info → audiopod-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiopod
-Version: 1.0.0
+Version: 1.1.1
 Summary: Professional Audio Processing API Client for Python
 Home-page: https://github.com/audiopod-ai/audiopod-python
 Author: AudioPod AI
@@ -25,6 +25,7 @@ Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: requests>=2.28.0
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pydantic>=1.10.0
@@ -46,6 +47,7 @@ Requires-Dist: sphinx-rtd-theme>=1.2.0; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints>=1.19.0; extra == "docs"
 Dynamic: author
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-python
 
 # AudioPod Python SDK
@@ -140,17 +142,25 @@ print(f"Transcript: {transcript.transcript}")
 print(f"Detected {len(transcript.segments)} speakers")
 ```
 
-#### Audio Translation
+#### Speech-to-Speech Translation
 
 ```python
-# Translate audio to another language
-translation = client.translation.translate_audio(
+# Translate speech while preserving voice characteristics
+translation = client.translation.translate_speech(
     audio_file="path/to/english_audio.wav",
     target_language="es",  # Spanish
+    source_language="en",  # English (optional - auto-detect)
     wait_for_completion=True
 )
 
-print(f"Translated audio URL: {translation.audio_output_url}")
+print(f"Translated audio URL: {translation.translated_audio_url}")
+
+# Or translate from URL
+url_translation = client.translation.translate_speech(
+    url="https://example.com/audio.mp3",
+    target_language="fr",  # French
+    wait_for_completion=True
+)
 ```
 
 ### Async Support
@@ -380,11 +390,10 @@ audiopod transcription transcribe audio.mp3 --language en
 
 ## Support
 
-- 📖 [Documentation](https://docs.audiopod.ai)
-- 🎯 [API Reference](https://api.audiopod.ai/docs) 
+- 📖 [API Reference](https://docs.audiopod.ai)
 - 💬 [Discord Community](https://discord.gg/audiopod)
 - 📧 [Email Support](mailto:support@audiopod.ai)
-- 🐛 [Bug Reports](https://github.com/audiopod-ai/audiopod-python/issues)
+- 🐛 [Bug Reports](https://github.com/AudiopodAI/audiopod)
 
 ## License
 

audiopod-1.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+audiopod/__init__.py,sha256=UsB5ET6nUy1Upx8wCiB17mMErdF3RvEHfAr51-pPPGQ,1790
+audiopod/cli.py,sha256=ZYzAQ3UpoYuOEWivMwMneJUf2z8DGGYTx1Nb6yRfdVY,9339
+audiopod/client.py,sha256=67oPSInSNssJpTR00ZuYSdk9lbx5KiRnDQw8UYKNVsA,11742
+audiopod/config.py,sha256=fuGtbuES4tXdHwqQqoZa5izCH6nVfFRP06D8eK1Cg10,1683
+audiopod/exceptions.py,sha256=c3Ym2tWyRE1kemVkXDaXFcfP3h6AokhKcUcCBImwGes,2386
+audiopod/models.py,sha256=R70iMqKDZfLtTB9FQ7KrFLBi-bFA5-FrS-5eMOtfK1o,8517
+audiopod/py.typed,sha256=ixa8YukDZ3kLo0WsFJRGohLMyHzbMur1ALmmASML2cs,64
+audiopod/services/__init__.py,sha256=9Ycl9VVscwwY42joBCSL67v8DrITW2T2QyuaokbpehM,653
+audiopod/services/base.py,sha256=mNbziYy2KsWWZrdHFlTl9pKLvoQUW-ZkkJuVWfCVP74,6731
+audiopod/services/credits.py,sha256=CjE2W8kmYjM4B02BwfPvvB3kl0YdVimM2kR7lhg43h8,1796
+audiopod/services/denoiser.py,sha256=Oi_1rCKs_L5lCG_2QuKwHzLe8_mbEIzlzM2X8TJ7Rnc,1750
+audiopod/services/karaoke.py,sha256=M0Befh4Y2DNM_uWFTmCIrzKfjqkvygrzCt0f_Dubj2o,2012
+audiopod/services/music.py,sha256=hDPjTSj-gAeEWBVB7PRPQrptMHJyQTz8e9p-p7yaRPI,20032
+audiopod/services/speaker.py,sha256=OPSOwArfrGXVzRgciS13n1QsCJSK1PB-Mz6VgwxuHAA,1866
+audiopod/services/stem_extraction.py,sha256=3ibMFKFR25xKHpVs3WGMNriZ88sB5PriFNa_s2Bvon4,6026
+audiopod/services/transcription.py,sha256=HyH6WpGWZsggYxIvt2dhB6_5UHaigk3XwXsVgarWzcE,7565
+audiopod/services/translation.py,sha256=oUU82c61CeAt13lzlWx8S-9xEgYlskwX8bLMbQw2Ni8,7396
+audiopod/services/voice.py,sha256=_IHv3zU3k184kfijxr1QRBenrIpmhhPOBS96DddZ8yw,13456
+audiopod-1.1.1.dist-info/licenses/LICENSE,sha256=hqEjnOaGNbnLSBxbtbC7WQVREU2vQI8FmwecCiZlMfA,1068
+audiopod-1.1.1.dist-info/METADATA,sha256=UG_csntfzscrZTjy-2v-lCTlS7-VSEM6WEwUw26hSYc,11217
+audiopod-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+audiopod-1.1.1.dist-info/entry_points.txt,sha256=uLcNDzXuOXnJAz9j91TDGayVjjZ7-ZiHBGDydqNUErU,47
+audiopod-1.1.1.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
+audiopod-1.1.1.dist-info/RECORD,,

audiopod-1.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AudioPod AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

audiopod-1.0.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-audiopod/__init__.py,sha256=GyQ7PUWGF3t4Ljuk_DD6O9MvG_A96T5bedXc3jJQCD4,1790
-audiopod/cli.py,sha256=ZYzAQ3UpoYuOEWivMwMneJUf2z8DGGYTx1Nb6yRfdVY,9339
-audiopod/client.py,sha256=AF5goB5CG5lJZ3XyGojRskvUNrNzn9A34BAx9Z1sEOE,11580
-audiopod/config.py,sha256=fuGtbuES4tXdHwqQqoZa5izCH6nVfFRP06D8eK1Cg10,1683
-audiopod/exceptions.py,sha256=c3Ym2tWyRE1kemVkXDaXFcfP3h6AokhKcUcCBImwGes,2386
-audiopod/models.py,sha256=gAfQkufA_hZdYBkniFJ_EXETy9ts-wr-soUEbT7ZKFM,7827
-audiopod/services/__init__.py,sha256=rt_9CHqmEJgHyVFdF2WwTE403CXpDGBCYzfCxJZZjgE,573
-audiopod/services/base.py,sha256=mNbziYy2KsWWZrdHFlTl9pKLvoQUW-ZkkJuVWfCVP74,6731
-audiopod/services/credits.py,sha256=CjE2W8kmYjM4B02BwfPvvB3kl0YdVimM2kR7lhg43h8,1796
-audiopod/services/denoiser.py,sha256=Oi_1rCKs_L5lCG_2QuKwHzLe8_mbEIzlzM2X8TJ7Rnc,1750
-audiopod/services/karaoke.py,sha256=M0Befh4Y2DNM_uWFTmCIrzKfjqkvygrzCt0f_Dubj2o,2012
-audiopod/services/music.py,sha256=m6cF_2cbB4X-BHvJH36oqD2NBF_dIWCAUB2HIpZgoxo,15948
-audiopod/services/speaker.py,sha256=OPSOwArfrGXVzRgciS13n1QsCJSK1PB-Mz6VgwxuHAA,1866
-audiopod/services/transcription.py,sha256=HyH6WpGWZsggYxIvt2dhB6_5UHaigk3XwXsVgarWzcE,7565
-audiopod/services/translation.py,sha256=Gpxmom-ZSLMXBwSQlOL5PyqxQCwRYNT2IUp2ZD5QhYc,3177
-audiopod/services/voice.py,sha256=_IHv3zU3k184kfijxr1QRBenrIpmhhPOBS96DddZ8yw,13456
-audiopod-1.0.0.dist-info/METADATA,sha256=S7iD1nLEk-xXknM1K8sze0ucL2oVGtxcXpvtIFRGtTY,10956
-audiopod-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-audiopod-1.0.0.dist-info/entry_points.txt,sha256=uLcNDzXuOXnJAz9j91TDGayVjjZ7-ZiHBGDydqNUErU,47
-audiopod-1.0.0.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
-audiopod-1.0.0.dist-info/RECORD,,