abstractvoice 0.4.1__tar.gz → 0.4.6__tar.gz

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractvoice
-Version: 0.4.1
+Version: 0.4.6
 Summary: A modular Python library for voice interactions with AI systems
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 License-Expression: MIT
@@ -19,6 +19,14 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: appdirs>=1.4.0
+Requires-Dist: coqui-tts<0.30.0,>=0.27.0
+Requires-Dist: torch<2.4.0,>=2.0.0
+Requires-Dist: torchvision<0.19.0,>=0.15.0
+Requires-Dist: torchaudio<2.4.0,>=2.0.0
+Requires-Dist: librosa>=0.10.0
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: soundfile>=0.12.1
 Provides-Extra: voice
 Requires-Dist: sounddevice>=0.4.6; extra == "voice"
 Requires-Dist: webrtcvad>=2.0.10; extra == "voice"

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice/__init__.py

@@ -32,5 +32,5 @@ 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.4.1"
+__version__ = "0.4.6"
 __all__ = ['VoiceManager', 'list_models', 'download_model', 'get_status', 'is_ready'] 

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice/examples/voice_cli.py

@@ -158,7 +158,7 @@ def main():
                     traceback.print_exc()
             return
         elif args.command == "download-models":
-            from abstractvoice.model_manager import download_models_cli
+            from abstractvoice.simple_model_manager import download_models_cli
             # Pass remaining arguments to download_models_cli
             import sys
             original_argv = sys.argv

abstractvoice-0.4.6/abstractvoice/instant_setup.py

