audiopod 1.1.1__tar.gz → 1.2.0__tar.gz

{audiopod-1.1.1 → audiopod-1.2.0}/CHANGELOG.md

@@ -5,6 +5,78 @@ All notable changes to the AudioPod Python SDK will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2024-12-15
+
+### 🎤 Unified Voice Generation
+
+This release introduces a major architectural improvement with unified voice generation endpoint, consolidating voice cloning and text-to-speech into a single, consistent API.
+
+### ✨ Added
+
+- **Unified Voice Generation Method**: New `generate_voice()` method handles both voice cloning and TTS
+  - Single endpoint `/api/v1/voice/voices/{voice_identifier}/generate` for all voice operations
+  - Supports both voice file upload (cloning) and voice ID (existing profiles)
+  - Enhanced parameter support: `audio_format`, `generation_params`, extended speed range (0.25-4.0)
+
+- **Enhanced Voice Generation Parameters**:
+  - `audio_format`: Support for 'mp3', 'wav', 'ogg' output formats
+  - `generation_params`: Provider-specific parameters (speed, temperature, pitch, etc.)
+  - Extended speed range: 0.25x to 4.0x (provider dependent)
+
+### 🔧 Fixed
+
+- **Removed Legacy Clone Endpoint**: No longer uses deprecated `/api/v1/voice/voice-clone`
+- **Unified API Architecture**: All voice generation now uses consistent endpoint structure
+- **Improved Error Handling**: Better validation for mutually exclusive parameters
+
+### 🏗️ Improved
+
+- **Backward Compatibility**: Existing `clone_voice()` and `generate_speech()` methods continue to work
+  - Legacy methods now internally use the unified `generate_voice()` approach
+  - No breaking changes for existing code
+  - Clear migration path with deprecation warnings in documentation
+
+- **Enhanced Documentation**: 
+  - Updated examples to showcase unified approach
+  - Clear distinction between recommended and legacy methods
+  - Comprehensive migration guide
+
+### 🚀 Usage Examples
+
+#### New Unified Approach (Recommended)
+```python
+# Voice cloning
+result = client.voice.generate_voice(
+    text="Hello world!",
+    voice_file="voice.wav",  # For cloning
+    language="en",
+    audio_format="mp3"
+)
+
+# TTS with existing voice
+result = client.voice.generate_voice(
+    text="Hello world!",
+    voice_id="profile-id",  # For existing voices
+    language="en",
+    audio_format="mp3"
+)
+```
+
+#### Backward Compatibility (Legacy methods still work)
+```python
+# These continue to work unchanged
+result = client.voice.clone_voice(voice_file="voice.wav", text="Hello")
+result = client.voice.generate_speech(voice_id="profile-id", text="Hello")
+```
+
+### 🔄 Migration Notes
+
+- **No Breaking Changes**: All existing code continues to work without modification
+- **Recommended**: Migrate to `generate_voice()` for new development
+- **Performance**: Unified endpoint provides better consistency and reliability
+
+---
+
 ## [1.1.1] - 2024-12-15
 
 ### 🔧 Translation Service Fixes

