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

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.0.0" # Updated version
+__version__ = "1.1.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -32,7 +32,7 @@ class LollmsClient():
     def __init__(self,
 
                  # Optional Modality Binding Names
-                 llm_binding_name: str = "lollms",
+                 llm_binding_name: Optional[str] = None,
                  tts_binding_name: Optional[str] = None,
                  tti_binding_name: Optional[str] = None,
                  stt_binding_name: Optional[str] = None,
@@ -106,21 +106,8 @@ class LollmsClient():
             ValueError: If the primary LLM binding cannot be created.
         """
         # --- LLM Binding Setup ---
-        self.llm_binding_manager = LollmsLLMBindingManager(llm_bindings_dir)
-        self.llm = self.llm_binding_manager.create_binding(
-            binding_name=llm_binding_name,
-            **{
-                k: v
-                for k, v in (llm_binding_config or {}).items()
-                if k != "binding_name"
-            }
-        )
-
-        if self.llm is None:
-            available = self.llm_binding_manager.get_available_bindings()
-            raise ValueError(f"Failed to create LLM binding: {llm_binding_name}. Available: {available}")
-
         # --- Modality Binding Setup ---
+        self.llm_binding_manager = LollmsLLMBindingManager(llm_bindings_dir)
         self.tts_binding_manager = LollmsTTSBindingManager(tts_bindings_dir)
         self.tti_binding_manager = LollmsTTIBindingManager(tti_bindings_dir)
         self.stt_binding_manager = LollmsSTTBindingManager(stt_bindings_dir)
@@ -128,6 +115,8 @@ class LollmsClient():
         self.ttm_binding_manager = LollmsTTMBindingManager(ttm_bindings_dir)
         self.mcp_binding_manager = LollmsMCPBindingManager(mcp_bindings_dir)
 
+
+        self.llm: Optional[LollmsLLMBinding] = None
         self.tts: Optional[LollmsTTSBinding] = None
         self.tti: Optional[LollmsTTIBinding] = None
         self.stt: Optional[LollmsSTTBinding] = None
@@ -135,6 +124,21 @@ class LollmsClient():
         self.ttm: Optional[LollmsTTMBinding] = None
         self.mcp: Optional[LollmsMCPBinding] = None
 
+
+        if llm_binding_name:
+            self.llm = self.llm_binding_manager.create_binding(
+                binding_name=llm_binding_name,
+                **{
+                    k: v
+                    for k, v in (llm_binding_config or {}).items()
+                    if k != "binding_name"
+                }
+            )
+
+            if self.llm is None:
+                available = self.llm_binding_manager.get_available_bindings()
+                ASCIIColors.warning(f"Failed to create LLM binding: {llm_binding_name}. Available: {available}")
+
         if tts_binding_name:
             self.tts = self.tts_binding_manager.create_binding(
                 binding_name=tts_binding_name,

lollms_client/lollms_llm_binding.py

@@ -380,7 +380,7 @@ class LollmsLLMBinding(ABC):
 class LollmsLLMBindingManager:
     """Manages binding discovery and instantiation"""
 
-    def __init__(self, llm_bindings_dir: str = "llm_bindings"):
+    def __init__(self, llm_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "llm_bindings"):
         """
         Initialize the LollmsLLMBindingManager.
 

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/tti_bindings/dalle/__init__.py

@@ -60,7 +60,7 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         super().__init__(binding_name="dalle")
 
         # Extract parameters from kwargs, providing defaults
-        self.api_key = kwargs.get("api_key")
+        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")
@@ -81,9 +81,11 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
 
         # Model name validation
         if not self.model_name:
-            raise ValueError("Model name is required.")
+            ASCIIColors.warning("Model name is required.")
         if self.model_name not in DALLE_MODELS:
-            raise ValueError(f"Unsupported DALL-E model: {self.model_name}. Supported models: {list(DALLE_MODELS.keys())}")
+            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]
 
@@ -431,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