lollms-client 0.8.2__tar.gz → 0.9.0__tar.gz

lollms_client-0.9.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.1
+Name: lollms_client
+Version: 0.9.0
+Summary: A client library for LoLLMs generate endpoint
+Home-page: https://github.com/ParisNeo/lollms_client
+Author: ParisNeo
+Author-email: parisneoai@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+
+# lollms_client
+
+[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apache/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
+
+Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
+
+## Installation
+
+To install the library from PyPI using `pip`, run:
+
+```
+pip install lollms-client
+``` 
+
+## Getting Started
+
+The LollmsClient class is the gateway to interacting with the lollms API. Here's how you can instantiate it in various ways to suit your needs:
+
+```python
+from lollms_client import LollmsClient
+
+# Default instantiation using the local lollms service - hosted at http://localhost:9600
+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)
+
+# Use a specific model with an Ollama binding on the server, with a context size of 32800
+lc = LollmsClient(
+    host_address="http://some.other.server:11434",
+    model_name="phi4:latest",
+    ctx_size=32800,
+    default_generation_mode=ELF_GENERATION_FORMAT.OLLAMA
+)
+```
+
+### Text Generation
+
+Use `generate()` for generating text from the lollms API.
+
+```python
+response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
+print(response)
+```
+
+### Code Generation
+
+The `generate_code()` function allows you to generate code snippets based on your input. Here's how you can use it:
+
+```python
+# A generic case to generate a snippet in python
+response = lc.generate_code(prompt="Create a function to add all numbers of a list", language='python')
+print(response)
+
+# generate_code can also be used to generate responses ready to be parsed - with json or yaml for instance
+response = lc.generate_code(prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.", language='json', template="""
+{
+ "name":"the first name of the person"
+ "family_name":"the family name of the person"
+ "age":"the age of the person"
+ "appointment_date":"the date of the appointment"
+ "reason":"the reason for the appointment. if not specified fill out with 'N/A'"
+}
+""")
+data = json.loads(response)
+print(data['name'], data['family_name'], "- Reason:", data['reason'])
+```
+
+
+### List Mounted Personalities (only on lollms)
+
+List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
+
+```python
+response = lc.listMountedPersonalities()
+print(response)
+```
+
+### List Models
+
+List available models of the lollms API with the `listModels()` method.
+
+```python
+response = lc.listModels()
+print(response)
+```
+
+## Complete Example
+
+```python
+import json
+from datetime import datetime
+
+# Assuming LollmsClient is already imported and instantiated as lc
+lc = LollmsClient()
+
+# Generate code using the LollmsClient
+response = lc.generate_code(
+    prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.",
+    language='json',
+    template="""
+    {
+        "name": "the first name of the person",
+        "family_name": "the family name of the person",
+        "age": "the age of the person",
+        "appointment_date": "the date of the appointment in the format DD/MM/YYYY",
+        "reason": "the reason for the appointment. if not specified fill out with 'N/A'"
+    }
+    """
+)
+
+# Parse the JSON response
+data = json.loads(response)
+
+# Function to validate the data
+def validate_data(data):
+    try:
+        # Validate age
+        if not (0 < int(data['age']) < 120):
+            raise ValueError("Invalid age provided.")
+        
+        # Validate appointment date
+        appointment_date = datetime.strptime(data['appointment_date'], '%d/%m/%Y')
+        if appointment_date < datetime.now():
+            raise ValueError("Appointment date cannot be in the past.")
+        
+        # Validate name fields
+        if not data['name'] or not data['family_name']:
+            raise ValueError("Name fields cannot be empty.")
+        
+        return True
+    except Exception as e:
+        print(f"Validation Error: {e}")
+        return False
+
+# Function to simulate a response to the user
+def simulate_response(data):
+    if validate_data(data):
+        print(f"Appointment confirmed for {data['name']} {data['family_name']}.")
+        print(f"Date: {data['appointment_date']}")
+        print(f"Reason: {data['reason']}")
+    else:
+        print("Failed to confirm appointment due to invalid data.")
+
+# Execute the simulation
+simulate_response(data)
+```
+
+Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
+
+Happy coding!

lollms_client-0.9.0/README.md

@@ -0,0 +1,158 @@
+# lollms_client
+
+[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apache/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
+
+Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
+
+## Installation
+
+To install the library from PyPI using `pip`, run:
+
+```
+pip install lollms-client
+``` 
+
+## Getting Started
+
+The LollmsClient class is the gateway to interacting with the lollms API. Here's how you can instantiate it in various ways to suit your needs:
+
+```python
+from lollms_client import LollmsClient
+
+# Default instantiation using the local lollms service - hosted at http://localhost:9600
+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)
+
+# Use a specific model with an Ollama binding on the server, with a context size of 32800
+lc = LollmsClient(
+    host_address="http://some.other.server:11434",
+    model_name="phi4:latest",
+    ctx_size=32800,
+    default_generation_mode=ELF_GENERATION_FORMAT.OLLAMA
+)
+```
+
+### Text Generation
+
+Use `generate()` for generating text from the lollms API.
+
+```python
+response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
+print(response)
+```
+
+### Code Generation
+
+The `generate_code()` function allows you to generate code snippets based on your input. Here's how you can use it:
+
+```python
+# A generic case to generate a snippet in python
+response = lc.generate_code(prompt="Create a function to add all numbers of a list", language='python')
+print(response)
+
+# generate_code can also be used to generate responses ready to be parsed - with json or yaml for instance
+response = lc.generate_code(prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.", language='json', template="""
+{
+ "name":"the first name of the person"
+ "family_name":"the family name of the person"
+ "age":"the age of the person"
+ "appointment_date":"the date of the appointment"
+ "reason":"the reason for the appointment. if not specified fill out with 'N/A'"
+}
+""")
+data = json.loads(response)
+print(data['name'], data['family_name'], "- Reason:", data['reason'])
+```
+
+
+### List Mounted Personalities (only on lollms)
+
+List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
+
+```python
+response = lc.listMountedPersonalities()
+print(response)
+```
+
+### List Models
+
+List available models of the lollms API with the `listModels()` method.
+
+```python
+response = lc.listModels()
+print(response)
+```
+
+## Complete Example
+
+```python
+import json
+from datetime import datetime
+
+# Assuming LollmsClient is already imported and instantiated as lc
+lc = LollmsClient()
+
+# Generate code using the LollmsClient
+response = lc.generate_code(
+    prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.",
+    language='json',
+    template="""
+    {
+        "name": "the first name of the person",
+        "family_name": "the family name of the person",
+        "age": "the age of the person",
+        "appointment_date": "the date of the appointment in the format DD/MM/YYYY",
+        "reason": "the reason for the appointment. if not specified fill out with 'N/A'"
+    }
+    """
+)
+
+# Parse the JSON response
+data = json.loads(response)
+
+# Function to validate the data
+def validate_data(data):
+    try:
+        # Validate age
+        if not (0 < int(data['age']) < 120):
+            raise ValueError("Invalid age provided.")
+        
+        # Validate appointment date
+        appointment_date = datetime.strptime(data['appointment_date'], '%d/%m/%Y')
+        if appointment_date < datetime.now():
+            raise ValueError("Appointment date cannot be in the past.")
+        
+        # Validate name fields
+        if not data['name'] or not data['family_name']:
+            raise ValueError("Name fields cannot be empty.")
+        
+        return True
+    except Exception as e:
+        print(f"Validation Error: {e}")
+        return False
+
+# Function to simulate a response to the user
+def simulate_response(data):
+    if validate_data(data):
+        print(f"Appointment confirmed for {data['name']} {data['family_name']}.")
+        print(f"Date: {data['appointment_date']}")
+        print(f"Reason: {data['reason']}")
+    else:
+        print("Failed to confirm appointment due to invalid data.")
+
+# Execute the simulation
+simulate_response(data)
+```
+
+Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
+
+Happy coding!

{lollms_client-0.8.2 → lollms_client-0.9.0}/lollms_client/lollms_core.py

@@ -1555,20 +1555,42 @@ Do not split the code in multiple tags.
         
         return cleaned_text
 
-    def sequential_summarize(self, text, summary_context="", task="Create final summary using this memory.", format="bullet points", tone="neutral", ctx_size=8192, callback = None):
+    def sequential_summarize(
+                                self, 
+                                text:str,
+                                chunk_processing_prompt:str="Extract relevant information from the current text chunk and update the memory if needed.",
+                                chunk_processing_output_format="markdown",
+                                final_memory_processing_prompt="Create final summary using this memory.",
+                                final_output_format="markdown",
+                                ctx_size:int=None,
+                                chunk_size:int=None,
+                                bootstrap_chunk_size:int=None,
+                                bootstrap_steps:int=None,
+                                callback = None,
+                                debug:bool= False):
         """
-        Summarizes a long text sequentially by processing chunks and maintaining a memory.
-        
-        Args:
-            text (str): The input text to summarize.
-            summary_context (str): Optional context to guide the summarization.
-            format (str): Desired format for the final summary (e.g., "bullet points").
-            tone (str): Desired tone for the final summary (e.g., "neutral").
-            ctx_size (int): Total context window size of the model.
-        
-        Returns:
-            str: The final formatted summary.
+            This function processes a given text in chunks and generates a summary for each chunk.
+            It then combines the summaries to create a final summary.
+
+            Parameters:
+            text (str): The input text to be summarized.
+            chunk_processing_prompt (str, optional): The prompt used for processing each chunk. Defaults to "".
+            chunk_processing_output_format (str, optional): The format of the output for each chunk. Defaults to "markdown".
+            final_memory_processing_prompt (str, optional): The prompt used for processing the final memory. Defaults to "Create final summary using this memory.".
+            final_output_format (str, optional): The format of the final output. Defaults to "markdown".
+            ctx_size (int, optional): The size of the context. Defaults to None.
+            chunk_size (int, optional): The size of each chunk. Defaults to None.
+            callback (callable, optional): A function to be called after processing each chunk. Defaults to None.
+            debug (bool, optional): A flag to enable debug mode. Defaults to False.
+
+            Returns:
+            The final summary in the specified format.
         """
+        if ctx_size is None:
+            ctx_size = self.ctx_size
+        
+        if chunk_size is None:
+            chunk_size = ctx_size//4
         
         # Tokenize entire text
         all_tokens = self.tokenize(text)
@@ -1579,21 +1601,46 @@ Do not split the code in multiple tags.
         start_token_idx = 0
         
         # Create static prompt template
-        static_prompt_template = f"""!@>instruction:
-Update the summary memory by combining previous memory with key information from this text chunk. {summary_context if summary_context else ''}
-Keep memory concise using bullet points.
+        static_prompt_template = f"""{self.system_full_header}
+You are a structured sequential text summary assistant that processes documents chunk by chunk, updating a memory of previously generated information at each step.
 
-!@>current memory:
-{{memory}}
+Your goal is to extract and combine relevant information from each text chunk with the existing memory, ensuring no key details are omitted or invented.
 
-!@>new text chunk:
+If requested, infer metadata like titles or authors from the content.
+
+{self.user_full_header}
+Update the memory by merging previous information with new details from this text chunk.
+Only add information explicitly present in the chunk. Retain all relevant prior memory unless clarified or updated by the current chunk.
+
+----
+# Text chunk:
+# Chunk number: {{chunk_id}}
+----
+```markdown
 {{chunk}}
+```
 
-!@>updated memory:
-"""
-        
+{{custom_prompt}}
+
+Before updating, verify each requested detail:
+1. Does the chunk explicitly mention the information?
+2. Should prior memory be retained, updated, or clarified?
+
+Include only confirmed details in the output.
+Rewrite the full memory including the updates and keeping relevant data.
+Do not discuss the information inside thememory, just put the relevant information without comments.
+
+----
+# Current document analysis memory:
+----
+```{chunk_processing_output_format}
+{{memory}}
+```
+{self.ai_full_header}
+""" 
         # Calculate static prompt tokens (with empty memory and chunk)
-        example_prompt = static_prompt_template.format(memory="", chunk="")
+        chunk_id=0
+        example_prompt = static_prompt_template.format(custom_prompt=chunk_processing_prompt if chunk_processing_prompt else '', memory="", chunk="", chunk_id=chunk_id)
         static_tokens = len(self.tokenize(example_prompt))
         
         # Process text in chunks
@@ -1606,31 +1653,47 @@ Keep memory concise using bullet points.
                 raise ValueError("Memory too large - consider reducing chunk size or increasing context window")
             
             # Get chunk tokens
-            end_token_idx = min(start_token_idx + available_tokens, total_tokens)
+            if bootstrap_chunk_size is not None and chunk_id < bootstrap_steps:
+                end_token_idx = min(start_token_idx + bootstrap_chunk_size, total_tokens)
+            else:                
+                end_token_idx = min(start_token_idx + chunk_size, total_tokens)
             chunk_tokens = all_tokens[start_token_idx:end_token_idx]
             chunk = self.detokenize(chunk_tokens)
+            chunk_id +=1
             
             # Generate memory update
-            prompt = static_prompt_template.format(memory=memory, chunk=chunk)
-            memory = self.generate(prompt, n_predict=ctx_size//4, streaming_callback=callback).strip()
+            prompt = static_prompt_template.format(custom_prompt=chunk_processing_prompt if chunk_processing_prompt else '', memory=memory, chunk=chunk, chunk_id=chunk_id)
+            if debug:
+                ASCIIColors.yellow(f" ----- {chunk_id-1} ------")
+                ASCIIColors.red(prompt)
             
+            memory = self.generate(prompt, n_predict=ctx_size//4, streaming_callback=callback).strip()
+            code = self.extract_code_blocks(memory)
+            if code:
+                memory=code[0]["content"]
+                
+            if debug:
+                ASCIIColors.yellow(f" ----- OUT ------")
+                ASCIIColors.yellow(memory)
+                ASCIIColors.yellow(" ----- ------")
             # Move to next chunk
             start_token_idx = end_token_idx
         
         # Prepare final summary prompt
-        final_prompt_template = f"""!@>instruction:
-{task}. Follow these requirements:
-Format: {format}
-Tone: {tone}
-
-!@>memory:
-{{memory}}
-
-!@>summary:
+        final_prompt_template = f"""!@>system:
+You are a memory summarizer assistant that helps users format their memory information into coherant text in a specific style or format.
+{final_memory_processing_prompt}.
+!@>user:
+Here is my document analysis memory:
+```{chunk_processing_output_format}
+{memory}
+```
+The output must be put inside a {final_output_format} markdown tag.
+The updated memory must be put in a {chunk_processing_output_format} markdown tag.
+!@>assistant:
 """
-        
         # Truncate memory if needed for final prompt
-        example_final_prompt = final_prompt_template.format(memory=memory)
+        example_final_prompt = final_prompt_template
         final_static_tokens = len(self.tokenize(example_final_prompt))
         available_final_tokens = ctx_size - final_static_tokens
         
@@ -1639,8 +1702,12 @@ Tone: {tone}
             memory = self.detokenize(memory_tokens[:available_final_tokens])
         
         # Generate final summary
-        final_prompt = final_prompt_template.format(memory=memory)
-        return self.generate(final_prompt, streaming_callback=callback)
+        final_prompt = final_prompt_template
+        memory = self.generate(final_prompt, streaming_callback=callback)
+        code = self.extract_code_blocks(memory)
+        if code:
+            memory=code[0]["content"]
+        return memory
 
 def error(self, content, duration:int=4, client_id=None, verbose:bool=True):
     ASCIIColors.error(content)

lollms_client-0.9.0/lollms_client.egg-info/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.1
+Name: lollms_client
+Version: 0.9.0
+Summary: A client library for LoLLMs generate endpoint
+Home-page: https://github.com/ParisNeo/lollms_client
+Author: ParisNeo
+Author-email: parisneoai@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+
+# lollms_client
+
+[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apache/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
+
+Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
+
+## Installation
+
+To install the library from PyPI using `pip`, run:
+
+```
+pip install lollms-client
+``` 
+
+## Getting Started
+
+The LollmsClient class is the gateway to interacting with the lollms API. Here's how you can instantiate it in various ways to suit your needs:
+
+```python
+from lollms_client import LollmsClient
+
+# Default instantiation using the local lollms service - hosted at http://localhost:9600
+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)
+
+# Use a specific model with an Ollama binding on the server, with a context size of 32800
+lc = LollmsClient(
+    host_address="http://some.other.server:11434",
+    model_name="phi4:latest",
+    ctx_size=32800,
+    default_generation_mode=ELF_GENERATION_FORMAT.OLLAMA
+)
+```
+
+### Text Generation
+
+Use `generate()` for generating text from the lollms API.
+
+```python
+response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
+print(response)
+```
+
+### Code Generation
+
+The `generate_code()` function allows you to generate code snippets based on your input. Here's how you can use it:
+
+```python
+# A generic case to generate a snippet in python
+response = lc.generate_code(prompt="Create a function to add all numbers of a list", language='python')
+print(response)
+
+# generate_code can also be used to generate responses ready to be parsed - with json or yaml for instance
+response = lc.generate_code(prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.", language='json', template="""
+{
+ "name":"the first name of the person"
+ "family_name":"the family name of the person"
+ "age":"the age of the person"
+ "appointment_date":"the date of the appointment"
+ "reason":"the reason for the appointment. if not specified fill out with 'N/A'"
+}
+""")
+data = json.loads(response)
+print(data['name'], data['family_name'], "- Reason:", data['reason'])
+```
+
+
+### List Mounted Personalities (only on lollms)
+
+List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
+
+```python
+response = lc.listMountedPersonalities()
+print(response)
+```
+
+### List Models
+
+List available models of the lollms API with the `listModels()` method.
+
+```python
+response = lc.listModels()
+print(response)
+```
+
+## Complete Example
+
+```python
+import json
+from datetime import datetime
+
+# Assuming LollmsClient is already imported and instantiated as lc
+lc = LollmsClient()
+
+# Generate code using the LollmsClient
+response = lc.generate_code(
+    prompt="Mr Alex Brown presents himself to the pharmacist. He is 20 years old and seeks an appointment for the 12th of October. Fill out his application.",
+    language='json',
+    template="""
+    {
+        "name": "the first name of the person",
+        "family_name": "the family name of the person",
+        "age": "the age of the person",
+        "appointment_date": "the date of the appointment in the format DD/MM/YYYY",
+        "reason": "the reason for the appointment. if not specified fill out with 'N/A'"
+    }
+    """
+)
+
+# Parse the JSON response
+data = json.loads(response)
+
+# Function to validate the data
+def validate_data(data):
+    try:
+        # Validate age
+        if not (0 < int(data['age']) < 120):
+            raise ValueError("Invalid age provided.")
+        
+        # Validate appointment date
+        appointment_date = datetime.strptime(data['appointment_date'], '%d/%m/%Y')
+        if appointment_date < datetime.now():
+            raise ValueError("Appointment date cannot be in the past.")
+        
+        # Validate name fields
+        if not data['name'] or not data['family_name']:
+            raise ValueError("Name fields cannot be empty.")
+        
+        return True
+    except Exception as e:
+        print(f"Validation Error: {e}")
+        return False
+
+# Function to simulate a response to the user
+def simulate_response(data):
+    if validate_data(data):
+        print(f"Appointment confirmed for {data['name']} {data['family_name']}.")
+        print(f"Date: {data['appointment_date']}")
+        print(f"Reason: {data['reason']}")
+    else:
+        print("Failed to confirm appointment due to invalid data.")
+
+# Execute the simulation
+simulate_response(data)
+```
+
+Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
+
+Happy coding!

{lollms_client-0.8.2 → lollms_client-0.9.0}/setup.py

@@ -8,7 +8,7 @@ with open('requirements.txt', 'r') as f:
     
 setuptools.setup(
     name="lollms_client",
-    version="0.8.2",
+    version="0.9.0",
     author="ParisNeo",
     author_email="parisneoai@gmail.com",
     description="A client library for LoLLMs generate endpoint",

lollms_client-0.8.2/PKG-INFO

@@ -1,97 +0,0 @@
-Metadata-Version: 2.1
-Name: lollms_client
-Version: 0.8.2
-Summary: A client library for LoLLMs generate endpoint
-Home-page: https://github.com/ParisNeo/lollms_client
-Author: ParisNeo
-Author-email: parisneoai@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests
-
-# lollms_client
-
-[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apachie/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
-
-Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
-
-## Installation
-
-To install the library from PyPI using `pip`, run:
-
-```
-pip install lollms-client
-``` 
-
-## Usage
-
-To use the lollms_client, first import the necessary classes:
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance this uses the default lollms localhost service http://localhost:9600
-lc = LollmsClient()
-# You can also use a different host and port number if you please
-lc = LollmsClient("http://some.other.server:9600")
-# You can also use a local or remote ollama server
-lc = LollmsClient(model_name="mistral-nemo:latest", default_generation_mode = ELF_GENERATION_FORMAT.OLLAMA)
-# You can also use 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)
-```
-
-### Text Generation
-
-Use `generate()` for generating text from the lollms API.
-
-```python
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-```
-
-
-### List Mounted Personalities (only on lollms)
-
-List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
-
-```python
-response = lc.listMountedPersonalities()
-print(response)
-```
-
-### List Models
-
-List available models of the lollms API with the `listModels()` method.
-
-```python
-response = lc.listModels()
-print(response)
-```
-
-## Complete Example
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance
-lc = LollmsClient()
-
-# Generate Text
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-
-# List Mounted Personalities
-response = lc.listMountedPersonalities()
-print(response)
-
-# List Models
-response = lc.listModels()
-print(response)
-```
-
-Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
-
-Happy coding!

lollms_client-0.8.2/README.md

@@ -1,83 +0,0 @@
-# lollms_client
-
-[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apachie/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
-
-Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
-
-## Installation
-
-To install the library from PyPI using `pip`, run:
-
-```
-pip install lollms-client
-``` 
-
-## Usage
-
-To use the lollms_client, first import the necessary classes:
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance this uses the default lollms localhost service http://localhost:9600
-lc = LollmsClient()
-# You can also use a different host and port number if you please
-lc = LollmsClient("http://some.other.server:9600")
-# You can also use a local or remote ollama server
-lc = LollmsClient(model_name="mistral-nemo:latest", default_generation_mode = ELF_GENERATION_FORMAT.OLLAMA)
-# You can also use 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)
-```
-
-### Text Generation
-
-Use `generate()` for generating text from the lollms API.
-
-```python
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-```
-
-
-### List Mounted Personalities (only on lollms)
-
-List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
-
-```python
-response = lc.listMountedPersonalities()
-print(response)
-```
-
-### List Models
-
-List available models of the lollms API with the `listModels()` method.
-
-```python
-response = lc.listModels()
-print(response)
-```
-
-## Complete Example
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance
-lc = LollmsClient()
-
-# Generate Text
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-
-# List Mounted Personalities
-response = lc.listMountedPersonalities()
-print(response)
-
-# List Models
-response = lc.listModels()
-print(response)
-```
-
-Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
-
-Happy coding!

lollms_client-0.8.2/lollms_client.egg-info/PKG-INFO

@@ -1,97 +0,0 @@
-Metadata-Version: 2.1
-Name: lollms_client
-Version: 0.8.2
-Summary: A client library for LoLLMs generate endpoint
-Home-page: https://github.com/ParisNeo/lollms_client
-Author: ParisNeo
-Author-email: parisneoai@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests
-
-# lollms_client
-
-[![Python Version](https://img.shields.io/pypi/pyversions/lollms-client)](https://pypi.org/project/lollms-client/) [![PyPI Downloads](https://img.shields.io/pypi/dw/lollms-client)](https://pypi.org/project/lollms-client/) [![Apache License](https://img.shields.io/apachie/2.0)](https://www.apache.org/licenses/LICENSE-2.0)
-
-Welcome to the lollms_client repository! This library is built by [ParisNeo](https://github.com/ParisNeo) and provides a convenient way to interact with the lollms (Lord Of Large Language Models) API. It is available on [PyPI](https://pypi.org/project/lollms-client/) and distributed under the Apache 2.0 License.
-
-## Installation
-
-To install the library from PyPI using `pip`, run:
-
-```
-pip install lollms-client
-``` 
-
-## Usage
-
-To use the lollms_client, first import the necessary classes:
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance this uses the default lollms localhost service http://localhost:9600
-lc = LollmsClient()
-# You can also use a different host and port number if you please
-lc = LollmsClient("http://some.other.server:9600")
-# You can also use a local or remote ollama server
-lc = LollmsClient(model_name="mistral-nemo:latest", default_generation_mode = ELF_GENERATION_FORMAT.OLLAMA)
-# You can also use 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)
-```
-
-### Text Generation
-
-Use `generate()` for generating text from the lollms API.
-
-```python
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-```
-
-
-### List Mounted Personalities (only on lollms)
-
-List mounted personalities of the lollms API with the `listMountedPersonalities()` method.
-
-```python
-response = lc.listMountedPersonalities()
-print(response)
-```
-
-### List Models
-
-List available models of the lollms API with the `listModels()` method.
-
-```python
-response = lc.listModels()
-print(response)
-```
-
-## Complete Example
-
-```python
-from lollms_client import LollmsClient
-
-# Initialize the LollmsClient instance
-lc = LollmsClient()
-
-# Generate Text
-response = lc.generate(prompt="Once upon a time", stream=False, temperature=0.5)
-print(response)
-
-# List Mounted Personalities
-response = lc.listMountedPersonalities()
-print(response)
-
-# List Models
-response = lc.listModels()
-print(response)
-```
-
-Feel free to contribute to the project by submitting issues or pull requests. Follow [ParisNeo](https://github.com/ParisNeo) on [GitHub](https://github.com/ParisNeo), [Twitter](https://twitter.com/ParisNeo_AI), [Discord](https://discord.gg/BDxacQmv), [Sub-Reddit](r/lollms), and [Instagram](https://www.instagram.com/spacenerduino/) for updates and news.
-
-Happy coding!