abstractvoice 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

abstractvoice/__main__.py

@@ -15,20 +15,27 @@ def print_examples():
     print("  cli       - Command-line REPL example")
     print("  web       - Web API example")
     print("  simple    - Simple usage example")
-    print("\nUsage: python -m abstractvoice <example> [args...]")
+    print("  check-deps - Check dependency compatibility")
+    print("\nUsage: python -m abstractvoice <example> [--language <lang>] [args...]")
+    print("\nSupported languages: en, fr, es, de, it, ru, multilingual")
+    print("\nExamples:")
+    print("  python -m abstractvoice cli --language fr    # French CLI")
+    print("  python -m abstractvoice simple --language ru # Russian simple example")
+    print("  python -m abstractvoice check-deps           # Check dependencies")
 
 
 def simple_example():
     """Run a simple example demonstrating basic usage."""
     from abstractvoice import VoiceManager
     import time
-    
+
     print("Simple AbstractVoice Example")
     print("============================")
     print("This example demonstrates basic TTS and STT functionality.")
+    print("(Use --language argument to test different languages)")
     print()
-    
-    # Initialize voice manager
+
+    # Initialize voice manager (can be overridden with --language)
     manager = VoiceManager(debug_mode=True)
     
     try:
@@ -90,18 +97,33 @@ def simple_example():
 def main():
     """Main entry point."""
     parser = argparse.ArgumentParser(description="AbstractVoice examples")
-    parser.add_argument("example", nargs="?", help="Example to run (cli, web, simple)")
-    
-    # Parse just the first argument
+    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"],
+                      help="Voice language for examples")
+
+    # Parse just the first argument and language
     args, remaining = parser.parse_known_args()
-    
+
     if not args.example:
         print_examples()
         return
-    
-    # Set remaining args as sys.argv for the examples
+
+    # Handle check-deps specially (doesn't need language)
+    if args.example == "check-deps":
+        from abstractvoice.dependency_check import check_dependencies
+        try:
+            check_dependencies(verbose=True)
+        except Exception as e:
+            print(f"❌ Error running dependency check: {e}")
+            print("This might indicate a dependency issue.")
+        return
+
+    # Set remaining args as sys.argv for the examples, including language
+    if args.language != "en":
+        remaining = ["--language", args.language] + remaining
     sys.argv = [sys.argv[0]] + remaining
-    
+
     if args.example == "cli":
         from abstractvoice.examples.cli_repl import main
         main()

abstractvoice/dependency_check.py