@@ -0,0 +1,83 @@
+"""
+Instant Setup Module for AbstractVoice
+Provides immediate TTS functionality with seamless model download.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Essential model for instant functionality (lightweight, reliable)
+ESSENTIAL_MODEL = "tts_models/en/ljspeech/fast_pitch"
+ESSENTIAL_MODEL_SIZE = "~100MB"
+
+def ensure_instant_tts():
+    """
+    Ensure TTS is ready for immediate use.
+    Downloads essential model if needed with progress indicator.
+
+    Returns:
+        bool: True if TTS is ready, False if failed
+    """
+    try:
+        from TTS.api import TTS
+        from TTS.utils.manage import ModelManager
+
+        manager = ModelManager()
+
+        # Check if essential model is already cached
+        if is_model_cached(ESSENTIAL_MODEL):
+            return True
+
+        # Download essential model with user-friendly progress
+        print(f"🚀 AbstractVoice: Setting up TTS ({ESSENTIAL_MODEL_SIZE})...")
+        print(f"   This happens once and takes ~30 seconds")
+
+        try:
+            # Download with progress bar
+            tts = TTS(model_name=ESSENTIAL_MODEL, progress_bar=True)
+            print(f"✅ TTS ready! AbstractVoice is now fully functional.")
+            return True
+
+        except Exception as e:
+            print(f"❌ Setup failed: {e}")
+            print(f"💡 Try: pip install abstractvoice[all]")
+            return False
+
+    except ImportError as e:
+        print(f"❌ Missing dependencies: {e}")
+        print(f"💡 Install with: pip install abstractvoice[all]")
+        return False
+
+def is_model_cached(model_name):
+    """Check if a model is already cached."""
+    try:
+        from TTS.utils.manage import ModelManager
+        manager = ModelManager()
+
+        # Get cached models list
+        models_file = os.path.join(manager.output_prefix, ".models.json")
+        if os.path.exists(models_file):
+            import json
+            with open(models_file, 'r') as f:
+                cached_models = json.load(f)
+                return model_name in cached_models
+
+        # Fallback: check if model directory exists and has content
+        model_dir = model_name.replace("/", "--")
+        model_path = os.path.join(manager.output_prefix, model_dir)
+        return os.path.exists(model_path) and bool(os.listdir(model_path))
+
+    except:
+        # If anything fails, assume not cached
+        return False
+
+def get_instant_model():
+    """Get the essential model name for instant setup."""
+    return ESSENTIAL_MODEL
+
+if __name__ == "__main__":
+    # CLI test
+    print("🧪 Testing instant setup...")
+    success = ensure_instant_tts()
+    print(f"Result: {'✅ Ready' if success else '❌ Failed'}")

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice/simple_model_manager.py

@@ -31,37 +31,65 @@ class SimpleModelManager:
     """Simple, clean model manager for AbstractVoice."""
 
     # Essential model - guaranteed to work everywhere, reasonable size
-    ESSENTIAL_MODEL = "tts_models/en/ljspeech/fast_pitch"
+    # Changed from fast_pitch to tacotron2-DDC because fast_pitch downloads are failing
+    ESSENTIAL_MODEL = "tts_models/en/ljspeech/tacotron2-DDC"
 
     # Available models organized by language with metadata
     AVAILABLE_MODELS = {
         "en": {
+            "tacotron2": {
+                "model": "tts_models/en/ljspeech/tacotron2-DDC",
+                "name": "Linda (LJSpeech)",
+                "quality": "good",
+                "size_mb": 362,
+                "description": "Standard female voice (LJSpeech speaker)",
+                "requires_espeak": False,
+                "default": True
+            },
+            "jenny": {
+                "model": "tts_models/en/jenny/jenny",
+                "name": "Jenny",
+                "quality": "excellent",
+                "size_mb": 368,
+                "description": "Different female voice, clear and natural",
+                "requires_espeak": False,
+                "default": False
+            },
+            "ek1": {
+                "model": "tts_models/en/ek1/tacotron2",
+                "name": "Edward (EK1)",
+                "quality": "excellent",
+                "size_mb": 310,
+                "description": "Male voice with British accent",
+                "requires_espeak": False,
+                "default": False
+            },
+            "sam": {
+                "model": "tts_models/en/sam/tacotron-DDC",
+                "name": "Sam",
+                "quality": "good",
+                "size_mb": 370,
+                "description": "Different male voice, deeper tone",
+                "requires_espeak": False,
+                "default": False
+            },
             "fast_pitch": {
                 "model": "tts_models/en/ljspeech/fast_pitch",
-                "name": "Fast Pitch (English)",
+                "name": "Linda Fast (LJSpeech)",
                 "quality": "good",
                 "size_mb": 107,
-                "description": "Lightweight, reliable English voice",
+                "description": "Same speaker as Linda but faster engine",
                 "requires_espeak": False,
-                "default": True
+                "default": False
             },
             "vits": {
                 "model": "tts_models/en/ljspeech/vits",
-                "name": "VITS (English)",
+                "name": "Linda Premium (LJSpeech)",
                 "quality": "excellent",
                 "size_mb": 328,
-                "description": "High-quality English voice with natural prosody",
+                "description": "Same speaker as Linda but premium quality",
                 "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": {
@@ -395,4 +423,78 @@ def get_status() -> str:
 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)
+    return manager.is_model_cached(manager.ESSENTIAL_MODEL)
+
+
+def download_models_cli():
+    """Simple CLI entry point for downloading models."""
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Download TTS models for offline use")
+    parser.add_argument("--essential", action="store_true",
+                       help="Download essential model (default)")
+    parser.add_argument("--all", action="store_true",
+                       help="Download all available models")
+    parser.add_argument("--model", type=str,
+                       help="Download specific model by name")
+    parser.add_argument("--language", type=str,
+                       help="Download models for specific language (en, fr, es, de, it)")
+    parser.add_argument("--status", action="store_true",
+                       help="Show current cache status")
+    parser.add_argument("--clear", action="store_true",
+                       help="Clear model cache")
+
+    args = parser.parse_args()
+
+    manager = get_model_manager(debug_mode=True)
+
+    if args.status:
+        print(get_status())
+        return
+
+    if args.clear:
+        manager.clear_cache()
+        print("✅ Cache cleared")
+        return
+
+    if args.model:
+        success = download_model(args.model)
+        if success:
+            print(f"✅ Downloaded {args.model}")
+        else:
+            print(f"❌ Failed to download {args.model}")
+        sys.exit(0 if success else 1)
+
+    if args.language:
+        # Language-specific downloads using our simple API
+        lang_models = {
+            'en': ['en.tacotron2', 'en.jenny', 'en.ek1'],
+            'fr': ['fr.css10_vits', 'fr.mai_tacotron2'],
+            'es': ['es.mai_tacotron2'],
+            'de': ['de.thorsten_vits'],
+            'it': ['it.mai_male_vits', 'it.mai_female_vits']
+        }
+
+        if args.language not in lang_models:
+            print(f"❌ Language '{args.language}' not supported")
+            print(f"   Available: {list(lang_models.keys())}")
+            sys.exit(1)
+
+        success = False
+        for model_id in lang_models[args.language]:
+            if download_model(model_id):
+                print(f"✅ Downloaded {model_id}")
+                success = True
+                break
+
+        sys.exit(0 if success else 1)
+
+    # Default: download essential model
+    print("📦 Downloading essential TTS model...")
+    success = download_model(manager.ESSENTIAL_MODEL)
+    if success:
+        print("✅ Essential model ready!")
+    else:
+        print("❌ Failed to download essential model")
+    sys.exit(0 if success else 1)

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice/tts/tts_engine.py

@@ -300,11 +300,24 @@ class NonBlockingAudioPlayer:
                     print(f"Error stopping audio stream: {e}")
             finally:
                 self.stream = None
-        
+
         self.is_playing = False
         with self.pause_lock:
             self.is_paused = False
         self.clear_queue()
+
+    def cleanup(self):
+        """Cleanup resources to prevent memory conflicts."""
+        try:
+            self.stop_stream()
+            # Clear any remaining references
+            self.current_audio = None
+            self.playback_complete_callback = None
+            if self.debug_mode:
+                print(" > Audio player cleaned up")
+        except Exception as e:
+            if self.debug_mode:
+                print(f"Audio cleanup warning: {e}")
     
     def play_audio(self, audio_array):
         """Add audio to the playback queue."""
@@ -509,58 +522,155 @@ class TTSEngine:
         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."""
