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

audiopod/services/voice.py

@@ -1,376 +1,187 @@
 """
-Voice Service - Voice cloning and TTS operations
-"""
+Voice Service - Voice cloning and text-to-speech
 
-from typing import List, Optional, Dict, Any, Union
-from pathlib import Path
+API Routes:
+- GET  /api/v1/voice/voice-profiles           - List all voices
+- GET  /api/v1/voice/voices/{id}/status       - Get voice details
+- POST /api/v1/voice/voice-profiles           - Create voice clone
+- DELETE /api/v1/voice/voices/{id}            - Delete voice
+- POST /api/v1/voice/voices/{id}/generate     - Generate TTS
+- GET  /api/v1/voice/tts-jobs/{id}/status     - Get TTS job status
+"""
 
+from typing import Optional, Dict, Any, List, Union
 from .base import BaseService
-from ..models import Job, VoiceProfile, JobStatus
-from ..exceptions import ValidationError
 
 
 class VoiceService(BaseService):
-    """Service for voice cloning and text-to-speech operations"""
-    
-    def clone_voice(
+    """Service for voice cloning and text-to-speech."""
+
+    def list_voices(
         self,
-        voice_file: str,
-        text: str,
-        language: Optional[str] = None,
-        speed: float = 1.0,
-        wait_for_completion: bool = False,
-        timeout: int = 300
-    ) -> Union[Job, Dict[str, Any]]:
-        """
-        Clone a voice from an audio file
-        
-        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.5 to 2.0)
-            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
-        """
-        # 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")
-            
-        # Prepare file upload
-        files = self._prepare_file_upload(voice_file, "file")
-        
-        # Prepare form data
-        data = {
-            "input_text": text,
-            "speed": speed
+        skip: int = 0,
+        limit: int = 100,
+        include_public: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """List available voices (both custom and public)."""
+        params = {
+            "skip": skip,
+            "limit": limit,
+            "include_public": str(include_public).lower(),
         }
-        if language:
-            data["target_language"] = language
-            
-        # Make request
         if self.async_mode:
-            return self._async_clone_voice(files, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request(
-                "POST", 
-                "/api/v1/voice/voice-clone",
-                data=data,
-                files=files
-            )
-            
-            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_clone_voice(
-        self,
-        files: Dict[str, Any],
-        data: Dict[str, Any],
-        wait_for_completion: bool,
-        timeout: int
-    ) -> Union[Job, Dict[str, Any]]:
-        """Async version of clone_voice"""
-        response = await self.client.request(
-            "POST",
-            "/api/v1/voice/voice-clone", 
-            data=data,
-            files=files
-        )
-        
-        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
-        
-    def create_voice_profile(
+            return self._async_list_voices(params)
+        return self.client.request("GET", "/api/v1/voice/voice-profiles", params=params)
+
+    async def _async_list_voices(self, params: Dict) -> List[Dict[str, Any]]:
+        return await self.client.request("GET", "/api/v1/voice/voice-profiles", params=params)
+
+    def get_voice(self, voice_id: Union[int, str]) -> Dict[str, Any]:
+        """Get voice details by ID or UUID."""
+        if self.async_mode:
+            return self._async_get_voice(voice_id)
+        return self.client.request("GET", f"/api/v1/voice/voices/{voice_id}/status")
+
+    async def _async_get_voice(self, voice_id: Union[int, str]) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v1/voice/voices/{voice_id}/status")
+
+    def create_voice(
         self,
         name: str,
-        voice_file: str,
+        audio_file: str,
         description: Optional[str] = None,
-        is_public: bool = False,
-        wait_for_completion: bool = False,
-        timeout: int = 600
-    ) -> Union[Job, VoiceProfile]:
-        """
-        Create a reusable voice profile
-        
-        Args:
-            name: Name for the voice profile
-            voice_file: Path to audio file containing voice sample
-            description: Optional description
-            is_public: Whether to make the voice profile public
-            wait_for_completion: Whether to wait for processing completion
-            timeout: Maximum time to wait if wait_for_completion=True
-            
-        Returns:
-            Job object if wait_for_completion=False, otherwise VoiceProfile
-        """
-        # Validate inputs
-        if not name or len(name.strip()) < 1:
-            raise ValidationError("Voice profile name cannot be empty")
-        if len(name) > 100:
-            raise ValidationError("Voice profile name too long (max 100 characters)")
-            
-        # Prepare file upload
-        files = self._prepare_file_upload(voice_file, "file")
-        
-        # Prepare form data
-        data = {
-            "name": name.strip(),
-            "is_public": is_public
-        }
+    ) -> Dict[str, Any]:
+        """Create a new voice clone from an audio file."""
+        files = self._prepare_file_upload(audio_file, "file")
+        data = {"name": name}
         if description:
-            data["description"] = description.strip()
-            
-        # Make request
+            data["description"] = description
+
         if self.async_mode:
-            return self._async_create_voice_profile(files, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request(
-                "POST",
-                "/api/v1/voice/voice-profiles",
-                data=data,
-                files=files
-            )
-            
-            if wait_for_completion:
-                voice_id = response["id"]
-                # Poll for completion
-                import time
-                start_time = time.time()
-                while time.time() - start_time < timeout:
-                    voice_data = self.client.request("GET", f"/api/v1/voice/voice-profiles/{voice_id}")
-                    if voice_data["status"] == "completed":
-                        return VoiceProfile.from_dict(voice_data)
-                    elif voice_data["status"] == "failed":
-                        raise ValidationError(f"Voice profile creation failed: {voice_data.get('error_message')}")
-                    time.sleep(5)
-                raise ValidationError("Voice profile creation timed out")
-            else:
-                return VoiceProfile.from_dict(response)
-                
-    async def _async_create_voice_profile(
-        self,
-        files: Dict[str, Any],
-        data: Dict[str, Any],
-        wait_for_completion: bool,
-        timeout: int
-    ) -> Union[Job, VoiceProfile]:
-        """Async version of create_voice_profile"""
-        import asyncio
-        
-        response = await self.client.request(
-            "POST",
-            "/api/v1/voice/voice-profiles",
-            data=data,
-            files=files
-        )
-        
-        if wait_for_completion:
-            voice_id = response["id"]
-            # Poll for completion
-            start_time = time.time()
-            while time.time() - start_time < timeout:
-                voice_data = await self.client.request("GET", f"/api/v1/voice/voice-profiles/{voice_id}")
-                if voice_data["status"] == "completed":
-                    return VoiceProfile.from_dict(voice_data)
-                elif voice_data["status"] == "failed":
-                    raise ValidationError(f"Voice profile creation failed: {voice_data.get('error_message')}")
-                await asyncio.sleep(5)
-            raise ValidationError("Voice profile creation timed out")
-        else:
-            return VoiceProfile.from_dict(response)
-            
+            return self._async_create_voice(data, files)
+        return self.client.request("POST", "/api/v1/voice/voice-profiles", data=data, files=files)
+
+    async def _async_create_voice(self, data: Dict, files: Dict) -> Dict[str, Any]:
+        return await self.client.request("POST", "/api/v1/voice/voice-profiles", data=data, files=files)
+
+    def delete_voice(self, voice_id: Union[int, str]) -> Dict[str, str]:
+        """Delete a voice by ID or UUID."""
+        if self.async_mode:
+            return self._async_delete_voice(voice_id)
+        return self.client.request("DELETE", f"/api/v1/voice/voices/{voice_id}")
+
+    async def _async_delete_voice(self, voice_id: Union[int, str]) -> Dict[str, str]:
+        return await self.client.request("DELETE", f"/api/v1/voice/voices/{voice_id}")
+
     def generate_speech(
         self,
         voice_id: Union[int, str],
         text: str,
-        language: Optional[str] = None,
         speed: float = 1.0,
+        language: str = "en",
         audio_format: str = "mp3",
         wait_for_completion: bool = False,
-        timeout: int = 300
-    ) -> Union[Job, Dict[str, Any]]:
+        timeout: int = 300,
+    ) -> Dict[str, Any]:
         """
