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

audiopod/services/__init__.py

@@ -1,28 +0,0 @@
-"""
-AudioPod SDK Services
-"""
-
-from .base import BaseService
-from .voice import VoiceService
-from .music import MusicService
-from .transcription import TranscriptionService
-from .translation import TranslationService
-from .speaker import SpeakerService
-from .denoiser import DenoiserService
-from .credits import CreditService
-from .stem_extraction import StemExtractionService
-from .wallet import WalletService
-
-__all__ = [
-    "BaseService",
-    "VoiceService",
-    "MusicService",
-    "TranscriptionService",
-    "TranslationService",
-    "SpeakerService",
-    "DenoiserService",
-    "CreditService",
-    "StemExtractionService",
-    "WalletService",
-]
-

audiopod/services/base.py

@@ -1,69 +0,0 @@
-"""
-Base Service Class
-"""
-
-import time
-from typing import Any, Dict, Optional, Tuple, BinaryIO
-
-
-class BaseService:
-    """Base class for all services"""
-
-    def __init__(self, client: Any, async_mode: bool = False):
-        self.client = client
-        self.async_mode = async_mode
-
-    def _prepare_file_upload(
-        self, file_path: str, field_name: str = "file"
-    ) -> Dict[str, Tuple[str, BinaryIO, str]]:
-        """Prepare file for upload."""
-        import mimetypes
-
-        mime_type, _ = mimetypes.guess_type(file_path)
-        mime_type = mime_type or "application/octet-stream"
-
-        file_handle = open(file_path, "rb")
-        filename = file_path.split("/")[-1]
-
-        return {field_name: (filename, file_handle, mime_type)}
-
-    def _wait_for_completion(
-        self, job_id: int, timeout: int = 900, poll_interval: int = 5
-    ) -> Dict[str, Any]:
-        """Wait for job completion."""
-        start_time = time.time()
-
-        while time.time() - start_time < timeout:
-            response = self.client.request("GET", f"/api/v1/jobs/{job_id}")
-
-            status = response.get("status", "").upper()
-            if status == "COMPLETED":
-                return response
-            elif status in ["FAILED", "ERROR"]:
-                raise Exception(f"Job failed: {response.get('error_message', 'Unknown error')}")
-
-            time.sleep(poll_interval)
-
-        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
-
-    async def _async_wait_for_completion(
-        self, job_id: int, timeout: int = 900, poll_interval: int = 5
-    ) -> Dict[str, Any]:
-        """Async wait for job completion."""
-        import asyncio
-
-        start_time = time.time()
-
-        while time.time() - start_time < timeout:
-            response = await self.client.request("GET", f"/api/v1/jobs/{job_id}")
-
-            status = response.get("status", "").upper()
-            if status == "COMPLETED":
-                return response
-            elif status in ["FAILED", "ERROR"]:
-                raise Exception(f"Job failed: {response.get('error_message', 'Unknown error')}")
-
-            await asyncio.sleep(poll_interval)
-
-        raise TimeoutError(f"Job {job_id} did not complete within {timeout} seconds")
-

audiopod/services/credits.py

@@ -1,42 +0,0 @@
-"""
-Credits Service - User credits and usage (subscription credits)
-"""
-
-from typing import List, Dict, Any
-from .base import BaseService
-
-
-class CreditService(BaseService):
-    """
-    Service for managing subscription credits.
-
-    Note: For API wallet (USD-based billing), use client.wallet instead.
-    """
-
-    def get_balance(self) -> Dict[str, Any]:
-        """Get subscription credit balance."""
-        if self.async_mode:
-            return self._async_get_balance()
-        return self.client.request("GET", "/api/v1/credits")
-
-    async def _async_get_balance(self) -> Dict[str, Any]:
-        return await self.client.request("GET", "/api/v1/credits")
-
-    def get_usage_history(self) -> List[Dict[str, Any]]:
-        """Get credit usage history."""
-        if self.async_mode:
-            return self._async_get_usage_history()
-        return self.client.request("GET", "/api/v1/credits/usage")
-
-    async def _async_get_usage_history(self) -> List[Dict[str, Any]]:
-        return await self.client.request("GET", "/api/v1/credits/usage")
-
-    def get_multipliers(self) -> Dict[str, float]:
-        """Get credit multipliers for services."""
-        if self.async_mode:
-            return self._async_get_multipliers()
-        return self.client.request("GET", "/api/v1/credits/multipliers")
-
-    async def _async_get_multipliers(self) -> Dict[str, float]:
-        return await self.client.request("GET", "/api/v1/credits/multipliers")
-

audiopod/services/denoiser.py