@@ -0,0 +1,274 @@
+"""Dependency compatibility checker for AbstractVoice.
+
+This module provides utilities to check dependency versions and compatibility,
+helping users diagnose and resolve installation issues.
+"""
+
+import sys
+import importlib
+from typing import Dict, List, Tuple, Optional
+import warnings
+
+
+class DependencyChecker:
+    """Check and validate AbstractVoice dependencies."""
+
+    # Known compatible version ranges
+    PYTORCH_COMPAT = {
+        "torch": ("2.0.0", "2.4.0"),
+        "torchvision": ("0.15.0", "0.19.0"),
+        "torchaudio": ("2.0.0", "2.4.0"),
+    }
+
+    CORE_DEPS = {
+        "numpy": ("1.24.0", None),
+        "requests": ("2.31.0", None),
+    }
+
+    OPTIONAL_DEPS = {
+        "coqui-tts": ("0.27.0", "0.30.0"),
+        "openai-whisper": ("20230314", None),
+        "sounddevice": ("0.4.6", None),
+        "librosa": ("0.10.0", "0.11.0"),
+        "flask": ("2.0.0", None),
+        "webrtcvad": ("2.0.10", None),
+        "PyAudio": ("0.2.13", None),
+        "soundfile": ("0.12.1", None),
+        "tiktoken": ("0.6.0", None),
+    }
+
+    def __init__(self, verbose: bool = True):
+        self.verbose = verbose
+        self.results = {}
+
+    def _parse_version(self, version_str: str) -> Tuple[int, ...]:
+        """Parse version string into tuple of integers for comparison."""
+        try:
+            # Handle version strings like "20230314" or "2.0.0"
+            if version_str.isdigit():
+                return (int(version_str),)
+
+            # Standard semantic versioning
+            version_parts = version_str.split('.')
+            return tuple(int(part) for part in version_parts if part.isdigit())
+        except (ValueError, AttributeError):
+            return (0,)
+
+    def _check_version_range(self, current: str, min_ver: Optional[str], max_ver: Optional[str]) -> bool:
+        """Check if current version is within the specified range."""
+        current_tuple = self._parse_version(current)
+
+        if min_ver:
+            min_tuple = self._parse_version(min_ver)
+            if current_tuple < min_tuple:
+                return False
+
+        if max_ver:
+            max_tuple = self._parse_version(max_ver)
+            if current_tuple >= max_tuple:
+                return False
+
+        return True
+
+    def _check_package(self, package_name: str, min_ver: Optional[str], max_ver: Optional[str]) -> Dict:
+        """Check a single package installation and version."""
+        try:
+            module = importlib.import_module(package_name.replace('-', '_'))
+            version = getattr(module, '__version__', 'unknown')
+
+            # Special handling for packages with different version attributes
+            if version == 'unknown':
+                if hasattr(module, 'version'):
+                    version = module.version
+                elif hasattr(module, 'VERSION'):
+                    version = module.VERSION
+                elif package_name == 'openai-whisper':
+                    # Whisper uses different versioning
+                    try:
+                        import whisper
+                        version = getattr(whisper, '__version__', 'installed')
+                    except:
+                        version = 'installed'
+
+            compatible = self._check_version_range(str(version), min_ver, max_ver)
+
+            return {
+                'status': 'installed',
+                'version': str(version),
+                'compatible': compatible,
+                'min_version': min_ver,
+                'max_version': max_ver
+            }
+
+        except ImportError:
+            return {
+                'status': 'missing',
+                'version': None,
+                'compatible': False,
+                'min_version': min_ver,
+                'max_version': max_ver
+            }
+        except Exception as e:
+            return {
+                'status': 'error',
+                'version': None,
+                'compatible': False,
+                'error': str(e),
+                'min_version': min_ver,
+                'max_version': max_ver
+            }
+
+    def check_core_dependencies(self) -> Dict:
+        """Check core dependencies (always required)."""
+        results = {}
+        for package, (min_ver, max_ver) in self.CORE_DEPS.items():
+            results[package] = self._check_package(package, min_ver, max_ver)
+        return results
+
+    def check_pytorch_ecosystem(self) -> Dict:
+        """Check PyTorch ecosystem for compatibility issues."""
+        results = {}
+        for package, (min_ver, max_ver) in self.PYTORCH_COMPAT.items():
+            results[package] = self._check_package(package, min_ver, max_ver)
+        return results
+
+    def check_optional_dependencies(self) -> Dict:
+        """Check optional dependencies."""
+        results = {}
+        for package, (min_ver, max_ver) in self.OPTIONAL_DEPS.items():
+            results[package] = self._check_package(package, min_ver, max_ver)
+        return results
+
+    def check_pytorch_conflicts(self) -> List[str]:
+        """Detect specific PyTorch/TorchVision conflicts."""
+        conflicts = []
+
+        try:
+            import torch
+            import torchvision
+
+            torch_version = self._parse_version(torch.__version__)
+            tv_version = self._parse_version(torchvision.__version__)
+
+            # Check known incompatible combinations
+            if torch_version >= (2, 3, 0) and tv_version < (0, 18, 0):
+                conflicts.append(f"PyTorch {torch.__version__} is incompatible with TorchVision {torchvision.__version__}")
+
+            # Test torchvision::nms operator availability
+            try:
+                from torchvision.ops import nms
+                # Try to use nms to check if it actually works
+                import torch
+                boxes = torch.tensor([[0, 0, 1, 1]], dtype=torch.float32)
+                scores = torch.tensor([1.0], dtype=torch.float32)
+                nms(boxes, scores, 0.5)
+            except Exception as e:
+                if "torchvision::nms does not exist" in str(e):
+                    conflicts.append("TorchVision NMS operator not available - version mismatch detected")
+
+        except ImportError:
+            pass  # PyTorch not installed
+
+        return conflicts
+
+    def check_all(self) -> Dict:
+        """Run comprehensive dependency check."""
+        results = {
+            'core': self.check_core_dependencies(),
+            'pytorch': self.check_pytorch_ecosystem(),
+            'optional': self.check_optional_dependencies(),
+            'conflicts': self.check_pytorch_conflicts(),
+            'python_version': sys.version,
+            'platform': sys.platform
+        }
+
+        self.results = results
+        return results
+
+    def print_report(self, results: Optional[Dict] = None):
+        """Print a formatted dependency report."""
+        if results is None:
+            results = self.results
+
+        print("🔍 AbstractVoice Dependency Check Report")
+        print("=" * 50)
+
+        # Python version
+        print(f"\n🐍 Python: {results['python_version']}")
+        print(f"🖥️  Platform: {results['platform']}")
+
+        # Core dependencies
+        print(f"\n📦 Core Dependencies:")
+        for package, info in results['core'].items():
+            status_icon = "✅" if info['status'] == 'installed' and info['compatible'] else "❌"
+            version_info = f"v{info['version']}" if info['version'] else "not installed"
+            print(f"  {status_icon} {package}: {version_info}")
+
+        # PyTorch ecosystem
+        print(f"\n🔥 PyTorch Ecosystem:")
+        pytorch_all_good = True
+        for package, info in results['pytorch'].items():
+            status_icon = "✅" if info['status'] == 'installed' and info['compatible'] else "❌"
+            version_info = f"v{info['version']}" if info['version'] else "not installed"
+            if info['status'] != 'installed' or not info['compatible']:
+                pytorch_all_good = False
+            print(f"  {status_icon} {package}: {version_info}")
+
+        # Conflicts
+        if results['conflicts']:
+            print(f"\n⚠️  Detected Conflicts:")
+            for conflict in results['conflicts']:
+                print(f"  ❌ {conflict}")
+            pytorch_all_good = False
+
+        if pytorch_all_good and all(info['status'] == 'installed' for info in results['pytorch'].values()):
+            print("  🎉 PyTorch ecosystem looks compatible!")
+
+        # Optional dependencies
+        print(f"\n🔧 Optional Dependencies:")
+        installed_optional = []
+        missing_optional = []
+
+        for package, info in results['optional'].items():
+            if info['status'] == 'installed':
+                status_icon = "✅" if info['compatible'] else "⚠️"
+                installed_optional.append(f"  {status_icon} {package}: v{info['version']}")
+            else:
+                missing_optional.append(f"  ⭕ {package}: not installed")
+
+        if installed_optional:
+            print("  Installed:")
+            for line in installed_optional:
+                print(line)
+
+        if missing_optional:
+            print("  Missing:")
+            for line in missing_optional:
+                print(line)
+
+        # Recommendations
+        print(f"\n💡 Recommendations:")
+
+        if not pytorch_all_good:
+            print("  🔧 Fix PyTorch conflicts with:")
+            print("     pip uninstall torch torchvision torchaudio")
+            print("     pip install abstractvoice[all]")
+
+        if not any(info['status'] == 'installed' for info in results['optional'].values()):
+            print("  📦 Install voice functionality with:")
+            print("     pip install abstractvoice[voice-full]")
+
+        print("\n" + "=" * 50)
+
+
+def check_dependencies(verbose: bool = True) -> Dict:
+    """Quick function to check all dependencies."""
+    checker = DependencyChecker(verbose=verbose)
+    results = checker.check_all()
+    if verbose:
+        checker.print_report(results)
+    return results
+
+
+if __name__ == "__main__":
+    check_dependencies()

