lollms-client 1.4.1__py3-none-any.whl → 1.7.10__py3-none-any.whl

lollms_client/lollms_tts_binding.py

@@ -1,15 +1,16 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
 import yaml
 from ascii_colors import trace_exception
+from lollms_client.lollms_base_binding import LollmsBaseBinding
 
-class LollmsTTSBinding(ABC):
+class LollmsTTSBinding(LollmsBaseBinding):
     def __init__(self,
                  binding_name: str = "unknown",
                  **kwargs):
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
         self.settings = kwargs
 
     @abstractmethod
@@ -49,26 +50,21 @@ class LollmsTTSBindingManager:
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to load TTS binding {binding_name}: {str(e)}")
-
-    def create_binding(self,
+    def create_binding(self, 
                       binding_name: str,
-                      config: Dict[str, Any] = None) -> Optional[LollmsTTSBinding]:
-        if config is None:
-            config = {}
-            
+                      **kwargs) -> Optional[LollmsTTSBinding]:
+        """
+        Create an instance of a specific binding.
+        """
         if binding_name not in self.available_bindings:
             self._load_binding(binding_name)
-
+        
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
-            try:
-                return binding_class(**config)
-            except Exception as e:
-                trace_exception(e)
-                print(f"Failed to instantiate TTS binding {binding_name}: {str(e)}")
-                return None
+            return binding_class(binding_name=binding_name, **kwargs)
         return None
 