+        """Load TTS model with bulletproof compatibility-first 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):
+        # Step 1: Check espeak availability for smart model filtering
+        espeak_available = self._check_espeak_available()
+        if debug_mode and not espeak_available:
+            print(" > espeak-ng not found, will skip VITS models")
+
+        # Step 2: Try the REQUESTED model first if it's cached
+        cached_models = model_manager.get_cached_models()
+        if cached_models and debug_mode:
+            print(f" > Found {len(cached_models)} cached models")
+
+        # FORCE USER'S CHOICE: Try the specifically requested model first
+        if preferred_model in cached_models:
             try:
                 if debug_mode:
-                    print(f" > Using cached model: {preferred_model}")
+                    print(f" > LOADING REQUESTED MODEL: {preferred_model}")
+
+                # Safety check for Italian VITS models that might crash
+                if "it/" in preferred_model and "vits" in preferred_model:
+                    if debug_mode:
+                        print(f" > Italian VITS model detected - using safe loading...")
+
                 self.tts = TTS(model_name=preferred_model, progress_bar=self.debug_mode)
+
+                if debug_mode:
+                    print(f" > ✅ SUCCESS: Loaded requested model: {preferred_model}")
                 return True, preferred_model
+
             except Exception as e:
+                error_msg = str(e).lower()
                 if debug_mode:
-                    print(f" > Cached model failed: {e}")
+                    print(f" > ❌ Requested model failed: {e}")
+
+                # Special handling for Italian model crashes
+                if "it/" in preferred_model and ("segmentation" in error_msg or "crash" in error_msg):
+                    if debug_mode:
+                        print(f" > Italian model caused crash - marking as incompatible")
+                    # Force fallback for crashed Italian models
+                    pass
+
+                # Only fall back if the model actually failed to load, not due to dependencies
+
+        # Step 3: Only fall back to compatibility order if requested model failed
+        if debug_mode:
+            print(" > Requested model unavailable, trying fallback models...")
+
+        # Compatibility-first fallback order
+        fallback_models = [
+            "tts_models/en/ljspeech/tacotron2-DDC",  # Most reliable (Linda)
+            "tts_models/en/jenny/jenny",             # Different female speaker (Jenny)
+            "tts_models/en/ek1/tacotron2",           # Male British accent (Edward)
+            "tts_models/en/sam/tacotron-DDC",        # Different male voice (Sam)
+            "tts_models/en/ljspeech/fast_pitch",     # Lightweight alternative
+            "tts_models/en/ljspeech/glow-tts",       # Another alternative
+            "tts_models/en/vctk/vits",               # Multi-speaker (requires espeak)
+            "tts_models/en/ljspeech/vits",           # Premium (requires espeak)
+        ]
+
+        # Remove the preferred model from fallbacks to avoid duplicate attempts
+        fallback_models = [m for m in fallback_models if m != preferred_model]
 
-        # 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 fallback models
+        for model in fallback_models:
+            if model in cached_models:
+                # Skip VITS models if no espeak
+                if "vits" in model and not espeak_available:
+                    if debug_mode:
+                        print(f" > Skipping {model} (requires espeak-ng)")
+                    continue
+
+                try:
+                    if debug_mode:
+                        print(f" > Trying fallback model: {model}")
+                    self.tts = TTS(model_name=model, progress_bar=self.debug_mode)
+                    if debug_mode:
+                        print(f" > ✅ Successfully loaded fallback: {model}")
+                    return True, model
+                except Exception as e:
+                    if debug_mode:
+                        print(f" > ❌ Fallback {model} failed: {e}")
+
+        # Step 4: If no cached models work, try downloading requested model first
+        if debug_mode:
+            print(" > No cached models worked, attempting downloads...")
+
+        # Try downloading the requested model first
+        if "vits" not in preferred_model or espeak_available:
             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
+                    print(f" > Downloading requested model: {preferred_model}...")
+                success = model_manager.download_model(preferred_model)
+                if success:
+                    self.tts = TTS(model_name=preferred_model, progress_bar=self.debug_mode)
+                    if debug_mode:
+                        print(f" > ✅ Downloaded and loaded requested: {preferred_model}")
+                    return True, preferred_model
+                elif debug_mode:
+                    print(f" > ❌ Download failed for requested model: {preferred_model}")
             except Exception as e:
                 if debug_mode:
-                    print(f" > Essential model failed: {e}")
+                    print(f" > ❌ Failed to download/load requested model: {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}")
+        # Step 5: If requested model download failed, try fallback downloads
+        for model in fallback_models:
+            # Skip VITS models if no espeak
+            if "vits" in model and not espeak_available:
+                continue
 
-        # 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}")
+            try:
+                if debug_mode:
+                    print(f" > Downloading fallback: {model}...")
+
+                # First try to download
+                success = model_manager.download_model(model)
+                if success:
+                    # Then try to load
+                    self.tts = TTS(model_name=model, progress_bar=self.debug_mode)
+                    if debug_mode:
+                        print(f" > ✅ Downloaded and loaded fallback: {model}")
+                    return True, model
+                elif debug_mode:
+                    print(f" > ❌ Download failed for {model}")
+
+            except Exception as e:
+                if debug_mode:
+                    print(f" > ❌ Failed to load {model}: {e}")
 
         return False, None
 
+    def _check_espeak_available(self) -> bool:
+        """Check if espeak-ng is available on the system."""
+        import subprocess
+        try:
+            subprocess.run(['espeak-ng', '--version'],
+                         capture_output=True, check=True, timeout=5)
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+            # Try alternative espeak command
+            try:
+                subprocess.run(['espeak', '--version'],
+                             capture_output=True, check=True, timeout=5)
+                return True
+            except:
+                return False
+
     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
@@ -574,7 +684,7 @@ class TTSEngine:
         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("\nFalling back to compatible models (no espeak dependency)")
         print("="*70 + "\n")
 
         if not debug_mode:
@@ -582,12 +692,15 @@ class TTSEngine:
             null_out = open(os.devnull, 'w')
             sys.stdout = null_out
 
-        # Try non-phoneme models that don't require espeak
+        # Try non-phoneme models that don't require espeak (compatibility-first order)
         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_models/en/ljspeech/tacotron2-DDC",  # Most reliable (Linda)
+            "tts_models/en/jenny/jenny",             # Different female speaker (Jenny)
+            "tts_models/en/ek1/tacotron2",           # Male British accent (Edward)
+            "tts_models/en/sam/tacotron-DDC",        # Different male voice (Sam)
+            "tts_models/en/ljspeech/fast_pitch",     # Lightweight alternative
+            "tts_models/en/ljspeech/glow-tts"        # Another alternative
         ]
 
         tts_loaded = False

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice/voice_manager.py

@@ -38,8 +38,8 @@ class VoiceManager:
     # Smart language configuration - high quality stable defaults
     LANGUAGES = {
         'en': {
-            'default': 'tts_models/en/ljspeech/vits',          # High quality premium voice
-            'premium': 'tts_models/en/ljspeech/vits',          # Use same stable model
+            'default': 'tts_models/en/ljspeech/tacotron2-DDC', # Reliable, compatible voice
+            'premium': 'tts_models/en/ljspeech/vits',          # High quality (requires espeak)
             'name': 'English'
         },
         'fr': {
@@ -70,15 +70,39 @@ class VoiceManager:
     # Complete voice catalog with metadata
     VOICE_CATALOG = {
         'en': {
-            'vits_premium': {
-                'model': 'tts_models/en/ljspeech/vits',
-                'quality': 'premium',
+            'tacotron2': {
+                'model': 'tts_models/en/ljspeech/tacotron2-DDC',
+                'quality': 'good',
                 'gender': 'female',
                 'accent': 'US English',
                 'license': 'Open source (LJSpeech)',
-                'requires': 'espeak-ng'
+                'requires': 'none'
+            },
+            'jenny': {
+                'model': 'tts_models/en/jenny/jenny',
+                'quality': 'excellent',
+                'gender': 'female',
+                'accent': 'US English',
+                'license': 'Open source (Jenny)',
+                'requires': 'none'
+            },
+            'ek1': {
+                'model': 'tts_models/en/ek1/tacotron2',
+                'quality': 'excellent',
+                'gender': 'male',
+                'accent': 'British English',
+                'license': 'Open source (EK1)',
+                'requires': 'none'
             },
-            'fast_pitch_reliable': {
+            'sam': {
+                'model': 'tts_models/en/sam/tacotron-DDC',
+                'quality': 'good',
+                'gender': 'male',
+                'accent': 'US English',
+                'license': 'Open source (Sam)',
+                'requires': 'none'
+            },
+            'fast_pitch': {
                 'model': 'tts_models/en/ljspeech/fast_pitch',
                 'quality': 'good',
                 'gender': 'female',
@@ -86,12 +110,12 @@ class VoiceManager:
                 'license': 'Open source (LJSpeech)',
                 'requires': 'none'
             },
-            'vctk_multi': {
-                'model': 'tts_models/en/vctk/vits',
+            'vits': {
+                'model': 'tts_models/en/ljspeech/vits',
                 'quality': 'premium',
-                'gender': 'multiple',
-                'accent': 'British English',
-                'license': 'Open source (VCTK)',
+                'gender': 'female',
+                'accent': 'US English',
+                'license': 'Open source (LJSpeech)',
                 'requires': 'espeak-ng'
             }
         },
@@ -191,6 +215,20 @@ class VoiceManager:
                 lang_name = self.LANGUAGES[self.language]['name']
                 print(f"🌍 Using {lang_name} voice: {tts_model}")
 
+        # Initialize TTS engine with instant setup for new users
+        from .instant_setup import ensure_instant_tts, get_instant_model, is_model_cached
+
+        # If using default VITS model but it's not cached, use instant setup
+        if tts_model == "tts_models/en/ljspeech/vits" and not is_model_cached(tts_model):
+            if debug_mode:
+                print("🚀 First-time setup: ensuring instant TTS availability...")
+
+            # Try instant setup with lightweight model
+            if ensure_instant_tts():
+                tts_model = get_instant_model()  # Use fast_pitch instead
+                if debug_mode:
+                    print(f"✅ Using essential model: {tts_model}")
+
         # Initialize TTS engine using lazy import
         TTSEngine = _import_tts_engine()
         self.tts_engine = TTSEngine(
@@ -391,32 +429,68 @@ class VoiceManager:
         return self.speed
 
     def set_tts_model(self, model_name):
-        """Change the TTS model.
-        
+        """Change the TTS model safely without memory conflicts.
+
         Available models (all pure Python, cross-platform):
         - "tts_models/en/ljspeech/fast_pitch" (default, recommended)
         - "tts_models/en/ljspeech/glow-tts" (alternative)
         - "tts_models/en/ljspeech/tacotron2-DDC" (legacy)
-        
+
         Args:
             model_name: TTS model name to use
-            
+
         Returns:
             True if successful
-            
+
         Example:
             vm.set_tts_model("tts_models/en/ljspeech/glow-tts")
         """
         # Stop any current speech
         self.stop_speaking()
