isa-model 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

isa_model/inference/providers/yyds_provider.py

@@ -1,83 +0,0 @@
-from isa_model.inference.providers.base_provider import BaseProvider
-from isa_model.inference.base import ModelType, Capability
-from typing import Dict, List, Any
-import logging
-
-logger = logging.getLogger(__name__)
-
-class YYDSProvider(BaseProvider):
-    """Provider for YYDS API (Your YYDS Provider API)"""
-    
-    def __init__(self, config=None):
-        """
-        Initialize the YYDS Provider
-        
-        Args:
-            config (dict, optional): Configuration for the provider
-                - api_key: API key for authentication
-                - api_base: Base URL for YYDS API
-                - timeout: Timeout for API calls in seconds
-        """
-        default_config = {
-            "api_base": "https://api.yyds.ai/v1",
-            "timeout": 60,
-            "max_retries": 3,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "max_tokens": 2048
-        }
-        
-        # Merge default config with provided config
-        merged_config = {**default_config, **(config or {})}
-        
-        super().__init__(config=merged_config)
-        self.name = "yyds"
-        
-        # Validate API key
-        api_key = self.config.get("api_key")
-        if not api_key:
-            logger.warning("No API key provided for YYDS Provider. Some operations may fail.")
-        
-        logger.info(f"Initialized YYDSProvider with API base: {self.config['api_base']}")
-    
-    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
-        """Get provider capabilities by model type"""
-        return {
-            ModelType.LLM: [
-                Capability.CHAT, 
-                Capability.COMPLETION
-            ],
-            ModelType.VISION: [
-                Capability.IMAGE_CLASSIFICATION,
-                Capability.IMAGE_UNDERSTANDING
-            ],
-            ModelType.AUDIO: [
-                Capability.SPEECH_TO_TEXT,
-                Capability.TEXT_TO_SPEECH
-            ]
-        }
-    
-    def get_models(self, model_type: ModelType) -> List[str]:
-        """Get available models for given type"""
-        # Placeholder: In real implementation, this would query the YYDS API
-        if model_type == ModelType.LLM:
-            return ["yyds-l", "yyds-xl", "yyds-xxl"]
-        elif model_type == ModelType.VISION:
-            return ["yyds-vision", "yyds-multimodal"]
-        elif model_type == ModelType.AUDIO:
-            return ["yyds-speech", "yyds-tts"]
-        else:
-            return []
-    
-    def get_config(self) -> Dict[str, Any]:
-        """Get provider configuration"""
-        # Return a copy of the config, without the API key for security
-        config_copy = self.config.copy()
-        if "api_key" in config_copy:
-            config_copy["api_key"] = "***"  # Mask the API key
-        return config_copy
-    
-    def is_reasoning_model(self, model_name: str) -> bool:
-        """Check if the model is optimized for reasoning tasks"""
-        # Only the largest models are considered reasoning-capable
-        return model_name in ["yyds-xxl"]

isa_model/inference/services/audio/fish_speech/handler.py