abstractvoice/examples/cli_repl.py

@@ -37,21 +37,28 @@ class VoiceREPL(cmd.Cmd):
     ruler = ""  # No horizontal rule line
     use_rawinput = True
     
-    def __init__(self, api_url="http://localhost:11434/api/chat", 
-                 model="granite3.3:2b", debug_mode=False):
+    def __init__(self, api_url="http://localhost:11434/api/chat",
+                 model="granite3.3:2b", debug_mode=False, language="en", tts_model=None):
         super().__init__()
-        
+
         # Debug mode
         self.debug_mode = debug_mode
-        
+
         # API settings
         self.api_url = api_url
         self.model = model
         self.temperature = 0.4
         self.max_tokens = 4096
-        
-        # Initialize voice manager
-        self.voice_manager = VoiceManager(debug_mode=debug_mode)
+
+        # Language settings
+        self.current_language = language
+
+        # Initialize voice manager with language support
+        self.voice_manager = VoiceManager(
+            language=language,
+            tts_model=tts_model,
+            debug_mode=debug_mode
+        )
         
         # Settings
         self.use_tts = True
@@ -83,10 +90,12 @@ class VoiceREPL(cmd.Cmd):
     def _get_intro(self):
         """Generate intro message with help."""
         intro = f"\n{Colors.BOLD}Welcome to AbstractVoice CLI REPL{Colors.END}\n"
