lollms-client 0.33.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

lollms_client/lollms_tti_binding.py

@@ -4,7 +4,7 @@ import importlib
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
 from ascii_colors import trace_exception
-
+import yaml
 class LollmsTTIBinding(ABC):
     """Abstract base class for all LOLLMS Text-to-Image bindings."""
 
@@ -58,6 +58,7 @@ class LollmsTTIBinding(ABC):
         """
         pass
 
+
     @abstractmethod
     def get_settings(self, **kwargs) -> Optional[Dict[str, Any]]:
         """
@@ -73,6 +74,11 @@ class LollmsTTIBinding(ABC):
         """
         pass
 
+    @abstractmethod
+    def listModels(self) -> list:
+        """Lists models"""
+        pass
+
     @abstractmethod
     def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
         """
@@ -139,7 +145,86 @@ class LollmsTTIBindingManager:
                 print(f"Failed to instantiate TTI binding {binding_name}: {str(e)}")
                 return None
         return None
+    def _get_fallback_description(binding_name: str) -> Dict:
+        """
+        Generates a default description dictionary for a binding without a description.yaml file.
+        """
+        return {
+            "binding_name": binding_name,
+            "title": binding_name.replace("_", " ").title(),
+            "author": "Unknown",
+            "creation_date": "N/A",
+            "last_update_date": "N/A",
+            "description": f"A binding for {binding_name}. No description.yaml file was found, so common parameters are shown as a fallback.",
+            "input_parameters": [
+                {
+                    "name": "model_name",
+                    "type": "str",
+                    "description": "The model name, ID, or filename to be used.",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "host_address",
+                    "type": "str",
+                    "description": "The host address of the service (for API-based bindings).",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "models_path",
+                    "type": "str",
+                    "description": "The path to the models directory (for local bindings).",
+                    "mandatory": False,
+                    "default": ""
+                },
+                {
+                    "name": "service_key",
+                    "type": "str",
+                    "description": "The API key or service key for authentication (if applicable).",
+                    "mandatory": False,
+                    "default": ""
+                }
+            ]
+        }
 
+    @staticmethod
+    def get_bindings_list(llm_bindings_dir: Union[str, Path]) -> List[Dict]:
+        """
+        Lists all available LLM bindings by scanning a directory, loading their
+        description.yaml file if present, or providing a default description.
+
+        Args:
+            llm_bindings_dir (Union[str, Path]): The path to the directory containing LLM binding folders.
+
+        Returns:
+            List[Dict]: A list of dictionaries, each describing a binding.
+        """
+        bindings_dir = Path(llm_bindings_dir)
+        if not bindings_dir.is_dir():
+            return []
+
+        bindings_list = []
+        for binding_folder in bindings_dir.iterdir():
+            if binding_folder.is_dir() and (binding_folder / "__init__.py").exists():
+                binding_name = binding_folder.name
+                description_file = binding_folder / "description.yaml"
+                
+                binding_info = {}
+                if description_file.exists():
+                    try:
+                        with open(description_file, 'r', encoding='utf-8') as f:
+                            binding_info = yaml.safe_load(f)
+                        binding_info['binding_name'] = binding_name
+                    except Exception as e:
+                        print(f"Error loading description.yaml for {binding_name}: {e}")
+                        binding_info = LollmsTTIBindingManager._get_fallback_description(binding_name)
+                else:
+                    binding_info = LollmsTTIBindingManager._get_fallback_description(binding_name)
+                
+                bindings_list.append(binding_info)
+
+        return sorted(bindings_list, key=lambda b: b.get('title', b['binding_name']))
     def get_available_bindings(self) -> list[str]:
         """
         Return list of available TTI binding names based on subdirectories.
@@ -148,4 +233,24 @@ class LollmsTTIBindingManager:
             list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.tti_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 get_available_bindings(tti_bindings_dir: Union[str, Path] = None) -> List[Dict]:
+    """
+    Lists all available LLM bindings with their detailed descriptions.
+
+    This function serves as a primary entry point for discovering what bindings
+    are available and how to configure them.
+
+    Args:
+        llm_bindings_dir (Union[str, Path], optional): 
+            The path to the LLM bindings directory. If None, it defaults to the
+            'llm_bindings' subdirectory relative to this file. 
+            Defaults to None.
+
+    Returns:
+        List[Dict]: A list of dictionaries, each describing a binding.
+    """
+    if tti_bindings_dir is None:
+        tti_bindings_dir = Path(__file__).parent / "tti_bindings"
+    return LollmsTTIBindingManager.get_bindings_list(tti_bindings_dir)

lollms_client/mcp_bindings/local_mcp/__init__.py

@@ -21,15 +21,16 @@ class LocalMCPBinding(LollmsMCPBinding):
     """
 
     def __init__(self,
-                 tools_folder_path: str|Path|None = None):
+                 **kwargs: Any
+                 ):
         """
         Initialize the LocalMCPBinding.
 
         Args:
-            binding_name (str): The name of this binding.
             tools_folder_path (str|Path) a folder where to find tools
         """
         super().__init__(binding_name="LocalMCP")