@@ -1,131 +0,0 @@
-"""
-Denoiser Service - Audio noise reduction
-
-API Routes:
-- POST /api/v1/denoiser/denoise      - Denoise audio
-- GET  /api/v1/denoiser/jobs/{id}    - Get job details
-- GET  /api/v1/denoiser/jobs         - List jobs
-- DELETE /api/v1/denoiser/jobs/{id}  - Delete job
-"""
-
-from typing import Optional, Dict, Any, List
-from .base import BaseService
-
-
-class DenoiserService(BaseService):
-    """Service for audio noise reduction."""
-
-    def denoise(
-        self,
-        audio_file: Optional[str] = None,
-        url: Optional[str] = None,
-        mode: str = "balanced",
-        wait_for_completion: bool = False,
-        timeout: int = 300,
-    ) -> Dict[str, Any]:
-        """
-        Remove noise from audio.
-
-        Args:
-            audio_file: Path to local audio file
-            url: URL of audio file
-            mode: Denoise mode ("balanced", "studio", or "ultra")
-            wait_for_completion: Wait for completion
-            timeout: Max wait time in seconds
-
-        Returns:
-            Job dict with denoised audio URL when completed
-        """
-        data = {"mode": mode}
-        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_denoise(data, files, wait_for_completion, timeout)
-
-        response = self.client.request("POST", "/api/v1/denoiser/denoise", data=data, files=files)
-
-        if wait_for_completion:
-            job_id = response.get("id") or response.get("job_id")
-            return self._wait_for_denoise(job_id, timeout)
-        return response
-
-    async def _async_denoise(
-        self, data: Dict, files: Optional[Dict], wait_for_completion: bool, timeout: int
-    ) -> Dict[str, Any]:
-        response = await self.client.request("POST", "/api/v1/denoiser/denoise", data=data, files=files)
-        if wait_for_completion:
-            job_id = response.get("id") or response.get("job_id")
-            return await self._async_wait_for_denoise(job_id, timeout)
-        return response
-
-    def get_job(self, job_id: int) -> Dict[str, Any]:
-        """Get denoise job details and status."""
-        if self.async_mode:
-            return self._async_get_job(job_id)
-        return self.client.request("GET", f"/api/v1/denoiser/jobs/{job_id}")
-
-    async def _async_get_job(self, job_id: int) -> Dict[str, Any]:
-        return await self.client.request("GET", f"/api/v1/denoiser/jobs/{job_id}")
-
-    def list_jobs(self, skip: int = 0, limit: int = 50) -> List[Dict[str, Any]]:
-        """List denoiser jobs."""
-        if self.async_mode:
-            return self._async_list_jobs(skip, limit)
-        return self.client.request(
-            "GET", "/api/v1/denoiser/jobs", 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/denoiser/jobs", params={"skip": skip, "limit": limit}
-        )
-
-    def delete_job(self, job_id: int) -> Dict[str, str]:
-        """Delete a denoiser job."""
-        if self.async_mode:
-            return self._async_delete_job(job_id)
-        return self.client.request("DELETE", f"/api/v1/denoiser/jobs/{job_id}")
-
-    async def _async_delete_job(self, job_id: int) -> Dict[str, str]:
-        return await self.client.request("DELETE", f"/api/v1/denoiser/jobs/{job_id}")
-
-    def _wait_for_denoise(self, job_id: int, timeout: int) -> Dict[str, Any]:
-        """Wait for denoise 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"Denoising failed: {job.get('error_message', 'Unknown error')}")
-
-            time.sleep(3)
-
-        raise TimeoutError(f"Denoising {job_id} did not complete within {timeout} seconds")
-
-    async def _async_wait_for_denoise(self, job_id: int, timeout: int) -> Dict[str, Any]:
-        """Async wait for denoise 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"Denoising failed: {job.get('error_message', 'Unknown error')}")
-
-            await asyncio.sleep(3)
-
-        raise TimeoutError(f"Denoising {job_id} did not complete within {timeout} seconds")
-

audiopod/services/music.py

