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

lollms_client/lollms_ttv_binding.py

@@ -0,0 +1,135 @@
+# lollms_client/lollms_ttv_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 LollmsTTVBinding(ABC):
+    """Abstract base class for all LOLLMS Text-to-Video 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 LollmsTTVBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the TTV 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_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
+
+    @abstractmethod
+    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
+
+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 = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific TTV binding implementation."""
+        binding_dir = self.ttv_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                module = importlib.import_module(f"lollms_client.ttv_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 TTV 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[LollmsTTVBinding]:
+        """
+        Create an instance of a specific TTV binding.
+
+        Args:
+            binding_name (str): Name of the TTV 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[LollmsTTVBinding]: 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 TTV binding {binding_name}: {str(e)}")
+                return None
+        return None
+
+    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()]

lollms_client/stt_bindings/lollms/__init__.py

@@ -0,0 +1,138 @@
+# lollms_client/stt_bindings/lollms/__init__.py
+import requests
+import base64
+from pathlib import Path
+from lollms_client.lollms_stt_binding import LollmsSTTBinding
+from typing import Optional, List, Union
+from ascii_colors import trace_exception, ASCIIColors
+import json # Added for potential error parsing
+
+# Defines the binding name for the manager
+BindingName = "LollmsSTTBinding_Impl"
+
+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):
+        """
+        Initialize the LOLLMS STT binding.
+
+        Args:
+            host_address (Optional[str]): Host address for the LOLLMS service.
+            model_name (Optional[str]): Default STT model identifier.
+            service_key (Optional[str]): Authentication key (currently unused by default LOLLMS STT).
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        super().__init__(host_address=host_address,
+                         model_name=model_name,
+                         service_key=service_key,
+                         verify_ssl_certificate=verify_ssl_certificate)
+
+    def transcribe_audio(self, audio_path: Union[str, Path], model: Optional[str] = None, **kwargs) -> str:
+        """
+        Transcribes audio using an assumed LOLLMS /audio2text endpoint.
+        Sends audio data as base64 encoded string.
+
+        Args:
+            audio_path (Union[str, Path]): Path to the audio file.
+            model (Optional[str]): Specific STT model to use. If None, uses default from init.
+            **kwargs: Additional parameters (e.g., language hint - passed if provided).
+
+        Returns:
+            str: The transcribed text.
+
+        Raises:
+            FileNotFoundError: If the audio file does not exist.
+            Exception: If the request fails or transcription fails on the server.
+        """
+        endpoint = f"{self.host_address}/audio2text" # Assumed endpoint
+        model_to_use = model if model else self.model_name
+
+        audio_file = Path(audio_path)
+        if not audio_file.exists():
+            raise FileNotFoundError(f"Audio file not found at: {audio_path}")
+
+        try:
+            # Read audio file and encode as base64
+            with open(audio_file, "rb") as f:
+                audio_data = f.read()
+            audio_base64 = base64.b64encode(audio_data).decode('utf-8')
+
+            request_data = {
+                "audio_data": audio_base64, # Sending data instead of path
+                "model": model_to_use,
+                "file_name": audio_file.name # Send filename as metadata if server supports it
+            }
+            # Add language hint if provided in kwargs
+            if "language" in kwargs:
+                 request_data["language"] = kwargs["language"]
+
+            # Filter out None values if server requires it
+            request_data = {k: v for k, v in request_data.items() if v is not None}
+
+            headers = {'Content-Type': 'application/json'}
+            if self.service_key:
+                headers['Authorization'] = f'Bearer {self.service_key}'
+
+            response = requests.post(endpoint, json=request_data, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+
+            response_json = response.json()
+            transcribed_text = response_json.get("text")
+
+            if transcribed_text is None:
+                 # Check for error message from server
+                 error_msg = response_json.get("error", "Server did not return transcribed text.")
+                 raise Exception(error_msg)
+
+            return transcribed_text
+
+        except FileNotFoundError as e:
+            raise e # Re-raise file not found
+        except requests.exceptions.RequestException as e:
+            trace_exception(e)
+            raise Exception(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Audio transcription failed: {e}") from e
+
+
+    def list_models(self, **kwargs) -> List[str]:
+        """
+        Lists available STT models using an assumed LOLLMS /list_stt_models endpoint.
+
+        Args:
+            **kwargs: Additional parameters (currently unused).
+
+        Returns:
+            List[str]: List of STT model identifiers. Returns empty list on failure.
+        """
+        endpoint = f"{self.host_address}/list_stt_models" # Assumed endpoint
+        headers = {'Content-Type': 'application/json'}
+        if self.service_key:
+            headers['Authorization'] = f'Bearer {self.service_key}'
+
+        try:
+            response = requests.get(endpoint, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            models_data = response.json()
+            if "error" in models_data:
+                 ASCIIColors.error(f"Error listing STT models from server: {models_data['error']}")
+                 return [] # Fallback
+            return models_data.get("models", []) # Default if key missing
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"Couldn't list STT models due to connection error: {e}")
+            trace_exception(e)
+            return [] # Fallback
+        except json.JSONDecodeError as e:
+            ASCIIColors.error(f"Couldn't parse STT models response from server: {e}")
+            trace_exception(e)
+            return [] # Fallback
+        except Exception as e:
+            ASCIIColors.error(f"An unexpected error occurred while listing STT models: {e}")
+            trace_exception(e)
+            return [] # Fallback

lollms_client/tti_bindings/lollms/__init__.py

@@ -0,0 +1,210 @@
+# lollms_client/tti_bindings/lollms/__init__.py
+import requests
+import base64
+import io
+from PIL import Image
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from typing import Optional, List, Dict, Any
+from ascii_colors import trace_exception, ASCIIColors
+import json # Added for potential error parsing
+
+# Defines the binding name for the manager
+BindingName = "LollmsTTIBinding_Impl"
+
+class LollmsTTIBinding_Impl(LollmsTTIBinding):
+    """Concrete implementation of the LollmsTTIBinding for the standard LOLLMS server."""
+
+    def __init__(self,
+                 host_address: Optional[str] = "http://localhost:9600", # Default LOLLMS host
+                 model_name: Optional[str] = None, # Default service name (server decides if None)
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True):
+        """
+        Initialize the LOLLMS TTI binding.
+
+        Args:
+            host_address (Optional[str]): Host address for the LOLLMS service.
+            model_name (Optional[str]): Default service/model identifier (currently unused by LOLLMS TTI endpoints).
+            service_key (Optional[str]): Authentication key (used for client_id verification).
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        super().__init__(host_address=host_address,
+                         model_name=model_name, # model_name is not directly used by LOLLMS TTI API yet
+                         service_key=service_key,
+                         verify_ssl_certificate=verify_ssl_certificate)
+        # The 'service_key' here will act as the 'client_id' for TTI requests if provided.
+        # This assumes the client library user provides their LOLLMS client_id here.
+        self.client_id = service_key
+
+    def _get_client_id(self, **kwargs) -> str:
+        """Helper to get client_id, prioritizing kwargs then instance default."""
+        client_id = kwargs.get("client_id", self.client_id)
+        if not client_id:
+             # Allowing anonymous access for generation, but other endpoints might fail
+             # raise ValueError("client_id is required for this TTI operation but was not provided.")
+             ASCIIColors.warning("client_id not provided for TTI operation. Some features might require it.")
+             return "lollms_client_user" # Default anonymous ID
+        return client_id
+
+    def generate_image(self,
+                       prompt: str,
+                       negative_prompt: Optional[str] = "",
+                       width: int = 512,
+                       height: int = 512,
+                       **kwargs) -> bytes:
+        """
+        Generates image data using the LOLLMS /generate_image endpoint.
+
+        Args:
+            prompt (str): The positive text prompt.
+            negative_prompt (Optional[str]): The negative prompt.
+            width (int): Image width.
+            height (int): Image height.
+            **kwargs: Additional parameters (passed to server if needed, currently unused by endpoint).
+
+        Returns:
+            bytes: The generated image data (JPEG format).
+
+        Raises:
+            Exception: If the request fails or image generation fails on the server.
+        """
+        endpoint = f"{self.host_address}/generate_image"
+        request_data = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "width": width,
+            "height": height
+        }
+        # Include extra kwargs if the server API might use them in the future
+        request_data.update(kwargs)
+
+        headers = {'Content-Type': 'application/json'}
+        # Note: /generate_image endpoint doesn't currently require client_id based on provided code
+
+        try:
+            response = requests.post(endpoint, json=request_data, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+
+            response_json = response.json()
+            img_base64 = response_json.get("image")
+
+            if not img_base64:
+                raise Exception("Server did not return image data.")
+
+            # Decode the base64 string to bytes
+            img_bytes = base64.b64decode(img_base64)
+            return img_bytes
+
+        except requests.exceptions.RequestException as e:
+            trace_exception(e)
+            raise Exception(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            trace_exception(e)
+            # Attempt to get error detail from response if possible
+            error_detail = "Unknown server error"
+            try:
+                error_detail = response.json().get("detail", error_detail)
+            except: pass
+            raise Exception(f"Image generation failed: {e} - Detail: {error_detail}") from e
+
+
+    def list_services(self, **kwargs) -> List[Dict[str, str]]:
+        """
+        Lists available TTI services using the LOLLMS /list_tti_services endpoint.
+
+        Args:
+            **kwargs: Must include 'client_id' for server verification.
+
+        Returns:
+            List[Dict[str, str]]: List of service dictionaries.
+
+        Raises:
+            ValueError: If client_id is not provided.
+            Exception: If the request fails.
+        """
+        endpoint = f"{self.host_address}/list_tti_services"
+        client_id = self._get_client_id(**kwargs) # Raises ValueError if missing
+
+        request_data = {"client_id": client_id}
+        headers = {'Content-Type': 'application/json'}
+
+        try:
+            response = requests.post(endpoint, json=request_data, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            return response.json() # Returns the list directly
+        except requests.exceptions.RequestException as e:
+            trace_exception(e)
+            raise Exception(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Failed to list TTI services: {e}") from e
+
+    def get_settings(self, **kwargs) -> Optional[Dict[str, Any]]:
+        """
+        Retrieves TTI settings using the LOLLMS /get_active_tti_settings endpoint.
+
+        Args:
+            **kwargs: Must include 'client_id' for server verification.
+
+        Returns:
+            Optional[Dict[str, Any]]: Settings dictionary or empty dict if not available/failed.
+
+        Raises:
+            ValueError: If client_id is not provided.
+            Exception: If the request fails.
+        """
+        endpoint = f"{self.host_address}/get_active_tti_settings"
+        client_id = self._get_client_id(**kwargs) # Raises ValueError if missing
+
+        request_data = {"client_id": client_id}
+        headers = {'Content-Type': 'application/json'}
+
+        try:
+            response = requests.post(endpoint, json=request_data, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            settings = response.json()
+            # The endpoint returns the template directly if successful, or {} if no TTI/settings
+            return settings if isinstance(settings, list) else {} # Ensure correct format or empty
+        except requests.exceptions.RequestException as e:
+            trace_exception(e)
+            raise Exception(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Failed to get TTI settings: {e}") from e
+
+
+    def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
+        """
+        Applies TTI settings using the LOLLMS /set_active_tti_settings endpoint.
+
+        Args:
+            settings (Dict[str, Any]): The new settings (matching server's expected format).
+            **kwargs: Must include 'client_id' for server verification.
+
+        Returns:
+            bool: True if successful, False otherwise.
+
+        Raises:
+            ValueError: If client_id is not provided.
+            Exception: If the request fails.
+        """
+        endpoint = f"{self.host_address}/set_active_tti_settings"
+        client_id = self._get_client_id(**kwargs) # Raises ValueError if missing
+
+        request_data = {
+            "client_id": client_id,
+            "settings": settings
+            }
+        headers = {'Content-Type': 'application/json'}
+
+        try:
+            response = requests.post(endpoint, json=request_data, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            response_json = response.json()
+            return response_json.get("status", False)
+        except requests.exceptions.RequestException as e:
+            trace_exception(e)
+            raise Exception(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            trace_exception(e)
+            raise Exception(f"Failed to set TTI settings: {e}") from e

lollms_client/ttm_bindings/lollms/__init__.py

@@ -0,0 +1,73 @@
+# lollms_client/ttm_bindings/lollms/__init__.py
+import requests
+from lollms_client.lollms_ttm_binding import LollmsTTMBinding
+from typing import Optional, List
+from ascii_colors import trace_exception, ASCIIColors
+
+# Defines the binding name for the manager
+BindingName = "LollmsTTMBinding_Impl"
+
+class LollmsTTMBinding_Impl(LollmsTTMBinding):
+    """Concrete implementation of the LollmsTTMBinding for the standard LOLLMS server (Placeholder)."""
+
+    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):
+        """
+        Initialize the LOLLMS TTM binding.
+
+        Args:
+            host_address (Optional[str]): Host address for the LOLLMS service.
+            model_name (Optional[str]): Default TTM model identifier.
+            service_key (Optional[str]): Authentication key.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        super().__init__(host_address=host_address,
+                         model_name=model_name,
+                         service_key=service_key,
+                         verify_ssl_certificate=verify_ssl_certificate)
+        ASCIIColors.warning("LOLLMS TTM binding is not yet fully implemented in the client.")
+        ASCIIColors.warning("Please ensure your LOLLMS server has a TTM service running.")
+
+
+    def generate_music(self, prompt: str, **kwargs) -> bytes:
+        """
+        Generates music data using an assumed LOLLMS /generate_music endpoint. (Not Implemented)
+
+        Args:
+            prompt (str): The text prompt describing the desired music.
+            **kwargs: Additional parameters (e.g., duration, style).
+
+        Returns:
+            bytes: Placeholder empty bytes.
+
+        Raises:
+            NotImplementedError: This method is not yet implemented.
+        """
+        # endpoint = f"{self.host_address}/generate_music" # Assumed endpoint
+        # request_data = {"prompt": prompt, **kwargs}
+        # headers = {'Content-Type': 'application/json'}
+        # ... make request ...
+        # return response.content # Assuming direct bytes response
+        raise NotImplementedError("LOLLMS TTM generate_music client binding is not implemented yet.")
+
+
+    def list_models(self, **kwargs) -> List[str]:
+        """
+        Lists available TTM models using an assumed LOLLMS /list_ttm_models endpoint. (Not Implemented)
+
+        Args:
+            **kwargs: Additional parameters.
+
+        Returns:
+            List[str]: Placeholder empty list.
+
+        Raises:
+            NotImplementedError: This method is not yet implemented.
+        """
+        # endpoint = f"{self.host_address}/list_ttm_models" # Assumed endpoint
+        # ... make request ...
+        # return response.json().get("models", [])
+        raise NotImplementedError("LOLLMS TTM list_models client binding is not implemented yet.")