+
     @staticmethod
     def _get_fallback_description(binding_name: str) -> Dict:
         return {
@@ -124,4 +120,19 @@ class LollmsTTSBindingManager:
 def get_available_bindings(tts_bindings_dir: Union[str, Path] = None) -> List[Dict]:
     if tts_bindings_dir is None:
         tts_bindings_dir = Path(__file__).resolve().parent / "tts_bindings"
-    return LollmsTTSBindingManager.get_bindings_list(tts_bindings_dir)
+    return LollmsTTSBindingManager.get_bindings_list(tts_bindings_dir)
+
+def list_binding_models(stt_binding_name: str, stt_binding_config: Optional[Dict[str, any]]|None = None, stt_bindings_dir: str|Path = Path(__file__).parent / "stt_bindings") -> List[Dict]:
+    """
+    Lists all available models for a specific binding.
+    """
+    binding = LollmsTTSBindingManager(stt_bindings_dir).create_binding(
+        binding_name=stt_binding_name,
+        **{
+            k: v
+            for k, v in (stt_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.list_models() if binding else []

lollms_client/lollms_ttv_binding.py

@@ -1,37 +1,26 @@
 # lollms_client/lollms_ttv_binding.py
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 import importlib
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
 from ascii_colors import trace_exception
+from lollms_client.lollms_base_binding import LollmsBaseBinding
 
-class LollmsTTVBinding(ABC):
+class LollmsTTVBinding(LollmsBaseBinding):
     """Abstract base class for all LOLLMS Text-to-Video bindings."""
 
     def __init__(self,
-                 binding_name:str="unknown"):
+                 binding_name:str="unknown",
+                 **kwargs):
         """
         Initialize the LollmsTTVBinding base class.
-
-        Args:
-            binding_name (Optional[str]): The binding name
         """
-        self.binding_name = binding_name
+        super().__init__(binding_name=binding_name, **kwargs)
 
     @abstractmethod
     def generate_video(self, prompt: str, **kwargs) -> bytes:
         """
         Generates video data from the provided text prompt.
-
-        Args:
-            prompt (str): The text prompt describing the desired video content.
-            **kwargs: Additional binding-specific parameters (e.g., duration, fps, style, seed).
-
-        Returns:
-            bytes: The generated video data (e.g., in MP4 format).
-
-        Raises:
-            Exception: If video generation fails.
         """
         pass
 
@@ -39,12 +28,6 @@ class LollmsTTVBinding(ABC):
     def list_models(self, **kwargs) -> List[str]:
         """
         Lists the available TTV models or services supported by the binding.
-
-        Args:
-            **kwargs: Additional binding-specific parameters.
-
-        Returns:
-            List[str]: A list of available model/service identifiers.
         """
         pass
 
@@ -52,13 +35,6 @@ class LollmsTTVBindingManager:
     """Manages TTV binding discovery and instantiation."""
 
     def __init__(self, ttv_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "ttv_bindings"):
-        """
-        Initialize the LollmsTTVBindingManager.
-
-        Args:
-            ttv_bindings_dir (Union[str, Path]): Directory containing TTV binding implementations.
-                                                 Defaults to the "ttv_bindings" subdirectory.
-        """
         self.ttv_bindings_dir = Path(ttv_bindings_dir)
         self.available_bindings = {}
 
@@ -79,13 +55,6 @@ class LollmsTTVBindingManager:
                       **kwargs) -> Optional[LollmsTTVBinding]:
         """
         Create an instance of a specific TTV binding.
-
-        Args:
-            binding_name (str): Name of the TTV binding to create.
-            **kwargs: Additional parameters specific to the binding's __init__.
-
-        Returns:
-            Optional[LollmsTTVBinding]: Binding instance or None if creation failed.
         """
         if binding_name not in self.available_bindings:
             self._load_binding(binding_name)
@@ -93,7 +62,7 @@ class LollmsTTVBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(**kwargs)
+                return binding_class(binding_name=binding_name, **kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTV binding {binding_name}: {str(e)}")
@@ -103,9 +72,22 @@ class LollmsTTVBindingManager:
     def get_available_bindings(self) -> list[str]:
         """
         Return list of available TTV binding names based on subdirectories.
-
-        Returns:
-            list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.ttv_bindings_dir.iterdir()
-                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+
+def list_binding_models(ttv_binding_name: str, ttv_binding_config: Optional[Dict[str, any]]|None = None, ttv_bindings_dir: str|Path = Path(__file__).parent / "ttv_bindings") -> List[Dict]:
+    """
+    Lists all available models for a specific binding.
+    """
+    binding = LollmsTTVBindingManager(ttv_bindings_dir).create_binding(
+        binding_name=ttv_binding_name,
+        **{
+            k: v
+            for k, v in (ttv_binding_config or {}).items()
+            if k != "binding_name"
+        }
+    )
+
+    return binding.list_models() if binding else []

lollms_client/lollms_types.py

@@ -41,8 +41,10 @@ class MSG_TYPE(Enum):
     MSG_TYPE_OBSERVATION            = 23# the ai shows its reasoning
 
     MSG_TYPE_ERROR                  = 24#a severe error hapened
-    MSG_TYPE_GENERATING_TITLE_START = 25#a severe error hapened
-    MSG_TYPE_GENERATING_TITLE_END   = 26#a severe error hapened
+    MSG_TYPE_GENERATING_TITLE_START = 25#title generation started
+    MSG_TYPE_GENERATING_TITLE_END   = 26#title generation done
+
+    MSG_TYPE_SOURCES_LIST           = 27# List of sources provided
 
 
 class SENDER_TYPES(Enum):

lollms_client/stt_bindings/whisper/__init__.py

@@ -3,6 +3,8 @@ import os
 from pathlib import Path
 from typing import Optional, List, Union, Dict, Any
 from ascii_colors import trace_exception, ASCIIColors
+import time
+import filelock
 
 # --- Package Management and Conditional Imports ---
 _whisper_installed = False
@@ -25,7 +27,7 @@ try:
         preferred_torch_device_for_install = "mps" # or keep cpu if mps detection is later
 
     torch_pkgs = ["torch", "torchaudio","xformers"]
-    audiocraft_core_pkgs = ["openai-whisper"]
+    audiocraft_core_pkgs = ["openai-whisper", "filelock"]
 
     torch_index_url = None
     if preferred_torch_device_for_install == "cuda":
@@ -67,7 +69,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
     """
 
     # Standard Whisper model sizes
-    WHISPER_MODEL_SIZES = ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large", "large-v1", "large-v2", "large-v3"]
+    WHISPER_MODEL_SIZES = ["turbo"]
 
     def __init__(self,
                  **kwargs # To catch any other LollmsSTTBinding standard args
@@ -76,18 +78,19 @@ class WhisperSTTBinding(LollmsSTTBinding):
         Initialize the Whisper STT binding.
 
         Args:
-            model_name (str): The Whisper model size to use (e.g., "tiny", "base", "small", "medium", "large", "large-v2", "large-v3").
-                              Defaults to "base".
+            model_name (str): The Whisper model size to use (e.g., "turbo").
+                              Defaults to "turno".
             device (Optional[str]): The device to run the model on ("cpu", "cuda", "mps").
                                     If None, `torch` will attempt to auto-detect. Defaults to None.
         """
         super().__init__(binding_name="whisper") # Not applicable
+        self.default_model_name = kwargs.get("model_name", "turbo")
 
         if not _whisper_installed:
             raise ImportError(f"Whisper STT binding dependencies not met. Please ensure 'openai-whisper' and 'torch' are installed. Error: {_whisper_installation_error}")
 
-        self.device = kwargs.get("device",None)
-        if self.device is None: # Auto-detect if not specified
+        self.device = kwargs.get("device", None)
+        if self.device is None or self.device == "": # Auto-detect if not specified or empty
             if torch.cuda.is_available():
                 self.device = "cuda"
             elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available(): # For Apple Silicon
@@ -95,37 +98,115 @@ class WhisperSTTBinding(LollmsSTTBinding):
             else:
                 self.device = "cpu"
         
+        # Validate device string
+        if not self.device or self.device.strip() == "":
+            ASCIIColors.warning("Device was empty or invalid, defaulting to 'cpu'")
+            self.device = "cpu"
+        
         ASCIIColors.info(f"WhisperSTTBinding: Using device '{self.device}'.")
         
         self.loaded_model_name = None
         self.model = None
-        self._load_whisper_model(kwargs.get("model_name", "base")) # Default to "base" if not specified
+        try:
+            self._load_whisper_model(kwargs.get("model_name", "turbo")) # Default to "turbo" if not specified
+        except Exception as e:
+            pass
+
+
+    def _get_whisper_cache_dir(self) -> Path:
+        """Get the Whisper cache directory."""
+        # Whisper uses the same cache location as specified in its code
+        cache_dir = os.getenv("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
+        return Path(cache_dir) / "whisper"
 
+    def _is_model_downloaded(self, model_name: str) -> bool:
+        """Check if a Whisper model is already downloaded and valid."""
+        cache_dir = self._get_whisper_cache_dir()
+        # Whisper models are stored as {model_name}.pt
+        model_file = cache_dir / f"{model_name}.pt"
+        
+        if not model_file.exists():
+            return False
+        
+        # Check if file size is reasonable (at least 1MB to catch partial downloads)
+        try:
+            file_size = model_file.stat().st_size
+            if file_size < 1_000_000:  # Less than 1MB is likely corrupted
+                ASCIIColors.warning(f"Model file {model_file} appears corrupted (size: {file_size} bytes). Will re-download.")
+                return False
+        except Exception as e:
+            ASCIIColors.warning(f"Could not check model file size: {e}")
+            return False
+        
+        return True
 
     def _load_whisper_model(self, model_name_to_load: str):
-        """Loads or reloads the Whisper model."""
-        if model_name_to_load not in self.WHISPER_MODEL_SIZES:
+        """Loads or reloads the Whisper model with file locking to prevent concurrent downloads."""
+        if model_name_to_load not in whisper.available_models():
             ASCIIColors.warning(f"'{model_name_to_load}' is not a standard Whisper model size. Attempting to load anyway. Known sizes: {self.WHISPER_MODEL_SIZES}")
 
         if self.model is not None and self.loaded_model_name == model_name_to_load:
             ASCIIColors.info(f"Whisper model '{model_name_to_load}' already loaded.")
             return
 
+        # Get the cache directory and create lock file path
+        cache_dir = self._get_whisper_cache_dir()
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        lock_file = cache_dir / f"{model_name_to_load}.lock"
+        model_file = cache_dir / f"{model_name_to_load}.pt"
+
         ASCIIColors.info(f"Loading Whisper model: '{model_name_to_load}' on device '{self.device}'...")
+        
+        # Use file lock to prevent concurrent downloads
+        lock = filelock.FileLock(lock_file, timeout=300)  # 5 minute timeout
+        
         try:
-            # Whisper's load_model might download the model if not already cached.
-            # Cache is typically in ~/.cache/whisper
-            self.model = whisper.load_model(model_name_to_load, device=self.device)
-            self.loaded_model_name = model_name_to_load
-            self.model_name = model_name_to_load # Update the binding's current model_name
-            ASCIIColors.green(f"Whisper model '{model_name_to_load}' loaded successfully.")
+            with lock:
+                # Check if model is already downloaded and valid
+                if self._is_model_downloaded(model_name_to_load):
+                    ASCIIColors.info(f"Model '{model_name_to_load}' already downloaded, loading from cache...")
+                else:
+                    ASCIIColors.info(f"Downloading model '{model_name_to_load}' (this process has the lock)...")
+                    # If model file exists but is corrupted, delete it first
+                    if model_file.exists():
+                        try:
+                            ASCIIColors.warning(f"Removing corrupted model file: {model_file}")
+                            model_file.unlink()
+                        except Exception as e:
+                            ASCIIColors.error(f"Could not remove corrupted model file: {e}")
+                
+                # Load the model (will download if not cached)
+                self.model = whisper.load_model(model_name_to_load, device=self.device)
+                self.loaded_model_name = model_name_to_load
+                self.model_name = model_name_to_load
+                ASCIIColors.green(f"Whisper model '{model_name_to_load}' loaded successfully.")
+                
+        except filelock.Timeout:
+            error_msg = f"Timeout waiting for model '{model_name_to_load}' download lock. Another process may be downloading."
+            ASCIIColors.error(error_msg)
+            self.model = None
+            self.loaded_model_name = None
+            raise RuntimeError(error_msg)
         except Exception as e:
             self.model = None
             self.loaded_model_name = None
             ASCIIColors.error(f"Failed to load Whisper model '{model_name_to_load}': {e}")
             trace_exception(e)
-            # Re-raise critical error for initialization or model switching
+            # If loading failed, try to clean up potentially corrupted file
+            if model_file.exists():
+                try:
+                    ASCIIColors.warning(f"Cleaning up potentially corrupted model file after error...")
+                    model_file.unlink()
+                except Exception as cleanup_error:
+                    ASCIIColors.error(f"Could not clean up model file: {cleanup_error}")
             raise RuntimeError(f"Failed to load Whisper model '{model_name_to_load}'") from e
+        finally:
+            # Clean up lock file if it exists and is not locked
+            try:
+                if lock_file.exists() and not lock.is_locked:
+                    lock_file.unlink()
+            except Exception:
+                pass  # Ignore cleanup errors
 
 
     def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
@@ -149,6 +230,10 @@ class WhisperSTTBinding(LollmsSTTBinding):
             RuntimeError: If the Whisper model is not loaded or transcription fails.
             Exception: For other errors during transcription.
         """
+        if not self.model:
+            self._load_whisper_model(self.default_model_name)
+
+            
         audio_file = Path(audio_path)
         if not audio_file.exists():
             raise FileNotFoundError(f"Audio file not found at: {audio_path}")
@@ -191,8 +276,8 @@ class WhisperSTTBinding(LollmsSTTBinding):
             trace_exception(e)
             raise Exception(f"Whisper transcription error: {e}") from e
 
-
-    def list_models(self, **kwargs) -> List[str]:
+    @staticmethod
+    def list_models(**kwargs) -> List[str]:
         """
         Lists the available standard Whisper model sizes.
 
@@ -202,7 +287,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         Returns:
             List[str]: A list of available Whisper model size identifiers.
         """
-        return self.WHISPER_MODEL_SIZES.copy() # Return a copy
+        return whisper.available_models() # Return a copy
 
     def __del__(self):
         """Clean up: Unload the model to free resources."""
@@ -252,7 +337,7 @@ if __name__ == '__main__':
     else:
         try:
             ASCIIColors.cyan("\n--- Initializing WhisperSTTBinding (model: 'tiny') ---")
-            # Using 'tiny' model for faster testing. Change to 'base' or 'small' for better quality.
+            # Using 'tiny' model for faster testing. Change to 'turbo' or 'small' for better quality.
             stt_binding = WhisperSTTBinding(model_name="tiny")
 
             ASCIIColors.cyan("\n--- Listing available Whisper models ---")
@@ -269,9 +354,9 @@ if __name__ == '__main__':
             # print(f"Transcription (tiny, lang='en'): '{transcription_lang_hint}'")
 
             # Test switching model dynamically (optional, will re-download/load if different)
-            # ASCIIColors.cyan(f"\n--- Transcribing '{test_audio_file.name}' by switching to 'base' model ---")
-            # transcription_base = stt_binding.transcribe_audio(test_audio_file, model="base")
-            # print(f"Transcription (base): '{transcription_base}'")
+            # ASCIIColors.cyan(f"\n--- Transcribing '{test_audio_file.name}' by switching to 'turbo' model ---")
+            # transcription_base = stt_binding.transcribe_audio(test_audio_file, model="turbo")
+            # print(f"Transcription (turbo): '{transcription_base}'")
 
 
         except ImportError as e_imp:

lollms_client/stt_bindings/whispercpp/__init__.py

@@ -31,6 +31,8 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
         n_threads = kwargs.get("n_threads", 4)
         extra_whisper_args = kwargs.get("extra_whisper_args", [])  # e.g. ["--no-timestamps"]
 
+        self.default_model_name = "base"
+
         # --- Validate FFMPEG ---
         self.ffmpeg_exe = None
         if ffmpeg_path:
@@ -376,4 +378,8 @@ if __name__ == '__main__':
                     TEST_MODELS_SEARCH_DIR.rmdir()
             except OSError: pass # Ignore if not empty or other issues
 
-    ASCIIColors.yellow("\n--- WhisperCppSTTBinding Test Finished ---")
+    ASCIIColors.yellow("\n--- WhisperCppSTTBinding Test Finished ---")
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        return ["base" , "small", "medium", "large"]
+