-        
+
+        # CRITICAL: Crash-safe cleanup of old TTS engine
+        if hasattr(self, 'tts_engine') and self.tts_engine:
+            try:
+                # Stop all audio and cleanup player
+                if hasattr(self.tts_engine, 'audio_player') and self.tts_engine.audio_player:
+                    # Try stop method if available
+                    if hasattr(self.tts_engine.audio_player, 'stop'):
+                        self.tts_engine.audio_player.stop()
+                    self.tts_engine.audio_player.cleanup()
+
+                # Force cleanup of TTS object and release GPU memory
+                if hasattr(self.tts_engine, 'tts') and self.tts_engine.tts:
+                    # Clear CUDA cache if using GPU
+                    try:
+                        import torch
+                        if torch.cuda.is_available():
+                            torch.cuda.empty_cache()
+                    except:
+                        pass
+
+                    del self.tts_engine.tts
+
+                # Clear the engine itself
+                del self.tts_engine
+                self.tts_engine = None
+
+                # Force garbage collection to prevent memory leaks
+                import gc
+                gc.collect()
+
+            except Exception as e:
+                if self.debug_mode:
+                    print(f"Warning: TTS cleanup issue: {e}")
+                # Force clear even if cleanup failed
+                self.tts_engine = None
+
         # Reinitialize TTS engine with new model using lazy import
         TTSEngine = _import_tts_engine()
         self.tts_engine = TTSEngine(
             model_name=model_name,
             debug_mode=self.debug_mode
         )