+        tools_folder_path = kwargs.get("tools_folder_path")
         if tools_folder_path:
             try:
                 self.tools_folder_path: Optional[Path] = Path(tools_folder_path)

lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -27,8 +27,8 @@ class RemoteMCPBinding(LollmsMCPBinding):
     Tools from all connected servers are aggregated and prefixed with the server's alias.
     """
     def __init__(self,
-                 servers_infos: Dict[str, Dict[str, Any]],
-                 **other_config_params: Any):
+                 **kwargs: Any
+                 ):
         """
         Initializes the binding to connect to multiple MCP servers.
 
@@ -41,10 +41,11 @@ class RemoteMCPBinding(LollmsMCPBinding):
                     "main_server": {"server_url": "http://localhost:8787", "auth_config": {}},
                     "experimental_server": {"server_url": "http://test.server:9000"}
                 }
-            **other_config_params (Any): Additional configuration parameters.
+            **kwargs (Any): Additional configuration parameters.
         """
         super().__init__(binding_name="remote_mcp")
         # initialization in case no servers are present
+        servers_infos: Dict[str, Dict[str, Any]] = kwargs.get("servers_infos", {})
         self.servers = None
         if not MCP_LIBRARY_AVAILABLE:
             ASCIIColors.error(f"{self.binding_name}: MCP library not available. This binding will be disabled.")
@@ -56,8 +57,8 @@ class RemoteMCPBinding(LollmsMCPBinding):
 
         ### NEW: Store the overall configuration
         self.config = {
-            "servers_infos": servers_infos,
-            **other_config_params
+            "servers_infos": kwargs.get("servers_infos"),
+            **kwargs
         }
 
         ### NEW: State management for multiple servers.

lollms_client/mcp_bindings/standard_mcp/__init__.py

@@ -48,12 +48,10 @@ class StandardMCPBinding(LollmsMCPBinding):
     """
 
     def __init__(self,
-                 initial_servers: Optional[Dict[str, Dict[str, Any]]] = None,
-                 **other_config_params: Any):
+                 **kwargs: Any):
         super().__init__(binding_name="standard_mcp")
-
-        self.config = {"initial_servers": initial_servers if initial_servers else {}}
-        self.config.update(other_config_params)
+        self.config = kwargs
+        initial_servers = kwargs.get("initial_servers", {})
 
         self._server_configs: Dict[str, Dict[str, Any]] = {}
         # Type hint with ClientSession, actual obj if MCP_LIBRARY_AVAILABLE

lollms_client/stt_bindings/lollms/__init__.py

@@ -14,10 +14,8 @@ class LollmsSTTBinding_Impl(LollmsSTTBinding):
     """Concrete implementation of the LollmsSTTBinding for the standard LOLLMS server."""
 
     def __init__(self,
-                 host_address: Optional[str] = "http://localhost:9600", # Default LOLLMS host
-                 model_name: Optional[str] = None, # Default model (server decides if None)
-                 service_key: Optional[str] = None,
-                 verify_ssl_certificate: bool = True):
+                 **kwargs
+                 ):
         """
         Initialize the LOLLMS STT binding.
 
@@ -28,10 +26,10 @@ class LollmsSTTBinding_Impl(LollmsSTTBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates.
         """
         super().__init__("lollms")
-        self.host_address=host_address
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
+        self.host_address=kwargs.get("host_address")
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate")
 
     def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
         """

lollms_client/stt_bindings/whisper/__init__.py

@@ -70,8 +70,6 @@ class WhisperSTTBinding(LollmsSTTBinding):
     WHISPER_MODEL_SIZES = ["tiny", "tiny.en", "base", "base.en", "small", "small.en", "medium", "medium.en", "large", "large-v1", "large-v2", "large-v3"]
 
     def __init__(self,
-                 model_name: str = "base", # Default Whisper model size
-                 device: Optional[str] = None, # "cpu", "cuda", "mps", or None for auto
                  **kwargs # To catch any other LollmsSTTBinding standard args
                  ):
         """
@@ -88,7 +86,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         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 = device
+        self.device = kwargs.get("device",None)
         if self.device is None: # Auto-detect if not specified
             if torch.cuda.is_available():
                 self.device = "cuda"
