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

audiopod/services/wallet.py

@@ -0,0 +1,235 @@
+"""
+API Wallet Service - Manage API billing and balance
+"""
+
+from typing import Dict, Any, Optional, List
+from .base import BaseService
+
+
+class WalletService(BaseService):
+    """
+    Service for managing API wallet balance and billing.
+
+    Example:
+        ```python
+        from audiopod import Client
+
+        client = Client()
+
+        # Get balance
+        balance = client.wallet.get_balance()
+        print(f"Balance: {balance['balance_usd']}")
+
+        # Estimate cost
+        estimate = client.wallet.estimate_cost("stem_extraction", 300)
+        print(f"Cost: {estimate['cost_usd']}")
+
+        # Create top-up checkout
+        checkout = client.wallet.create_topup_checkout(2500)  # $25.00
+        print(f"Pay at: {checkout['url']}")
+        ```
+    """
+
+    def get_balance(self) -> Dict[str, Any]:
+        """
+        Get current API wallet balance.
+
+        Returns:
+            Dict with balance_cents, balance_usd, total_topup_cents, total_spent_cents
+        """
+        if self.async_mode:
+            return self._async_get_balance()
+        return self.client.request("GET", "/api/v1/api-wallet/balance")
+
+    async def _async_get_balance(self) -> Dict[str, Any]:
+        return await self.client.request("GET", "/api/v1/api-wallet/balance")
+
+    def get_pricing(self) -> Dict[str, Any]:
+        """
+        Get pricing table for all services.
+
+        Returns:
+            Dict with services pricing and wallet configuration
+        """
+        if self.async_mode:
+            return self._async_get_pricing()
+        return self.client.request("GET", "/api/v1/api-wallet/pricing")
+
+    async def _async_get_pricing(self) -> Dict[str, Any]:
+        return await self.client.request("GET", "/api/v1/api-wallet/pricing")
+
+    def estimate_cost(self, service_type: str, duration_seconds: int) -> Dict[str, Any]:
+        """
+        Estimate cost for a service operation.
+
+        Args:
+            service_type: Type of service (e.g., "stem_extraction", "transcription")
+            duration_seconds: Duration of audio in seconds
+
+        Returns:
+            Dict with cost_cents, cost_usd, duration_minutes
+        """
+        if self.async_mode:
+            return self._async_estimate_cost(service_type, duration_seconds)
+        return self.client.request(
+            "POST",
+            "/api/v1/api-wallet/estimate",
+            json_data={"service_type": service_type, "duration_seconds": duration_seconds},
+        )
+
+    async def _async_estimate_cost(self, service_type: str, duration_seconds: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "POST",
+            "/api/v1/api-wallet/estimate",
+            json_data={"service_type": service_type, "duration_seconds": duration_seconds},
+        )
+
+    def check_balance(self, service_type: str, duration_seconds: int) -> Dict[str, Any]:
+        """
+        Check if balance is sufficient for an operation.
+
+        Args:
+            service_type: Type of service
+            duration_seconds: Duration of audio in seconds
+
+        Returns:
+            Dict with can_proceed, cost_cents, current_balance_cents
+
+        Raises:
+            InsufficientBalanceError: If balance is insufficient (402 response)
+        """
+        if self.async_mode:
+            return self._async_check_balance(service_type, duration_seconds)
+        return self.client.request(
+            "POST",
+            "/api/v1/api-wallet/check-balance",
+            json_data={"service_type": service_type, "duration_seconds": duration_seconds},
+        )
+
+    async def _async_check_balance(self, service_type: str, duration_seconds: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "POST",
+            "/api/v1/api-wallet/check-balance",
+            json_data={"service_type": service_type, "duration_seconds": duration_seconds},
+        )
+
+    def create_topup_checkout(self, amount_cents: int) -> Dict[str, Any]:
+        """
+        Create a Stripe checkout session to top up wallet.
+
+        Args:
+            amount_cents: Amount in cents (min 100 = $1.00, max 1000000 = $10,000)
+
+        Returns:
+            Dict with session_id, url, amount_cents, amount_usd
+        """
+        if self.async_mode:
+            return self._async_create_topup_checkout(amount_cents)
+        return self.client.request(
+            "POST",
+            "/api/v1/api-wallet/topup/checkout",
+            json_data={"amount_cents": amount_cents},
+        )
+
+    async def _async_create_topup_checkout(self, amount_cents: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "POST",
+            "/api/v1/api-wallet/topup/checkout",
+            json_data={"amount_cents": amount_cents},
+        )
+
+    def create_topup_payment_intent(self, amount_cents: int) -> Dict[str, Any]:
+        """
+        Create a Stripe PaymentIntent for custom payment flows.
+
+        Args:
+            amount_cents: Amount in cents
+
+        Returns:
+            Dict with client_secret, payment_intent_id, amount_cents
+        """
+        if self.async_mode:
+            return self._async_create_topup_payment_intent(amount_cents)
+        return self.client.request(
+            "POST",
+            "/api/v1/api-wallet/topup/payment-intent",
+            json_data={"amount_cents": amount_cents},
+        )
+
+    async def _async_create_topup_payment_intent(self, amount_cents: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "POST",
+            "/api/v1/api-wallet/topup/payment-intent",
+            json_data={"amount_cents": amount_cents},
+        )
+
+    def get_usage_history(
+        self, page: int = 1, limit: int = 50
+    ) -> Dict[str, Any]:
+        """
+        Get API usage history.
+
+        Args:
+            page: Page number (1-indexed)
+            limit: Results per page (max 100)
+
+        Returns:
+            Dict with page, limit, logs (list of usage records)
+        """
+        if self.async_mode:
+            return self._async_get_usage_history(page, limit)
+        return self.client.request(
+            "GET",
+            "/api/v1/api-wallet/usage",
+            params={"page": page, "limit": limit},
+        )
+
+    async def _async_get_usage_history(self, page: int, limit: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "GET",
+            "/api/v1/api-wallet/usage",
+            params={"page": page, "limit": limit},
+        )
+
+    def get_topup_history(
+        self, page: int = 1, limit: int = 20
+    ) -> Dict[str, Any]:
+        """
+        Get wallet top-up history.
+
+        Args:
+            page: Page number (1-indexed)
+            limit: Results per page (max 100)
+
+        Returns:
+            Dict with page, limit, topups (list of top-up records)
+        """
+        if self.async_mode:
+            return self._async_get_topup_history(page, limit)
+        return self.client.request(
+            "GET",
+            "/api/v1/api-wallet/topups",
+            params={"page": page, "limit": limit},
+        )
+
+    async def _async_get_topup_history(self, page: int, limit: int) -> Dict[str, Any]:
+        return await self.client.request(
+            "GET",
+            "/api/v1/api-wallet/topups",
+            params={"page": page, "limit": limit},
+        )
+
+    def get_service_types(self) -> List[str]:
+        """
+        Get list of available service types.
+
+        Returns:
+            List of service type strings
+        """
+        if self.async_mode:
+            return self._async_get_service_types()
+        return self.client.request("GET", "/api/v1/api-wallet/service-types")
+
+    async def _async_get_service_types(self) -> List[str]:
+        return await self.client.request("GET", "/api/v1/api-wallet/service-types")
+