@@ -1,215 +0,0 @@
-import os
-import base64
-import tempfile
-import runpod
-import torch
-import torchaudio
-import sys
-import json
-from pathlib import Path
-from typing import Dict, Any, List, Union
-
-# Add Fish-Speech to the Python path
-sys.path.append('/app/fish-speech')
-
-# Import Fish-Speech modules
-from fish_speech.models.fish_speech.model import FishSpeech
-from fish_speech.models.fish_speech.config import FishSpeechConfig
-from fish_speech.utils.audio import load_audio, save_audio
-from fish_speech.utils.tokenizer import load_tokenizer
-
-# Load the model
-MODEL_PATH = "/app/models/fish_speech_v1.4.0.pth"
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Initialize the model
-def load_model():
-    print("Loading Fish-Speech model...")
-    config = FishSpeechConfig()
-    model = FishSpeech(config)
-    
-    # Load the model weights
-    checkpoint = torch.load(MODEL_PATH, map_location=DEVICE)
-    model.load_state_dict(checkpoint["model"])
-    model.eval()
-    model.to(DEVICE)
-    
-    # Load the tokenizer
-    tokenizer = load_tokenizer()
-    
-    print(f"Model loaded successfully on {DEVICE}")
-    return model, tokenizer
-
-model, tokenizer = load_model()
-
-# Download a file from a URL
-async def download_file(url: str) -> str:
-    import aiohttp
-    import os
-    
-    # Create a temporary file
-    temp_dir = tempfile.mkdtemp()
-    local_filename = os.path.join(temp_dir, "reference_audio.wav")
-    
-    # Download the file
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url) as response:
-            if response.status != 200:
-                raise Exception(f"Failed to download file: {response.status}")
-            
-            with open(local_filename, "wb") as f:
-                f.write(await response.read())
-    
-    return local_filename
-
-# Generate speech using Fish-Speech
-def generate_speech(
-    text: str,
-    reference_audio_path: str = None,
-    language: str = "auto",
-    speed: float = 1.0,
-    gpt_cond_len: int = 30,
-    max_ref_len: int = 60,
-    enhance_audio: bool = True
-) -> str:
-    """
-    Generate speech using Fish-Speech
-    
-    Args:
-        text: Text to convert to speech
-        reference_audio_path: Path to reference audio file for voice cloning
-        language: Language code (auto for auto-detection)
-        speed: Speech speed factor
-        gpt_cond_len: GPT conditioning length
-        max_ref_len: Maximum reference length
-        enhance_audio: Whether to enhance audio quality
-        
-    Returns:
-        Path to the generated audio file
-    """
-    print(f"Generating speech for text: {text}")
-    
-    # Load reference audio if provided
-    reference = None
-    if reference_audio_path:
-        print(f"Loading reference audio: {reference_audio_path}")
-        reference, sr = load_audio(reference_audio_path)
-        reference = reference.to(DEVICE)
-    
-    # Generate speech
-    with torch.no_grad():
-        # Tokenize the text
-        tokens = tokenizer.encode(text, language=language)
-        tokens = torch.tensor(tokens, dtype=torch.long, device=DEVICE).unsqueeze(0)
-        
-        # Generate speech
-        output = model.generate(
-            tokens,
-            reference=reference,
-            gpt_cond_latent_length=gpt_cond_len,
-            max_ref_length=max_ref_len,
-            top_k=50,
-            top_p=0.95,
-            temperature=0.7,
-            speed=speed
-        )
-        
-        # Get the audio
-        audio = output["audio"]
-        
-        # Enhance audio if requested
-        if enhance_audio:
-            # Apply simple normalization
-            audio = audio / torch.max(torch.abs(audio))
-        
-        # Save the audio to a temporary file
-        temp_dir = tempfile.mkdtemp()
-        output_path = os.path.join(temp_dir, "output.wav")
-        save_audio(audio.cpu(), output_path, sample_rate=24000)
-        
-        print(f"Speech generated successfully: {output_path}")
-        return output_path
-
-# RunPod handler
-def handler(event):
-    """
-    RunPod handler function
-    
-    Args:
-        event: RunPod event object
-        
-    Returns:
-        Dictionary with the generated audio
-    """
-    try:
-        # Get the input data
-        input_data = event.get("input", {})
-        
-        # Extract parameters
-        text_data = input_data.get("text", [])
-        language = input_data.get("language", "auto")
-        speed = input_data.get("speed", 1.0)
-        gpt_cond_len = input_data.get("gpt_cond_len", 30)
-        max_ref_len = input_data.get("max_ref_len", 60)
-        enhance_audio = input_data.get("enhance_audio", True)
-        voice_data = input_data.get("voice", {})
-        
-        # Validate input
-        if not text_data:
-            return {"error": "No text provided"}
-        
-        # Process each text segment
-        results = []
-        
-        # Download reference audio if provided
-        reference_audio_paths = {}
-        for speaker_id, url in voice_data.items():
-            if url:
-                # Use runpod.download_file for synchronous download
-                local_path = runpod.download_file(url)
-                reference_audio_paths[speaker_id] = local_path
-        
-        # Process each text segment
-        for speaker_id, text in text_data:
-            # Get reference audio path
-            reference_path = reference_audio_paths.get(speaker_id)
-            
-            # Generate speech
-            output_path = generate_speech(
-                text=text,
-                reference_audio_path=reference_path,
-                language=language,
-                speed=speed,
-                gpt_cond_len=gpt_cond_len,
-                max_ref_len=max_ref_len,
-                enhance_audio=enhance_audio
-            )
-            
-            # Read the audio file and convert to base64
-            with open(output_path, "rb") as f:
-                audio_data = f.read()
-                audio_base64 = base64.b64encode(audio_data).decode("utf-8")
-            
-            # Add to results
-            results.append({
-                "speaker_id": speaker_id,
-                "text": text,
-                "audio_base64": audio_base64
-            })
-        
-        # Return the results
-        return {
-            "audio_base64": results[0]["audio_base64"] if results else None,
-            "results": results
-        }
-    
-    except Exception as e:
-        import traceback
-        error_message = str(e)
-        stack_trace = traceback.format_exc()
-        print(f"Error: {error_message}")
-        print(f"Stack trace: {stack_trace}")
-        return {"error": error_message, "stack_trace": stack_trace}
-
-# Start the RunPod handler
-runpod.serverless.start({"handler": handler}) 

