abstractvoice 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

abstractvoice/simple_model_manager.py

@@ -0,0 +1,398 @@
+"""
+Simple Model Manager for AbstractVoice
+
+Provides clean, simple APIs for model management that can be used by both
+CLI commands and third-party applications.
+"""
+
+import os
+import json
+import time
+import threading
+from typing import Dict, List, Optional, Callable, Any
+from pathlib import Path
+
+
+def _import_tts():
+    """Import TTS with helpful error message if dependencies missing."""
+    try:
+        from TTS.api import TTS
+        from TTS.utils.manage import ModelManager
+        return TTS, ModelManager
+    except ImportError as e:
+        raise ImportError(
+            "TTS functionality requires coqui-tts. Install with:\n"
+            "  pip install abstractvoice[tts]\n"
+            f"Original error: {e}"
+        ) from e
+
+
+class SimpleModelManager:
+    """Simple, clean model manager for AbstractVoice."""
+
+    # Essential model - guaranteed to work everywhere, reasonable size
+    ESSENTIAL_MODEL = "tts_models/en/ljspeech/fast_pitch"
+
+    # Available models organized by language with metadata
+    AVAILABLE_MODELS = {
+        "en": {
+            "fast_pitch": {
+                "model": "tts_models/en/ljspeech/fast_pitch",
+                "name": "Fast Pitch (English)",
+                "quality": "good",
+                "size_mb": 107,
+                "description": "Lightweight, reliable English voice",
+                "requires_espeak": False,
+                "default": True
+            },
+            "vits": {
+                "model": "tts_models/en/ljspeech/vits",
+                "name": "VITS (English)",
+                "quality": "excellent",
+                "size_mb": 328,
+                "description": "High-quality English voice with natural prosody",
+                "requires_espeak": True,
+                "default": False
+            },
+            "tacotron2": {
+                "model": "tts_models/en/ljspeech/tacotron2-DDC",
+                "name": "Tacotron2 (English)",
+                "quality": "good",
+                "size_mb": 362,
+                "description": "Classic English voice, reliable",
+                "requires_espeak": False,
+                "default": False
+            }
+        },
+        "fr": {
+            "css10_vits": {
+                "model": "tts_models/fr/css10/vits",
+                "name": "CSS10 VITS (French)",
+                "quality": "excellent",
+                "size_mb": 548,
+                "description": "High-quality French voice",
+                "requires_espeak": True,
+                "default": True
+            },
+            "mai_tacotron2": {
+                "model": "tts_models/fr/mai/tacotron2-DDC",
+                "name": "MAI Tacotron2 (French)",
+                "quality": "good",
+                "size_mb": 362,
+                "description": "Reliable French voice",
+                "requires_espeak": False,
+                "default": False
+            }
+        },
+        "es": {
+            "mai_tacotron2": {
+                "model": "tts_models/es/mai/tacotron2-DDC",
+                "name": "MAI Tacotron2 (Spanish)",
+                "quality": "good",
+                "size_mb": 362,
+                "description": "Reliable Spanish voice",
+                "requires_espeak": False,
+                "default": True
+            },
+            "css10_vits": {
+                "model": "tts_models/es/css10/vits",
+                "name": "CSS10 VITS (Spanish)",
+                "quality": "excellent",
+                "size_mb": 548,
+                "description": "High-quality Spanish voice",
+                "requires_espeak": True,
+                "default": False
+            }
+        },
+        "de": {
+            "thorsten_vits": {
+                "model": "tts_models/de/thorsten/vits",
+                "name": "Thorsten VITS (German)",
+                "quality": "excellent",
+                "size_mb": 548,
+                "description": "High-quality German voice",
+                "requires_espeak": True,
+                "default": True
+            }
+        },
+        "it": {
+            "mai_male_vits": {
+                "model": "tts_models/it/mai_male/vits",
+                "name": "MAI Male VITS (Italian)",
+                "quality": "excellent",
+                "size_mb": 548,
+                "description": "High-quality Italian male voice",
+                "requires_espeak": True,
+                "default": True
+            },
+            "mai_female_vits": {
+                "model": "tts_models/it/mai_female/vits",
+                "name": "MAI Female VITS (Italian)",
+                "quality": "excellent",
+                "size_mb": 548,
+                "description": "High-quality Italian female voice",
+                "requires_espeak": True,
+                "default": False
+            }
+        }
+    }
+
+    def __init__(self, debug_mode: bool = False):
+        self.debug_mode = debug_mode
+        self._cache_dir = None
+
+    @property
+    def cache_dir(self) -> str:
+        """Get the TTS model cache directory."""
+        if self._cache_dir is None:
+            # Check common cache locations
+            import appdirs
+            potential_dirs = [
+                os.path.expanduser("~/.cache/tts"),
+                appdirs.user_data_dir("tts"),
+                os.path.expanduser("~/.local/share/tts"),
+                os.path.expanduser("~/Library/Application Support/tts"),  # macOS
+            ]
+
+            # Find existing cache or use default
+            for cache_dir in potential_dirs:
+                if os.path.exists(cache_dir):
+                    self._cache_dir = cache_dir
+                    break
+            else:
+                # Use appdirs default
+                self._cache_dir = appdirs.user_data_dir("tts")
+
+        return self._cache_dir
+
+    def is_model_cached(self, model_name: str) -> bool:
+        """Check if a specific model is cached locally."""
+        try:
+            # Convert model name to cache directory structure
+            cache_name = model_name.replace("/", "--")
+            model_path = os.path.join(self.cache_dir, cache_name)
+
+            if not os.path.exists(model_path):
+                return False
+
+            # Check for essential model files
+            essential_files = ["model.pth", "config.json"]
+            return any(os.path.exists(os.path.join(model_path, f)) for f in essential_files)
+        except Exception as e:
+            if self.debug_mode:
+                print(f"Error checking cache for {model_name}: {e}")
+            return False
+
+    def download_model(self, model_name: str, progress_callback: Optional[Callable[[str, bool], None]] = None) -> bool:
+        """Download a specific model.
+
+        Args:
+            model_name: TTS model name (e.g., 'tts_models/en/ljspeech/fast_pitch')
+            progress_callback: Optional callback function(model_name, success)
+
+        Returns:
+            bool: True if successful
+        """
+        if self.is_model_cached(model_name):
+            if self.debug_mode:
+                print(f"✅ {model_name} already cached")
+            if progress_callback:
+                progress_callback(model_name, True)
+            return True
+
+        try:
+            TTS, _ = _import_tts()
+
+            if self.debug_mode:
+                print(f"📥 Downloading {model_name}...")
+
+            start_time = time.time()
+
+            # Initialize TTS to trigger download
+            tts = TTS(model_name=model_name, progress_bar=True)
+
+            download_time = time.time() - start_time
+            if self.debug_mode:
+                print(f"✅ Downloaded {model_name} in {download_time:.1f}s")
+
+            if progress_callback:
+                progress_callback(model_name, True)
+            return True
+
+        except Exception as e:
+            if self.debug_mode:
+                print(f"❌ Failed to download {model_name}: {e}")
+            if progress_callback:
+                progress_callback(model_name, False)
+            return False
+
+    def download_essential_model(self, progress_callback: Optional[Callable[[str, bool], None]] = None) -> bool:
+        """Download the essential English model for immediate functionality."""
+        return self.download_model(self.ESSENTIAL_MODEL, progress_callback)
+
+    def list_available_models(self, language: Optional[str] = None) -> Dict[str, Any]:
+        """Get list of available models with metadata.
+
+        Args:
+            language: Optional language filter
+
+        Returns:
+            dict: Model information in JSON-serializable format
+        """
+        if language:
+            if language in self.AVAILABLE_MODELS:
+                return {language: self.AVAILABLE_MODELS[language]}
+            else:
+                return {}
+
+        # Return all models with cache status
+        result = {}
+        for lang, models in self.AVAILABLE_MODELS.items():
+            result[lang] = {}
+            for model_id, model_info in models.items():
+                # Add cache status to each model
+                model_data = model_info.copy()
+                model_data["cached"] = self.is_model_cached(model_info["model"])
+                result[lang][model_id] = model_data
+
+        return result
+
+    def get_cached_models(self) -> List[str]:
+        """Get list of model names that are currently cached."""
+        if not os.path.exists(self.cache_dir):
+            return []
+
+        cached = []
+        try:
+            for item in os.listdir(self.cache_dir):
+                if item.startswith("tts_models--"):
+                    # Convert cache name back to model name
+                    model_name = item.replace("--", "/")
+                    if self.is_model_cached(model_name):
+                        cached.append(model_name)
+        except Exception as e:
+            if self.debug_mode:
+                print(f"Error listing cached models: {e}")
+
+        return cached
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get comprehensive status information."""
+        cached_models = self.get_cached_models()
+        essential_cached = self.ESSENTIAL_MODEL in cached_models
+
+        # Calculate total cache size
+        total_size_mb = 0
+        if os.path.exists(self.cache_dir):
+            try:
+                for root, dirs, files in os.walk(self.cache_dir):
+                    for file in files:
+                        total_size_mb += os.path.getsize(os.path.join(root, file)) / (1024 * 1024)
+            except:
+                pass
+
+        return {
+            "cache_dir": self.cache_dir,
+            "cached_models": cached_models,
+            "total_cached": len(cached_models),
+            "essential_model_cached": essential_cached,
+            "essential_model": self.ESSENTIAL_MODEL,
+            "ready_for_offline": essential_cached,
+            "total_size_mb": round(total_size_mb, 1),
+            "available_languages": list(self.AVAILABLE_MODELS.keys()),
+        }
+
+    def clear_cache(self, confirm: bool = False) -> bool:
+        """Clear the model cache."""
+        if not confirm:
+            return False
+
+        try:
+            import shutil
+            if os.path.exists(self.cache_dir):
+                shutil.rmtree(self.cache_dir)
+                if self.debug_mode:
+                    print(f"✅ Cleared model cache: {self.cache_dir}")
+                return True
+            return True
+        except Exception as e:
+            if self.debug_mode:
+                print(f"❌ Failed to clear cache: {e}")
+            return False
+
+    def ensure_essential_model(self, auto_download: bool = True) -> bool:
+        """Ensure the essential model is available.
+
+        Args:
+            auto_download: Whether to download if not cached
+
+        Returns:
+            bool: True if essential model is ready
+        """
+        if self.is_model_cached(self.ESSENTIAL_MODEL):
+            return True
+
+        if not auto_download:
+            return False
+
+        return self.download_essential_model()
+
+
+# Global instance for easy access
+_model_manager = None
+
+def get_model_manager(debug_mode: bool = False) -> SimpleModelManager:
+    """Get the global model manager instance."""
+    global _model_manager
+    if _model_manager is None:
+        _model_manager = SimpleModelManager(debug_mode=debug_mode)
+    return _model_manager
+
+
+# Simple API functions for third-party use
+def list_models(language: Optional[str] = None) -> str:
+    """Get available models as JSON string.
+
+    Args:
+        language: Optional language filter
+
+    Returns:
+        str: JSON string of available models
+    """
+    manager = get_model_manager()
+    return json.dumps(manager.list_available_models(language), indent=2)
+
+
+def download_model(model_name: str, progress_callback: Optional[Callable[[str, bool], None]] = None) -> bool:
+    """Download a specific model.
+
+    Args:
+        model_name: Model name or voice ID (e.g., 'en.vits' or 'tts_models/en/ljspeech/vits')
+        progress_callback: Optional progress callback
+
+    Returns:
+        bool: True if successful
+    """
+    manager = get_model_manager()
+
+    # Handle voice ID format (e.g., 'en.vits')
+    if '.' in model_name and not model_name.startswith('tts_models'):
+        lang, voice_id = model_name.split('.', 1)
+        if lang in manager.AVAILABLE_MODELS and voice_id in manager.AVAILABLE_MODELS[lang]:
+            model_name = manager.AVAILABLE_MODELS[lang][voice_id]["model"]
+        else:
+            return False
+
+    return manager.download_model(model_name, progress_callback)
+
+
+def get_status() -> str:
+    """Get model cache status as JSON string."""
+    manager = get_model_manager()
+    return json.dumps(manager.get_status(), indent=2)
+
+
+def is_ready() -> bool:
+    """Check if essential model is ready for immediate use."""
+    manager = get_model_manager()
+    return manager.is_model_cached(manager.ESSENTIAL_MODEL)

abstractvoice/tts/tts_engine.py

@@ -466,34 +466,21 @@ class TTSEngine:
         try:
             if self.debug_mode:
                 print(f" > Loading TTS model: {model_name}")
-            
-            # Try to initialize TTS using lazy import
+
+            # Try simple, effective initialization strategy
             try:
                 TTS = _import_tts()
-                self.tts = TTS(model_name=model_name, progress_bar=self.debug_mode)
+                success, final_model = self._load_with_simple_fallback(TTS, model_name, debug_mode)
+                if not success:
+                    # If all fails, provide actionable guidance
+                    self._handle_model_load_failure(debug_mode)
+                elif self.debug_mode and final_model != model_name:
+                    print(f" > Loaded fallback model: {final_model}")
             except Exception as e:
                 error_msg = str(e).lower()
                 # Check if this is an espeak-related error
                 if ("espeak" in error_msg or "phoneme" in error_msg):
-                    # Restore stdout to show user-friendly message
-                    if not debug_mode:
-                        sys.stdout = sys.__stdout__
-                    
-                    print("\n" + "="*70)
-                    print("⚠️  VITS Model Requires espeak-ng (Not Found)")
-                    print("="*70)
-                    print("\nFor BEST voice quality, install espeak-ng:")
-                    print("  • macOS:   brew install espeak-ng")
-                    print("  • Linux:   sudo apt-get install espeak-ng")
-                    print("  • Windows: conda install espeak-ng  (or see README)")
-                    print("\nFalling back to fast_pitch (lower quality, but works)")
-                    print("="*70 + "\n")
-                    
-                    if not debug_mode:
-                        sys.stdout = null_out
-                    
-                    # Fallback to fast_pitch
-                    self.tts = TTS(model_name="tts_models/en/ljspeech/fast_pitch", progress_bar=self.debug_mode)
+                    self._handle_espeak_fallback(debug_mode)
                 else:
                     # Different error, re-raise
                     raise
@@ -520,6 +507,136 @@ class TTSEngine:
         # Pause/resume state
         self.pause_lock = threading.Lock()  # Thread-safe pause operations
         self.is_paused_state = False  # Explicit paused state tracking
+
+    def _load_with_simple_fallback(self, TTS, preferred_model: str, debug_mode: bool) -> tuple[bool, str]:
+        """Load TTS model with simple, effective strategy."""
+        from ..simple_model_manager import get_model_manager
+
+        model_manager = get_model_manager(debug_mode=debug_mode)
+
+        # Strategy 1: Try preferred model if cached
+        if model_manager.is_model_cached(preferred_model):
+            try:
+                if debug_mode:
+                    print(f" > Using cached model: {preferred_model}")
+                self.tts = TTS(model_name=preferred_model, progress_bar=self.debug_mode)
+                return True, preferred_model
+            except Exception as e:
+                if debug_mode:
+                    print(f" > Cached model failed: {e}")
+
+        # Strategy 2: Try essential model if cached
+        essential_model = model_manager.ESSENTIAL_MODEL
+        if essential_model != preferred_model and model_manager.is_model_cached(essential_model):
+            try:
+                if debug_mode:
+                    print(f" > Using cached essential model: {essential_model}")
+                self.tts = TTS(model_name=essential_model, progress_bar=self.debug_mode)
+                return True, essential_model
+            except Exception as e:
+                if debug_mode:
+                    print(f" > Essential model failed: {e}")
+
+        # Strategy 3: Download essential model (guaranteed to work)
+        try:
+            if debug_mode:
+                print(f" > Downloading essential model: {essential_model}")
+            success = model_manager.download_model(essential_model)
+            if success:
+                self.tts = TTS(model_name=essential_model, progress_bar=self.debug_mode)
+                return True, essential_model
+        except Exception as e:
+            if debug_mode:
+                print(f" > Essential model download failed: {e}")
+
+        # Strategy 4: Try downloading preferred model
+        try:
+            if debug_mode:
+                print(f" > Attempting preferred model download: {preferred_model}")
+            self.tts = TTS(model_name=preferred_model, progress_bar=self.debug_mode)
+            return True, preferred_model
+        except Exception as e:
+            if debug_mode:
+                print(f" > Preferred model download failed: {e}")
+
+        return False, None
+
+    def _handle_espeak_fallback(self, debug_mode: bool):
+        """Handle espeak-related errors with fallback to non-phoneme models."""
+        # Restore stdout to show user-friendly message
+        if not debug_mode:
+            sys.stdout = sys.__stdout__
+
+        print("\n" + "="*70)
+        print("⚠️  VITS Model Requires espeak-ng (Not Found)")
+        print("="*70)
+        print("\nFor BEST voice quality, install espeak-ng:")
+        print("  • macOS:   brew install espeak-ng")
+        print("  • Linux:   sudo apt-get install espeak-ng")
+        print("  • Windows: conda install espeak-ng  (or see README)")
+        print("\nFalling back to fast_pitch (no espeak dependency)")
+        print("="*70 + "\n")
+
+        if not debug_mode:
+            import os
+            null_out = open(os.devnull, 'w')
+            sys.stdout = null_out
+
+        # Try non-phoneme models that don't require espeak
+        from TTS.api import TTS
+        fallback_models = [
+            "tts_models/en/ljspeech/fast_pitch",
+            "tts_models/en/ljspeech/tacotron2-DDC",
+            "tts_models/en/ljspeech/glow-tts"
+        ]
+
+        tts_loaded = False
+        for fallback_model in fallback_models:
+            try:
+                if debug_mode:
+                    print(f"Trying fallback model: {fallback_model}")
+                self.tts = TTS(model_name=fallback_model, progress_bar=self.debug_mode)
+                tts_loaded = True
+                break
+            except Exception as fallback_error:
+                if debug_mode:
+                    print(f"Fallback {fallback_model} failed: {fallback_error}")
+                continue
+
+        if not tts_loaded:
+            self._handle_model_load_failure(debug_mode)
+
+    def _handle_model_load_failure(self, debug_mode: bool):
+        """Handle complete model loading failure with actionable guidance."""
+        # Restore stdout to show user-friendly message
+        if not debug_mode:
+            sys.stdout = sys.__stdout__
+
+        print("\n" + "="*70)
+        print("❌ TTS Model Loading Failed")
+        print("="*70)
+        print("\nNo TTS models could be loaded (offline or online).")
+        print("\nQuick fixes:")
+        print("  1. Download essential models:")
+        print("     abstractvoice download-models")
+        print("  2. Check internet connectivity")
+        print("  3. Clear corrupted cache:")
+        print("     rm -rf ~/.cache/tts ~/.local/share/tts")
+        print("  4. Reinstall TTS:")
+        print("     pip install --force-reinstall coqui-tts")
+        print("  5. Use text-only mode:")
+        print("     abstractvoice --no-tts")
+        print("="*70)
+
+        raise RuntimeError(
+            "❌ Failed to load any TTS model.\n"
+            "This typically means:\n"
+            "  • No models cached locally AND no internet connection\n"
+            "  • Corrupted model cache\n"
+            "  • Insufficient disk space\n"
+            "  • Network firewall blocking downloads\n\n"
+            "Run 'abstractvoice download-models' when you have internet access."
+        )
     
     def _on_playback_complete(self):
         """Callback when audio playback completes."""

abstractvoice/voice_manager.py

@@ -823,14 +823,95 @@ class VoiceManager:
             return self.voice_recognizer.change_vad_aggressiveness(aggressiveness)
         return False
     
+    # ===== SIMPLE MODEL MANAGEMENT METHODS =====
+    # Clean, simple APIs for both CLI and third-party applications
+
+    def list_available_models(self, language: str = None) -> dict:
+        """Get available models with metadata.
+
+        Args:
+            language: Optional language filter
+
+        Returns:
+            dict: Model information with cache status
+
+        Example:
+            >>> vm = VoiceManager()
+            >>> models = vm.list_available_models('en')
+            >>> print(json.dumps(models, indent=2))
+        """
+        from .simple_model_manager import get_model_manager
+        manager = get_model_manager(self.debug_mode)
+        return manager.list_available_models(language)
+
+    def download_model(self, model_name: str, progress_callback=None) -> bool:
+        """Download a specific model.
+
+        Args:
+            model_name: Model name or voice ID (e.g., 'en.vits' or full model path)
+            progress_callback: Optional function(model_name, success)
+
+        Returns:
+            bool: True if successful
+
+        Example:
+            >>> vm = VoiceManager()
+            >>> vm.download_model('en.vits')  # or 'tts_models/en/ljspeech/vits'
+        """
+        from .simple_model_manager import download_model
+        return download_model(model_name, progress_callback)
+
+    def is_model_ready(self) -> bool:
+        """Check if essential model is ready for immediate use.
+
+        Returns:
+            bool: True if can speak immediately without download
+        """
+        from .simple_model_manager import is_ready
+        return is_ready()
+
+    def ensure_ready(self, auto_download: bool = True) -> bool:
+        """Ensure TTS is ready for immediate use.
+
+        Args:
+            auto_download: Whether to download essential model if needed
+
+        Returns:
+            bool: True if TTS is ready
+
+        Example:
+            >>> vm = VoiceManager()
+            >>> if vm.ensure_ready():
+            ...     vm.speak("Ready to go!")
+        """
+        if self.is_model_ready():
+            return True
+
+        if not auto_download:
+            return False
+
+        from .simple_model_manager import get_model_manager
+        manager = get_model_manager(self.debug_mode)
+        return manager.download_essential_model()
+
+    def get_cache_status(self) -> dict:
+        """Get model cache status.
+
+        Returns:
+            dict: Cache information including total models, sizes, etc.
+        """
+        from .simple_model_manager import get_model_manager
+        manager = get_model_manager(self.debug_mode)
+        return manager.get_status()
+
     def cleanup(self):
         """Clean up resources.
-        
+
         Returns:
             True if cleanup successful
         """
         if self.voice_recognizer:
             self.voice_recognizer.stop()
-        
+
         self.stop_speaking()
         return True