-        intro += f"API: {self.api_url} | Model: {self.model}\n"
+        lang_name = self.voice_manager.get_language_name()
+        intro += f"API: {self.api_url} | Model: {self.model} | Voice: {lang_name}\n"
         intro += f"\n{Colors.CYAN}Quick Start:{Colors.END}\n"
         intro += "  • Type messages to chat with the LLM\n"
         intro += "  • Use /voice <mode> to enable voice input\n"
+        intro += "  • Use /language <lang> to switch voice language\n"
         intro += "  • Type /help for full command list\n"
         intro += "  • Type /exit or /q to quit\n"
         return intro
@@ -278,7 +287,172 @@ class VoiceREPL(cmd.Cmd):
             text = re.sub(pattern, "", text, flags=re.DOTALL)
             
         return text.strip()
-    
+
+    def do_language(self, args):
+        """Switch voice language.
+
+        Usage: /language <lang>
+        Available languages: en, fr, es, de, it
+        """
+        if not args:
+            current_name = self.voice_manager.get_language_name()
+            current_code = self.voice_manager.get_language()
+            print(f"Current language: {current_name} ({current_code})")
+
+            print("Available languages:")
+            for code in self.voice_manager.get_supported_languages():
+                name = self.voice_manager.get_language_name(code)
+                print(f"  {code} - {name}")
+            return
+
+        language = args.strip().lower()
+
+        # Stop any current voice activity
+        if self.voice_mode_active:
+            self._voice_stop_callback()
+            was_active = True
+        else:
+            was_active = False
+
+        # Switch language
+        old_lang = self.current_language
+        if self.voice_manager.set_language(language):
+            self.current_language = language
+            old_name = self.voice_manager.get_language_name(old_lang)
+            new_name = self.voice_manager.get_language_name(language)
+            print(f"🌍 Language changed: {old_name} → {new_name}")
+
+            # Test the new language with localized message
+            test_messages = {
+                'en': "Language switched to English.",
+                'fr': "Langue changée en français.",
+                'es': "Idioma cambiado a español.",
+                'de': "Sprache auf Deutsch umgestellt.",
+                'it': "Lingua cambiata in italiano."
+            }
+            test_msg = test_messages.get(language, "Language switched.")
+            self.voice_manager.speak(test_msg)
+
+            # Restart voice mode if it was active
+            if was_active:
+                self.do_voice(self.voice_mode)
+        else:
+            supported = ', '.join(self.voice_manager.get_supported_languages())
+            print(f"Failed to switch to language: {language}")
+            print(f"Supported languages: {supported}")
+            if self.debug_mode:
+                import traceback
+                traceback.print_exc()
+
+    def do_setvoice(self, args):
+        """Set a specific voice model.
+
+        Usage:
+          /setvoice                    # Show all available voices
+          /setvoice <voice_id>         # Set voice (format: language.voice_id)
+
+        Examples:
+          /setvoice                    # List all voices
+          /setvoice fr.css10_vits      # Set French CSS10 VITS voice
+          /setvoice it.mai_male_vits   # Set Italian male VITS voice
+        """
+        if not args:
+            # Show all available voices organized by language
+            print(f"\n{Colors.CYAN}Available Voice Models:{Colors.END}")
+            self.voice_manager.list_voices()
+
+            print(f"\n{Colors.YELLOW}Usage:{Colors.END}")
+            print("  /setvoice <language>.<voice_id>")
+            print("  Example: /setvoice fr.css10_vits")
+            return
+
+        voice_spec = args.strip()
+
+        # Parse language.voice_id format
+        if '.' not in voice_spec:
+            print(f"❌ Invalid format. Use: language.voice_id")
+            print(f"   Example: /setvoice fr.css10_vits")
+            print(f"   Run '/setvoice' to see available voices")
+            return
+
+        try:
+            language, voice_id = voice_spec.split('.', 1)
+        except ValueError:
+            print(f"❌ Invalid format. Use: language.voice_id")
+            return
+
+        # Stop any current voice activity
+        if self.voice_mode_active:
+            self._voice_stop_callback()
+            was_active = True
+        else:
+            was_active = False
+
+        # Set the specific voice
+        try:
+            success = self.voice_manager.set_voice(language, voice_id)
+            if success:
+                # Update current language to match the voice
+                self.current_language = language
+
+                # Get voice info for confirmation
+                voice_info = self.voice_manager.VOICE_CATALOG.get(language, {}).get(voice_id, {})
+                lang_name = self.voice_manager.get_language_name(language)
+
+                print(f"✅ Voice changed successfully!")
+                print(f"   Language: {lang_name} ({language})")
+                print(f"   Voice: {voice_id}")
+                if voice_info:
+                    quality_icon = "✨" if voice_info.get('quality') == 'premium' else "🔧"
+                    gender_icon = {"male": "👨", "female": "👩", "multiple": "👥"}.get(voice_info.get('gender'), "🗣️")
+                    print(f"   Details: {quality_icon} {gender_icon} {voice_info.get('accent', 'Unknown accent')}")
+
+                # Test the new voice
+                test_messages = {
+                    'en': "Voice changed to English.",
+                    'fr': "Voix changée en français.",
+                    'es': "Voz cambiada al español.",
+                    'de': "Stimme auf Deutsch geändert.",
+                    'it': "Voce cambiata in italiano."
+                }
+                test_msg = test_messages.get(language, "Voice changed successfully.")
+                self.voice_manager.speak(test_msg)
+
+                # Restart voice mode if it was active
+                if was_active:
+                    self.do_voice(self.voice_mode)
+            else:
+                print(f"❌ Failed to set voice: {voice_spec}")
+                print(f"   Run '/setvoice' to see available voices")
+
+        except Exception as e:
+            print(f"❌ Error setting voice: {e}")
+            if self.debug_mode:
+                import traceback
+                traceback.print_exc()
+
+    def do_lang_info(self, args):
+        """Show current language information."""
+        info = self.voice_manager.get_language_info()
+        print(f"\n{Colors.CYAN}Current Language Information:{Colors.END}")
+        print(f"  Language: {info['name']} ({info['code']})")
+        print(f"  Model: {info['model']}")
+        print(f"  Available models: {list(info['available_models'].keys())}")
+
+        # Check if XTTS supports multiple languages
+        if 'xtts' in (info['model'] or '').lower():
+            print(f"  ✅ Supports multilingual synthesis")
+        else:
+            print(f"  ℹ️ Monolingual model")
+
+    def do_list_languages(self, args):
+        """List all supported languages."""
+        print(f"\n{Colors.CYAN}Supported Languages:{Colors.END}")
+        for lang in self.voice_manager.get_supported_languages():
+            name = self.voice_manager.get_language_name(lang)
+            current = " (current)" if lang == self.current_language else ""
+            print(f"  {lang} - {name}{current}")
+
     def do_voice(self, arg):
         """Control voice input mode.
         
@@ -554,6 +728,10 @@ class VoiceREPL(cmd.Cmd):
         print("  /clear              Clear history")
         print("  /tts on|off         Toggle TTS")
         print("  /voice <mode>       Voice input: off|full|wait|stop|ptt")
+        print("  /language <lang>    Switch voice language (en, fr, es, de, it)")
+        print("  /setvoice [id]      List voices or set specific voice (lang.voice_id)")
+        print("  /lang_info          Show current language information")
+        print("  /list_languages     List all supported languages")
         print("  /speed <number>     Set TTS speed (0.5-2.0, default: 1.0, pitch preserved)")
         print("  /tts_model <model>  Switch TTS model: vits(best)|fast_pitch|glow-tts|tacotron2-DDC")
         print("  /whisper <model>    Switch Whisper model: tiny|base|small|medium|large")
@@ -831,10 +1009,15 @@ def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(description="AbstractVoice CLI Example")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    parser.add_argument("--api", default="http://localhost:11434/api/chat", 
+    parser.add_argument("--api", default="http://localhost:11434/api/chat",
                       help="LLM API URL")
-    parser.add_argument("--model", default="granite3.3:2b", 
+    parser.add_argument("--model", default="granite3.3:2b",
                       help="LLM model name")
+    parser.add_argument("--language", "--lang", default="en",
+                      choices=["en", "fr", "es", "de", "it", "ru", "multilingual"],
+                      help="Voice language (en=English, fr=French, es=Spanish, de=German, it=Italian, ru=Russian, multilingual=All)")
+    parser.add_argument("--tts-model",
+                      help="Specific TTS model to use (overrides language default)")
     return parser.parse_args()
 
 
@@ -844,11 +1027,13 @@ def main():
         # Parse command line arguments
         args = parse_args()
         
-        # Initialize and run REPL
+        # Initialize and run REPL with language support
         repl = VoiceREPL(
             api_url=args.api,
             model=args.model,
-            debug_mode=args.debug
+            debug_mode=args.debug,
+            language=args.language,
+            tts_model=args.tts_model
         )
         repl.cmdloop()
     except KeyboardInterrupt:

abstractvoice/examples/voice_cli.py

@@ -13,20 +13,25 @@ def parse_args():
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(description="AbstractVoice Voice Mode")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
-    parser.add_argument("--api", default="http://localhost:11434/api/chat", 
+    parser.add_argument("--api", default="http://localhost:11434/api/chat",
                       help="LLM API URL")
-    parser.add_argument("--model", default="granite3.3:2b", 
+    parser.add_argument("--model", default="granite3.3:2b",
                       help="LLM model name")
     parser.add_argument("--whisper", default="tiny",
                       help="Whisper model to use (tiny, base, small, medium, large)")
     parser.add_argument("--no-listening", action="store_true",
                       help="Disable speech-to-text (listening), TTS still works")
-    parser.add_argument("--system", 
+    parser.add_argument("--system",
                       help="Custom system prompt")
     parser.add_argument("--temperature", type=float, default=0.4,
                       help="Set temperature (0.0-2.0) for the LLM")
     parser.add_argument("--max-tokens", type=int, default=4096,
                       help="Set maximum tokens for the LLM response")
+    parser.add_argument("--language", "--lang", default="en",
+                      choices=["en", "fr", "es", "de", "it", "ru", "multilingual"],
+                      help="Voice language (en=English, fr=French, es=Spanish, de=German, it=Italian, ru=Russian, multilingual=All)")
+    parser.add_argument("--tts-model",
+                      help="Specific TTS model to use (overrides language default)")
     return parser.parse_args()
 
 def main():
@@ -35,13 +40,22 @@ def main():
         # Parse command line arguments
         args = parse_args()
         
-        print("Starting AbstractVoice voice interface...")
+        # Show language information
+        language_names = {
+            'en': 'English', 'fr': 'French', 'es': 'Spanish',
+            'de': 'German', 'it': 'Italian', 'ru': 'Russian',
+            'multilingual': 'Multilingual'
+        }
+        lang_name = language_names.get(args.language, args.language)
+        print(f"Starting AbstractVoice voice interface ({lang_name})...")
         
-        # Initialize REPL
+        # Initialize REPL with language support
         repl = VoiceREPL(
             api_url=args.api,
             model=args.model,
-            debug_mode=args.debug
+            debug_mode=args.debug,
+            language=args.language,
+            tts_model=args.tts_model
         )
         
         # Set custom system prompt if provided