isa_model/inference/services/audio/runpod_tts_fish_service.py

@@ -1,212 +0,0 @@
-import os
-import json
-import aiohttp
-import asyncio
-import base64
-import tempfile
-from typing import Dict, Any, Optional, Union, BinaryIO, List
-from ...base_tts_service import BaseTTSService
-from ...providers.runpod_provider import RunPodProvider
-
-class RunPodTTSFishService(BaseTTSService):
-    """
-    RunPod TTS service using Fish-Speech
-    
-    This service uses the Fish-Speech TTS model deployed on RunPod to generate speech from text.
-    Fish-Speech is a state-of-the-art open-source TTS model that supports multilingual text-to-speech
-    and voice cloning capabilities.
-    """
-    
-    def __init__(self, provider: RunPodProvider, model_name: str = "fish-speech"):
-        """
-        Initialize the RunPod TTS Fish service
-        
-        Args:
-            provider: RunPod provider instance
-            model_name: Model name (default: "fish-speech")
-        """
-        super().__init__(provider, model_name)
-        self.api_key = self.config.get("api_key")
-        self.endpoint_id = self.config.get("endpoint_id")
-        self.base_url = self.config.get("base_url")
-        
-        if not self.api_key:
-            raise ValueError("RunPod API key is required")
-        
-        if not self.endpoint_id:
-            raise ValueError("RunPod endpoint ID is required")
-        
-        self.endpoint_url = f"{self.base_url}/{self.endpoint_id}/run"
-        self.status_url = f"{self.base_url}/{self.endpoint_id}/status"
-        self.headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        # Default voice reference URLs (can be overridden in the options)
-        self.default_voices = {}
-    
-    async def _run_inference(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Run inference on the RunPod endpoint
-        
-        Args:
-            payload: Request payload
-            
-        Returns:
-            Response from the RunPod endpoint
-        """
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                self.endpoint_url,
-                headers=self.headers,
-                json={"input": payload}
-            ) as response:
-                if response.status != 200:
-                    error_text = await response.text()
-                    raise Exception(f"RunPod API error: {response.status} - {error_text}")
-                
-                result = await response.json()
-                job_id = result.get("id")
-                
-                if not job_id:
-                    raise Exception("No job ID returned from RunPod API")
-                
-                # Poll for job completion
-                while True:
-                    async with session.get(
-                        f"{self.status_url}/{job_id}",
-                        headers=self.headers
-                    ) as status_response:
-                        status_data = await status_response.json()
-                        status = status_data.get("status")
-                        
-                        if status == "COMPLETED":
-                            return status_data.get("output", {})
-                        elif status == "FAILED":
-                            error = status_data.get("error", "Unknown error")
-                            raise Exception(f"RunPod job failed: {error}")
-                        
-                        # Wait before polling again
-                        await asyncio.sleep(1)
-    
-    async def generate_speech(
-        self, 
-        text: str, 
-        voice_id: Optional[str] = None,
-        language: Optional[str] = None,
-        speed: float = 1.0,
-        options: Optional[Dict[str, Any]] = None
-    ) -> bytes:
-        """
-        Generate speech from text using Fish-Speech
-        
-        Args:
-            text: The text to convert to speech
-            voice_id: Voice identifier (URL to reference audio)
-            language: Language code (auto-detected if not provided)
-            speed: Speech speed factor (1.0 is normal speed)
-            options: Additional options:
-                - gpt_cond_len: GPT conditioning length
-                - max_ref_len: Maximum reference length
-                - enhance_audio: Whether to enhance audio quality
-                
-        Returns:
-            Audio data as bytes
-        """
-        options = options or {}
-        
-        # Prepare the payload
-        payload = {
-            "text": [[voice_id or "speaker_0", text]],
-            "language": language or "auto",
-            "speed": speed,
-            "gpt_cond_len": options.get("gpt_cond_len", 30),
-            "max_ref_len": options.get("max_ref_len", 60),
-            "enhance_audio": options.get("enhance_audio", True)
-        }
-        
-        # Add voice reference
-        voice_url = None
-        if voice_id and voice_id.startswith(("http://", "https://")):
-            voice_url = voice_id
-        elif voice_id and voice_id in self.default_voices:
-            voice_url = self.default_voices[voice_id]
-        
-        if voice_url:
-            payload["voice"] = {"speaker_0": voice_url}
-        
-        # Run inference
-        result = await self._run_inference(payload)
-        
-        # Extract audio data
-        if "audio_base64" in result:
-            return base64.b64decode(result["audio_base64"])
-        elif "audio_url" in result:
-            # Download audio from URL
-            async with aiohttp.ClientSession() as session:
-                async with session.get(result["audio_url"]) as response:
-                    if response.status != 200:
-                        raise Exception(f"Failed to download audio: {response.status}")
-                    return await response.read()
-        else:
-            raise Exception("No audio data in response")
-    
-    async def save_to_file(
-        self,
-        text: str,
-        output_file: Union[str, BinaryIO],
-        voice_id: Optional[str] = None,
-        language: Optional[str] = None,
-        speed: float = 1.0,
-        options: Optional[Dict[str, Any]] = None
-    ) -> str:
-        """
-        Generate speech and save to file
-        
-        Args:
-            text: The text to convert to speech
-            output_file: Path to output file or file-like object
-            voice_id: Voice identifier
-            language: Language code
-            speed: Speech speed factor
-            options: Additional options
-            
-        Returns:
-            Path to the saved file
-        """
-        audio_data = await self.generate_speech(text, voice_id, language, speed, options)
-        
-        if isinstance(output_file, str):
-            with open(output_file, "wb") as f:
-                f.write(audio_data)
-            return output_file
-        else:
-            output_file.write(audio_data)
-            if hasattr(output_file, "name"):
-                return output_file.name
-            return "audio.wav"
-    
-    async def get_available_voices(self) -> Dict[str, Any]:
-        """
-        Get available voices for the TTS service
-        
-        Returns:
-            Dictionary of available voices with their details
-        """
-        # Fish-Speech doesn't have a fixed set of voices as it uses voice cloning
-        # Return the default voices that have been configured
-        return {
-            "voices": list(self.default_voices.keys()),
-            "note": "Fish-Speech supports voice cloning. Provide a URL to a reference audio file to clone a voice."
-        }
-    
-    def add_voice(self, voice_id: str, reference_url: str) -> None:
-        """
-        Add a voice to the default voices
-        
-        Args:
-            voice_id: Voice identifier
-            reference_url: URL to the reference audio file
-        """
-        self.default_voices[voice_id] = reference_url

isa_model/inference/services/audio/triton_speech_service.py

@@ -1,138 +0,0 @@
-import json
-import logging
-import asyncio
-import io
-import numpy as np
-from typing import Dict, List, Any, AsyncGenerator, Optional, Union, BinaryIO
-
-from isa_model.inference.services.base_service import BaseService
-from isa_model.inference.providers.triton_provider import TritonProvider
-
-logger = logging.getLogger(__name__)
-
-
-class TritonSpeechService(BaseService):
-    """
-    Speech service that uses Triton Inference Server to run speech-to-text inference.
-    """
-    
-    def __init__(self, provider: TritonProvider, model_name: str):
-        """
-        Initialize the Triton Speech service.
-        
-        Args:
-            provider: The Triton provider
-            model_name: Name of the model in Triton (e.g., "whisper_tiny")
-        """
-        super().__init__(provider, model_name)
-        self.client = None
-        
-    async def _initialize_client(self):
-        """Initialize the Triton client"""
-        if self.client is None:
-            self.client = self.provider.create_client()
-            
-            # Check if model is ready
-            if not self.provider.is_model_ready(self.model_name):
-                logger.error(f"Model {self.model_name} is not ready on Triton server")
-                raise RuntimeError(f"Model {self.model_name} is not ready on Triton server")
-                
-            logger.info(f"Initialized Triton client for speech model: {self.model_name}")
-    
-    async def transcribe(self, 
-                       audio: Union[str, BinaryIO, bytes, np.ndarray], 
-                       language: str = "en",
-                       config: Optional[Dict[str, Any]] = None) -> str:
-        """
-        Transcribe audio to text using the Triton Inference Server.
-        
-        Args:
-            audio: Audio input (file path, file-like object, bytes, or numpy array)
-            language: Language code (e.g., "en", "fr")
-            config: Additional configuration parameters
-            
-        Returns:
-            Transcribed text
-        """
-        await self._initialize_client()
-        
-        try:
-            import tritonclient.http as httpclient
-            
-            # Process audio to get numpy array
-            audio_array = await self._process_audio_input(audio)
-            
-            # Create input tensors for audio
-            audio_input = httpclient.InferInput("audio_input", audio_array.shape, "FP32")
-            audio_input.set_data_from_numpy(audio_array)
-            inputs = [audio_input]
-            
-            # Add language input
-            language_data = np.array([language], dtype=np.object_)
-            language_input = httpclient.InferInput("language", language_data.shape, "BYTES")
-            language_input.set_data_from_numpy(language_data)
-            inputs.append(language_input)
-            
-            # Create output tensor
-            outputs = [httpclient.InferRequestedOutput("text_output")]
-            
-            # Send the request
-            response = await asyncio.to_thread(
-                self.client.infer,
-                self.model_name,
-                inputs,
-                outputs=outputs
-            )
-            
-            # Process the response
-            output = response.as_numpy("text_output")
-            transcription = output[0].decode('utf-8')
-            
-            return transcription
-            
-        except Exception as e:
-            logger.error(f"Error during Triton speech inference: {str(e)}")
-            raise
-    
-    async def _process_audio_input(self, audio: Union[str, BinaryIO, bytes, np.ndarray]) -> np.ndarray:
-        """
-        Process different types of audio inputs into a numpy array.
-        
-        Args:
-            audio: Audio input (file path, file-like object, bytes, or numpy array)
-            
-        Returns:
-            Numpy array of the audio
-        """
-        if isinstance(audio, np.ndarray):
-            return audio
-        
-        try:
-            import librosa
-            
-            if isinstance(audio, str):
-                # File path
-                y, sr = librosa.load(audio, sr=16000)  # Whisper expects 16kHz audio
-                return y.astype(np.float32)
-            
-            elif isinstance(audio, (io.IOBase, BinaryIO)):
-                # File-like object
-                audio.seek(0)
-                y, sr = librosa.load(audio, sr=16000)
-                return y.astype(np.float32)
-            
-            elif isinstance(audio, bytes):
-                # Bytes
-                with io.BytesIO(audio) as audio_bytes:
-                    y, sr = librosa.load(audio_bytes, sr=16000)
-                return y.astype(np.float32)
-            
-            else:
-                raise ValueError(f"Unsupported audio type: {type(audio)}")
-                
-        except ImportError:
-            logger.error("librosa not installed. Please install with: pip install librosa")
-            raise
-        except Exception as e:
-            logger.error(f"Error processing audio: {str(e)}")
-            raise