lollms-client 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

lollms_client/lollms_llm_binding.py

@@ -0,0 +1,210 @@
+# lollms_binding.py
+from abc import ABC, abstractmethod
+import importlib
+from pathlib import Path
+from typing import Optional, Callable, List
+from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
+import importlib
+from pathlib import Path
+from typing import Optional
+from ascii_colors import trace_exception
+
+class LollmsLLMBinding(ABC):
+    """Abstract base class for all LOLLMS LLM bindings"""
+    
+    def __init__(self, 
+                 host_address: Optional[str] = None,
+                 model_name: str = "",
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True,
+                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat
+        ):
+        """
+        Initialize the LollmsLLMBinding base class.
+
+        Args:
+            host_address (Optional[str]): The host address for the service. Defaults to None.
+            model_name (str): The name of the model to use. Defaults to empty string.
+            service_key (Optional[str]): Authentication key for the service. Defaults to None.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
+            default_completion_format (ELF_COMPLETION_FORMAT): The completion format (Chat or Instruct)
+        """
+        if host_address is not None:
+            self.host_address = host_address[:-1] if host_address.endswith("/") else host_address
+        else:
+            self.host_address = None
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+        self.default_completion_format = default_completion_format
+    
+    @abstractmethod
+    def generate_text(self, 
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     n_predict: Optional[int] = None,
+                     stream: bool = False,
+                     temperature: float = 0.1,
+                     top_k: int = 50,
+                     top_p: float = 0.95,
+                     repeat_penalty: float = 0.8,
+                     repeat_last_n: int = 40,
+                     seed: Optional[int] = None,
+                     n_threads: int = 8,
+                     streaming_callback: Optional[Callable[[str, str], None]] = None) -> str:
+        """
+        Generate text based on the provided prompt and parameters.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths for multimodal generation.
+            n_predict (Optional[int]): Maximum number of tokens to generate.
+            stream (bool): Whether to stream the output. Defaults to False.
+            temperature (float): Sampling temperature. Defaults to 0.1.
+            top_k (int): Top-k sampling parameter. Defaults to 50.
+            top_p (float): Top-p sampling parameter. Defaults to 0.95.
+            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40.
+            seed (Optional[int]): Random seed for generation.
+            n_threads (int): Number of threads to use. Defaults to 8.
+            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
+                - First parameter (str): The chunk of text received.
+                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+
+        Returns:
+            str: Generated text or error dictionary if failed.
+        """
+        pass
+    
+    @abstractmethod
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text into a list of tokens.
+
+        Args:
+            text (str): The text to tokenize.
+
+        Returns:
+            list: List of tokens.
+        """
+        pass
+    
+    @abstractmethod
+    def detokenize(self, tokens: list) -> str:
+        """
+        Convert a list of tokens back to text.
+
+        Args:
+            tokens (list): List of tokens to detokenize.
+
+        Returns:
+            str: Detokenized text.
+        """
+        pass
+
+    @abstractmethod
+    def embed(self, text: str, **kwargs) -> list:
+        """
+        Get embeddings for the input text using Ollama API
+        
+        Args:
+            text (str or List[str]): Input text to embed
+            **kwargs: Additional arguments like model, truncate, options, keep_alive
+        
+        Returns:
+            dict: Response containing embeddings
+        """
+        pass    
+    
+    @abstractmethod
+    def get_model_info(self) -> dict:
+        """
+        Return information about the current model.
+
+        Returns:
+            dict: Model information dictionary.
+        """
+        pass
+
+    @abstractmethod
+    def listModels(self) -> list:
+        """Lists models"""
+        pass
+    
+    
+    @abstractmethod
+    def load_model(self, model_name: str) -> bool:
+        """
+        Load a specific model.
+
+        Args:
+            model_name (str): Name of the model to load.
+
+        Returns:
+            bool: True if model loaded successfully, False otherwise.
+        """
+        pass
+
+
+class LollmsLLMBindingManager:
+    """Manages binding discovery and instantiation"""
+
+    def __init__(self, llm_bindings_dir: str = "llm_bindings"):
+        """
+        Initialize the LollmsLLMBindingManager.
+
+        Args:
+            llm_bindings_dir (str): Directory containing binding implementations. Defaults to "llm_bindings".
+        """
+        self.llm_bindings_dir = Path(llm_bindings_dir)
+        self.available_bindings = {}
+
+    def _load_binding(self, binding_name: str):
+        """Dynamically load a specific binding implementation from the llm bindings directory."""
+        binding_dir = self.llm_bindings_dir / binding_name
+        if binding_dir.is_dir() and (binding_dir / "__init__.py").exists():
+            try:
+                module = importlib.import_module(f"lollms_client.llm_bindings.{binding_name}")
+                binding_class = getattr(module, module.BindingName)
+                self.available_bindings[binding_name] = binding_class
+            except Exception as e:
+                trace_exception(e)
+                print(f"Failed to load binding {binding_name}: {str(e)}")
+
+    def create_binding(self, 
+                      binding_name: str,
+                      host_address: Optional[str] = None,
+                      model_name: str = "",
+                      service_key: Optional[str] = None,
+                      verify_ssl_certificate: bool = True,
+                      personality: Optional[int] = None) -> Optional[LollmsLLMBinding]:
+        """
+        Create an instance of a specific binding.
+
+        Args:
+            binding_name (str): Name of the binding to create.
+            host_address (Optional[str]): Host address for the service.
+            model_name (str): Name of the model to use.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+            personality (Optional[int]): Personality ID for LOLLMS binding.
+
+        Returns:
+            Optional[LollmsLLMBinding]: 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:
+            return binding_class(host_address, model_name, service_key, verify_ssl_certificate, personality)
+        return None
+
+    def get_available_bindings(self) -> list[str]:
+        """
+        Return list of available binding names.
+
+        Returns:
+            list[str]: List of binding names.
+        """
+        return [binding_dir.name for binding_dir in self.llm_bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]

