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

audiopod/__init__.py

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

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/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/services/voice.py

@@ -2,6 +2,7 @@
 Voice Service - Voice cloning and TTS operations
 """
 
+import time
 from typing import List, Optional, Dict, Any, Union
 from pathlib import Path
 
@@ -13,54 +14,103 @@ from ..exceptions import ValidationError
 class VoiceService(BaseService):
     """Service for voice cloning and text-to-speech operations"""
     
-    def clone_voice(
+    def generate_voice(
         self,
-        voice_file: str,
         text: str,
+        voice_file: Optional[str] = None,
+        voice_id: Optional[Union[int, str]] = None,
         language: Optional[str] = None,
         speed: float = 1.0,
+        audio_format: str = "mp3",
+        generation_params: Optional[Dict[str, Any]] = None,
         wait_for_completion: bool = False,
         timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
         """
-        Clone a voice from an audio file
+        Generate speech using either a voice file (for cloning) or existing voice profile
+        
+        This unified method handles both voice cloning and text-to-speech generation:
+        - For voice cloning: Provide voice_file parameter
+        - For TTS with existing voice: Provide voice_id parameter
         
         Args:
-            voice_file: Path to audio file containing voice to clone
-            text: Text to generate with the cloned voice
+            text: Text to generate speech for
+            voice_file: Path to audio file for voice cloning (mutually exclusive with voice_id)
+            voice_id: ID/UUID of existing voice profile (mutually exclusive with voice_file)
             language: Target language code (e.g., 'en', 'es')
-            speed: Speech speed (0.5 to 2.0)
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            audio_format: Output audio format ('mp3', 'wav', 'ogg')
+            generation_params: Provider-specific parameters (speed, temperature, etc.)
             wait_for_completion: Whether to wait for job completion
             timeout: Maximum time to wait if wait_for_completion=True
             
         Returns:
             Job object if wait_for_completion=False, otherwise job result
