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

audiopod/resources/music.py

@@ -0,0 +1,166 @@
+"""
+Music Service - AI Music Generation
+"""
+
+import time
+from typing import Optional, List, Dict, Any, Literal, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+POLL_INTERVAL = 5  # seconds
+DEFAULT_TIMEOUT = 600  # 10 minutes
+
+MusicTask = Literal[
+    "text2music",
+    "prompt2instrumental",
+    "lyric2vocals",
+    "text2rap",
+    "text2samples",
+    "audio2audio",
+    "songbloom",
+]
+
+
+class Music:
+    """AI music generation service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def create(
+        self,
+        prompt: str,
+        *,
+        lyrics: Optional[str] = None,
+        duration: int = 30,
+        task: Optional[MusicTask] = None,
+        genre: Optional[str] = None,
+        display_name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Generate music from text.
+
+        Args:
+            prompt: Text prompt describing the music
+            lyrics: Lyrics (for vocal tracks)
+            duration: Duration in seconds (default: 30)
+            task: Task type (auto-detected based on lyrics if not specified)
+            genre: Genre preset
+            display_name: Display name for the track
+
+        Returns:
+            Music job object
+
+        Example:
+            >>> job = client.music.create(
+            ...     prompt="Upbeat electronic dance music",
+            ...     duration=30,
+            ... )
+        """
+        if task is None:
+            task = "text2music" if lyrics else "prompt2instrumental"
+
+        endpoint = f"/api/v1/music/{task}"
+
+        return self._client.post(
+            endpoint,
+            json_data={
+                "prompt": prompt,
+                "lyrics": lyrics,
+                "audio_duration": duration,
+                "display_name": display_name,
+                "genre_preset": genre,
+            },
+        )
+
+    def instrumental(
+        self, prompt: str, duration: int = 30
+    ) -> Dict[str, Any]:
+        """Generate instrumental music."""
+        return self.create(prompt, duration=duration, task="prompt2instrumental")
+
+    def song(
+        self, prompt: str, lyrics: str, duration: int = 60
+    ) -> Dict[str, Any]:
+        """Generate a song with vocals."""
+        return self.create(prompt, lyrics=lyrics, duration=duration, task="text2music")
+
+    def rap(
+        self, prompt: str, lyrics: str, duration: int = 60
+    ) -> Dict[str, Any]:
+        """Generate rap music."""
+        return self.create(prompt, lyrics=lyrics, duration=duration, task="text2rap")
+
+    def get(self, job_id: int) -> Dict[str, Any]:
+        """Get a music job by ID."""
+        return self._client.get(f"/api/v1/music/jobs/{job_id}/status")
+
+    def list(
+        self,
+        *,
+        skip: int = 0,
+        limit: int = 50,
+        task: Optional[MusicTask] = None,
+        status: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List music jobs."""
+        return self._client.get(
+            "/api/v1/music/jobs",
+            params={"skip": skip, "limit": limit, "task": task, "status": status},
+        )
+
+    def delete(self, job_id: int) -> None:
+        """Delete a music job."""
+        self._client.delete(f"/api/v1/music/jobs/{job_id}")
+
+    def wait_for_completion(
+        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
+    ) -> Dict[str, Any]:
+        """Wait for music generation to complete."""
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get(job_id)
+            status = job.get("status", "").upper()
+
+            if status == "COMPLETED":
+                return job
+            if status == "FAILED":
+                raise RuntimeError(
+                    f"Music generation failed: {job.get('error_message', 'Unknown error')}"
+                )
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"Music generation timed out after {timeout}s")
+
+    def generate(
+        self,
+        prompt: str,
+        *,
+        lyrics: Optional[str] = None,
+        duration: int = 30,
+        task: Optional[MusicTask] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Generate music and wait for completion.
+
+        Example:
+            >>> result = client.music.generate(
+            ...     prompt="Upbeat electronic dance music",
+            ...     duration=30,
+            ... )
+            >>> print(result["output_url"])
+        """
+        job = self.create(prompt, lyrics=lyrics, duration=duration, task=task)
+        return self.wait_for_completion(job["id"], timeout=timeout)
+
+    def get_presets(self) -> Dict[str, Any]:
+        """Get available genre presets."""
+        return self._client.get("/api/v1/music/presets")
+
+
+
+

audiopod/resources/speaker.py

@@ -0,0 +1,132 @@
+"""
+Speaker Service - Speaker Diarization & Separation
+"""
+
+import time
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+POLL_INTERVAL = 3  # seconds
+DEFAULT_TIMEOUT = 600  # 10 minutes
+
+
+class Speaker:
+    """Speaker diarization and separation service."""
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def diarize(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        num_speakers: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a speaker diarization job.
+
+        Args:
+            file: Path to audio file
+            url: URL of audio/video
+            num_speakers: Number of speakers (hint for better accuracy)
+
+        Returns:
+            Speaker job object
+
+        Example:
+            >>> job = client.speaker.diarize(
+            ...     file="./meeting.mp3",
+            ...     num_speakers=3,
+            ... )
+        """
+        if file:
+            return self._client.upload(
+                "/api/v1/speaker/diarize",
+                file,
+                field_name="file",
+                additional_fields={"num_speakers": num_speakers},
+            )
+
+        if url:
+            return self._client.post(
+                "/api/v1/speaker/diarize",
+                json_data={"url": url, "num_speakers": num_speakers},
+            )
+
+        raise ValueError("Either file or url must be provided")
+
+    def get(self, job_id: int) -> Dict[str, Any]:
+        """Get a speaker job by ID."""
+        return self._client.get(f"/api/v1/speaker/jobs/{job_id}")
+
+    def list(
+        self,
+        *,
+        skip: int = 0,
+        limit: int = 50,
+        status: Optional[str] = None,
+        job_type: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List speaker jobs."""
+        return self._client.get(
+            "/api/v1/speaker/jobs",
+            params={
+                "skip": skip,
+                "limit": limit,
+                "status": status,
+                "job_type": job_type,
+            },
+        )
+
+    def delete(self, job_id: int) -> None:
+        """Delete a speaker job."""
+        self._client.delete(f"/api/v1/speaker/jobs/{job_id}")
+
+    def wait_for_completion(
+        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
+    ) -> Dict[str, Any]:
+        """Wait for speaker job to complete."""
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.get(job_id)
+            status = job.get("status", "")
+
+            if status == "COMPLETED":
+                return job
+            if status == "FAILED":
+                raise RuntimeError(
+                    f"Speaker processing failed: {job.get('error_message', 'Unknown error')}"
+                )
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"Speaker processing timed out after {timeout}s")
+
+    def identify(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        num_speakers: Optional[int] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Diarize audio and wait for completion.
+
+        Example:
+            >>> result = client.speaker.identify(
+            ...     file="./meeting.mp3",
+            ...     num_speakers=3,
+            ... )
+            >>> print(result["segments"])
+        """
+        job = self.diarize(file=file, url=url, num_speakers=num_speakers)
+        return self.wait_for_completion(job["id"], timeout=timeout)
+
+
+
+

audiopod/resources/stems.py

@@ -0,0 +1,267 @@
+"""
+Stem Extraction Service - Audio Stem Separation
+
+Simple mode-based API for separating audio into individual stems.
+"""
+
+import time
+from typing import Optional, Dict, Any, Literal, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..client import AudioPod
+
+POLL_INTERVAL = 3  # seconds
+DEFAULT_TIMEOUT = 600  # 10 minutes
+
+# Separation modes
+StemMode = Literal["single", "two", "four", "six", "producer", "studio", "mastering"]
+
+# Single stem options
+SingleStem = Literal["vocals", "drums", "bass", "guitar", "piano", "other"]
+
+
+class StemExtraction:
+    """
+    Audio stem separation service.
+
+    Separate audio into individual components using simple mode selection.
+
+    Modes:
+        - single: Extract one stem (requires stem parameter)
+        - two: Vocals + Instrumental
+        - four: Vocals, Drums, Bass, Other
+        - six: Vocals, Drums, Bass, Guitar, Piano, Other
+        - producer: 8 stems with drum kit decomposition
+        - studio: 12 stems for professional mixing
+        - mastering: 16 stems maximum detail
+
+    Example:
+        >>> client = AudioPod(api_key="ap_...")
+        >>>
+        >>> # Six-stem separation from YouTube
+        >>> job = client.stems.extract(
+        ...     url="https://youtube.com/watch?v=VIDEO_ID",
+        ...     mode="six"
+        ... )
+        >>>
+        >>> # Wait for completion
+        >>> result = client.stems.wait_for_completion(job["id"])
+        >>> print(result["download_urls"])
+    """
+
+    def __init__(self, client: "AudioPod"):
+        self._client = client
+
+    def extract(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        mode: StemMode = "four",
+        stem: Optional[SingleStem] = None,
+    ) -> Dict[str, Any]:
+        """
+        Extract stems from audio using simple mode selection.
+
+        Args:
+            file: Path to local audio file (MP3, WAV, FLAC, M4A, OGG)
+            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:
+                vocals, drums, bass, guitar, piano, other
+
+        Returns:
+            Job object with id, status, task_id
+
+        Raises:
+            ValueError: If neither file nor url provided, or missing stem for single mode
+
+        Example:
+            >>> # From URL with 6 stems
+            >>> job = client.stems.extract(
+            ...     url="https://youtube.com/watch?v=VIDEO_ID",
+            ...     mode="six"
+            ... )
+            >>>
+            >>> # From file with 4 stems
+            >>> job = client.stems.extract(
+            ...     file="./song.mp3",
+            ...     mode="four"
+            ... )
+            >>>
+            >>> # Extract only vocals
+            >>> job = client.stems.extract(
+            ...     url="https://youtube.com/watch?v=VIDEO_ID",
+            ...     mode="single",
+            ...     stem="vocals"
+            ... )
+        """
+        if not file and not url:
+            raise ValueError("Either file or url must be provided")
+
+        if mode == "single" and not stem:
+            raise ValueError(
+                "stem parameter required for mode='single'. Options: vocals, drums, bass, guitar, piano, other"
+            )
+
+        # Build form data
+        data = {"mode": mode}
+        if stem:
+            data["stem"] = stem
+
+        if file:
+            return self._client.upload(
+                "/api/v1/stem-extraction/api/extract",
+                file,
+                field_name="file",
+                additional_fields=data,
+            )
+
+        if url:
+            data["url"] = url
+            return self._client.post(
+                "/api/v1/stem-extraction/api/extract",
+                data=data,
+            )
+
+        raise ValueError("Either file or url must be provided")
+
+    def status(self, job_id: int) -> Dict[str, Any]:
+        """
+        Get the status of a stem extraction job.
+
+        Args:
+            job_id: The job ID returned from extract()
+
+        Returns:
+            Job status with download_urls when completed
+
+        Example:
+            >>> status = client.stems.status(5512)
+            >>> if status["status"] == "COMPLETED":
+            ...     print(status["download_urls"])
+        """
+        return self._client.get(f"/api/v1/stem-extraction/status/{job_id}")
+
+    def get(self, job_id: int) -> Dict[str, Any]:
+        """Get a stem extraction job by ID."""
+        return self._client.get(f"/api/v1/stem-extraction/jobs/{job_id}")
+
+    def list(
+        self,
+        *,
+        skip: int = 0,
+        limit: int = 50,
+        status: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        List stem extraction jobs.
+
+        Args:
+            skip: Number of jobs to skip (pagination)
+            limit: Maximum jobs to return (default: 50)
+            status: Filter by status (PENDING, PROCESSING, COMPLETED, FAILED)
+
+        Returns:
+            List of stem extraction jobs
+        """
+        return self._client.get(
+            "/api/v1/stem-extraction/jobs",
+            params={"skip": skip, "limit": limit, "status": status},
+        )
+
+    def delete(self, job_id: int) -> None:
+        """Delete a stem extraction job."""
+        self._client.delete(f"/api/v1/stem-extraction/jobs/{job_id}")
+
+    def wait_for_completion(self, job_id: int, timeout: int = DEFAULT_TIMEOUT) -> Dict[str, Any]:
+        """
+        Wait for stem extraction to complete.
+
+        Args:
+            job_id: The job ID to wait for
+            timeout: Maximum wait time in seconds (default: 600)
+
+        Returns:
+            Completed job with download_urls
+
+        Raises:
+            RuntimeError: If job fails
+            TimeoutError: If timeout exceeded
+
+        Example:
+            >>> job = client.stems.extract(url="...", mode="six")
+            >>> result = client.stems.wait_for_completion(job["id"])
+            >>> for stem, url in result["download_urls"].items():
+            ...     print(f"{stem}: {url}")
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            job = self.status(job_id)
+            job_status = job.get("status", "")
+
+            if job_status == "COMPLETED":
+                return job
+            if job_status == "FAILED":
+                raise RuntimeError(
+                    f"Stem extraction failed: {job.get('error_message', 'Unknown error')}"
+                )
+
+            time.sleep(POLL_INTERVAL)
+
+        raise TimeoutError(f"Stem extraction timed out after {timeout}s")
+
+    def separate(
+        self,
+        *,
+        file: Optional[str] = None,
+        url: Optional[str] = None,
+        mode: StemMode = "four",
+        stem: Optional[SingleStem] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> Dict[str, Any]:
+        """
+        Extract stems and wait for completion (convenience method).
+
+        Args:
+            file: Path to local audio file
+            url: URL of audio/video
+            mode: Separation mode (single, two, four, six, producer, studio, mastering)
+            stem: For mode="single", which stem to extract
+            timeout: Maximum wait time in seconds
+
+        Returns:
+            Completed job with download_urls
+
+        Example:
+            >>> # One-liner: extract and wait
+            >>> result = client.stems.separate(
+            ...     url="https://youtube.com/watch?v=VIDEO_ID",
+            ...     mode="six"
+            ... )
+            >>> print(result["download_urls"]["vocals"])
+        """
+        job = self.extract(file=file, url=url, mode=mode, stem=stem)
+        return self.wait_for_completion(job["id"], timeout=timeout)
+
+    def modes(self) -> Dict[str, Any]:
+        """
+        Get available separation modes.
+
+        Returns:
+            List of available modes with descriptions
+
+        Example:
+            >>> modes = client.stems.modes()
+            >>> for m in modes["modes"]:
+            ...     print(f"{m['mode']}: {m['description']}")
+        """
+        return self._client.get("/api/v1/stem-extraction/modes")