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

audiopod/services/translation.py

@@ -1,196 +1,135 @@
 """
-Translation Service - Speech-to-speech translation operations
+Translation Service - Audio/speech translation
+
+API Routes:
+- POST /api/v1/translation/translate/speech   - Translate speech
+- GET  /api/v1/translation/translations/{id}  - Get translation job
+- GET  /api/v1/translation/translations       - List translations
+- DELETE /api/v1/translation/translations/{id} - Delete translation
 """
 
-from typing import Optional, Union
+from typing import Optional, Dict, Any, List
 from .base import BaseService
-from ..models import Job, TranslationResult
-from ..exceptions import ValidationError
 
 
 class TranslationService(BaseService):
-    """Service for speech-to-speech translation operations"""
-    
-    def translate_audio(
+    """Service for audio translation."""
+
+    def translate(
         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]:
+        timeout: int = 900,
+    ) -> Dict[str, Any]:
         """
-        Translate speech from audio/video file to another language while preserving voice characteristics
-        
+        Translate audio to another language.
+
         Args:
-            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
-            
+            audio_file: Path to local audio file
+            url: URL of audio file
+            target_language: Target language code
+            source_language: Source language (auto-detected if not provided)
+            wait_for_completion: Wait for completion
+            timeout: Max wait time in seconds
+
         Returns:
-            Job object or translation result
+            Job dict with translated audio URL when completed
         """
-        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)
-            
-        # 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
-            
+        if url:
+            data["url"] = url
+
+        files = self._prepare_file_upload(audio_file, "file") if audio_file else None
+
         if self.async_mode:
-            return self._async_translate_audio(files, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request(
-                "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)
-            
-            if wait_for_completion:
-                completed_job = self._wait_for_completion(job.id, timeout)
-                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/speech",  # FIXED: Use correct speech-to-speech endpoint
-            data=data, 
-            files=files if files else None
-        )
-        job = Job.from_dict(response)
-        
+            return self._async_translate(data, files, wait_for_completion, timeout)
+
+        response = self.client.request("POST", "/api/v1/translation/translate/speech", data=data, files=files)
+
         if wait_for_completion:
-            completed_job = await self._async_wait_for_completion(job.id, timeout)
-            return TranslationResult.from_dict(completed_job.result or completed_job.__dict__)
-            
-        return job
-        
-    def get_translation_job(self, job_id: int) -> TranslationResult:
-        """Get translation job details"""
-        if self.async_mode:
-            return self._async_get_translation_job(job_id)
-        else:
-            response = self.client.request("GET", f"/api/v1/translation/translations/{job_id}")
-            return TranslationResult.from_dict(response)
-            
-    async def _async_get_translation_job(self, job_id: int) -> TranslationResult:
-        """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
-        }
-        
+            job_id = response.get("id") or response.get("job_id")
+            return self._wait_for_translation(job_id, timeout)
+        return response
+
+    async def _async_translate(
+        self, data: Dict, files: Optional[Dict], wait_for_completion: bool, timeout: int
+    ) -> Dict[str, Any]:
+        response = await self.client.request("POST", "/api/v1/translation/translate/speech", data=data, files=files)
+        if wait_for_completion:
+            job_id = response.get("id") or response.get("job_id")
+            return await self._async_wait_for_translation(job_id, timeout)
+        return response
+
+    def get_job(self, job_id: int) -> Dict[str, Any]:
+        """Get translation job details and status."""
         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
-        """
+            return self._async_get_job(job_id)
+        return self.client.request("GET", f"/api/v1/translation/translations/{job_id}")
+
+    async def _async_get_job(self, job_id: int) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v1/translation/translations/{job_id}")
+
+    def list_jobs(self, skip: int = 0, limit: int = 50) -> List[Dict[str, Any]]:
+        """List translation jobs."""
         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
-        """
+            return self._async_list_jobs(skip, limit)
+        return self.client.request(
+            "GET", "/api/v1/translation/translations", params={"skip": skip, "limit": limit}
+        )
+
+    async def _async_list_jobs(self, skip: int, limit: int) -> List[Dict[str, Any]]:
+        return await self.client.request(
+            "GET", "/api/v1/translation/translations", params={"skip": skip, "limit": limit}
+        )
+
+    def delete_job(self, job_id: int) -> Dict[str, str]:
+        """Delete a translation job."""
         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 self._async_delete_job(job_id)
+        return self.client.request("DELETE", f"/api/v1/translation/translations/{job_id}")
+
+    async def _async_delete_job(self, job_id: int) -> Dict[str, str]:
         return await self.client.request("DELETE", f"/api/v1/translation/translations/{job_id}")
+
+    def _wait_for_translation(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Wait for translation job completion."""
+        import time
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get_job(job_id)
+            status = job.get("status", "").upper()
+
+            if status == "COMPLETED":
+                return job
+            elif status in ("FAILED", "ERROR"):
+                raise Exception(f"Translation failed: {job.get('error_message', 'Unknown error')}")
+
+            time.sleep(5)
+
+        raise TimeoutError(f"Translation {job_id} did not complete within {timeout} seconds")
+
+    async def _async_wait_for_translation(self, job_id: int, timeout: int) -> Dict[str, Any]:
+        """Async wait for translation job completion."""
+        import asyncio
+        import time
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = await self.get_job(job_id)
+            status = job.get("status", "").upper()
+
+            if status == "COMPLETED":
+                return job
+            elif status in ("FAILED", "ERROR"):
+                raise Exception(f"Translation failed: {job.get('error_message', 'Unknown error')}")
+
+            await asyncio.sleep(5)
+
+        raise TimeoutError(f"Translation {job_id} did not complete within {timeout} seconds")
+

audiopod/services/video.py

@@ -0,0 +1,329 @@
+"""
+Video Service - Video generation
+
+API Routes:
+- POST /api/v2/video/karaoke      - Create karaoke video
+- POST /api/v2/video/music-video  - Create AI music video
+- POST /api/v2/video/lyric-video  - Create lyric video
+- GET  /api/v2/video/{id}         - Get job status
+- GET  /api/v2/video/{id}/download - Get download URLs
+- DELETE /api/v2/video/{id}       - Delete job
+"""
+
+from typing import Optional, Dict, Any, List, Literal
+from .base import BaseService
+
+
+VideoType = Literal["karaoke", "music_video", "lyric_video"]
+AspectRatio = Literal["16:9", "9:16", "1:1"]
+SceneGeneration = Literal["flux", "veo3", "static"]
+AnimationStyle = Literal["typewriter", "fade-word", "slide-up", "bounce", "wave", "zoom"]
+
+
+class VideoService(BaseService):
+    """Service for video generation."""
+
+    def create_karaoke(
+        self,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        aspect_ratio: AspectRatio = "16:9",
+        scene_generation: SceneGeneration = "flux",
+        key_shift: int = 0,
+        style: Optional[Dict[str, Any]] = None,
+        webhook_url: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 600,
+    ) -> Dict[str, Any]:
+        """
+        Create a karaoke video from audio.
+
+        Args:
+            audio_file: Path to local audio file
+            url: URL of audio/video (YouTube, etc.)
+            aspect_ratio: Video aspect ratio
+            scene_generation: Background generation method
+            key_shift: Pitch shift in semitones (-12 to 12)
+            style: Style configuration (colors, font, etc.)
+            webhook_url: URL for completion notification
+            wait_for_completion: Wait for video to finish
+            timeout: Max wait time in seconds
+
+        Returns:
+            Job dict with id, status, video_url (when completed)
+        """
+        if audio_file:
+            return self._create_from_upload(
+                "karaoke", audio_file, aspect_ratio, scene_generation,
+                key_shift, webhook_url, wait_for_completion, timeout
+            )
+        
+        data = {
+            "audio_url": url,
+            "aspect_ratio": aspect_ratio,
+            "scene_generation": scene_generation,
+            "key_shift": key_shift,
+        }
+        if style:
+            data["style"] = style
+        if webhook_url:
+            data["webhook_url"] = webhook_url
+
+        if self.async_mode:
+            return self._async_create("karaoke", data, wait_for_completion, timeout)
+
+        response = self.client.request("POST", "/api/v2/video/karaoke", json_data=data)
+        
+        if wait_for_completion:
+            return self._wait_for_video(response["id"], timeout)
+        return response
+
+    def create_music_video(
+        self,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        music_job_id: Optional[str] = None,
+        aspect_ratio: AspectRatio = "16:9",
+        scene_generation: SceneGeneration = "flux",
+        scene_count: int = 10,
+        include_lyrics: bool = True,
+        style: Optional[Dict[str, Any]] = None,
+        webhook_url: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 900,
+    ) -> Dict[str, Any]:
+        """
+        Create an AI music video.
+
+        Args:
+            audio_file: Path to local audio file
+            url: URL of audio file
+            music_job_id: AudioPod music generation job ID
+            aspect_ratio: Video aspect ratio
+            scene_generation: Scene generation method (flux or veo3)
+            scene_count: Number of scenes to generate (5-20)
+            include_lyrics: Overlay lyrics on video
+            style: Style configuration
+            webhook_url: URL for completion notification
+            wait_for_completion: Wait for video to finish
+            timeout: Max wait time in seconds
+
+        Returns:
+            Job dict with video_url when completed
+        """
+        data = {
+            "aspect_ratio": aspect_ratio,
+            "scene_generation": scene_generation,
+            "scene_count": scene_count,
+            "include_lyrics": include_lyrics,
+        }
+        if url:
+            data["audio_url"] = url
+        if music_job_id:
+            data["music_job_id"] = music_job_id
+        if style:
+            data["style"] = style
+        if webhook_url:
+            data["webhook_url"] = webhook_url
+
+        if self.async_mode:
+            return self._async_create("music-video", data, wait_for_completion, timeout)
+
+        response = self.client.request("POST", "/api/v2/video/music-video", json_data=data)
+        
+        if wait_for_completion:
+            return self._wait_for_video(response["id"], timeout)
+        return response
+
+    def create_lyric_video(
+        self,
+        audio_file: Optional[str] = None,
+        url: Optional[str] = None,
+        lyrics: Optional[str] = None,
+        aspect_ratio: AspectRatio = "16:9",
+        animation_style: AnimationStyle = "fade-word",
+        background_color: str = "#1a1a2e",
+        accent_color: str = "#e94560",
+        particles_enabled: bool = True,
+        background_image_url: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 600,
+    ) -> Dict[str, Any]:
+        """
+        Create a kinetic typography lyric video.
+
+        Args:
+            audio_file: Path to local audio file
+            url: URL of audio file
+            lyrics: Custom lyrics (auto-transcribed if not provided)
+            aspect_ratio: Video aspect ratio
+            animation_style: Text animation style
+            background_color: Background color
+            accent_color: Accent/highlight color
+            particles_enabled: Enable particle effects
+            background_image_url: Optional background image
+            webhook_url: URL for completion notification
+            wait_for_completion: Wait for video to finish
+            timeout: Max wait time in seconds
+
+        Returns:
+            Job dict with video_url when completed
+        """
+        data = {
+            "aspect_ratio": aspect_ratio,
+            "style": {
+                "animation_style": animation_style,
+                "background_color": background_color,
+                "accent_color": accent_color,
+                "particles_enabled": particles_enabled,
+            },
+        }
+        if url:
+            data["audio_url"] = url
+        if lyrics:
+            data["lyrics"] = lyrics
+        if background_image_url:
+            data["background_image_url"] = background_image_url
+        if webhook_url:
+            data["webhook_url"] = webhook_url
+
+        if self.async_mode:
+            return self._async_create("lyric-video", data, wait_for_completion, timeout)
+
+        response = self.client.request("POST", "/api/v2/video/lyric-video", json_data=data)
+        
+        if wait_for_completion:
+            return self._wait_for_video(response["id"], timeout)
+        return response
+
+    def get_job(self, job_id: str) -> Dict[str, Any]:
+        """Get video job status."""
+        if self.async_mode:
+            return self._async_get_job(job_id)
+        return self.client.request("GET", f"/api/v2/video/{job_id}")
+
+    async def _async_get_job(self, job_id: str) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v2/video/{job_id}")
+
+    def get_download_urls(self, job_id: str) -> Dict[str, Any]:
+        """Get download URLs for completed video."""
+        if self.async_mode:
+            return self._async_get_download(job_id)
+        return self.client.request("GET", f"/api/v2/video/{job_id}/download")
+
+    async def _async_get_download(self, job_id: str) -> Dict[str, Any]:
+        return await self.client.request("GET", f"/api/v2/video/{job_id}/download")
+
+    def delete_job(self, job_id: str) -> Dict[str, str]:
+        """Delete a video job."""
+        if self.async_mode:
+            return self._async_delete(job_id)
+        return self.client.request("DELETE", f"/api/v2/video/{job_id}")
+
+    async def _async_delete(self, job_id: str) -> Dict[str, str]:
+        return await self.client.request("DELETE", f"/api/v2/video/{job_id}")
+
+    def list_jobs(
+        self,
+        video_type: Optional[VideoType] = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """List video jobs."""
+        params = {"limit": limit, "offset": offset}
+        if video_type:
+            params["type"] = video_type
+        
+        if self.async_mode:
+            return self._async_list(params)
+        return self.client.request("GET", "/api/v2/video/", params=params)
+
+    async def _async_list(self, params: Dict) -> Dict[str, Any]:
+        return await self.client.request("GET", "/api/v2/video/", params=params)
+
+    def _create_from_upload(
+        self,
+        video_type: str,
+        audio_file: str,
+        aspect_ratio: str,
+        scene_generation: str,
+        key_shift: int,
+        webhook_url: Optional[str],
+        wait_for_completion: bool,
+        timeout: int,
+    ) -> Dict[str, Any]:
+        """Create video from file upload."""
+        data = {
+            "aspect_ratio": aspect_ratio,
+            "scene_generation": scene_generation,
+            "key_shift": str(key_shift),
+        }
+        if webhook_url:
+            data["webhook_url"] = webhook_url
+
+        files = self._prepare_file_upload(audio_file, "file")
+        
+        response = self.client.request(
+            "POST", f"/api/v2/video/{video_type}/upload", data=data, files=files
+        )
+        
+        if wait_for_completion:
+            return self._wait_for_video(response["id"], timeout)
+        return response
+
+    async def _async_create(
+        self,
+        endpoint: str,
+        data: Dict,
+        wait_for_completion: bool,
+        timeout: int,
+    ) -> Dict[str, Any]:
+        response = await self.client.request(
+            "POST", f"/api/v2/video/{endpoint}", json_data=data
+        )
+        if wait_for_completion:
+            return await self._async_wait_for_video(response["id"], timeout)
+        return response
+
+    def _wait_for_video(self, job_id: str, timeout: int) -> Dict[str, Any]:
+        """Wait for video job completion."""
+        import time
+        start = time.time()
+        
+        while time.time() - start < timeout:
+            job = self.get_job(job_id)
+            status = job.get("status", "")
+            
+            if status == "completed":
+                # Get download URLs
+                download = self.get_download_urls(job_id)
+                job.update(download)
+                return job
+            elif status == "failed":
+                raise Exception(f"Video generation failed: {job.get('error', 'Unknown')}")
+            
+            time.sleep(5)
+        
+        raise TimeoutError(f"Video {job_id} timed out after {timeout}s")
+
+    async def _async_wait_for_video(self, job_id: str, timeout: int) -> Dict[str, Any]:
+        """Async wait for video job completion."""
+        import asyncio
+        import time
+        start = time.time()
+        
+        while time.time() - start < timeout:
+            job = await self.get_job(job_id)
+            status = job.get("status", "")
+            
+            if status == "completed":
+                download = await self.get_download_urls(job_id)
+                job.update(download)
+                return job
+            elif status == "failed":
+                raise Exception(f"Video generation failed: {job.get('error', 'Unknown')}")
+            
+            await asyncio.sleep(5)
+        
+        raise TimeoutError(f"Video {job_id} timed out after {timeout}s")