{audiopod-1.1.1 → audiopod-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiopod
-Version: 1.1.1
+Version: 1.2.0
 Summary: Professional Audio Processing API Client for Python
 Home-page: https://github.com/audiopod-ai/audiopod-python
 Author: AudioPod AI
@@ -95,7 +95,7 @@ client = audiopod.Client(api_key="ap_your_api_key_here")
 
 ### Basic Usage
 
-#### Voice Cloning
+#### Voice Generation (Unified TTS & Cloning)
 
 ```python
 import audiopod
@@ -103,15 +103,39 @@ import audiopod
 # Initialize client
 client = audiopod.Client()
 
-# Clone a voice and generate speech
-job = client.voice.clone_voice(
+# Generate voice using file cloning (unified approach)
+job = client.voice.generate_voice(
+    text="Hello! This is voice generation using a cloned voice.",
+    voice_file="path/to/voice_sample.wav",  # For voice cloning
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+print(f"Generated audio URL: {job.output_url}")
+
+# Generate speech with existing voice profile (unified approach)
+speech = client.voice.generate_voice(
+    text="Hello from my voice profile!",
+    voice_id="voice-profile-id",  # For existing voice profiles
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Backward compatibility methods (deprecated - use generate_voice instead)
+legacy_clone = client.voice.clone_voice(
     voice_file="path/to/voice_sample.wav",
     text="Hello! This is a cloned voice speaking.",
     language="en",
     wait_for_completion=True
 )
-
-print(f"Generated audio URL: {job['output_url']}")
 ```
 
 #### Music Generation
@@ -197,10 +221,22 @@ voice_profile = client.voice.create_voice_profile(
     wait_for_completion=True
 )
 
-# Use the voice profile for speech generation
-speech = client.voice.generate_speech(
+# Use the voice profile for speech generation (unified approach - recommended)
+speech = client.voice.generate_voice(
+    text="This uses my custom voice profile with the unified method!",
     voice_id=voice_profile.id,
-    text="This uses my custom voice profile!",
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Legacy method (still works - uses generate_voice internally)
+legacy_speech = client.voice.generate_speech(
+    voice_id=voice_profile.id,
+    text="This uses the legacy method.",
     wait_for_completion=True
 )
 ```
@@ -343,7 +379,7 @@ client = audiopod.Client(
 
 ### Services
 
-- `client.voice`: Voice cloning and TTS operations
+- `client.voice`: **Voice generation operations** (unified TTS & cloning using `generate_voice()`)
 - `client.music`: Music generation and editing
 - `client.transcription`: Speech-to-text transcription
 - `client.translation`: Audio/video translation
@@ -352,6 +388,20 @@ client = audiopod.Client(
 - `client.karaoke`: Karaoke video generation
 - `client.credits`: Credit management and usage tracking
 
+#### Voice Service Methods
+
+**Recommended (Unified Approach):**
+- `client.voice.generate_voice()` - Generate speech with voice file (cloning) or voice ID (TTS)
+
+**Legacy Methods (Backward Compatibility):**
+- `client.voice.clone_voice()` - Clone voice from audio file (deprecated, uses `generate_voice` internally)
+- `client.voice.generate_speech()` - Generate speech with voice profile (deprecated, uses `generate_voice` internally)
+
+**Voice Management:**
+- `client.voice.create_voice_profile()` - Create reusable voice profiles
+- `client.voice.list_voice_profiles()` - List available voice profiles
+- `client.voice.delete_voice_profile()` - Delete voice profiles
+
 ### Models
 
 - `Job`: Base job information and status

{audiopod-1.1.1 → audiopod-1.2.0}/README.md

@@ -43,7 +43,7 @@ client = audiopod.Client(api_key="ap_your_api_key_here")
 
 ### Basic Usage
 
-#### Voice Cloning
+#### Voice Generation (Unified TTS & Cloning)
 
 ```python
 import audiopod
@@ -51,15 +51,39 @@ import audiopod
 # Initialize client
 client = audiopod.Client()
 
-# Clone a voice and generate speech
-job = client.voice.clone_voice(
+# Generate voice using file cloning (unified approach)
+job = client.voice.generate_voice(
+    text="Hello! This is voice generation using a cloned voice.",
+    voice_file="path/to/voice_sample.wav",  # For voice cloning
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+print(f"Generated audio URL: {job.output_url}")
+
+# Generate speech with existing voice profile (unified approach)
+speech = client.voice.generate_voice(
+    text="Hello from my voice profile!",
+    voice_id="voice-profile-id",  # For existing voice profiles
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Backward compatibility methods (deprecated - use generate_voice instead)
+legacy_clone = client.voice.clone_voice(
     voice_file="path/to/voice_sample.wav",
     text="Hello! This is a cloned voice speaking.",
     language="en",
     wait_for_completion=True
 )
-
-print(f"Generated audio URL: {job['output_url']}")
 ```
 
 #### Music Generation
@@ -145,10 +169,22 @@ voice_profile = client.voice.create_voice_profile(
     wait_for_completion=True
 )
 
-# Use the voice profile for speech generation
-speech = client.voice.generate_speech(
+# Use the voice profile for speech generation (unified approach - recommended)
+speech = client.voice.generate_voice(
+    text="This uses my custom voice profile with the unified method!",
     voice_id=voice_profile.id,
-    text="This uses my custom voice profile!",
+    language="en",
+    audio_format="mp3",
+    generation_params={
+        "speed": 1.0
+    },
+    wait_for_completion=True
+)
+
+# Legacy method (still works - uses generate_voice internally)
+legacy_speech = client.voice.generate_speech(
+    voice_id=voice_profile.id,
+    text="This uses the legacy method.",
     wait_for_completion=True
 )
 ```
@@ -291,7 +327,7 @@ client = audiopod.Client(
 
 ### Services
 
-- `client.voice`: Voice cloning and TTS operations
+- `client.voice`: **Voice generation operations** (unified TTS & cloning using `generate_voice()`)
 - `client.music`: Music generation and editing
 - `client.transcription`: Speech-to-text transcription
 - `client.translation`: Audio/video translation
@@ -300,6 +336,20 @@ client = audiopod.Client(
 - `client.karaoke`: Karaoke video generation
 - `client.credits`: Credit management and usage tracking
 
+#### Voice Service Methods
+
+**Recommended (Unified Approach):**
+- `client.voice.generate_voice()` - Generate speech with voice file (cloning) or voice ID (TTS)
+
+**Legacy Methods (Backward Compatibility):**
+- `client.voice.clone_voice()` - Clone voice from audio file (deprecated, uses `generate_voice` internally)
+- `client.voice.generate_speech()` - Generate speech with voice profile (deprecated, uses `generate_voice` internally)
+
+**Voice Management:**
+- `client.voice.create_voice_profile()` - Create reusable voice profiles
+- `client.voice.list_voice_profiles()` - List available voice profiles
+- `client.voice.delete_voice_profile()` - Delete voice profiles
+
 ### Models
 
 - `Job`: Base job information and status

{audiopod-1.1.1 → audiopod-1.2.0}/audiopod/__init__.py

@@ -47,7 +47,7 @@ from .models import (
     TranslationResult
 )
 
-__version__ = "1.1.1"
+__version__ = "1.2.0"
 __author__ = "AudioPod AI"
 __email__ = "support@audiopod.ai"
 __license__ = "MIT"

{audiopod-1.1.1 → audiopod-1.2.0}/audiopod/services/voice.py

@@ -2,6 +2,7 @@
 Voice Service - Voice cloning and TTS operations
 """
 
+import time
 from typing import List, Optional, Dict, Any, Union
 from pathlib import Path
 
@@ -13,54 +14,103 @@ from ..exceptions import ValidationError
 class VoiceService(BaseService):
     """Service for voice cloning and text-to-speech operations"""
     
-    def clone_voice(
+    def generate_voice(
         self,
-        voice_file: str,
         text: str,
+        voice_file: Optional[str] = None,
+        voice_id: Optional[Union[int, str]] = None,
         language: Optional[str] = None,
         speed: float = 1.0,
+        audio_format: str = "mp3",
+        generation_params: Optional[Dict[str, Any]] = None,
         wait_for_completion: bool = False,
         timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
         """
-        Clone a voice from an audio file
+        Generate speech using either a voice file (for cloning) or existing voice profile
+        
+        This unified method handles both voice cloning and text-to-speech generation:
+        - For voice cloning: Provide voice_file parameter
+        - For TTS with existing voice: Provide voice_id parameter
         
         Args:
-            voice_file: Path to audio file containing voice to clone
-            text: Text to generate with the cloned voice
+            text: Text to generate speech for
+            voice_file: Path to audio file for voice cloning (mutually exclusive with voice_id)
+            voice_id: ID/UUID of existing voice profile (mutually exclusive with voice_file)
             language: Target language code (e.g., 'en', 'es')
-            speed: Speech speed (0.5 to 2.0)
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            audio_format: Output audio format ('mp3', 'wav', 'ogg')
+            generation_params: Provider-specific parameters (speed, temperature, etc.)
             wait_for_completion: Whether to wait for job completion
             timeout: Maximum time to wait if wait_for_completion=True
             
         Returns:
             Job object if wait_for_completion=False, otherwise job result
+            
+        Raises:
+            ValidationError: If both or neither voice_file and voice_id are provided
         """
         # Validate inputs
+        if not voice_file and not voice_id:
+            raise ValidationError("Either voice_file (for cloning) or voice_id (for TTS) must be provided")
+        if voice_file and voice_id:
+            raise ValidationError("Provide either voice_file or voice_id, not both")
+            
         text = self._validate_text_input(text)
         if language:
             language = self._validate_language_code(language)
-        if not 0.5 <= speed <= 2.0:
-            raise ValidationError("Speed must be between 0.5 and 2.0")
+        if not 0.25 <= speed <= 4.0:
+            raise ValidationError("Speed must be between 0.25 and 4.0")
+        if audio_format not in ["mp3", "wav", "ogg"]:
+            raise ValidationError("Audio format must be 'mp3', 'wav', or 'ogg'")
             
-        # Prepare file upload
+        # For voice cloning, we need to create a temporary voice first, then generate
+        if voice_file:
+            return self._generate_with_voice_file(
+                voice_file, text, language, speed, audio_format, 
+                generation_params, wait_for_completion, timeout
+            )
+        else:
+            # Use existing voice profile with unified endpoint
+            return self._generate_with_voice_id(
+                voice_id, text, language, speed, audio_format,
+                generation_params, wait_for_completion, timeout
+            )
+            
+    def _generate_with_voice_file(
+        self,
+        voice_file: str,
+        text: str,
+        language: Optional[str],
+        speed: float,
+        audio_format: str,
+        generation_params: Optional[Dict[str, Any]],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Union[Job, Dict[str, Any]]:
+        """Generate speech with voice cloning using unified endpoint"""
+        # For voice cloning, we use the "clone" identifier with the unified endpoint
         files = self._prepare_file_upload(voice_file, "file")
         
-        # Prepare form data
+        # Prepare form data for unified endpoint
         data = {
             "input_text": text,
-            "speed": speed
+            "speed": speed,
+            "audio_format": audio_format
         }
         if language:
-            data["target_language"] = language
+            data["language"] = language
+        if generation_params:
+            # Add generation parameters
+            data.update(generation_params)
             
-        # Make request
         if self.async_mode:
-            return self._async_clone_voice(files, data, wait_for_completion, timeout)
+            return self._async_generate_voice("clone", data, files, wait_for_completion, timeout)
         else:
+            # Use unified voice generation endpoint with "clone" identifier
             response = self.client.request(
                 "POST", 
-                "/api/v1/voice/voice-clone",
+                "/api/v1/voice/voices/clone/generate",
                 data=data,
                 files=files
             )
@@ -73,17 +123,60 @@ class VoiceService(BaseService):
             
             return job
             
-    async def _async_clone_voice(
+    def _generate_with_voice_id(
         self,
-        files: Dict[str, Any],
+        voice_id: Union[int, str],
+        text: str,
+        language: Optional[str],
+        speed: float,
+        audio_format: str,
+        generation_params: Optional[Dict[str, Any]],
+        wait_for_completion: bool,
+        timeout: int
+    ) -> Union[Job, Dict[str, Any]]:
+        """Generate speech with existing voice profile using unified endpoint"""
+        # Prepare form data for unified endpoint
+        data = {
+            "input_text": text,
+            "speed": speed,
+            "audio_format": audio_format
+        }
+        if language:
+            data["language"] = language
+        if generation_params:
+            # Add generation parameters
+            data.update(generation_params)
+            
+        if self.async_mode:
+            return self._async_generate_voice(voice_id, data, None, wait_for_completion, timeout)
+        else:
+            # Use unified voice generation endpoint
+            response = self.client.request(
+                "POST", 
+                f"/api/v1/voice/voices/{voice_id}/generate",
+                data=data
+            )
+            
+            job = Job.from_dict(response)
+            
+            if wait_for_completion:
+                job = self._wait_for_completion(job.id, timeout)
+                return job.result if job.result else job
+            
+            return job
+            
+    async def _async_generate_voice(
+        self,
+        voice_identifier: Union[int, str],
         data: Dict[str, Any],
+        files: Optional[Dict[str, Any]],
         wait_for_completion: bool,
         timeout: int
     ) -> Union[Job, Dict[str, Any]]:
-        """Async version of clone_voice"""
+        """Async version of unified voice generation"""
         response = await self.client.request(
-            "POST",
-            "/api/v1/voice/voice-clone", 
+            "POST", 
+            f"/api/v1/voice/voices/{voice_identifier}/generate",
             data=data,
             files=files
         )
@@ -93,7 +186,7 @@ class VoiceService(BaseService):
         if wait_for_completion:
             job = await self._async_wait_for_completion(job.id, timeout)
             return job.result if job.result else job
-            
+        
         return job
         
     def create_voice_profile(
@@ -202,78 +295,79 @@ class VoiceService(BaseService):
         language: Optional[str] = None,
         speed: float = 1.0,
         audio_format: str = "mp3",
+        generation_params: Optional[Dict[str, Any]] = None,
         wait_for_completion: bool = False,
         timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
         """
-        Generate speech using an existing voice profile
+        Generate speech using an existing voice profile (unified endpoint)
+        
+        This method now uses the unified voice generation endpoint for consistency.
         
         Args:
             voice_id: ID or UUID of the voice profile
             text: Text to generate speech for
             language: Target language code
-            speed: Speech speed (0.5 to 2.0)
-            audio_format: Output audio format (mp3, wav)
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            audio_format: Output audio format ('mp3', 'wav', 'ogg')
+            generation_params: Additional generation parameters
             wait_for_completion: Whether to wait for completion
             timeout: Maximum time to wait
             
         Returns:
             Job object or generation result
         """
-        # Validate inputs
-        text = self._validate_text_input(text)
-        if language:
-            language = self._validate_language_code(language)
-        if not 0.5 <= speed <= 2.0:
-            raise ValidationError("Speed must be between 0.5 and 2.0")
-        if audio_format not in ["mp3", "wav"]:
-            raise ValidationError("Audio format must be 'mp3' or 'wav'")
-            
-        # Prepare form data
-        data = {
-            "input_text": text,
-            "speed": speed,
-            "audio_format": audio_format
-        }
-        if language:
-            data["language"] = language
-            
-        # Make request
-        endpoint = f"/api/v1/voice/voices/{voice_id}/generate"
-        
-        if self.async_mode:
-            return self._async_generate_speech(endpoint, data, wait_for_completion, timeout)
-        else:
-            response = self.client.request("POST", endpoint, data=data)
-            
-            if "job_id" in response:
-                job = Job.from_dict(response)
-                if wait_for_completion:
-                    job = self._wait_for_completion(job.id, timeout)
-                    return job.result if job.result else job
-                return job
-            else:
-                # Direct response with audio URL
-                return response
-                
-    async def _async_generate_speech(
+        # Use unified voice generation method
+        return self.generate_voice(
+            text=text,
+            voice_id=voice_id,
+            language=language,
+            speed=speed,
+            audio_format=audio_format,
+            generation_params=generation_params,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout
+        )
+    
+    def clone_voice(
         self,
-        endpoint: str,
-        data: Dict[str, Any],
-        wait_for_completion: bool,
-        timeout: int
+        voice_file: str,
+        text: str,
+        language: Optional[str] = None,
+        speed: float = 1.0,
+        generation_params: Optional[Dict[str, Any]] = None,
+        wait_for_completion: bool = False,
+        timeout: int = 300
     ) -> Union[Job, Dict[str, Any]]:
-        """Async version of generate_speech"""
-        response = await self.client.request("POST", endpoint, data=data)
+        """
+        Clone a voice from an audio file (backward compatibility)
         
-        if "job_id" in response:
-            job = Job.from_dict(response)
-            if wait_for_completion:
-                job = await self._async_wait_for_completion(job.id, timeout)
-                return job.result if job.result else job
-            return job
-        else:
-            return response
+        This method is now a wrapper around the unified generate_voice method.
+        For new code, consider using generate_voice() directly with voice_file parameter.
+        
+        Args:
+            voice_file: Path to audio file containing voice to clone
+            text: Text to generate with the cloned voice
+            language: Target language code (e.g., 'en', 'es')
+            speed: Speech speed (0.25 to 4.0, provider dependent)
+            generation_params: Additional generation parameters
+            wait_for_completion: Whether to wait for job completion
+            timeout: Maximum time to wait if wait_for_completion=True
+            
+        Returns:
+            Job object if wait_for_completion=False, otherwise job result
+        """
+        # Use unified voice generation method
+        return self.generate_voice(
+            text=text,
+            voice_file=voice_file,
+            language=language,
+            speed=speed,
+            audio_format="mp3",  # Default format for backward compatibility
+            generation_params=generation_params,
+            wait_for_completion=wait_for_completion,
+            timeout=timeout
+        )
             
     def list_voice_profiles(
         self,

{audiopod-1.1.1 → audiopod-1.2.0}/examples/basic_usage.py

@@ -61,9 +61,50 @@ def check_credits(client):
         return False
 
 
+def voice_generation_example(client):
+    """Demonstrate unified voice generation functionality"""
+    print("\n🎤 Voice Generation Example (Unified Approach)")
+    print("=" * 50)
+    
+    # For this example, you'll need a voice sample file
+    # Replace with path to your audio file
+    voice_file = "examples/voice_sample.wav"
+    
+    if not Path(voice_file).exists():
+        print(f"⚠️  Voice sample file not found: {voice_file}")
+        print("   Please provide a voice sample (wav, mp3, etc.) to test voice generation")
+        return
+    
+    try:
+        print(f"🔄 Generating voice using: {voice_file}")
+        
+        # Generate voice using unified method (for voice cloning)
+        job = client.voice.generate_voice(
+            text="Hello! This is an example of voice generation using the AudioPod API.",
+            voice_file=voice_file,  # For voice cloning
+            language="en",
+            audio_format="mp3",
+            generation_params={
+                "speed": 1.0
+            },
+            wait_for_completion=True,
+            timeout=300
+        )
+        
+        print("✅ Voice generation completed!")
+        if hasattr(job, 'output_url') and job.output_url:
+            print(f"🎵 Generated audio: {job.output_url}")
+        elif isinstance(job, dict) and 'output_url' in job:
+            print(f"🎵 Generated audio: {job['output_url']}")
+        
+    except ProcessingError as e:
+        print(f"❌ Voice generation failed: {e.message}")
+    except AudioPodError as e:
+        print(f"❌ API Error: {e.message}")
+
 def voice_cloning_example(client):
-    """Demonstrate voice cloning functionality"""
-    print("\n🎤 Voice Cloning Example")
+    """Demonstrate voice cloning functionality (backward compatibility)"""
+    print("\n🔄 Voice Cloning Example (Legacy - uses generate_voice internally)")
     print("=" * 50)
     
     # For this example, you'll need a voice sample file
@@ -76,12 +117,12 @@ def voice_cloning_example(client):
         return
     
     try:
-        print(f"🔄 Cloning voice from: {voice_file}")
+        print(f"🔄 Cloning voice from: {voice_file} (legacy method)")
         
-        # Clone voice with sample text
+        # Clone voice with sample text (legacy method - now uses generate_voice internally)
         job = client.voice.clone_voice(
             voice_file=voice_file,
-            text="Hello! This is an example of voice cloning using the AudioPod API.",
+            text="Hello! This is an example using the legacy clone_voice method.",
             language="en",
             speed=1.0,
             wait_for_completion=True,
@@ -89,7 +130,9 @@ def voice_cloning_example(client):
         )
         
         print("✅ Voice cloning completed!")
-        if 'output_url' in job:
+        if hasattr(job, 'output_url') and job.output_url:
+            print(f"🎵 Generated audio: {job.output_url}")
+        elif isinstance(job, dict) and 'output_url' in job:
             print(f"🎵 Generated audio: {job['output_url']}")
         
     except ProcessingError as e:
@@ -122,19 +165,40 @@ def voice_profile_example(client):
         
         print(f"✅ Voice profile created: {voice_profile.name} (ID: {voice_profile.id})")
         
-        # Use the voice profile for speech generation
-        print("🔄 Generating speech with voice profile...")
-        speech = client.voice.generate_speech(
-            voice_id=voice_profile.id,
-            text="This speech was generated using my custom voice profile!",
+        # Use the voice profile for speech generation (unified method - recommended)
+        print("🔄 Generating speech with voice profile using unified method...")
+        speech = client.voice.generate_voice(
+            text="This speech was generated using my custom voice profile with the unified method!",
+            voice_id=voice_profile.id,  # For existing voice profile
             language="en",
+            audio_format="mp3",
+            generation_params={
+                "speed": 1.0
+            },
             wait_for_completion=True
         )
         
         print("✅ Speech generation completed!")
-        if 'output_url' in speech:
+        if hasattr(speech, 'output_url') and speech.output_url:
+            print(f"🎵 Generated speech: {speech.output_url}")
+        elif isinstance(speech, dict) and 'output_url' in speech:
             print(f"🎵 Generated speech: {speech['output_url']}")
         
+        # Also demonstrate legacy method for comparison
+        print("🔄 Generating speech with voice profile using legacy method...")
+        legacy_speech = client.voice.generate_speech(
+            voice_id=voice_profile.id,
+            text="This speech was generated using the legacy generate_speech method.",
+            language="en",
+            wait_for_completion=True
+        )
+        
+        print("✅ Legacy speech generation completed!")
+        if hasattr(legacy_speech, 'output_url') and legacy_speech.output_url:
+            print(f"🎵 Generated speech (legacy): {legacy_speech.output_url}")
+        elif isinstance(legacy_speech, dict) and 'output_url' in legacy_speech:
+            print(f"🎵 Generated speech (legacy): {legacy_speech['output_url']}")
+        
         # List all voice profiles
         print("\n📋 Your voice profiles:")
         voices = client.voice.list_voice_profiles(limit=10)
@@ -443,7 +507,8 @@ def main():
     
     # Run examples
     try:
-        voice_cloning_example(client)
+        voice_generation_example(client)  # New unified method (recommended)
+        voice_cloning_example(client)    # Legacy method for backward compatibility
         voice_profile_example(client)
         music_generation_example(client)
         transcription_example(client)

{audiopod-1.1.1 → audiopod-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "audiopod"
-version = "1.1.1"
+version = "1.2.0"
 authors = [
     {name = "AudioPod AI", email = "support@audiopod.ai"},
 ]

{audiopod-1.1.1 → audiopod-1.2.0}/setup.py

@@ -31,7 +31,7 @@ def read_requirements():
 
 setup(
     name="audiopod",
-    version="1.1.0",
+    version="1.2.0",
     author="AudioPod AI",
     author_email="support@audiopod.ai",
     description="Professional Audio Processing API Client for Python",