audiopod-2.2.0.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: audiopod
+Version: 2.2.0
+Summary: AudioPod SDK for Python - Professional Audio Processing powered by AI
+Author-email: AudioPod AI <support@audiopod.ai>
+License: MIT
+Project-URL: Homepage, https://audiopod.ai
+Project-URL: Documentation, https://docs.audiopod.ai
+Project-URL: Repository, https://github.com/AudiopodAI/audiopod-python
+Keywords: audiopod,audio,ai,voice,cloning,transcription,stem-separation,music,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: aiohttp>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# AudioPod Python SDK
+
+Official Python SDK for [AudioPod AI](https://audiopod.ai) - Professional Audio Processing powered by AI.
+
+## Installation
+
+```bash
+pip install audiopod
+```
+
+## Quick Start
+
+```python
+from audiopod import Client
+
+# Initialize client
+client = Client(api_key="ap_your_api_key")
+# Or set AUDIOPOD_API_KEY environment variable
+
+# Check wallet balance
+balance = client.wallet.get_balance()
+print(f"Balance: {balance['balance_usd']}")
+
+# Extract stems from audio
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# Download stems
+for stem, url in job["download_urls"].items():
+    print(f"{stem}: {url}")
+```
+
+## Services
+
+### Wallet (API Billing)
+
+```python
+# Get balance
+balance = client.wallet.get_balance()
+
+# Get pricing
+pricing = client.wallet.get_pricing()
+
+# Estimate cost
+estimate = client.wallet.estimate_cost("stem_extraction", duration_seconds=300)
+
+# Top up wallet
+checkout = client.wallet.create_topup_checkout(amount_cents=2500)  # $25
+print(f"Pay at: {checkout['url']}")
+
+# Usage history
+usage = client.wallet.get_usage_history(page=1, limit=50)
+```
+
+### Stem Extraction
+
+```python
+# Extract all stems
+job = client.stem_extraction.extract_stems(
+    audio_file="song.mp3",
+    stem_types=["vocals", "drums", "bass", "other"],
+    wait_for_completion=True
+)
+
+# From URL
+job = client.stem_extraction.extract_stems(
+    url="https://example.com/song.mp3",
+    stem_types=["vocals", "other"]
+)
+
+# Check status
+status = client.stem_extraction.get_job(job_id=123)
+```
+
+### Transcription
+
+```python
+# Transcribe audio
+result = client.transcription.transcribe(
+    audio_file="podcast.mp3",
+    speaker_diarization=True,
+    wait_for_completion=True
+)
+print(result["transcript"])
+```
+
+### Voice Cloning & TTS
+
+```python
+# List voices
+voices = client.voice.list_voices()
+
+# Generate speech
+audio = client.voice.generate_speech(
+    text="Hello, world!",
+    voice_id=123,
+    wait_for_completion=True
+)
+```
+
+### Music Generation
+
+```python
+# Generate music
+result = client.music.generate(
+    prompt="upbeat electronic dance music",
+    duration=30,
+    wait_for_completion=True
+)
+```
+
+### Noise Reduction
+
+```python
+# Denoise audio
+result = client.denoiser.denoise(
+    audio_file="noisy.mp3",
+    mode="studio",
+    wait_for_completion=True
+)
+```
+
+## Async Support
+
+```python
+import asyncio
+from audiopod import AsyncClient
+
+async def main():
+    async with AsyncClient() as client:
+        balance = await client.wallet.get_balance()
+        print(f"Balance: {balance['balance_usd']}")
+
+asyncio.run(main())
+```
+
+## Error Handling
+
+```python
+from audiopod import Client
+from audiopod.exceptions import (
+    AuthenticationError,
+    InsufficientBalanceError,
+    RateLimitError,
+    APIError
+)
+
+try:
+    client = Client()
+    job = client.stem_extraction.extract_stems(audio_file="song.mp3")
+except AuthenticationError:
+    print("Invalid API key")
+except InsufficientBalanceError as e:
+    print(f"Need to top up: required {e.required_cents} cents")
+except RateLimitError:
+    print("Rate limit exceeded, try again later")
+except APIError as e:
+    print(f"API error ({e.status_code}): {e}")
+```
+
+## Documentation
+
+- [API Reference](https://docs.audiopod.ai)
+- [API Wallet](https://docs.audiopod.ai/account/api-wallet)
+- [Stem Separation](https://docs.audiopod.ai/api-reference/stem-splitter)
+
+## License
+
+MIT
+

audiopod-2.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+audiopod/__init__.py,sha256=1L2mJzzdEVx9vKmhMV1RDHZ_v3DqJAxMvDNd1mp7eDk,621
+audiopod/client.py,sha256=UyUqCHh2l770Tr5cgThWbxf5na5T551ZOvfXp2vepE8,10482
+audiopod/config.py,sha256=pbmISyy8K9QpR4aYON7xHG5kpimac2lbqgi9wXF7q-Q,316
+audiopod/exceptions.py,sha256=djjLqVHGhUIe2SXFMWkVOw3TdHOZLQzFpQ5EWPjlGFM,946
+audiopod/services/__init__.py,sha256=F7JgtEzVcUqDLjgavUNes6SozoqD74ebwUqPwBWRWY4,708
+audiopod/services/base.py,sha256=-g3PQnXnrJyszj7wdV5Jb1SkUNSvm65TMpWqyIsh8Yo,2256
+audiopod/services/credits.py,sha256=l8zk1XR77nsvMVwjSDOqN_8hUPbwWVCqSXo4JmocXrI,1450
+audiopod/services/denoiser.py,sha256=LeV2zw-BVXkz-wWdXAQPx2mbtJeWBRPCvV0Q_avAAKA,4984
+audiopod/services/music.py,sha256=iihNVLaGCDp5A0jDbziLNLDASdsY1XJbStWkpH6lfuQ,7676
+audiopod/services/speaker.py,sha256=wrQcoKUS9VHjfYwDPYCncXJmeBSJm0bUH8fwlis-NMo,4692
+audiopod/services/stem_extraction.py,sha256=JJwDT63bn7Y7UrRYNd0qXcl6lFkrV1o4yZXkmMzXdYg,10311
+audiopod/services/transcription.py,sha256=OdIaqoYtVLg3O8zTZ1p3LZKH1arFprJuDJc2II9IgnU,7920
+audiopod/services/translation.py,sha256=lpkXKpSGz_ounvDRMCa4vbvv9jHQtQ-Gk3BDR_9fWJo,5222
+audiopod/services/video.py,sha256=y-gSpo8yu6U5bQrpOmT9wqgc4n9tuEag7PcPWyDOQRM,11711
+audiopod/services/voice.py,sha256=JtlH9DCHi-D9eVSo3g95VeB99aBjdcOxTOm6RN8Re1E,7234
+audiopod/services/wallet.py,sha256=Dg32Ak51w7BcbLVRl4TrI7yipA4QE5_RUZPHp2JS8T8,7735
+audiopod-2.2.0.dist-info/licenses/LICENSE,sha256=hqEjnOaGNbnLSBxbtbC7WQVREU2vQI8FmwecCiZlMfA,1068
+audiopod-2.2.0.dist-info/METADATA,sha256=Z1BSKVVEmm6Ez-lerTHrHqnoorAuCH9rU_bEhHaNKuQ,4819
+audiopod-2.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+audiopod-2.2.0.dist-info/top_level.txt,sha256=M6yyOFFNpLdH4i1AMRqJZLRIgfpg1NvrQVmnPd8A6N8,9
+audiopod-2.2.0.dist-info/RECORD,,

{audiopod-2.1.0.dist-info → audiopod-2.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

audiopod/resources/__init__.py

@@ -1,23 +0,0 @@
-"""AudioPod SDK Resources"""
-
-from .transcription import Transcription
-from .voice import Voice
-from .music import Music
-from .stems import StemExtraction
-from .denoiser import Denoiser
-from .speaker import Speaker
-from .wallet import Wallet
-
-__all__ = [
-    "Transcription",
-    "Voice",
-    "Music",
-    "StemExtraction",
-    "Denoiser",
-    "Speaker",
-    "Wallet",
-]
-
-
-
-

audiopod/resources/denoiser.py

@@ -1,116 +0,0 @@
-"""
-Denoiser Service - Audio Noise Reduction
-"""
-
-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 Denoiser:
-    """Audio noise reduction service."""
-
-    def __init__(self, client: "AudioPod"):
-        self._client = client
-
-    def create(
-        self,
-        *,
-        file: Optional[str] = None,
-        url: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        Create a denoise job.
-
-        Args:
-            file: Path to audio file
-            url: URL of audio/video
-
-        Returns:
-            Denoise job object
-
-        Example:
-            >>> job = client.denoiser.create(file="./noisy-audio.mp3")
-        """
-        if file:
-            return self._client.upload(
-                "/api/v1/denoiser/denoise",
-                file,
-                field_name="file",
-            )
-
-        if url:
-            return self._client.post(
-                "/api/v1/denoiser/denoise",
-                json_data={"url": url},
-            )
-
-        raise ValueError("Either file or url must be provided")
-
-    def get(self, job_id: int) -> Dict[str, Any]:
-        """Get a denoise job by ID."""
-        return self._client.get(f"/api/v1/denoiser/jobs/{job_id}")
-
-    def list(
-        self,
-        *,
-        skip: int = 0,
-        limit: int = 50,
-        status: Optional[str] = None,
-    ) -> List[Dict[str, Any]]:
-        """List denoise jobs."""
-        return self._client.get(
-            "/api/v1/denoiser/jobs",
-            params={"skip": skip, "limit": limit, "status": status},
-        )
-
-    def delete(self, job_id: int) -> None:
-        """Delete a denoise job."""
-        self._client.delete(f"/api/v1/denoiser/jobs/{job_id}")
-
-    def wait_for_completion(
-        self, job_id: int, timeout: int = DEFAULT_TIMEOUT
-    ) -> Dict[str, Any]:
-        """Wait for denoising 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"Denoising failed: {job.get('error_message', 'Unknown error')}"
-                )
-
-            time.sleep(POLL_INTERVAL)
-
-        raise TimeoutError(f"Denoising timed out after {timeout}s")
-
-    def denoise(
-        self,
-        *,
-        file: Optional[str] = None,
-        url: Optional[str] = None,
-        timeout: int = DEFAULT_TIMEOUT,
-    ) -> Dict[str, Any]:
-        """
-        Denoise audio and wait for completion.
-
-        Example:
-            >>> result = client.denoiser.denoise(file="./noisy-audio.mp3")
-            >>> print(result["output_url"])
-        """
-        job = self.create(file=file, url=url)
-        return self.wait_for_completion(job["id"], timeout=timeout)
-
-
-
-