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

audiopod/resources/music.py

@@ -1,166 +0,0 @@
-"""
-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

@@ -1,132 +0,0 @@
-"""
-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

@@ -1,267 +0,0 @@
-"""
-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")