audiopod 1.4.0__tar.gz → 1.5.0__tar.gz

{audiopod-1.4.0 → audiopod-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiopod
-Version: 1.4.0
+Version: 1.5.0
 Summary: AudioPod SDK for Python - Professional Audio Processing powered by AI
 Author-email: AudioPod AI <support@audiopod.ai>
 License: MIT

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/__init__.py

@@ -3,7 +3,7 @@ AudioPod SDK for Python
 Professional Audio Processing powered by AI
 """
 
-__version__ = "1.3.0"
+__version__ = "1.5.0"
 
 from .client import Client, AsyncClient
 from .exceptions import (
@@ -15,9 +15,13 @@ from .exceptions import (
     InsufficientBalanceError,
 )
 
+# Alias for consistency with documentation and Node.js SDK
+AudioPod = Client
+
 __all__ = [
     "Client",
     "AsyncClient",
+    "AudioPod",  # Alias for Client
     "AudioPodError",
     "AuthenticationError", 
     "APIError",

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/client.py

@@ -24,6 +24,7 @@ from .services import (
     CreditService,
     StemExtractionService,
     WalletService,
+    VideoService,
 )
 
 logger = logging.getLogger(__name__)
@@ -75,6 +76,7 @@ class BaseClient:
     def _get_headers(self) -> Dict[str, str]:
         return {
             "Authorization": f"Bearer {self.api_key}",
+            "X-API-Key": self.api_key,
             "Content-Type": "application/json",
             "User-Agent": f"audiopod-python/{self.config.version}",
             "Accept": "application/json",
@@ -155,7 +157,9 @@ class Client(BaseClient):
         self.denoiser = DenoiserService(self)
         self.credits = CreditService(self)
         self.stem_extraction = StemExtractionService(self)
+        self.stems = self.stem_extraction  # Alias for consistency with Node.js SDK
         self.wallet = WalletService(self)
+        self.video = VideoService(self)
 
     def request(
         self,
@@ -232,7 +236,9 @@ class AsyncClient(BaseClient):
         self.denoiser = DenoiserService(self, async_mode=True)
         self.credits = CreditService(self, async_mode=True)
         self.stem_extraction = StemExtractionService(self, async_mode=True)
+        self.stems = self.stem_extraction  # Alias for consistency with Node.js SDK
         self.wallet = WalletService(self, async_mode=True)
+        self.video = VideoService(self, async_mode=True)
 
     @property
     def session(self) -> aiohttp.ClientSession:

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/services/__init__.py

@@ -12,6 +12,7 @@ from .denoiser import DenoiserService
 from .credits import CreditService
 from .stem_extraction import StemExtractionService
 from .wallet import WalletService
+from .video import VideoService
 
 __all__ = [
     "BaseService",
@@ -24,5 +25,6 @@ __all__ = [
     "CreditService",
     "StemExtractionService",
     "WalletService",
+    "VideoService",
 ]
 

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/services/denoiser.py

@@ -17,25 +17,30 @@ class DenoiserService(BaseService):
 
     def denoise(
         self,
-        audio_file: Optional[str] = None,
+        file: Optional[str] = None,
         url: Optional[str] = None,
         mode: str = "balanced",
-        wait_for_completion: bool = False,
+        wait_for_completion: bool = True,
         timeout: int = 300,
+        # Legacy parameter name
+        audio_file: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Remove noise from audio.
 
         Args:
-            audio_file: Path to local audio file
+            file: Path to local audio file
             url: URL of audio file
             mode: Denoise mode ("balanced", "studio", or "ultra")
-            wait_for_completion: Wait for completion
+            wait_for_completion: Wait for completion (default: True)
             timeout: Max wait time in seconds
 
         Returns:
             Job dict with denoised audio URL when completed
         """
+        # Support both 'file' and legacy 'audio_file' parameter names
+        audio_file = file or audio_file
+        
         data = {"mode": mode}
         if url:
             data["url"] = url

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/services/stem_extraction.py

@@ -2,11 +2,16 @@
 Stem Extraction Service - Audio stem separation
 """
 
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Literal
 from .base import BaseService
 from ..exceptions import ValidationError
 
 
+# Valid separation modes for the new API
+StemMode = Literal["single", "two", "four", "six", "producer", "studio", "mastering"]
+SingleStem = Literal["vocals", "drums", "bass", "guitar", "piano", "other", "instrumental"]
+
+
 class StemExtractionService(BaseService):
     """
     Service for audio stem separation.
@@ -17,19 +22,131 @@ class StemExtractionService(BaseService):
 
         client = Client()
 
-        # Extract all stems
-        job = client.stem_extraction.extract_stems(
-            audio_file="song.mp3",
-            stem_types=["vocals", "drums", "bass", "other"],
-            wait_for_completion=True
+        # Simple mode-based extraction (recommended)
+        result = client.stem_extraction.separate(
+            url="https://youtube.com/watch?v=VIDEO_ID",
+            mode="six"
+        )
+        for stem, url in result["download_urls"].items():
+            print(f"{stem}: {url}")
+
+        # Or extract only vocals
+        result = client.stem_extraction.separate(
+            file="song.mp3",
+            mode="single",
+            stem="vocals"
         )
-
-        # Download stems
-        for stem_name, url in job["download_urls"].items():
-            print(f"{stem_name}: {url}")
         ```
     """
 
+    def separate(
+        self,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        mode: StemMode = "four",
+        stem: Optional[SingleStem] = None,
+        wait_for_completion: bool = True,
+        timeout: int = 900,
+    ) -> Dict[str, Any]:
+        """
+        Separate audio into stems using simple mode selection.
+
+        Args:
+            file: Path to local audio file
+            url: URL of audio/video (YouTube, SoundCloud, direct link)
+            mode: Separation mode:
+                - "single": Extract one stem (specify stem param)
+                - "two": Vocals + Instrumental
+                - "four": Vocals, Drums, Bass, Other (default)
+                - "six": Vocals, Drums, Bass, Guitar, Piano, Other
+                - "producer": 8 stems with kick, snare, hihat
+                - "studio": 12 stems for professional mixing
+                - "mastering": 16 stems maximum detail
+            stem: For mode="single", which stem to extract
+            wait_for_completion: Wait for job to complete (default: True)
+            timeout: Max wait time in seconds
+
+        Returns:
+            Job dict with id, status, download_urls (when completed)
+        """
+        if not file and not url:
+            raise ValidationError("Provide file or url")
+
+        if file and url:
+            raise ValidationError("Provide file or url, not both")
+
+        if mode == "single" and not stem:
+            raise ValidationError(
+                "stem parameter required for mode='single'. "
+                "Options: vocals, drums, bass, guitar, piano, other, instrumental"
+            )
+
+        data = {"mode": mode}
+        if stem:
+            data["stem"] = stem
+        if url:
+            data["url"] = url
+
+        files = self._prepare_file_upload(file, "file") if file else None
+
+        if self.async_mode:
+            return self._async_separate(data, files, wait_for_completion, timeout)
+
+        response = self.client.request(
+            "POST", "/api/v1/stem-extraction/api/extract", data=data, files=files
+        )
+
+        if wait_for_completion:
+            return self._wait_for_stem_job(response["id"], timeout)
+
+        return response
+
+    async def _async_separate(
+        self,
+        data: Dict[str, Any],
+        files: Optional[Dict[str, Any]],
+        wait_for_completion: bool,
+        timeout: int,
+    ) -> Dict[str, Any]:
+        response = await self.client.request(
+            "POST", "/api/v1/stem-extraction/api/extract", data=data, files=files
+        )
+        if wait_for_completion:
+            return await self._async_wait_for_stem_job(response["id"], timeout)
+        return response
+
+    def extract(
+        self,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        mode: StemMode = "four",
+        stem: Optional[SingleStem] = None,
+    ) -> Dict[str, Any]:
+        """
+        Submit stem extraction job (returns immediately without waiting).
+
+        Use wait_for_completion() to poll for results.
+        """
+        return self.separate(file=file, url=url, mode=mode, stem=stem, wait_for_completion=False)
+
+    def wait_for_completion(self, job_id: int, timeout: int = 900) -> Dict[str, Any]:
+        """Wait for stem extraction job to complete."""
+        return self._wait_for_stem_job(job_id, timeout)
+
+    def status(self, job_id: int) -> Dict[str, Any]:
+        """Get stem extraction job status (alias for get_job)."""
+        return self.get_job(job_id)
+
+    def modes(self) -> Dict[str, Any]:
+        """Get available separation modes."""
+        if self.async_mode:
+            return self._async_modes()
+        return self.client.request("GET", "/api/v1/stem-extraction/modes")
+
+    async def _async_modes(self) -> Dict[str, Any]:
+        return await self.client.request("GET", "/api/v1/stem-extraction/modes")
+
+    # Legacy method - kept for backward compatibility
     def extract_stems(
         self,
         audio_file: Optional[str] = None,
@@ -41,7 +158,9 @@ class StemExtractionService(BaseService):
         timeout: int = 900,
     ) -> Dict[str, Any]:
         """
-        Extract stems from audio.
+        Extract stems from audio (legacy method).
+
+        For new code, use separate() instead which uses the simpler mode-based API.
 
         Args:
             audio_file: Path to local audio file

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod/services/transcription.py

@@ -16,6 +16,25 @@ from .base import BaseService
 class TranscriptionService(BaseService):
     """Service for speech-to-text transcription."""
 
+    def create(
+        self,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        language: Optional[str] = None,
+        speaker_diarization: bool = False,
+        wait_for_completion: bool = False,
+        timeout: int = 600,
+    ) -> Dict[str, Any]:
+        """Alias for transcribe() - matches Node.js SDK."""
+        return self.transcribe(
+            audio_file=file,
+            url=url,
+            language=language,
+            speaker_diarization=speaker_diarization,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout,
+        )
+
     def transcribe(
         self,
         audio_file: Optional[str] = None,
@@ -148,6 +167,10 @@ class TranscriptionService(BaseService):
             "GET", f"/api/v1/transcription/jobs/{job_id}/transcript", params={"format": format}
         )
 
+    def wait_for_completion(self, job_id: int, timeout: int = 600) -> Dict[str, Any]:
+        """Wait for transcription job completion (matches Node.js SDK)."""
+        return self._wait_for_transcription(job_id, timeout)
+
     def _wait_for_transcription(self, job_id: int, timeout: int) -> Dict[str, Any]:
         """Wait for transcription job completion."""
         import time

audiopod-1.5.0/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")

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiopod
-Version: 1.4.0
+Version: 1.5.0
 Summary: AudioPod SDK for Python - Professional Audio Processing powered by AI
 Author-email: AudioPod AI <support@audiopod.ai>
 License: MIT

{audiopod-1.4.0 → audiopod-1.5.0}/audiopod.egg-info/SOURCES.txt

@@ -19,5 +19,6 @@ audiopod/services/speaker.py
 audiopod/services/stem_extraction.py
 audiopod/services/transcription.py
 audiopod/services/translation.py
+audiopod/services/video.py
 audiopod/services/voice.py
 audiopod/services/wallet.py

{audiopod-1.4.0 → audiopod-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "audiopod"
-version = "1.4.0"
+version = "1.5.0"
 description = "AudioPod SDK for Python - Professional Audio Processing powered by AI"
 readme = "README.md"
 license = {text = "MIT"}