lollms-client 0.11.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

lollms_client/lollms_llm_binding.py

@@ -13,6 +13,7 @@ class LollmsLLMBinding(ABC):
     """Abstract base class for all LOLLMS LLM bindings"""
     
     def __init__(self, 
+                 binding_name: Optional[str] ="unknown",
                  host_address: Optional[str] = None,
                  model_name: str = "",
                  service_key: Optional[str] = None,
@@ -29,6 +30,7 @@ class LollmsLLMBinding(ABC):
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
             default_completion_format (ELF_COMPLETION_FORMAT): The completion format (Chat or Instruct)
         """
+        self.binding_name=binding_name
         if host_address is not None:
             self.host_address = host_address[:-1] if host_address.endswith("/") else host_address
         else:

lollms_client/lollms_stt_binding.py

@@ -0,0 +1,137 @@
+# lollms_client/lollms_stt_binding.py
+from abc import ABC, abstractmethod
+import importlib
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+from ascii_colors import trace_exception
+
+class LollmsSTTBinding(ABC):
+    """Abstract base class for all LOLLMS Speech-to-Text bindings."""
+
+    def __init__(self,
+                 host_address: Optional[str] = None,
+                 model_name: Optional[str] = None, # Can represent a default model
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True):
+        """
+        Initialize the LollmsSTTBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the STT service.
+            model_name (Optional[str]): A default identifier for the STT model.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        if host_address is not None:
+            self.host_address = host_address.rstrip('/')
+        else:
+            self.host_address = None
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    @abstractmethod
+    def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
+        """
+        Transcribes the audio file at the given path into text.
+
+        Args:
+            audio_path (Union[str, Path]): The path to the audio file to transcribe.
+            model (Optional[str]): The specific STT model to use (if supported by the binding).
+                                  If None, a default model might be used.
+            **kwargs: Additional binding-specific parameters (e.g., language hint).
+
+        Returns:
+            str: The transcribed text.
+
+        Raises:
+            Exception: If audio transcription fails.
+        """
+        pass
+
+    @abstractmethod
+    def list_models(self, **kwargs) -> List[str]:
+        """
+        Lists the available STT models supported by the binding.
+
+        Args:
+            **kwargs: Additional binding-specific parameters.
+
+        Returns:
+            List[str]: A list of available STT model identifiers.
+        """
+        pass
+
+class LollmsSTTBindingManager:
+    """Manages STT binding discovery and instantiation."""
+
+    def __init__(self, stt_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "stt_bindings"):
+        """
+        Initialize the LollmsSTTBindingManager.
+
+        Args:
+            stt_bindings_dir (Union[str, Path]): Directory containing STT binding implementations.
+                                                 Defaults to the "stt_bindings" subdirectory.
+        """
+        self.stt_bindings_dir = Path(stt_bindings_dir)
+        self.available_bindings = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific STT binding implementation."""
+        binding_dir = self.stt_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                module = importlib.import_module(f"lollms_client.stt_bindings.{binding_name}")
+                binding_class = getattr(module, module.BindingName) # Assumes BindingName is defined
+                self.available_bindings[binding_name] = binding_class
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to load STT binding {binding_name}: {str(e)}")
+
+    def create_binding(self,
+                      binding_name: str,
+                      host_address: Optional[str] = None,
+                      model_name: Optional[str] = None,
+                      service_key: Optional[str] = None,
+                      verify_ssl_certificate: bool = True,
+                      **kwargs) -> Optional[LollmsSTTBinding]:
+        """
+        Create an instance of a specific STT binding.
+
+        Args:
+            binding_name (str): Name of the STT binding to create.
+            host_address (Optional[str]): Host address for the service.
+            model_name (Optional[str]): Default model identifier.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            **kwargs: Additional parameters specific to the binding's __init__.
+
+        Returns:
+            Optional[LollmsSTTBinding]: Binding instance or None if creation failed.
+        """
+        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(host_address=host_address,
+                                     model_name=model_name,
+                                     service_key=service_key,
+                                     verify_ssl_certificate=verify_ssl_certificate,
+                                     **kwargs)
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to instantiate STT binding {binding_name}: {str(e)}")
+                return None
+        return None
+
+    def get_available_bindings(self) -> list[str]:
+        """
+        Return list of available STT binding names based on subdirectories.
+
+        Returns:
+            list[str]: List of binding names.
+        """
+        return [binding_dir.name for binding_dir in self.stt_bindings_dir.iterdir()
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]

lollms_client/lollms_tasks.py

@@ -7,7 +7,6 @@ from functools import partial
 import json
 import sys
 from datetime import datetime
-from lollmsvectordb.text_chunker import TextChunker
 
 class TasksLibrary:
     def __init__(self, lollms:LollmsClient, callback: Callable[[str, MSG_TYPE, dict, list], bool]=None) -> None:
@@ -422,7 +421,7 @@ class TasksLibrary:
         while len(tk)>max_summary_size and (document_chunks is None or len(document_chunks)>1):
             self.step_start(f"Comprerssing {doc_name}... [depth {depth+1}]")
             chunk_size = int(self.lollms.ctx_size*0.6)
-            document_chunks = TextChunker.chunk_text(text, self.lollms, chunk_size, 0, True)
+            document_chunks = chunk_text(text, self.lollms, chunk_size, 0, True)
             text = self.summerize_chunks(
                                             document_chunks,
                                             summary_instruction, 

lollms_client/lollms_tti_binding.py

@@ -0,0 +1,175 @@
+# lollms_client/lollms_tti_binding.py
+from abc import ABC, abstractmethod
+import importlib
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+from ascii_colors import trace_exception
+
+class LollmsTTIBinding(ABC):
+    """Abstract base class for all LOLLMS Text-to-Image bindings."""
+
+    def __init__(self,
+                 host_address: Optional[str] = None,
+                 model_name: Optional[str] = None, # Can represent a default service/model
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True):
+        """
+        Initialize the LollmsTTIBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the TTI service.
+            model_name (Optional[str]): A default identifier (e.g., service or model name).
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        if host_address is not None:
+            self.host_address = host_address.rstrip('/')
+        else:
+            self.host_address = None
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    @abstractmethod
+    def generate_image(self,
+                       prompt: str,
+                       negative_prompt: Optional[str] = "",
+                       width: int = 512,
+                       height: int = 512,
+                       **kwargs) -> bytes:
+        """
+        Generates image data from the provided text prompt.
+
+        Args:
+            prompt (str): The positive text prompt describing the desired image.
+            negative_prompt (Optional[str]): Text prompt describing elements to avoid.
+            width (int): The desired width of the image.
+            height (int): The desired height of the image.
+            **kwargs: Additional binding-specific parameters (e.g., seed, steps, cfg_scale).
+
+        Returns:
+            bytes: The generated image data (e.g., in PNG or JPEG format).
+
+        Raises:
+            Exception: If image generation fails.
+        """
+        pass
+
+    @abstractmethod
+    def list_services(self, **kwargs) -> List[Dict[str, str]]:
+        """
+        Lists the available TTI services or models supported by the binding.
+        This might require authentication depending on the implementation.
+
+        Args:
+            **kwargs: Additional binding-specific parameters (e.g., client_id).
+
+        Returns:
+            List[Dict[str, str]]: A list of dictionaries, each describing a service
+                                  (e.g., {"name": "...", "caption": "...", "help": "..."}).
+        """
+        pass
+
+    @abstractmethod
+    def get_settings(self, **kwargs) -> Optional[Dict[str, Any]]:
+        """
+        Retrieves the current settings for the active TTI service/model.
+        This might require authentication depending on the implementation.
+
+        Args:
+            **kwargs: Additional binding-specific parameters (e.g., client_id).
+
+        Returns:
+            Optional[Dict[str, Any]]: A dictionary representing the settings structure
+                                     (often a list matching ConfigTemplate format) or None if not supported/failed.
+        """
+        pass
+
+    @abstractmethod
+    def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
+        """
+        Applies new settings to the active TTI service/model.
+        This might require authentication depending on the implementation.
+
+        Args:
+            settings (Dict[str, Any]): The new settings to apply (structure depends on the service).
+            **kwargs: Additional binding-specific parameters (e.g., client_id).
+
+        Returns:
+            bool: True if settings were applied successfully, False otherwise.
+        """
+        pass
+
+class LollmsTTIBindingManager:
+    """Manages TTI binding discovery and instantiation."""
+
+    def __init__(self, tti_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "tti_bindings"):
+        """
+        Initialize the LollmsTTIBindingManager.
+
+        Args:
+            tti_bindings_dir (Union[str, Path]): Directory containing TTI binding implementations.
+                                                 Defaults to the "tti_bindings" subdirectory.
+        """
+        self.tti_bindings_dir = Path(tti_bindings_dir)
+        self.available_bindings = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific TTI binding implementation."""
+        binding_dir = self.tti_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                module = importlib.import_module(f"lollms_client.tti_bindings.{binding_name}")
+                binding_class = getattr(module, module.BindingName) # Assumes BindingName is defined
+                self.available_bindings[binding_name] = binding_class
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to load TTI binding {binding_name}: {str(e)}")
+
+    def create_binding(self,
+                      binding_name: str,
+                      host_address: Optional[str] = None,
+                      model_name: Optional[str] = None,
+                      service_key: Optional[str] = None,
+                      verify_ssl_certificate: bool = True,
+                      **kwargs) -> Optional[LollmsTTIBinding]:
+        """
+        Create an instance of a specific TTI binding.
+
+        Args:
+            binding_name (str): Name of the TTI binding to create.
+            host_address (Optional[str]): Host address for the service.
+            model_name (Optional[str]): Default model/service identifier.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            **kwargs: Additional parameters specific to the binding's __init__.
+
+        Returns:
+            Optional[LollmsTTIBinding]: Binding instance or None if creation failed.
+        """
+        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(host_address=host_address,
+                                     model_name=model_name,
+                                     service_key=service_key,
+                                     verify_ssl_certificate=verify_ssl_certificate,
+                                     **kwargs)
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to instantiate TTI binding {binding_name}: {str(e)}")
+                return None
+        return None
+
+    def get_available_bindings(self) -> list[str]:
+        """
+        Return list of available TTI binding names based on subdirectories.
+
+        Returns:
+            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()]