+            
+        Raises:
+            ValidationError: If both or neither voice_file and voice_id are provided
         """
         # Validate inputs
+        if not voice_file and not voice_id:
+            raise ValidationError("Either voice_file (for cloning) or voice_id (for TTS) must be provided")
+        if voice_file and voice_id:
+            raise ValidationError("Provide either voice_file or voice_id, not both")
+            
         text = self._validate_text_input(text)
         if language:
             language = self._validate_language_code(language)
-        if not 0.5 <= speed <= 2.0:
-            raise ValidationError("Speed must be between 0.5 and 2.0")
+        if not 0.25 <= speed <= 4.0:
+            raise ValidationError("Speed must be between 0.25 and 4.0")
+        if audio_format not in ["mp3", "wav", "ogg"]:
+            raise ValidationError("Audio format must be 'mp3', 'wav', or 'ogg'")
             
-        # Prepare file upload
+        # For voice cloning, we need to create a temporary voice first, then generate
+        if voice_file:
+            return self._generate_with_voice_file(
+                voice_file, text, language, speed, audio_format, 
+                generation_params, wait_for_completion, timeout
+            )
+        else:
+            # Use existing voice profile with unified endpoint
+            return self._generate_with_voice_id(
+                voice_id, text, language, speed, audio_format,
+                generation_params, wait_for_completion, timeout
+            )
+            
+    def _generate_with_voice_file(
+        self,
+        voice_file: str,
+        text: str,
+        language: Optional[str],
+        speed: float,
+        audio_format: str,
+        generation_params: Optional[Dict[str, Any]],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Union[Job, Dict[str, Any]]:
+        """Generate speech with voice cloning using unified endpoint"""
+        # For voice cloning, we use the "clone" identifier with the unified endpoint
         files = self._prepare_file_upload(voice_file, "file")
         
-        # Prepare form data
+        # Prepare form data for unified endpoint
         data = {
             "input_text": text,
-            "speed": speed
+            "speed": speed,
+            "audio_format": audio_format
         }
         if language:
-            data["target_language"] = language
+            data["language"] = language
+        if generation_params:
+            # Add generation parameters
+            data.update(generation_params)
             
-        # Make request
         if self.async_mode:
-            return self._async_clone_voice(files, data, wait_for_completion, timeout)
+            return self._async_generate_voice("clone", data, files, wait_for_completion, timeout)
         else:
+            # Use unified voice generation endpoint with "clone" identifier
             response = self.client.request(
                 "POST", 
-                "/api/v1/voice/voice-clone",
+                "/api/v1/voice/voices/clone/generate",
                 data=data,
                 files=files
             )
@@ -73,17 +123,60 @@ class VoiceService(BaseService):
             
             return job
             
-    async def _async_clone_voice(
+    def _generate_with_voice_id(
         self,
-        files: Dict[str, Any],
+        voice_id: Union[int, str],
+        text: str,
+        language: Optional[str],
+        speed: float,
+        audio_format: str,
+        generation_params: Optional[Dict[str, Any]],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Union[Job, Dict[str, Any]]:
+        """Generate speech with existing voice profile using unified endpoint"""
+        # Prepare form data for unified endpoint
+        data = {
+            "input_text": text,
+            "speed": speed,
+            "audio_format": audio_format
+        }
+        if language:
+            data["language"] = language
+        if generation_params:
+            # Add generation parameters
+            data.update(generation_params)
+            
+        if self.async_mode:
+            return self._async_generate_voice(voice_id, data, None, wait_for_completion, timeout)
+        else:
+            # Use unified voice generation endpoint
+            response = self.client.request(
+                "POST", 
+                f"/api/v1/voice/voices/{voice_id}/generate",
+                data=data
+            )
+            
+            job = Job.from_dict(response)
+            
+            if wait_for_completion:
+                job = self._wait_for_completion(job.id, timeout)
+                return job.result if job.result else job
+            
+            return job
+            
+    async def _async_generate_voice(
+        self,
+        voice_identifier: Union[int, str],
         data: Dict[str, Any],
+        files: Optional[Dict[str, Any]],
         wait_for_completion: bool,
         timeout: int
     ) -> Union[Job, Dict[str, Any]]:
-        """Async version of clone_voice"""
+        """Async version of unified voice generation"""
         response = await self.client.request(
-            "POST",
-            "/api/v1/voice/voice-clone", 
+            "POST", 
+            f"/api/v1/voice/voices/{voice_identifier}/generate",
             data=data,
             files=files
         )
@@ -93,7 +186,7 @@ class VoiceService(BaseService):
         if wait_for_completion:
             job = await self._async_wait_for_completion(job.id, timeout)
             return job.result if job.result else job
-            
+        
         return job
         
     def create_voice_profile(
@@ -202,78 +295,79 @@ class VoiceService(BaseService):
         language: Optional[str] = None,
         speed: float = 1.0,
         audio_format: str = "mp3",
+        generation_params: Optional[Dict[str, Any]] = None,
         wait_for_completion: bool = False,
         timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
         """
-        Generate speech using an existing voice profile
+        Generate speech using an existing voice profile (unified endpoint)
+        
+        This method now uses the unified voice generation endpoint for consistency.
         
         Args:
             voice_id: ID or UUID of the voice profile
             text: Text to generate speech for
             language: Target language code
-            speed: Speech speed (0.5 to 2.0)
-            audio_format: Output audio format (mp3, wav)
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            audio_format: Output audio format ('mp3', 'wav', 'ogg')
+            generation_params: Additional generation parameters
             wait_for_completion: Whether to wait for completion
             timeout: Maximum time to wait
             
         Returns:
             Job object or generation result
         """
-        # Validate inputs
-        text = self._validate_text_input(text)
-        if language:
-            language = self._validate_language_code(language)
-        if not 0.5 <= speed <= 2.0:
-            raise ValidationError("Speed must be between 0.5 and 2.0")
-        if audio_format not in ["mp3", "wav"]:
-            raise ValidationError("Audio format must be 'mp3' or 'wav'")
-            
-        # Prepare form data
-        data = {
-            "input_text": text,
-            "speed": speed,
-            "audio_format": audio_format
-        }
-        if language:
-            data["language"] = language
-            
-        # Make request
-        endpoint = f"/api/v1/voice/voices/{voice_id}/generate"
-        
-        if self.async_mode:
-            return self._async_generate_speech(endpoint, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request("POST", endpoint, data=data)
-            
-            if "job_id" in response:
-                job = Job.from_dict(response)
-                if wait_for_completion:
-                    job = self._wait_for_completion(job.id, timeout)
-                    return job.result if job.result else job
-                return job
-            else:
-                # Direct response with audio URL
-                return response
-                
-    async def _async_generate_speech(
+        # Use unified voice generation method
+        return self.generate_voice(
+            text=text,
+            voice_id=voice_id,
+            language=language,
+            speed=speed,
+            audio_format=audio_format,
+            generation_params=generation_params,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout
+        )
+    
+    def clone_voice(
         self,
-        endpoint: str,
-        data: Dict[str, Any],
-        wait_for_completion: bool,
-        timeout: int
+        voice_file: str,
+        text: str,
+        language: Optional[str] = None,
+        speed: float = 1.0,
+        generation_params: Optional[Dict[str, Any]] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
-        """Async version of generate_speech"""
-        response = await self.client.request("POST", endpoint, data=data)
+        """
+        Clone a voice from an audio file (backward compatibility)
         