@@ -1,217 +0,0 @@
-"""
-Music Service - Music generation
-
-API Routes:
-- POST /api/v1/music/text2music         - Generate music with vocals
-- POST /api/v1/music/prompt2instrumental - Generate instrumental music
-- POST /api/v1/music/lyric2vocals       - Generate vocals from lyrics
-- POST /api/v1/music/text2rap           - Generate rap music
-- GET  /api/v1/music/jobs/{id}/status   - Get job status
-- GET  /api/v1/music/jobs               - List jobs
-- DELETE /api/v1/music/jobs/{id}        - Delete job
-- GET  /api/v1/music/presets            - Get genre presets
-"""
-
-from typing import Optional, Dict, Any, List, Literal
-from .base import BaseService
-
-
-MusicTask = Literal["text2music", "prompt2instrumental", "lyric2vocals", "text2rap", "text2samples"]
-
-
-class MusicService(BaseService):
-    """Service for AI music generation."""
-
-    def generate(
-        self,
-        prompt: str,
-        task: MusicTask = "prompt2instrumental",
-        duration: int = 30,
-        lyrics: Optional[str] = None,
-        genre_preset: Optional[str] = None,
-        display_name: Optional[str] = None,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """
-        Generate music from text prompt.
-
-        Args:
-            prompt: Text description of desired music
-            task: Generation task type:
-                - "prompt2instrumental": Instrumental music (no vocals)
-                - "text2music": Music with vocals (requires lyrics)
-                - "text2rap": Rap music (requires lyrics)
-                - "lyric2vocals": Generate vocals from lyrics
-            duration: Duration in seconds (default 30, max varies by task)
-            lyrics: Lyrics for vocal tasks
-            genre_preset: Genre preset name
-            display_name: Custom name for the job
-            wait_for_completion: Wait for completion
-            timeout: Max wait time in seconds
-
-        Returns:
-            Job dict with audio URL when completed
-        """
-        data = {
-            "prompt": prompt,
-            "audio_duration": duration,
-        }
-        
-        if lyrics:
-            data["lyrics"] = lyrics
-        if genre_preset:
-            data["genre_preset"] = genre_preset
-        if display_name:
-            data["display_name"] = display_name
-
-        endpoint = f"/api/v1/music/{task}"
-
-        if self.async_mode:
-            return self._async_generate(endpoint, data, wait_for_completion, timeout)
-
-        response = self.client.request("POST", endpoint, json_data=data)
-
-        if wait_for_completion:
-            job_id = response.get("id") or response.get("job_id")
-            return self._wait_for_music(job_id, timeout)
-        return response
-
-    async def _async_generate(
-        self, endpoint: str, data: Dict, wait_for_completion: bool, timeout: int
-    ) -> Dict[str, Any]:
-        response = await self.client.request("POST", endpoint, json_data=data)
-        if wait_for_completion:
-            job_id = response.get("id") or response.get("job_id")
-            return await self._async_wait_for_music(job_id, timeout)
-        return response
-
-    def instrumental(
-        self,
-        prompt: str,
-        duration: int = 30,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """Generate instrumental music (no vocals)."""
-        return self.generate(
-            prompt=prompt,
-            task="prompt2instrumental",
-            duration=duration,
-            wait_for_completion=wait_for_completion,
-            timeout=timeout,
-        )
-
-    def song(
-        self,
-        prompt: str,
-        lyrics: str,
-        duration: int = 60,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """Generate a song with vocals."""
-        return self.generate(
-            prompt=prompt,
-            task="text2music",
-            lyrics=lyrics,
-            duration=duration,
-            wait_for_completion=wait_for_completion,
-            timeout=timeout,
-        )
-
-    def rap(
-        self,
-        prompt: str,
-        lyrics: str,
-        duration: int = 60,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """Generate rap music."""
-        return self.generate(
-            prompt=prompt,
-            task="text2rap",
-            lyrics=lyrics,
-            duration=duration,
-            wait_for_completion=wait_for_completion,
-            timeout=timeout,
-        )
-
-    def get_job(self, job_id: int) -> Dict[str, Any]:
-        """Get music generation job status."""
-        if self.async_mode:
-            return self._async_get_job(job_id)
-        return self.client.request("GET", f"/api/v1/music/jobs/{job_id}/status")
-
-    async def _async_get_job(self, job_id: int) -> Dict[str, Any]:
-        return await self.client.request("GET", f"/api/v1/music/jobs/{job_id}/status")
-
-    def list_jobs(self, skip: int = 0, limit: int = 50, task: Optional[str] = None) -> List[Dict[str, Any]]:
-        """List music generation jobs."""
-        params = {"skip": skip, "limit": limit}
-        if task:
-            params["task"] = task
-            
-        if self.async_mode:
-            return self._async_list_jobs(params)
-        return self.client.request("GET", "/api/v1/music/jobs", params=params)
-
-    async def _async_list_jobs(self, params: Dict) -> List[Dict[str, Any]]:
-        return await self.client.request("GET", "/api/v1/music/jobs", params=params)
-
-    def delete_job(self, job_id: int) -> Dict[str, str]:
-        """Delete a music generation job."""
-        if self.async_mode:
-            return self._async_delete_job(job_id)
-        return self.client.request("DELETE", f"/api/v1/music/jobs/{job_id}")
-
-    async def _async_delete_job(self, job_id: int) -> Dict[str, str]:
-        return await self.client.request("DELETE", f"/api/v1/music/jobs/{job_id}")
-
-    def get_presets(self) -> Dict[str, Any]:
-        """Get available genre presets."""
-        if self.async_mode:
-            return self._async_get_presets()
-        return self.client.request("GET", "/api/v1/music/presets")
-
-    async def _async_get_presets(self) -> Dict[str, Any]:
-        return await self.client.request("GET", "/api/v1/music/presets")
-
-    def _wait_for_music(self, job_id: int, timeout: int) -> Dict[str, Any]:
-        """Wait for music generation 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"Music generation failed: {job.get('error_message', 'Unknown error')}")
-
-            time.sleep(5)
-
-        raise TimeoutError(f"Music generation {job_id} did not complete within {timeout} seconds")
-
-    async def _async_wait_for_music(self, job_id: int, timeout: int) -> Dict[str, Any]:
-        """Async wait for music generation 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"Music generation failed: {job.get('error_message', 'Unknown error')}")
-
-            await asyncio.sleep(5)
-
-        raise TimeoutError(f"Music generation {job_id} did not complete within {timeout} seconds")
-

audiopod/services/speaker.py

@@ -1,134 +0,0 @@
-"""
-Speaker Service - Speaker diarization and extraction
-"""
-
-from typing import Optional, Dict, Any, List
-from .base import BaseService
-
-
-class SpeakerService(BaseService):
-    """Service for speaker diarization and extraction."""
-
-    def diarize(
-        self,
-        audio_file: Optional[str] = None,
-        url: Optional[str] = None,
-        num_speakers: Optional[int] = None,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """
-        Identify and separate speakers in audio.
-
-        Args:
-            audio_file: Path to local audio file
-            url: URL of audio file
-            num_speakers: Expected number of speakers (auto-detected if not provided)
-            wait_for_completion: Wait for completion
-            timeout: Max wait time in seconds
-
-        Returns:
-            Job dict with speaker segments when completed
-        """
-        data = {}
-        if num_speakers:
-            data["num_speakers"] = num_speakers
-        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_diarize(data, files, wait_for_completion, timeout)
-
-        response = self.client.request("POST", "/api/v1/speaker/diarize", data=data, files=files)
-
-        if wait_for_completion:
-            return self._wait_for_completion(response["id"], timeout)
-        return response
-
-    async def _async_diarize(
-        self, data: Dict, files: Optional[Dict], wait_for_completion: bool, timeout: int
-    ) -> Dict[str, Any]:
-        response = await self.client.request(
-            "POST", "/api/v1/speaker/diarize", data=data, files=files
-        )
-        if wait_for_completion:
-            return await self._async_wait_for_completion(response["id"], timeout)
-        return response
-
-    def extract(
-        self,
-        audio_file: Optional[str] = None,
-        url: Optional[str] = None,
-        wait_for_completion: bool = False,
-        timeout: int = 600,
-    ) -> Dict[str, Any]:
-        """
-        Extract individual speaker audio tracks.
-
-        Args:
-            audio_file: Path to local audio file
-            url: URL of audio file
-            wait_for_completion: Wait for completion
-            timeout: Max wait time in seconds
-
-        Returns:
-            Job dict with speaker audio URLs when completed
-        """
-        data = {}
-        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_extract(data, files, wait_for_completion, timeout)
-
-        response = self.client.request("POST", "/api/v1/speaker/extract", data=data, files=files)
-
-        if wait_for_completion:
-            return self._wait_for_completion(response["id"], timeout)
-        return response
-
-    async def _async_extract(
-        self, data: Dict, files: Optional[Dict], wait_for_completion: bool, timeout: int
-    ) -> Dict[str, Any]:
-        response = await self.client.request(
-            "POST", "/api/v1/speaker/extract", data=data, files=files
-        )
-        if wait_for_completion:
-            return await self._async_wait_for_completion(response["id"], timeout)
-        return response
-
-    def get_job(self, job_id: int) -> Dict[str, Any]:
-        """Get speaker job details and status."""
-        if self.async_mode:
-            return self._async_get_job(job_id)
-        return self.client.request("GET", f"/api/v1/speaker/jobs/{job_id}")
-
-    async def _async_get_job(self, job_id: int) -> Dict[str, Any]:
-        return await self.client.request("GET", f"/api/v1/speaker/jobs/{job_id}")
-
-    def list_jobs(self, skip: int = 0, limit: int = 50) -> List[Dict[str, Any]]:
-        """List speaker jobs."""
-        if self.async_mode:
-            return self._async_list_jobs(skip, limit)
-        return self.client.request(
-            "GET", "/api/v1/speaker/jobs", 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/speaker/jobs", params={"skip": skip, "limit": limit}
-        )
-
-    def delete_job(self, job_id: int) -> Dict[str, str]:
-        """Delete a speaker job."""
-        if self.async_mode:
-            return self._async_delete_job(job_id)
-        return self.client.request("DELETE", f"/api/v1/speaker/jobs/{job_id}")
-
-    async def _async_delete_job(self, job_id: int) -> Dict[str, str]:
-        return await self.client.request("DELETE", f"/api/v1/speaker/jobs/{job_id}")
-