-        
+
         # Restore callbacks
         self.tts_engine.on_playback_start = self._on_tts_start
         self.tts_engine.on_playback_end = self._on_tts_end

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractvoice
-Version: 0.4.1
+Version: 0.4.6
 Summary: A modular Python library for voice interactions with AI systems
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 License-Expression: MIT
@@ -19,6 +19,14 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: requests>=2.31.0
+Requires-Dist: appdirs>=1.4.0
+Requires-Dist: coqui-tts<0.30.0,>=0.27.0
+Requires-Dist: torch<2.4.0,>=2.0.0
+Requires-Dist: torchvision<0.19.0,>=0.15.0
+Requires-Dist: torchaudio<2.4.0,>=2.0.0
+Requires-Dist: librosa>=0.10.0
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: soundfile>=0.12.1
 Provides-Extra: voice
 Requires-Dist: sounddevice>=0.4.6; extra == "voice"
 Requires-Dist: webrtcvad>=2.0.10; extra == "voice"

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice.egg-info/SOURCES.txt

@@ -4,7 +4,7 @@ pyproject.toml
 abstractvoice/__init__.py
 abstractvoice/__main__.py
 abstractvoice/dependency_check.py
-abstractvoice/model_manager.py
+abstractvoice/instant_setup.py
 abstractvoice/recognition.py
 abstractvoice/simple_model_manager.py
 abstractvoice/voice_manager.py

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/abstractvoice.egg-info/requires.txt