lollms_client/lollms_tasks.py

@@ -57,23 +57,23 @@ class TasksLibrary:
                 callback(text,message_type)
             self.bot_says = bot_says
             return True
-    def generate(self, prompt, max_size, temperature = None, top_k = None, top_p=None, repeat_penalty=None, repeat_last_n=None, callback=None, debug=False, show_progress=False, stream= False ):
+    def generate(self, prompt, n_predict, temperature = None, top_k = None, top_p=None, repeat_penalty=None, repeat_last_n=None, callback=None, debug=False, show_progress=False, stream= False ):
         ASCIIColors.info("Text generation started: Warming up")
         self.nb_received_tokens = 0
         self.bot_says = ""
         if debug:
             self.print_prompt("gen",prompt)
 
-        bot_says = self.lollms.generate(
-                                prompt,
-                                max_size,
+        bot_says = self.lollms.generate_text(
+                                prompt=prompt,
+                                n_predict = n_predict,
                                 stream=stream,
                                 streaming_callback=partial(self.process, callback=callback, show_progress=show_progress),
-                                temperature= temperature if temperature is not None else self.lollms.temperature,
-                                top_k= top_k if top_k is not None else self.lollms.top_k ,
-                                top_p= top_p if top_p is not None else self.lollms.top_p ,
-                                repeat_penalty= repeat_penalty if repeat_penalty is not None else self.lollms.repeat_penalty,
-                                repeat_last_n= repeat_last_n if repeat_last_n is not None else self.lollms.repeat_last_n,
+                                temperature= temperature,
+                                top_k= top_k,
+                                top_p= top_p,
+                                repeat_penalty= repeat_penalty,
+                                repeat_last_n= repeat_last_n,
                                 ).strip()
         return self.bot_says if stream else bot_says
 
@@ -81,10 +81,11 @@ class TasksLibrary:
     def fast_gen(
                     self, 
                     prompt: str, 
-                    max_generation_size: int=None, 
+                    n_predict: int=None, 
                     placeholders: dict = {}, 
                     sacrifice: list = ["previous_discussion"], 
                     debug: bool  = False, 
+                    stream: bool = False,
                     callback=None, 
                     show_progress=False, 
                     temperature = None, 
@@ -109,106 +110,39 @@ class TasksLibrary:
         Returns:
         - str: The generated text after removing special tokens ("<s>" and "</s>") and stripping any leading/trailing whitespace.
         """
-        if max_generation_size is None:
+        if n_predict is None:
             prompt_size = self.lollms.tokenize(prompt)
-            max_generation_size = self.lollms.ctx_size - len(prompt_size)
+            n_predict = self.lollms.default_ctx_size - len(prompt_size)
 
         pr = PromptReshaper(prompt)
         prompt = pr.build(placeholders,
-                        self.lollms.tokenize,
-                        self.lollms.detokenize,
-                        self.lollms.ctx_size - max_generation_size,
+                        self.lollms.binding.tokenize,
+                        self.lollms.binding.detokenize,
+                        self.lollms.default_ctx_size - n_predict,
                         sacrifice
                         )
-        ntk = len(self.lollms.tokenize(prompt))
-        max_generation_size = min(self.lollms.ctx_size - ntk, max_generation_size)
+        ntk = len(self.lollms.binding.tokenize(prompt))
+        n_predict = min(self.lollms.default_ctx_size - ntk, n_predict)
         # TODO : add show progress
 
-        gen = self.generate(prompt, max_generation_size, temperature = temperature, top_k = top_k, top_p=top_p, repeat_penalty=repeat_penalty, repeat_last_n=repeat_last_n, callback=callback, show_progress=show_progress).strip().replace("</s>", "").replace("<s>", "")
+        gen = self.lollms.generate_text(
+                            prompt=prompt,
+                            n_predict = n_predict,
+                            stream=stream,
+                            streaming_callback=partial(self.process, callback=callback, show_progress=show_progress),
+                            temperature= temperature,
+                            top_k= top_k,
+                            top_p= top_p,
+                            repeat_penalty= repeat_penalty,
+                            repeat_last_n= repeat_last_n
+            ).strip().replace("</s>", "").replace("<s>", "")
         if debug:
             self.print_prompt("prompt", prompt+gen)
 
         return gen
 
-    def generate_with_images(self, prompt, images, max_size, temperature = None, top_k = None, top_p=None, repeat_penalty=None, repeat_last_n=None, callback=None, debug=False, show_progress=False, stream=False ):
-        ASCIIColors.info("Text generation started: Warming up")
-        self.nb_received_tokens = 0
-        self.bot_says = ""
-        if debug:
-            self.print_prompt("gen",prompt)
-
-        bot_says = self.lollms.generate_with_images(
-                                prompt,
-                                images,
-                                max_size,
-                                stream=stream,
-                                streaming_callback= partial(self.process, callback=callback, show_progress=show_progress),
-                                temperature=self.lollms.temperature if temperature is None else temperature,
-                                top_k=self.lollms.top_k if top_k is None else top_k,
-                                top_p=self.lollms.top_p if top_p is None else top_p,
-                                repeat_penalty=self.lollms.repeat_penalty if repeat_penalty is None else repeat_penalty,
-                                repeat_last_n = self.lollms.repeat_last_n if repeat_last_n is None else repeat_last_n
-                                ).strip()
-        return self.bot_says if stream else bot_says
 
     
-    def fast_gen_with_images(self, prompt: str, images:list, max_generation_size: int=None, placeholders: dict = {}, sacrifice: list = ["previous_discussion"], debug: bool  = False, callback=None, show_progress=False) -> str:
-        """
-        Fast way to generate text from text and images
-
-        This method takes in a prompt, maximum generation size, optional placeholders, sacrifice list, and debug flag.
-        It reshapes the context before performing text generation by adjusting and cropping the number of tokens.
-
-        Parameters:
-        - prompt (str): The input prompt for text generation.
-        - max_generation_size (int): The maximum number of tokens to generate.
-        - placeholders (dict, optional): A dictionary of placeholders to be replaced in the prompt. Defaults to an empty dictionary.
-        - sacrifice (list, optional): A list of placeholders to sacrifice if the window is bigger than the context size minus the number of tokens to generate. Defaults to ["previous_discussion"].
-        - debug (bool, optional): Flag to enable/disable debug mode. Defaults to False.
-
-        Returns:
-        - str: The generated text after removing special tokens ("<s>" and "</s>") and stripping any leading/trailing whitespace.
-        """
-        prompt = "\n".join([
-            "!@>system: I am an AI assistant that can converse and analyze images. When asked to locate something in an image you send, I will reply with:",
-            "boundingbox(image_index, label, left, top, width, height)",
-            "Where:",
-            "image_index: 0-based index of the image",
-            "label: brief description of what is located",
-            "left, top: x,y coordinates of top-left box corner (0-1 scale)",
-            "width, height: box dimensions as fraction of image size",
-            "Coordinates have origin (0,0) at top-left, (1,1) at bottom-right.",
-            "For other queries, I will respond conversationally to the best of my abilities.",
-            prompt
-        ])
-
-        if max_generation_size is None:
-            prompt_size = self.lollms.tokenize(prompt)
-            max_generation_size = self.lollms.ctx_size - len(prompt_size)
-
-        pr = PromptReshaper(prompt)
-        prompt = pr.build(placeholders,
-                        self.lollms.tokenize,
-                        self.lollms.detokenize,
-                        self.lollms.ctx_size - max_generation_size,
-                        sacrifice
-                        )
-        ntk = len(self.lollms.tokenize(prompt))
-        max_generation_size = min(self.lollms.ctx_size - ntk, max_generation_size)
-        # TODO : add show progress
-
-        gen = self.generate_with_images(prompt, images, max_generation_size, callback=callback, show_progress=show_progress).strip().replace("</s>", "").replace("<s>", "")
-        try:
-            gen = process_ai_output(gen, images, "/discussions/")
-        except Exception as ex:
-            pass
-        if debug:
-            self.print_prompt("prompt", prompt+gen)
-
-        return gen    
-
-
-
     def step_start(self, step_text, callback: Callable[[str, MSG_TYPE, dict, list], bool]=None):
         """This triggers a step start
 
@@ -294,7 +228,7 @@ class TasksLibrary:
             prompt_parts[sacrifice_id] = sacrifice_text
             return "\n".join([s for s in prompt_parts if s!=""])
 
-    def translate_text_chunk(self, text_chunk, output_language:str="french", host_address:str=None, model_name: str = None, temperature=0.1, max_generation_size=3000):
+    def translate_text_chunk(self, text_chunk, output_language:str="french", host_address:str=None, model_name: str = None, temperature=0.1, max_generation_size=3000, callback=None, show_progress:bool=False):
         """
         This function translates a given text chunk into a specified language.
 
@@ -310,22 +244,19 @@ class TasksLibrary:
         str: The translated text.
         """        
         translated = self.lollms.generate_text(
-                                "\n".join([
-                                    f"!@>system:",
+                            prompt= "\n".join([
+                                    self.lollms.system_full_header,
                                     f"Translate the following text to {output_language}.",
                                     "Be faithful to the original text and do not add or remove any information.",
                                     "Respond only with the translated text.",
                                     "Do not add comments or explanations.",
-                                    f"!@>text to translate:",
+                                    self.lollms.system_custom_header("text to translate"),
                                     f"{text_chunk}",
-                                    f"!@>translation:",
+                                    self.lollms.ai_custom_header("translation"),
                                     ]),
-                                    host_address,
-                                    model_name,
-                                    personality = -1,
-                                    n_predict=max_generation_size,
-                                    stream=False,
-                                    temperature=temperature
+                                    n_predict = max_generation_size,
+                                    streaming_callback=partial(self.process, callback=callback, show_progress=show_progress),
+                                    temperature= temperature
                                     )
         return translated
 
@@ -435,12 +366,12 @@ class TasksLibrary:
         choices = "\n".join([f"{i}. {possible_answer}" for i, possible_answer in enumerate(possible_answers)])
         elements = [conditionning] if conditionning!="" else []
         elements += [
-                "!@>system:",
+                self.lollms.system_full_header,
                 "Answer this multi choices question.",
         ]
         if context!="":
             elements+=[
-                       "!@>Context:",
+                       self.lollms.system_custom_header("Context"),
                         f"{context}",
                     ]
         elements +=[
@@ -450,14 +381,16 @@ class TasksLibrary:
                 "the output should be an integer."
         ]
         elements += [
-                f"!@>question: {question}",
-                "!@>possible answers:",
+                f'{self.lollms.user_custom_header("question")} {question}',
+                f'{self.lollms.user_custom_header("possible answers")}',
                 f"{choices}",
         ]
-        elements += ["!@>answer:"]
+        elements += [self.lollms.ai_custom_header("answer")]
         prompt = self.build_prompt(elements)
 
-        gen = self.lollms.generate(prompt, max_answer_length, temperature=0.1, top_k=50, top_p=0.9, repeat_penalty=1.0, repeat_last_n=50, streaming_callback=self.sink).strip().replace("</s>","").replace("<s>","")
+        gen = self.lollms.generate_text(
+                            prompt=prompt,
+                            streaming_callback=self.sink).strip().replace("</s>","").replace("<s>","")
         if len(gen)>0:
             selection = gen.strip().split()[0].replace(",","").replace(".","")
             self.print_prompt("Multi choice selection",prompt+gen)
@@ -499,8 +432,8 @@ class TasksLibrary:
                                             callback, 
                                             chunk_summary_post_processing=chunk_summary_post_processing,
                                             summary_mode=summary_mode)
-            tk = self.lollms.tokenize(text)
-            tk = self.lollms.tokenize(text)
+            tk = self.lollms.binding.tokenize(text)
+            tk = self.lollms.binding.tokenize(text)
             dtk_ln=prev_len-len(tk)
             prev_len = len(tk)
             self.step(f"Current text size : {prev_len}, max summary size : {max_summary_size}")

lollms_client/lollms_tts.py

@@ -2,7 +2,7 @@ import requests
 from pydantic import BaseModel
 from lollms_client.lollms_core import LollmsClient
 from typing import Optional
-
+from ascii_colors import ASCIIColors
 class LollmsTTSRequest(BaseModel):
     text: str
     voice: str|None = None
@@ -10,7 +10,7 @@ class LollmsTTSRequest(BaseModel):
 
 class LollmsTTS:
     def __init__(self, lollmsClient:LollmsClient):
-        self.base_url = lollmsClient.host_address
+        self.base_url = lollmsClient.binding.host_address
 
     def text2Audio(self, text, voice=None, fn=None):
         endpoint = f"{self.base_url}/text2Audio"
@@ -28,7 +28,11 @@ class LollmsTTS:
             response = requests.get(endpoint)
             response.raise_for_status()  # Raise an error for bad status codes
             voices = response.json()  # Assuming the response is in JSON format
-            return voices["voices"]
+            if "error" in voices:
+                ASCIIColors.error(voices["error"])
+                return []
+            else:
+                return voices["voices"]
         except requests.exceptions.RequestException as e:
             print(f"Couldn't list voices: {e}")
             return ["main_voice"]

lollms_client/lollms_types.py

@@ -39,4 +39,22 @@ class SENDER_TYPES(Enum):
 
 class SUMMARY_MODE(Enum):
     SUMMARY_MODE_SEQUENCIAL        = 0
-    SUMMARY_MODE_HIERARCHICAL      = 0
+    SUMMARY_MODE_HIERARCHICAL      = 0
+
+class ELF_COMPLETION_FORMAT(Enum):
+    Instruct = 0
+    Chat = 1
+    @classmethod
+    def from_string(cls, format_string: str) -> 'ELF_COMPLETION_FORMAT':
+        format_mapping = {
+            "Instruct": cls.Instruct,
+            "Chat": cls.Chat,
+        }
+
+        try:
+            return format_mapping[format_string.upper()]
+        except KeyError:
+            raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
+    
+    def __str__(self):
+        return self.name    

{lollms_client-0.9.1.dist-info → lollms_client-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lollms_client
-Version: 0.9.1
+Version: 0.10.0
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo
@@ -37,30 +37,34 @@ from lollms_client import LollmsClient
 lc = LollmsClient()
 
 # Specify a custom host and port
-lc = LollmsClient(host_address="http://some.server:9600")
-
-# Use a specific model with a local or remote ollama server
-from lollms_client import ELF_GENERATION_FORMAT
-lc = LollmsClient(model_name="phi4:latest", default_generation_mode = ELF_GENERATION_FORMAT.OLLAMA)
-
-# Use a specific model with a local or remote OpenAI server (you can either set your key as an environment variable or pass it here)
-lc = LollmsClient(model_name="gpt-3.5-turbo-0125", default_generation_mode = ELF_GENERATION_FORMAT.OPENAI)
+lc = LollmsClient(host_address="http://some.lollms.server:9600")
 
+# Use a specific model with a local ollama server
+lc = LollmsClient("ollama", model_name="phi4:latest")
 # Use a specific model with an Ollama binding on the server, with a context size of 32800
 lc = LollmsClient(
+    "ollama",
     host_address="http://some.other.server:11434",
     model_name="phi4:latest",
     ctx_size=32800,
-    default_generation_mode=ELF_GENERATION_FORMAT.OLLAMA
 )
+# Use a specific model with a local or remote OpenAI server (you can either set your key as an environment variable or pass it here)
+lc = LollmsClient("openai", model_name="gpt-3.5-turbo-0125", service_key="Key, or don't put anything if you have already an environment variable with these informations")
+
+# Use a specific model with a other OpenAI compatible server
+lc = LollmsClient("openai", host_address="http://some.other.server", model_name="gpt-3.5-turbo-0125")
 ```
 
 ### Text Generation
 
-Use `generate()` for generating text from the lollms API.
+Use `generate_text()` for generating text from the lollms API.
 
 ```python
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
+response = lc.generate_text(prompt="Once upon a time", stream=False, temperature=0.5)
+print(response)
+```
+```python
+response = lc.generate_text(prompt="Once upon a time", images= ["path to image1", "path to image 2"] stream=False, temperature=0.5)
 print(response)
 ```
 

lollms_client-0.10.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+lollms_client/__init__.py,sha256=tBrrYsu4fpi8ZR5ZzTjY88O0UMv9_tqG--VXGQxK2UU,493
+lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
+lollms_client/lollms_core.py,sha256=wdeKdxXckXTqpjA2pRvmBt019v6KHEkZHGABeOsjcAU,47283
+lollms_client/lollms_discussion.py,sha256=9b83m0D894jwpgssWYTQHbVxp1gJoI-J947Ui_dRXII,2073
+lollms_client/lollms_functions.py,sha256=p8SFtmEPqvVCsIz2fZ5HxyOHaxjrAo5c12uTzJnb6m8,3594
+lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
+lollms_client/lollms_llm_binding.py,sha256=aegUdAz_3DwJ1nDmq6lxD6x1bI4c4jVa6IbgdAVyaFE,8233
+lollms_client/lollms_personality.py,sha256=gTOU7WJrxyNE88g-9-is5QxMf84s6xbEMAv--SD2P64,20313
+lollms_client/lollms_personality_worker.py,sha256=rQbZg9Gn-R3b6x0Ryb4JPWJzBfn4fObDzj5IWYez_9o,65331
+lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
+lollms_client/lollms_stt.py,sha256=4knP8SSj2S7DAFGXpIHc-_J6pb9xjExutEBd0RNex5E,1282
+lollms_client/lollms_tasks.py,sha256=Ur-Aaqr3Tm9htlRAI16NKwaVAGkY-_SENhUEikikZwA,34458
+lollms_client/lollms_tti.py,sha256=WznZ5ADhig-SFNmwlgviLZaAfl67NVqnZxYzhel3vxU,1287
+lollms_client/lollms_tts.py,sha256=KjFNkRmpM4kZpHm-IrPoYr4kPs2nOHNKPov0HXiinkg,1468
+lollms_client/lollms_types.py,sha256=cfc1sremM8KR4avkYX99fIVkkdRvXErrCWKGjLrgv50,2723
+lollms_client/lollms_utilities.py,sha256=YAgamfp0pBVApR68AHKjhp1lh6isMNF8iadwWLl63c0,7045
+lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
+lollms_client/llm_bindings/lollms/__init__.py,sha256=KGRMOSZGvlbAXiTLlaUio372jyfvt6AX8_j_DU0T-a4,11822
+lollms_client/llm_bindings/ollama/__init__.py,sha256=f798oBx7d5OR9JVT3W1m9S_GP-eZEn-g4zSJ31tAPhU,12294
+lollms_client/llm_bindings/openai/__init__.py,sha256=LeRMt1rZA4PHr3AGoa-oot7D0d62PNbduVCz5wOWyEY,10373
+lollms_client/llm_bindings/transformers/__init__.py,sha256=FBUTryB-GIKV6SlSNyj59KdbJ19g6VYwc385OD2vtLQ,11684
+lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/stt_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/tti_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/tts_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/tts_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/ttv_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lollms_client-0.10.0.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.10.0.dist-info/METADATA,sha256=ScADA2xlQdZwRXGAjwW2AvaeoZtcfOYbSbj0PlN4_-Q,6663
+lollms_client-0.10.0.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+lollms_client-0.10.0.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-0.10.0.dist-info/RECORD,,

lollms_client-0.9.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-lollms_client/__init__.py,sha256=_1_zkzDrAs43mf6LEBVZUEYCGZ8KRmj-jd_vgkB8xSw,516
-lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=KjDXCiCZS_dI1DyEHRlw0Qhim9zJfVmmCd_Lxp9U0aU,86103
-lollms_client/lollms_discussion.py,sha256=9b83m0D894jwpgssWYTQHbVxp1gJoI-J947Ui_dRXII,2073
-lollms_client/lollms_functions.py,sha256=p8SFtmEPqvVCsIz2fZ5HxyOHaxjrAo5c12uTzJnb6m8,3594
-lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_personality.py,sha256=gTOU7WJrxyNE88g-9-is5QxMf84s6xbEMAv--SD2P64,20313
-lollms_client/lollms_personality_worker.py,sha256=rQbZg9Gn-R3b6x0Ryb4JPWJzBfn4fObDzj5IWYez_9o,65331
-lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
-lollms_client/lollms_stt.py,sha256=4knP8SSj2S7DAFGXpIHc-_J6pb9xjExutEBd0RNex5E,1282
-lollms_client/lollms_tasks.py,sha256=Qy7BG4pqcwsjMLTCfRhG8M4PhJnRZhouV4blXHICqmI,38630
-lollms_client/lollms_tti.py,sha256=WznZ5ADhig-SFNmwlgviLZaAfl67NVqnZxYzhel3vxU,1287
-lollms_client/lollms_tts.py,sha256=WznZ5ADhig-SFNmwlgviLZaAfl67NVqnZxYzhel3vxU,1287
-lollms_client/lollms_types.py,sha256=uuaADVVfi1sZucY7gT8v-EDN5xrMI3vy_4M7k7Uz3eU,2170
-lollms_client/lollms_utilities.py,sha256=YAgamfp0pBVApR68AHKjhp1lh6isMNF8iadwWLl63c0,7045
-lollms_client-0.9.1.dist-info/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.9.1.dist-info/METADATA,sha256=gdd_TJNGajt13fJfPBaFPeyzulrc0ZWZWfTAK3VWTZw,6400
-lollms_client-0.9.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-lollms_client-0.9.1.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-0.9.1.dist-info/RECORD,,