lollms_client/lollms_ttm_binding.py

@@ -0,0 +1,135 @@
+# lollms_client/lollms_ttm_binding.py
+from abc import ABC, abstractmethod
+import importlib
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+from ascii_colors import trace_exception
+
+class LollmsTTMBinding(ABC):
+    """Abstract base class for all LOLLMS Text-to-Music bindings."""
+
+    def __init__(self,
+                 host_address: Optional[str] = None,
+                 model_name: Optional[str] = None, # Can represent a default model/service
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True):
+        """
+        Initialize the LollmsTTMBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the TTM service.
+            model_name (Optional[str]): A default identifier (e.g., service or model name).
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        if host_address is not None:
+            self.host_address = host_address.rstrip('/')
+        else:
+            self.host_address = None
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    @abstractmethod
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music data from the provided text prompt.
+
+        Args:
+            prompt (str): The text prompt describing the desired music (e.g., genre, mood, instruments).
+            **kwargs: Additional binding-specific parameters (e.g., duration, style, seed).
+
+        Returns:
+            bytes: The generated music data (e.g., in WAV, MP3, or MIDI format).
+
+        Raises:
+            Exception: If music generation fails.
+        """
+        pass
+
+    @abstractmethod
+    def list_models(self, **kwargs) -> List[str]:
+        """
+        Lists the available TTM models or services supported by the binding.
+
+        Args:
+            **kwargs: Additional binding-specific parameters.
+
+        Returns:
+            List[str]: A list of available model/service identifiers.
+        """
+        pass
+
+class LollmsTTMBindingManager:
+    """Manages TTM binding discovery and instantiation."""
+
+    def __init__(self, ttm_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "ttm_bindings"):
+        """
+        Initialize the LollmsTTMBindingManager.
+
+        Args:
+            ttm_bindings_dir (Union[str, Path]): Directory containing TTM binding implementations.
+                                                 Defaults to the "ttm_bindings" subdirectory.
+        """
+        self.ttm_bindings_dir = Path(ttm_bindings_dir)
+        self.available_bindings = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific TTM binding implementation."""
+        binding_dir = self.ttm_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                module = importlib.import_module(f"lollms_client.ttm_bindings.{binding_name}")
+                binding_class = getattr(module, module.BindingName) # Assumes BindingName is defined
+                self.available_bindings[binding_name] = binding_class
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to load TTM binding {binding_name}: {str(e)}")
+
+    def create_binding(self,
+                      binding_name: str,
+                      host_address: Optional[str] = None,
+                      model_name: Optional[str] = None,
+                      service_key: Optional[str] = None,
+                      verify_ssl_certificate: bool = True,
+                      **kwargs) -> Optional[LollmsTTMBinding]:
+        """
+        Create an instance of a specific TTM binding.
+
+        Args:
+            binding_name (str): Name of the TTM binding to create.
+            host_address (Optional[str]): Host address for the service.
+            model_name (Optional[str]): Default model/service identifier.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            **kwargs: Additional parameters specific to the binding's __init__.
+
+        Returns:
+            Optional[LollmsTTMBinding]: Binding instance or None if creation failed.
+        """
+        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(host_address=host_address,
+                                     model_name=model_name,
+                                     service_key=service_key,
+                                     verify_ssl_certificate=verify_ssl_certificate,
+                                     **kwargs)
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to instantiate TTM binding {binding_name}: {str(e)}")
+                return None
+        return None
+
+    def get_available_bindings(self) -> list[str]:
+        """
+        Return list of available TTM binding names based on subdirectories.
+
+        Returns:
+            list[str]: List of binding names.
+        """
+        return [binding_dir.name for binding_dir in self.ttm_bindings_dir.iterdir()
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]

lollms_client/lollms_tts_binding.py

@@ -0,0 +1,138 @@
+# lollms_client/lollms_tts_binding.py
+from abc import ABC, abstractmethod
+import importlib
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union, Callable
+from ascii_colors import trace_exception
+
+class LollmsTTSBinding(ABC):
+    """Abstract base class for all LOLLMS Text-to-Speech bindings."""
+
+    def __init__(self,
+                 host_address: Optional[str] = None,
+                 model_name: Optional[str] = None, # Can represent a default voice or model
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True):
+        """
+        Initialize the LollmsTTSBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the TTS service.
+            model_name (Optional[str]): A default identifier (e.g., voice or model name).
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        if host_address is not None:
+            self.host_address = host_address.rstrip('/')
+        else:
+            self.host_address = None
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    @abstractmethod
+    def generate_audio(self, text: str, voice: Optional[str] = None, **kwargs) -> bytes:
+        """
+        Generates audio data from the provided text.
+
+        Args:
+            text (str): The text content to synthesize.
+            voice (Optional[str]): The specific voice or model to use (if supported by the binding).
+                                   If None, a default voice might be used.
+            **kwargs: Additional binding-specific parameters.
+
+        Returns:
+            bytes: The generated audio data (e.g., in WAV or MP3 format).
+
+        Raises:
+            Exception: If audio generation fails.
+        """
+        pass
+
+    @abstractmethod
+    def list_voices(self, **kwargs) -> List[str]:
+        """
+        Lists the available voices or TTS models supported by the binding.
+
+        Args:
+            **kwargs: Additional binding-specific parameters.
+
+        Returns:
+            List[str]: A list of available voice/model identifiers.
+        """
+        pass
+
+class LollmsTTSBindingManager:
+    """Manages TTS binding discovery and instantiation."""
+
+    def __init__(self, tts_bindings_dir: Union[str, Path] = Path(__file__).parent.parent / "tts_bindings"):
+        """
+        Initialize the LollmsTTSBindingManager.
+
+        Args:
+            tts_bindings_dir (Union[str, Path]): Directory containing TTS binding implementations.
+                                                 Defaults to the "tts_bindings" subdirectory.
+        """
+        self.tts_bindings_dir = Path(tts_bindings_dir)
+        self.available_bindings = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific TTS binding implementation."""
+        binding_dir = self.tts_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                # Adjust module path for dynamic loading
+                module = importlib.import_module(f"lollms_client.tts_bindings.{binding_name}")
+                binding_class = getattr(module, module.BindingName) # Assumes BindingName is defined
+                self.available_bindings[binding_name] = binding_class
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to load TTS binding {binding_name}: {str(e)}")
+
+    def create_binding(self,
+                      binding_name: str,
+                      host_address: Optional[str] = None,
+                      model_name: Optional[str] = None,
+                      service_key: Optional[str] = None,
+                      verify_ssl_certificate: bool = True,
+                      **kwargs) -> Optional[LollmsTTSBinding]:
+        """
+        Create an instance of a specific TTS binding.
+
+        Args:
+            binding_name (str): Name of the TTS binding to create.
+            host_address (Optional[str]): Host address for the service.
+            model_name (Optional[str]): Default model/voice identifier.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            **kwargs: Additional parameters specific to the binding's __init__.
+
+        Returns:
+            Optional[LollmsTTSBinding]: Binding instance or None if creation failed.
+        """
+        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(host_address=host_address,
+                                     model_name=model_name,
+                                     service_key=service_key,
+                                     verify_ssl_certificate=verify_ssl_certificate,
+                                     **kwargs)
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to instantiate TTS binding {binding_name}: {str(e)}")
+                return None
+        return None
+
+    def get_available_bindings(self) -> list[str]:
+        """
+        Return list of available TTS binding names based on subdirectories.
+
+        Returns:
+            list[str]: List of binding names.
+        """
+        return [binding_dir.name for binding_dir in self.tts_bindings_dir.iterdir()
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]