@@ -1,5 +1,13 @@
 numpy>=1.24.0
 requests>=2.31.0
+appdirs>=1.4.0
+coqui-tts<0.30.0,>=0.27.0
+torch<2.4.0,>=2.0.0
+torchvision<0.19.0,>=0.15.0
+torchaudio<2.4.0,>=2.0.0
+librosa>=0.10.0
+sounddevice>=0.4.6
+soundfile>=0.12.1
 
 [all]
 sounddevice>=0.4.6

{abstractvoice-0.4.1 → abstractvoice-0.4.6}/pyproject.toml

@@ -26,6 +26,15 @@ classifiers = [
 dependencies = [
     "numpy>=1.24.0",
     "requests>=2.31.0",
+    "appdirs>=1.4.0",
+    # Essential TTS dependencies for immediate functionality
+    "coqui-tts>=0.27.0,<0.30.0",
+    "torch>=2.0.0,<2.4.0",
+    "torchvision>=0.15.0,<0.19.0",
+    "torchaudio>=2.0.0,<2.4.0",
+    "librosa>=0.10.0",
+    "sounddevice>=0.4.6",
+    "soundfile>=0.12.1",
 ]
 
 [project.optional-dependencies]

abstractvoice-0.4.1/abstractvoice/model_manager.py

@@ -1,384 +0,0 @@
-"""Model management utilities for AbstractVoice.
-
-This module provides utilities for downloading, caching, and managing TTS models
-to ensure offline functionality and better user experience.
-"""
-
-import os
-import sys
-import time
-import threading
-from typing import List, Optional, Dict, 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]        # For TTS only\n"
-            "  pip install abstractvoice[voice-full] # For complete voice functionality\n"
-            "  pip install abstractvoice[all]        # For all features\n"
-            f"Original error: {e}"
-        ) from e
-
-
-class ModelManager:
-    """Manages TTS model downloading, caching, and offline availability."""
-
-    # Essential models for immediate functionality
-    ESSENTIAL_MODELS = [
-        "tts_models/en/ljspeech/fast_pitch",     # Lightweight, no espeak dependency
-        "tts_models/en/ljspeech/tacotron2-DDC",  # Reliable fallback
-    ]
-
-    # Premium models for best quality (downloaded on-demand)
-    PREMIUM_MODELS = [
-        "tts_models/en/ljspeech/vits",           # Best quality English
-        "tts_models/fr/css10/vits",              # Best quality French
-        "tts_models/es/mai/tacotron2-DDC",       # Best quality Spanish
-        "tts_models/de/thorsten/vits",           # Best quality German
-        "tts_models/it/mai_male/vits",           # Best quality Italian
-    ]
-
-    # All supported models
-    ALL_MODELS = ESSENTIAL_MODELS + PREMIUM_MODELS
-
-    def __init__(self, debug_mode: bool = False):
-        self.debug_mode = debug_mode
-        self._cache_dir = None
-        self._model_manager = 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"),
-            ]
-
-            # 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
-
-    @property
-    def model_manager(self):
-        """Get TTS ModelManager instance."""
-        if self._model_manager is None:
-            _, ModelManagerClass = _import_tts()
-            self._model_manager = ModelManagerClass()
-        return self._model_manager
-
-    def check_model_cache(self, model_name: str) -> bool:
-        """Check if a model is already cached locally."""
-        try:
-            # Look for model files in cache
-            model_path = self._get_model_path(model_name)
-            if model_path and os.path.exists(model_path):
-                # Check for essential model files
-                model_files = ["model.pth", "config.json"]
-                return any(
-                    os.path.exists(os.path.join(model_path, f))
-                    for f in model_files
-                )
-            return False
-        except Exception as e:
-            if self.debug_mode:
-                print(f"Error checking cache for {model_name}: {e}")
-            return False
-
-    def _get_model_path(self, model_name: str) -> Optional[str]:
-        """Get the expected cache path for a model."""
-        # Convert model name to cache directory structure
-        # e.g., "tts_models/en/ljspeech/vits" -> "tts_models--en--ljspeech--vits"
-        cache_name = model_name.replace("/", "--")
-        return os.path.join(self.cache_dir, cache_name)
-
-    def get_cached_models(self) -> List[str]:
-        """Get list of models that are cached locally."""
-        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.check_model_cache(model_name):
-                        cached.append(model_name)
-        except Exception as e:
-            if self.debug_mode:
-                print(f"Error listing cached models: {e}")
-
-        return cached
-
-    def download_model(self, model_name: str, force: bool = False) -> bool:
-        """Download a specific model."""
-        if not force and self.check_model_cache(model_name):
-            if self.debug_mode:
-                print(f"✅ {model_name} already cached")
-            return True
-
-        try:
-            TTS, _ = _import_tts()
-
-            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
-            print(f"✅ Downloaded {model_name} in {download_time:.1f}s")
-            return True
-
-        except Exception as e:
-            print(f"❌ Failed to download {model_name}: {e}")
-            return False
-
-    def download_all_models(self) -> bool:
-        """Download all supported models."""
-        print("📦 Downloading all TTS models...")
-
-        success_count = 0
-        for model in self.ALL_MODELS:
-            if self.download_model(model):
-                success_count += 1
-
-        print(f"✅ Downloaded {success_count}/{len(self.ALL_MODELS)} models")
-        return success_count > 0
-
-    def get_offline_model(self, preferred_models: List[str]) -> Optional[str]:
-        """Get the best available cached model from a preference list."""
-        cached_models = self.get_cached_models()
-
-        # Return first preferred model that's cached
-        for model in preferred_models:
-            if model in cached_models:
-                return model
-
-        # Fallback to any cached model
-        if cached_models:
-            return cached_models[0]
-
-        return None
-
-    def print_status(self):
-        """Print current model cache status."""
-        print("🎭 TTS Model Cache Status")
-        print("=" * 50)
-
-        cached_models = self.get_cached_models()
-
-        if not cached_models:
-            print("❌ No models cached - first use will require internet")
-            print("\nTo download essential models for offline use:")
-            print("  abstractvoice download-models")
-            return
-
-        print(f"✅ {len(cached_models)} models cached for offline use:")
-
-        # Group by category
-        essential_cached = [m for m in cached_models if m in self.ESSENTIAL_MODELS]
-        premium_cached = [m for m in cached_models if m in self.PREMIUM_MODELS]
-        other_cached = [m for m in cached_models if m not in self.ALL_MODELS]
-
-        if essential_cached:
-            print(f"\n📦 Essential Models ({len(essential_cached)}):")
-            for model in essential_cached:
-                print(f"  ✅ {model}")
-
-        if premium_cached:
-            print(f"\n✨ Premium Models ({len(premium_cached)}):")
-            for model in premium_cached:
-                print(f"  ✅ {model}")
-
-        if other_cached:
-            print(f"\n🔧 Other Models ({len(other_cached)}):")
-            for model in other_cached:
-                print(f"  ✅ {model}")
-
-        print(f"\n💾 Cache location: {self.cache_dir}")
-
-        # Check cache size
-        try:
-            total_size = 0
-            for root, dirs, files in os.walk(self.cache_dir):
-                for file in files:
-                    total_size += os.path.getsize(os.path.join(root, file))
-            size_mb = total_size / (1024 * 1024)
-            print(f"💽 Total cache size: {size_mb:.1f} MB")
-        except:
-            pass
-
-    def clear_cache(self, confirm: bool = False) -> bool:
-        """Clear the model cache."""
-        if not confirm:
-            print("⚠️ This will delete all cached TTS models.")
-            print("Use clear_cache(confirm=True) to proceed.")
-            return False
-
-        try:
-            import shutil
-            if os.path.exists(self.cache_dir):
-                shutil.rmtree(self.cache_dir)
-                print(f"✅ Cleared model cache: {self.cache_dir}")
-                return True
-            else:
-                print("ℹ️ No cache to clear")
-                return True
-        except Exception as e:
-            print(f"❌ Failed to clear cache: {e}")
-            return False
-
-
-def download_models_cli():
-    """CLI entry point for downloading models."""
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="Download TTS models for offline use")
-    parser.add_argument("--essential", action="store_true",
-                       help="Download only essential models (recommended)")
-    parser.add_argument("--all", action="store_true",
-                       help="Download all supported models")
-    parser.add_argument("--model", type=str,
-                       help="Download specific model by name")
-    parser.add_argument("--language", type=str,
-                       help="Download models for specific language (en, fr, es, de, it)")
-    parser.add_argument("--status", action="store_true",
-                       help="Show current cache status")
-    parser.add_argument("--clear", action="store_true",
-                       help="Clear model cache")
-    parser.add_argument("--debug", action="store_true",
-                       help="Enable debug output")
-
-    args = parser.parse_args()
-
-    # Use VoiceManager for consistent programmatic API
-    from abstractvoice.voice_manager import VoiceManager
-
-    vm = VoiceManager(debug_mode=args.debug)
-
-    if args.status:
-        # Use VoiceManager's model status
-        status = vm.get_cache_status()
-        print("🎭 TTS Model Cache Status")
-        print("=" * 50)
-
-        if status['total_cached'] == 0:
-            print("❌ No models cached - first use will require internet")
-            print("\nTo download essential models for offline use:")
-            print("  abstractvoice download-models --essential")
-            return
-
-        print(f"✅ {status['total_cached']} models cached for offline use")
-        print(f"📦 Essential model cached: {status['essential_model_cached']}")
-        print(f"🌐 Ready for offline: {status['ready_for_offline']}")
-        print(f"💾 Cache location: {status['cache_dir']}")
-        print(f"💽 Total cache size: {status['total_size_mb']} MB")
-
-        # Show cached models
-        cached_models = status['cached_models']
-        essential_model = status['essential_model']
-
-        print(f"\n📦 Essential Model:")
-        if essential_model in cached_models:
-            print(f"  ✅ {essential_model}")
-        else:
-            print(f"  📥 {essential_model} (not cached)")
-
-        print(f"\n📋 All Cached Models ({len(cached_models)}):")
-        for model in sorted(cached_models)[:10]:  # Show first 10
-            print(f"  ✅ {model}")
-        if len(cached_models) > 10:
-            print(f"  ... and {len(cached_models) - 10} more")
-        return
-
-    if args.clear:
-        # Use ModelManager for low-level cache operations
-        manager = ModelManager(debug_mode=args.debug)
-        manager.clear_cache(confirm=True)
-        return
-
-    if args.model:
-        # Use ModelManager for direct model download
-        manager = ModelManager(debug_mode=args.debug)
-        success = manager.download_model(args.model)
-        sys.exit(0 if success else 1)
-
-    if args.language:
-        # Use simple model download for language-specific models
-        print(f"📦 Downloading models for {args.language}...")
-
-        # Get available models for this language
-        models = vm.list_available_models(args.language)
-        if args.language not in models:
-            print(f"❌ Language '{args.language}' not supported")
-            print(f"   Available languages: {list(vm.list_available_models().keys())}")
-            sys.exit(1)
-
-        # Download the default model for this language
-        language_models = models[args.language]
-        default_model = None
-        for voice_id, voice_info in language_models.items():
-            if voice_info.get('default', False):
-                default_model = f"{args.language}.{voice_id}"
-                break
-
-        if not default_model:
-            # Take the first available model
-            first_voice = list(language_models.keys())[0]
-            default_model = f"{args.language}.{first_voice}"
-
-        print(f"  📥 Downloading {default_model}...")
-        success = vm.download_model(default_model)
-
-        if success:
-            print(f"✅ Downloaded {default_model}")
-            print(f"✅ {args.language.upper()} voice is now ready!")
-        else:
-            print(f"❌ Failed to download {default_model}")
-        sys.exit(0 if success else 1)
-
-    if args.all:
-        # Use ModelManager for downloading all models
-        manager = ModelManager(debug_mode=args.debug)
-        success = manager.download_all_models()
-        sys.exit(0 if success else 1)
-
-    # Default to essential models via VoiceManager
-    if args.essential or (not args.all and not args.model and not args.language):
-        print("📦 Downloading essential TTS model for offline use...")
-
-        # Use the simple ensure_ready method
-        success = vm.ensure_ready(auto_download=True)
-
-        if success:
-            print("✅ Essential model downloaded successfully!")
-            print("🎉 AbstractVoice is now ready for offline use!")
-        else:
-            print("❌ Essential model download failed")
-            print("   Check your internet connection")
-        sys.exit(0 if success else 1)
-
-
-if __name__ == "__main__":
-    download_models_cli()