abstractvoice 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

abstractvoice/__init__.py

@@ -29,8 +29,5 @@ warnings.filterwarnings(
 # Import the main class for public API
 from .voice_manager import VoiceManager
 
-# Import simple APIs for third-party applications
-from .simple_model_manager import list_models, download_model, get_status, is_ready
-
-__version__ = "0.5.1"
-__all__ = ['VoiceManager', 'list_models', 'download_model', 'get_status', 'is_ready'] 
+__version__ = "0.6.1"
+__all__ = ["VoiceManager"]

abstractvoice/__main__.py

@@ -16,8 +16,9 @@ def print_examples():
     print("  web       - Web API example")
     print("  simple    - Simple usage example")
     print("  check-deps - Check dependency compatibility")
+    print("  download  - Explicitly prefetch model artifacts")
     print("\nUsage: python -m abstractvoice <example> [--language <lang>] [args...]")
-    print("\nSupported languages: en, fr, es, de, it, ru, multilingual")
+    print("\nSupported languages: en, fr, de, es, ru, zh")
     print("\nExamples:")
     print("  python -m abstractvoice cli --language fr    # French CLI")
     print("  python -m abstractvoice simple --language ru # Russian simple example")
@@ -99,7 +100,7 @@ def main():
     parser = argparse.ArgumentParser(description="AbstractVoice examples")
     parser.add_argument("example", nargs="?", help="Example to run (cli, web, simple, check-deps)")
     parser.add_argument("--language", "--lang", default="en",
-                      choices=["en", "fr", "es", "de", "it", "ru", "multilingual"],
+                      choices=["en", "fr", "de", "es", "ru", "zh"],
                       help="Voice language for examples")
 
     # Parse just the first argument and language
@@ -119,6 +120,84 @@ def main():
             print("This might indicate a dependency issue.")
         return
 
+    if args.example == "download":
+        dl = argparse.ArgumentParser(description="AbstractVoice explicit downloads")
+        dl.add_argument("--stt", dest="stt_model", default=None, help="Prefetch faster-whisper model (e.g. small)")
+        dl.add_argument(
+            "--openf5",
+            action="store_true",
+            help="Prefetch OpenF5 artifacts for cloning (~5.4GB, requires abstractvoice[cloning])",
+        )
+        dl.add_argument(
+            "--chroma",
+            action="store_true",
+            help="Prefetch Chroma-4B artifacts (~14GB+, requires HF access; install abstractvoice[chroma] to run inference)",
+        )
+        dl.add_argument(
+            "--piper",
+            dest="piper_language",
+            default=None,
+            help="Prefetch Piper voice model for a language (e.g. en/fr/de).",
+        )
+        dl_args = dl.parse_args(remaining)
+
+        if not dl_args.stt_model and not dl_args.openf5 and not dl_args.chroma and not dl_args.piper_language:
+            print("Nothing to download. Examples:")
+            print("  python -m abstractvoice download --stt small")
+            print("  python -m abstractvoice download --openf5")
+            print("  python -m abstractvoice download --chroma")
+            print("  python -m abstractvoice download --piper en")
+            return
+
+        if dl_args.stt_model:
+            try:
+                from abstractvoice.adapters.stt_faster_whisper import FasterWhisperAdapter
+
+                model = str(dl_args.stt_model).strip()
+                print(f"Downloading STT model (faster-whisper): {model}")
+                stt = FasterWhisperAdapter(model_size=model, device="cpu", compute_type="int8", allow_downloads=True)
+                if not stt.is_available():
+                    raise RuntimeError("Model download/load failed.")
+                print("✅ STT model ready.")
+            except Exception as e:
+                print(f"❌ STT download failed: {e}")
+
+        if dl_args.openf5:
+            try:
+                from abstractvoice.cloning.engine_f5 import F5TTSVoiceCloningEngine
+
+                print("Downloading OpenF5 artifacts (cloning)…")
+                engine = F5TTSVoiceCloningEngine(debug=True)
+                engine.ensure_openf5_artifacts_downloaded()
+                print("✅ OpenF5 artifacts ready.")
+            except Exception as e:
+                print(f"❌ OpenF5 download failed: {e}")
+
+        if dl_args.chroma:
+            try:
+                from abstractvoice.cloning.engine_chroma import ChromaVoiceCloningEngine
+
+                print("Downloading Chroma artifacts (cloning)…")
+                engine = ChromaVoiceCloningEngine(debug=True)
+                engine.ensure_chroma_artifacts_downloaded()
+                print("✅ Chroma artifacts ready.")
+            except Exception as e:
+                print(f"❌ Chroma download failed: {e}")
+
+        if dl_args.piper_language:
+            try:
+                from abstractvoice.adapters.tts_piper import PiperTTSAdapter
+
+                lang = str(dl_args.piper_language).strip().lower()
+                print(f"Downloading Piper voice model: {lang}")
+                piper = PiperTTSAdapter(language=lang, allow_downloads=True, auto_load=False)
+                if not piper.ensure_model_downloaded(lang):
+                    raise RuntimeError("Piper model download failed.")
+                print("✅ Piper model ready.")
+            except Exception as e:
+                print(f"❌ Piper download failed: {e}")
+        return
+
     # Set remaining args as sys.argv for the examples, including language
     if args.language != "en":
         remaining = ["--language", args.language] + remaining
@@ -138,4 +217,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main() 
+    main() 

abstractvoice/adapters/__init__.py

@@ -0,0 +1,12 @@
+"""Adapter interfaces for TTS and STT engines.
+
+This module defines base interfaces for pluggable TTS and STT engines,
+enabling easy integration of new speech synthesis and recognition backends
+while maintaining API compatibility.
+"""
+
+from .base import TTSAdapter, STTAdapter
+from .tts_piper import PiperTTSAdapter
+from .stt_faster_whisper import FasterWhisperAdapter
+
+__all__ = ['TTSAdapter', 'STTAdapter', 'PiperTTSAdapter', 'FasterWhisperAdapter']

abstractvoice/adapters/base.py

@@ -0,0 +1,207 @@
+"""Base adapter interfaces for TTS and STT engines.
+
+These abstract base classes define the contract that all TTS and STT adapters
+must implement, ensuring consistent API across different backends.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any, Union
+import numpy as np
+import io
+
+
+class TTSAdapter(ABC):
+    """Abstract base class for Text-to-Speech adapters.
+    
+    All TTS engines must implement this interface to be compatible with
+    the VoiceManager. This ensures we can swap engines without breaking
+    existing code.
+    """
+    
+    @abstractmethod
+    def synthesize(self, text: str) -> np.ndarray:
+        """Convert text to audio array for immediate playback.
+        
+        Args:
+            text: The text to synthesize
+            
+        Returns:
+            Audio data as numpy array (shape: [samples,], dtype: float32, range: -1.0 to 1.0)
+        """
+        pass
+    
+    @abstractmethod
+    def synthesize_to_bytes(self, text: str, format: str = 'wav') -> bytes:
+        """Convert text to audio bytes for network transmission or file storage.
+        
+        This method is essential for client-server architectures where the backend
+        generates speech and sends it to clients for playback.
+        
+        Args:
+            text: The text to synthesize
+            format: Audio format ('wav', 'mp3', 'ogg'). Default: 'wav'
+            
+        Returns:
+            Audio data as bytes in the specified format
+        """
+        pass
+    
+    @abstractmethod
+    def synthesize_to_file(self, text: str, output_path: str, format: Optional[str] = None) -> str:
+        """Convert text to audio file.
+        
+        Args:
+            text: The text to synthesize
+            output_path: Path to save the audio file
+            format: Audio format (optional, inferred from file extension if not provided)
+            
+        Returns:
+            Path to the saved audio file
+        """
+        pass
+    
+    @abstractmethod
+    def set_language(self, language: str) -> bool:
+        """Switch the TTS language.
+        
+        Args:
+            language: ISO 639-1 language code (e.g., 'en', 'fr', 'de')
+            
+        Returns:
+            True if language switch successful, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_languages(self) -> list[str]:
+        """Get list of supported language codes.
+        
+        Returns:
+            List of ISO 639-1 language codes
+        """
+        pass
+    
+    @abstractmethod
+    def get_sample_rate(self) -> int:
+        """Get the sample rate of the synthesized audio.
+        
+        Returns:
+            Sample rate in Hz (e.g., 22050, 16000)
+        """
+        pass
+    
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this TTS engine is available and functional.
+        
+        Returns:
+            True if the engine can be used, False if dependencies missing or initialization failed
+        """
+        pass
+    
+    def get_info(self) -> Dict[str, Any]:
+        """Get metadata about this TTS engine.
+        
+        Returns:
+            Dictionary with engine information (name, version, languages, etc.)
+        """
+        return {
+            'name': self.__class__.__name__,
+            'languages': self.get_supported_languages(),
+            'sample_rate': self.get_sample_rate(),
+            'available': self.is_available()
+        }
+
+
+class STTAdapter(ABC):
+    """Abstract base class for Speech-to-Text adapters.
+    
+    All STT engines must implement this interface to be compatible with
+    the VoiceManager.
+    """
+    
+    @abstractmethod
+    def transcribe(self, audio_path: str, language: Optional[str] = None) -> str:
+        """Transcribe audio file to text.
+        
+        Args:
+            audio_path: Path to audio file
+            language: Target language (optional, auto-detect if not provided)
+            
+        Returns:
+            Transcribed text
+        """
+        pass
+    
+    @abstractmethod
+    def transcribe_from_bytes(self, audio_bytes: bytes, language: Optional[str] = None) -> str:
+        """Transcribe audio from bytes (network use case).
+        
+        This method is essential for client-server architectures where clients
+        record audio and send it to the backend for transcription.
+        
+        Args:
+            audio_bytes: Audio data as bytes
+            language: Target language (optional, auto-detect if not provided)
+            
+        Returns:
+            Transcribed text
+        """
+        pass
+    
+    @abstractmethod
+    def transcribe_from_array(self, audio_array: np.ndarray, sample_rate: int, 
+                             language: Optional[str] = None) -> str:
+        """Transcribe audio from numpy array.
+        
+        Args:
+            audio_array: Audio data as numpy array
+            sample_rate: Sample rate of the audio in Hz
+            language: Target language (optional, auto-detect if not provided)
+            
+        Returns:
+            Transcribed text
+        """
+        pass
+    
+    @abstractmethod
+    def set_language(self, language: str) -> bool:
+        """Set the default language for transcription.
+        
+        Args:
+            language: ISO 639-1 language code
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_languages(self) -> list[str]:
+        """Get list of supported language codes.
+        
+        Returns:
+            List of ISO 639-1 language codes
+        """
+        pass
+    
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this STT engine is available and functional.
+        
+        Returns:
+            True if the engine can be used, False otherwise
+        """
+        pass
+    
+    def get_info(self) -> Dict[str, Any]:
+        """Get metadata about this STT engine.
+        
+        Returns:
+            Dictionary with engine information
+        """
+        return {
+            'name': self.__class__.__name__,
+            'languages': self.get_supported_languages(),
+            'available': self.is_available()
+        }