-        Generate speech using an existing voice profile
+        Generate speech from text using a voice.
         
         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)
-            wait_for_completion: Whether to wait for completion
-            timeout: Maximum time to wait
+            voice_id: Voice ID (int) or UUID (str) to use for generation
+            text: Text to convert to speech
+            speed: Speech speed (0.25 to 4.0, default 1.0)
+            language: Language code (default "en")
+            audio_format: Output format - mp3, wav, ogg (default "mp3")
+            wait_for_completion: If True, poll until job completes
+            timeout: Max seconds to wait for completion
             
         Returns:
-            Job object or generation result
+            Job info dict with job_id, status, etc.
+            If wait_for_completion=True, includes output_url when done.
         """
-        # 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
+            "language": language,
+            "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
-                
+            return self._async_generate_speech(voice_id, data, wait_for_completion, timeout)
+
+        response = self.client.request(
+            "POST",
+            f"/api/v1/voice/voices/{voice_id}/generate",
+            data=data,
+        )
+
+        if wait_for_completion:
+            job_id = response.get("job_id") or response.get("id")
+            return self._wait_for_job_completion(job_id, timeout)
+        return response
+
     async def _async_generate_speech(
-        self,
-        endpoint: str,
-        data: Dict[str, Any],
-        wait_for_completion: bool,
-        timeout: int
-    ) -> Union[Job, Dict[str, Any]]:
-        """Async version of generate_speech"""
-        response = await self.client.request("POST", endpoint, data=data)
-        
-        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
-            
-    def list_voice_profiles(
-        self,
-        voice_type: Optional[str] = None,
-        is_public: Optional[bool] = None,
-        include_public: bool = True,
-        limit: int = 50
-    ) -> List[VoiceProfile]:
+        self, voice_id: Union[int, str], data: Dict, wait_for_completion: bool, timeout: int
+    ) -> Dict[str, Any]:
+        response = await self.client.request(
+            "POST",
+            f"/api/v1/voice/voices/{voice_id}/generate",
+            data=data,
+        )
+        if wait_for_completion:
+            job_id = response.get("job_id") or response.get("id")
+            return await self._async_wait_for_job_completion(job_id, timeout)
+        return response
+
+    def get_job_status(self, job_id: int) -> Dict[str, Any]:
         """