@@ -101,7 +99,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         
         self.loaded_model_name = None
         self.model = None
-        self._load_whisper_model(model_name)
+        self._load_whisper_model(kwargs.get("model_name", "base")) # Default to "base" if not specified
 
 
     def _load_whisper_model(self, model_name_to_load: str):

lollms_client/stt_bindings/whispercpp/__init__.py

@@ -18,20 +18,19 @@ DEFAULT_WHISPERCPP_EXE_NAMES = ["main", "whisper-cli", "whisper"] # Common names
 
 class WhisperCppSTTBinding(LollmsSTTBinding):
     def __init__(self,
-                 model_path: Union[str, Path], # Path to the GGUF Whisper model
-                 whispercpp_exe_path: Optional[Union[str, Path]] = None, # Path to whisper.cpp executable
-                 ffmpeg_path: Optional[Union[str, Path]] = None, # Path to ffmpeg executable (if not in PATH)
-                 models_search_path: Optional[Union[str, Path]] = None, # Optional dir to scan for more models
-                 default_language: str = "auto",
-                 n_threads: int = 4,
-                 # Catch LollmsSTTBinding standard args even if not directly used by this local binding
-                 host_address: Optional[str] = None, # Not used for local binding
-                 service_key: Optional[str] = None, # Not used for local binding
-                 verify_ssl_certificate: bool = True, # Not used for local binding
                  **kwargs): # Catch-all for future compatibility or specific whisper.cpp params
 
-        super().__init__(binding_name="whispercpp") 
-        
+        super().__init__(binding_name="whispercpp")
+
+        # --- Extract values from kwargs with defaults ---
+        model_path = kwargs.get("model_path")
+        whispercpp_exe_path = kwargs.get("whispercpp_exe_path")
+        ffmpeg_path = kwargs.get("ffmpeg_path")
+        models_search_path = kwargs.get("models_search_path")
+        default_language = kwargs.get("default_language", "auto")
+        n_threads = kwargs.get("n_threads", 4)
+        extra_whisper_args = kwargs.get("extra_whisper_args", [])  # e.g. ["--no-timestamps"]
+
         # --- Validate FFMPEG ---
         self.ffmpeg_exe = None
         if ffmpeg_path:
@@ -42,7 +41,7 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                 raise FileNotFoundError(f"Provided ffmpeg_path '{ffmpeg_path}' not found or not executable.")
         else:
             self.ffmpeg_exe = shutil.which("ffmpeg")
-        
+
         if not self.ffmpeg_exe:
             ASCIIColors.warning("ffmpeg not found in PATH or explicitly provided. Audio conversion will not be possible for non-WAV files or incompatible WAV files.")
             ASCIIColors.warning("Please install ffmpeg and ensure it's in your system's PATH, or provide ffmpeg_path argument.")
@@ -63,7 +62,7 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                     self.whispercpp_exe = found_path
                     ASCIIColors.info(f"Found whisper.cpp executable via PATH: {self.whispercpp_exe}")
                     break
-        
+
         if not self.whispercpp_exe:
             raise FileNotFoundError(
                 f"Whisper.cpp executable (tried: {', '.join(DEFAULT_WHISPERCPP_EXE_NAMES)}) not found in PATH or explicitly provided. "
@@ -79,11 +78,11 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
                 self.model_path = Path(models_search_path, self.model_path).resolve()
             else:
                 raise FileNotFoundError(f"Whisper GGUF model file not found at '{self.model_path}'. Also checked in models_search_path if applicable.")
-        
+
         self.models_search_path = Path(models_search_path).resolve() if models_search_path else None
         self.default_language = default_language
         self.n_threads = n_threads
-        self.extra_whisper_args = kwargs.get("extra_whisper_args", []) # e.g. ["--no-timestamps"]
+        self.extra_whisper_args = extra_whisper_args
 
         ASCIIColors.green(f"WhisperCppSTTBinding initialized with model: {self.model_path}")
 

lollms_client/tti_bindings/dalle/__init__.py

@@ -35,22 +35,11 @@ DALLE_MODELS = {
         "max_prompt_length": 4000 # Characters
     }
 }
-
 class DalleTTIBinding_Impl(LollmsTTIBinding):
     """
     Concrete implementation of LollmsTTIBinding for OpenAI's DALL-E API.
     """