-        if "job_id" in response:
-            job = Job.from_dict(response)
-            if wait_for_completion:
-                job = await self._async_wait_for_completion(job.id, timeout)
-                return job.result if job.result else job
-            return job
-        else:
-            return response
+        This method is now a wrapper around the unified generate_voice method.
+        For new code, consider using generate_voice() directly with voice_file parameter.
+        
+        Args:
+            voice_file: Path to audio file containing voice to clone
+            text: Text to generate with the cloned voice
+            language: Target language code (e.g., 'en', 'es')
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            generation_params: Additional generation parameters
+            wait_for_completion: Whether to wait for job completion
+            timeout: Maximum time to wait if wait_for_completion=True
+            
+        Returns:
+            Job object if wait_for_completion=False, otherwise job result
+        """
+        # Use unified voice generation method
+        return self.generate_voice(
+            text=text,
+            voice_file=voice_file,
+            language=language,
+            speed=speed,
+            audio_format="mp3",  # Default format for backward compatibility
+            generation_params=generation_params,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout
+        )
             
     def list_voice_profiles(
         self,

{audiopod-1.1.0.dist-info → audiopod-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiopod
-Version: 1.1.0
+Version: 1.2.0
 Summary: Professional Audio Processing API Client for Python
 Home-page: https://github.com/audiopod-ai/audiopod-python
 Author: AudioPod AI
@@ -95,7 +95,7 @@ client = audiopod.Client(api_key="ap_your_api_key_here")
 
 ### Basic Usage
 
-#### Voice Cloning
+#### Voice Generation (Unified TTS & Cloning)
 
 ```python
 import audiopod
@@ -103,15 +103,39 @@ import audiopod
 # Initialize client
 client = audiopod.Client()
 
-# Clone a voice and generate speech
-job = client.voice.clone_voice(
+# Generate voice using file cloning (unified approach)
+job = client.voice.generate_voice(
+    text="Hello! This is voice generation using a cloned voice.",
+    voice_file="path/to/voice_sample.wav",  # For voice cloning
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+print(f"Generated audio URL: {job.output_url}")
+
+# Generate speech with existing voice profile (unified approach)
+speech = client.voice.generate_voice(
+    text="Hello from my voice profile!",
+    voice_id="voice-profile-id",  # For existing voice profiles
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Backward compatibility methods (deprecated - use generate_voice instead)
+legacy_clone = client.voice.clone_voice(
     voice_file="path/to/voice_sample.wav",
     text="Hello! This is a cloned voice speaking.",
     language="en",
     wait_for_completion=True
 )
-
-print(f"Generated audio URL: {job['output_url']}")
 ```
 
 #### Music Generation
@@ -142,17 +166,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
@@ -189,10 +221,22 @@ voice_profile = client.voice.create_voice_profile(
     wait_for_completion=True
 )
 
-# Use the voice profile for speech generation
-speech = client.voice.generate_speech(
+# Use the voice profile for speech generation (unified approach - recommended)
+speech = client.voice.generate_voice(
+    text="This uses my custom voice profile with the unified method!",
     voice_id=voice_profile.id,
-    text="This uses my custom voice profile!",
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Legacy method (still works - uses generate_voice internally)
+legacy_speech = client.voice.generate_speech(
+    voice_id=voice_profile.id,
+    text="This uses the legacy method.",
     wait_for_completion=True
 )
 ```
@@ -335,7 +379,7 @@ client = audiopod.Client(
 
 ### Services
 
-- `client.voice`: Voice cloning and TTS operations
+- `client.voice`: **Voice generation operations** (unified TTS & cloning using `generate_voice()`)
 - `client.music`: Music generation and editing
 - `client.transcription`: Speech-to-text transcription
 - `client.translation`: Audio/video translation
@@ -344,6 +388,20 @@ client = audiopod.Client(
 - `client.karaoke`: Karaoke video generation
 - `client.credits`: Credit management and usage tracking
 
+#### Voice Service Methods
+
+**Recommended (Unified Approach):**
+- `client.voice.generate_voice()` - Generate speech with voice file (cloning) or voice ID (TTS)
+
+**Legacy Methods (Backward Compatibility):**
+- `client.voice.clone_voice()` - Clone voice from audio file (deprecated, uses `generate_voice` internally)
+- `client.voice.generate_speech()` - Generate speech with voice profile (deprecated, uses `generate_voice` internally)
+
+**Voice Management:**
+- `client.voice.create_voice_profile()` - Create reusable voice profiles
+- `client.voice.list_voice_profiles()` - List available voice profiles
+- `client.voice.delete_voice_profile()` - Delete voice profiles
+
 ### Models
 
 - `Job`: Base job information and status

{audiopod-1.1.0.dist-info → audiopod-1.2.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-audiopod/__init__.py,sha256=U12jbLmXps3-NP3yXcucGMQbr8b6VCoWAXZSitK1pp4,1790
+audiopod/__init__.py,sha256=jQtsXMdmCZArJ1pOWG9huymdE_-WlyW8Rk8q0kcQn-c,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=gAfQkufA_hZdYBkniFJ_EXETy9ts-wr-soUEbT7ZKFM,7827
+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
@@ -14,11 +14,11 @@ audiopod/services/music.py,sha256=hDPjTSj-gAeEWBVB7PRPQrptMHJyQTz8e9p-p7yaRPI,20
 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=Gpxmom-ZSLMXBwSQlOL5PyqxQCwRYNT2IUp2ZD5QhYc,3177
-audiopod/services/voice.py,sha256=_IHv3zU3k184kfijxr1QRBenrIpmhhPOBS96DddZ8yw,13456
-audiopod-1.1.0.dist-info/licenses/LICENSE,sha256=hqEjnOaGNbnLSBxbtbC7WQVREU2vQI8FmwecCiZlMfA,1068
-audiopod-1.1.0.dist-info/METADATA,sha256=ee2Zg4iwkglAgnk3xwNuYg11LFZbKJQeUcxgG8Z_Dw0,10931
-audiopod-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-audiopod-1.1.0.dist-info/entry_points.txt,sha256=uLcNDzXuOXnJAz9j91TDGayVjjZ7-ZiHBGDydqNUErU,47
-audiopod-1.1.0.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
-audiopod-1.1.0.dist-info/RECORD,,
+audiopod/services/translation.py,sha256=oUU82c61CeAt13lzlWx8S-9xEgYlskwX8bLMbQw2Ni8,7396
+audiopod/services/voice.py,sha256=t0-4yjVrzWXJorfQCGbBSNRGE2wZfjoRQ76elJu1BvU,17748
+audiopod-1.2.0.dist-info/licenses/LICENSE,sha256=hqEjnOaGNbnLSBxbtbC7WQVREU2vQI8FmwecCiZlMfA,1068
+audiopod-1.2.0.dist-info/METADATA,sha256=mLpXkYWYxvd3k3LrDtH6Cr68C7Xk7JmpoBL4vwYPiOU,13048
+audiopod-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+audiopod-1.2.0.dist-info/entry_points.txt,sha256=uLcNDzXuOXnJAz9j91TDGayVjjZ7-ZiHBGDydqNUErU,47
+audiopod-1.2.0.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
+audiopod-1.2.0.dist-info/RECORD,,