-        List available voice profiles
+        Get TTS job status.
         
         Args:
-            voice_type: Filter by voice type ('custom', 'standard')
-            is_public: Filter by public status
-            include_public: Include public voices
-            limit: Maximum number of results
+            job_id: The job ID returned from generate_speech
             
         Returns:
-            List of voice profiles
+            Job status dict with status, progress, output_url (when completed), etc.
         """
-        params = {
-            "limit": limit,
-            "include_public": include_public
-        }
-        if voice_type:
-            params["voice_type"] = voice_type
-        if is_public is not None:
-            params["is_public"] = is_public
-            
         if self.async_mode:
-            return self._async_list_voice_profiles(params)
-        else:
-            response = self.client.request("GET", "/api/v1/voice/voice-profiles", params=params)
-            return [VoiceProfile.from_dict(voice_data) for voice_data in response]
-            
-    async def _async_list_voice_profiles(self, params: Dict[str, Any]) -> List[VoiceProfile]:
-        """Async version of list_voice_profiles"""
-        response = await self.client.request("GET", "/api/v1/voice/voice-profiles", params=params)
-        return [VoiceProfile.from_dict(voice_data) for voice_data in response]
-        
-    def get_voice_profile(self, voice_id: Union[int, str]) -> VoiceProfile:
-        """
-        Get details of a specific voice profile
+            return self._async_get_job_status(job_id)
+        return self.client.request("GET", f"/api/v1/voice/tts-jobs/{job_id}/status")
+
+    async def _async_get_job_status(self, job_id: int) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v1/voice/tts-jobs/{job_id}/status")
+
+    def _wait_for_job_completion(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Poll job status until completion or timeout."""
+        import time
+        start_time = time.time()
         
-        Args:
-            voice_id: ID or UUID of the voice profile
+        while time.time() - start_time < timeout:
+            status = self.get_job_status(job_id)
             
-        Returns:
-            Voice profile details
-        """
-        if self.async_mode:
-            return self._async_get_voice_profile(voice_id)
-        else:
-            response = self.client.request("GET", f"/api/v1/voice/voice-profiles/{voice_id}")
-            return VoiceProfile.from_dict(response)
+            if status.get("status") in ("completed", "COMPLETED"):
+                return status
+            elif status.get("status") in ("failed", "FAILED", "error", "ERROR"):
+                raise Exception(f"Job failed: {status.get('error_message', 'Unknown error')}")
             
-    async def _async_get_voice_profile(self, voice_id: Union[int, str]) -> VoiceProfile:
-        """Async version of get_voice_profile"""
-        response = await self.client.request("GET", f"/api/v1/voice/voice-profiles/{voice_id}")
-        return VoiceProfile.from_dict(response)
+            time.sleep(2)
         
-    def delete_voice_profile(self, voice_id: Union[int, str]) -> Dict[str, str]:
-        """
-        Delete a voice profile
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+
+    async def _async_wait_for_job_completion(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Async poll job status until completion or timeout."""
+        import asyncio
+        import time
+        start_time = time.time()
         
-        Args:
-            voice_id: ID or UUID of the voice profile
+        while time.time() - start_time < timeout:
+            status = await self.get_job_status(job_id)
             
-        Returns:
-            Deletion confirmation
-        """
-        if self.async_mode:
-            return self._async_delete_voice_profile(voice_id)
-        else:
-            return self.client.request("DELETE", f"/api/v1/voice/voices/{voice_id}")
+            if status.get("status") in ("completed", "COMPLETED"):
+                return status
+            elif status.get("status") in ("failed", "FAILED", "error", "ERROR"):
+                raise Exception(f"Job failed: {status.get('error_message', 'Unknown error')}")
             
-    async def _async_delete_voice_profile(self, voice_id: Union[int, str]) -> Dict[str, str]:
-        """Async version of delete_voice_profile"""
-        return await self.client.request("DELETE", f"/api/v1/voice/voices/{voice_id}")
-        
-    def get_job_status(self, job_id: int) -> Job:
-        """
-        Get status of a voice processing job
+            await asyncio.sleep(2)
         
-        Args:
-            job_id: ID of the job
-            
-        Returns:
-            Job status and details
-        """
-        if self.async_mode:
-            return self._async_get_job_status(job_id)
-        else:
-            response = self.client.request("GET", f"/api/v1/voice/clone/{job_id}/status")
-            return Job.from_dict(response)
-            
-    async def _async_get_job_status(self, job_id: int) -> Job:
-        """Async version of get_job_status"""
-        response = await self.client.request("GET", f"/api/v1/voice/clone/{job_id}/status")
-        return Job.from_dict(response)
+        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
+