-
-    def __init__(self,
-                 api_key: Optional[str] = None, # Can be None to check env var
-                 model_name: str = "dall-e-3", # Default to DALL-E 3
-                 default_size: Optional[str] = None, # e.g. "1024x1024"
-                 default_quality: Optional[str] = None, # "standard" or "hd" (DALL-E 3)
-                 default_style: Optional[str] = None, # "vivid" or "natural" (DALL-E 3)
-                 host_address: str = DALLE_API_HOST, # OpenAI API host
-                 verify_ssl_certificate: bool = True,
-                 **kwargs # To catch any other lollms_client specific params like service_key/client_id
-                 ):
+    def __init__(self, **kwargs):
         """
         Initialize the DALL-E TTI binding.
 
@@ -70,44 +59,58 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         """
         super().__init__(binding_name="dalle")
 
-        resolved_api_key = api_key
+        # Extract parameters from kwargs, providing defaults
+        self.api_key = kwargs.get("service_key")
+        self.model_name = kwargs.get("model_name")
+        self.default_size = kwargs.get("default_size")
+        self.default_quality = kwargs.get("default_quality")
+        self.default_style = kwargs.get("default_style")
+        self.host_address = kwargs.get("host_address", DALLE_API_HOST)  # Provide default
+        self.verify_ssl_certificate = kwargs.get("verify_ssl_certificate", True) # Provide default
+
+        # Resolve API key from kwargs or environment variable
+        resolved_api_key = self.api_key
         if not resolved_api_key:
             ASCIIColors.info(f"API key not provided directly, checking environment variable '{OPENAI_API_KEY_ENV_VAR}'...")
             resolved_api_key = os.environ.get(OPENAI_API_KEY_ENV_VAR)
 
         if not resolved_api_key:
             raise ValueError(f"OpenAI API key is required. Provide it directly or set the '{OPENAI_API_KEY_ENV_VAR}' environment variable.")
-        
+
         self.api_key = resolved_api_key
-        self.host_address = host_address
-        self.verify_ssl_certificate = verify_ssl_certificate
 
-        if model_name not in DALLE_MODELS:
-            raise ValueError(f"Unsupported DALL-E model: {model_name}. Supported models: {list(DALLE_MODELS.keys())}")
-        self.model_name = model_name
-        
+        # Model name validation
+        if not self.model_name:
+            ASCIIColors.warning("Model name is required.")
+        if self.model_name not in DALLE_MODELS:
+            ASCIIColors.warning(f"Unsupported DALL-E model: {self.model_name}. Supported models: {list(DALLE_MODELS.keys())}")
+            self.model_name = list(DALLE_MODELS.keys())[1]
+            ASCIIColors.warning(f"Defaulting to {self.model_name}")
+
         model_props = DALLE_MODELS[self.model_name]
 
-        # Set defaults from model_props, overridden by user-provided defaults
-        self.current_size = default_size or model_props["default_size"]
+        # Size
+        self.current_size = self.default_size or model_props["default_size"]
         if self.current_size not in model_props["sizes"]:
             raise ValueError(f"Unsupported size '{self.current_size}' for model '{self.model_name}'. Supported sizes: {model_props['sizes']}")
 
+        # Quality
         if model_props["supports_quality"]:
-            self.current_quality = default_quality or model_props["default_quality"]
+            self.current_quality = self.default_quality or model_props["default_quality"]
             if self.current_quality not in model_props["qualities"]:
                 raise ValueError(f"Unsupported quality '{self.current_quality}' for model '{self.model_name}'. Supported qualities: {model_props['qualities']}")
         else:
-            self.current_quality = None # Explicitly None if not supported
+            self.current_quality = None  # Explicitly None if not supported
 
+        # Style
         if model_props["supports_style"]:
-            self.current_style = default_style or model_props["default_style"]
+            self.current_style = self.default_style or model_props["default_style"]
             if self.current_style not in model_props["styles"]:
                 raise ValueError(f"Unsupported style '{self.current_style}' for model '{self.model_name}'. Supported styles: {model_props['styles']}")
         else:
-            self.current_style = None # Explicitly None if not supported
-        
-        # For potential lollms client specific features, if `service_key` is passed as `client_id`
+            self.current_style = None  # Explicitly None if not supported
+
+        # Client ID
         self.client_id = kwargs.get("service_key", kwargs.get("client_id", "dalle_client_user"))
 
 
@@ -430,4 +433,22 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         except Exception as e:
             trace_exception(e)
             ASCIIColors.error(f"Failed to apply settings due to an unexpected error: {e}")
-            return False
+            return False
+        
+    def listModels(self) -> list:
+        """Lists models"""
+        formatted_models=[
+            {
+                'model_name': "dall-e-2",
+                'display_name': "Dall-e 2",
+                'description': "Dalle 2 model",
+                'owned_by': 'openai'
+            },
+            {
+            'model_name': "dall-e-3",
+            'display_name': "Dall-e 3",
+            'description': "Dalle 3 model",
+            'owned_by': 'openai'
+            }
+        ]
+        return formatted_models