lollms-client 0.12.6__tar.gz → 0.13.0__tar.gz

{lollms_client-0.12.6 → lollms_client-0.13.0}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.12.6
+Version: 0.13.0
 Summary: A client library for LoLLMs generate endpoint
-Home-page: https://github.com/ParisNeo/lollms_client
-Author: ParisNeo
-Author-email: parisneoai@gmail.com
+Author-email: ParisNeo <parisneoai@gmail.com>
+License: Apache Software License
+Project-URL: Homepage, https://github.com/ParisNeo/lollms_client
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: summary
 
 # lollms_client
 

lollms_client-0.13.0/examples/article_summary/article_summary.py

@@ -0,0 +1,58 @@
+from lollms_client import LollmsClient
+import pipmaster as pm
+from ascii_colors import ASCIIColors
+if not pm.is_installed("docling"):
+    pm.install("docling")
+from docling.document_converter import DocumentConverter
+
+ASCIIColors.set_log_file("log.log")
+
+lc = LollmsClient()
+# Create prompts for each section
+article_url = "https://arxiv.org/pdf/2109.09572"
+converter = DocumentConverter()
+result = converter.convert(article_url)
+article_text = result.document.export_to_markdown()
+
+ASCIIColors.info("Article loaded successfully")
+
+# Use the sequential_summarize method from lollms
+summary = lc.sequential_summarize(
+                    article_text,
+                    """
+Extract the following information if present in the chunk:
+
+1. **Title**: 
+   - Found in text chunk number 1 at the beginning. It should be followed by # or ##
+   - Copy exactly as presented; do not interpret.
+   - Never alter this if already in the memory. This is important
+
+2. **Authors**: 
+   - Listed in text chunk number 1 at the beginning.
+   - If you fail to find the authors keep this empty.
+   - Copy exactly as presented; do not interpret.
+   - Never alter this if already in the memory. This is important
+
+3. **Summary**: 
+   - Provide a concise but detailed summary of the article by adding ned information from the text chunk to the memory content.
+
+4. **Results**: 
+   - Extract quantified results if available.
+
+Ensure that any information already in memory is retained unless explicitly updated by the current chunk.
+""",
+                    "markdown",
+                    """Write a final markdown with these sections:
+## Title
+## Authors
+## Summary
+## Results
+                    """,
+                    ctx_size=128000,
+                    chunk_size=4096,
+                    bootstrap_chunk_size=1024,
+                    bootstrap_steps=1,
+                    debug = True
+                )
+
+ASCIIColors.yellow(summary)

lollms_client-0.13.0/examples/deep_analyze/deep_analyse.py

@@ -0,0 +1,30 @@
+from lollms_client import LollmsClient
+import pipmaster as pm
+from ascii_colors import ASCIIColors
+if not pm.is_installed("docling"):
+    pm.install("docling")
+from docling.document_converter import DocumentConverter
+
+ASCIIColors.set_log_file("log.log")
+
+lc = LollmsClient()
+# Create prompts for each section
+article_url = "https://arxiv.org/pdf/2109.09572"
+converter = DocumentConverter()
+result = converter.convert(article_url)
+article_text = result.document.export_to_markdown()
+
+ASCIIColors.info("Article loaded successfully")
+
+# Use the sequential_summarize method from lollms
+result = lc.deep_analyze(
+                    "Explain what is the difference between HGG and QGG",
+                    article_text,
+                    ctx_size=128000,
+                    chunk_size=1024,
+                    bootstrap_chunk_size=512,
+                    bootstrap_steps=1,
+                    debug = True
+                )
+
+print(result)

lollms_client-0.13.0/examples/deep_analyze/deep_analyze_multiple_files.py

@@ -0,0 +1,32 @@
+from lollms_client import LollmsClient
+from pathlib import Path
+import pipmaster as pm
+from ascii_colors import ASCIIColors
+
+ASCIIColors.set_log_file("log.log")
+def load_and_analyze_files():
+    folder_path = Path('.')  # Change '.' to your desired directory
+    allowed_extensions = {'.pdf', '.txt', '.md', '.docx', '.pptx', '.html'}
+    
+    matching_files = []
+    for file in folder_path.rglob('*'):
+        if file.suffix.lower() in allowed_extensions and file.is_file():
+            matching_files.append(str(file.absolute()))
+            
+    # Now use these files with LollmsClient
+    lc = LollmsClient()
+    ASCIIColors.info(f"Loading {len(matching_files)} files for analysis")
+    
+    result = lc.deep_analyze(
+        "Explain what is the difference between HGG and QGG",
+        files=matching_files,
+        ctx_size=128000,
+        chunk_size=1024,
+        bootstrap_chunk_size=512,
+        bootstrap_steps=1,
+        debug=True
+    )
+    
+    print(result)
+
+load_and_analyze_files()

lollms_client-0.13.0/examples/function_call/functions_call_with images.py

@@ -0,0 +1,52 @@
+import cv2
+from lollms_client import LollmsClient, LollmsTTS, TasksLibrary, FunctionCalling_Library
+import random
+
+# Initialize the LollmsClient instance
+lc = LollmsClient()
+tl = TasksLibrary(lc)
+tts = LollmsTTS(lc)
+fcl = FunctionCalling_Library(tl)
+voices = tts.get_voices()
+if voices:
+    # Pick a voice randomly
+    random_voice = random.choice(voices)
+    print(f"Selected voice: {random_voice}")
+
+# File path to save the captured image
+file_path = "captured_image.jpg"
+images = []
+# Capture image from webcam and save it to a file
+def capture_image():
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        raise Exception("Could not open webcam")
+
+    ret, frame = cap.read()
+    if not ret:
+        raise Exception("Failed to capture image")
+    images.clear()
+    images.append(file_path)
+    cv2.imwrite(file_path, frame)
+    cap.release()
+    return "Image captured successfully"
+
+
+fcl.register_function("capture_image",capture_image,"Captures an image from the user webcam",[])
+
+
+
+# Function to handle streaming callback
+def cb(chunk, type):
+    print(chunk, end="", flush=True)
+
+# Generate text with image
+response, function_calls = fcl.generate_with_functions_and_images(prompt="user: take a look at me then tell ma how i look.\nassistant: ", images=images, stream=False, temperature=0.5, streaming_callback=cb)
+print(f"response: {response}")
+if len(function_calls)>0:
+    results = fcl.execute_function_calls(function_calls)
+    result = "\n".join(results)
+    prompt="user: take a look at me then tell ma how i look.\nassistant: "+response + f"\nfunction execution result: {result}\nassistant: "
+    response, function_calls = fcl.generate_with_functions_and_images(prompt, images=images, stream=False, temperature=0.5, streaming_callback=cb)
+print(f"response: {response}")
+tts.text2Audio(response, random_voice)

lollms_client-0.13.0/examples/personality_test/chat_test.py

@@ -0,0 +1,37 @@
+from lollms_client import LollmsClient, LollmsDiscussion
+from lollms_client import LollmsPersonality
+from lollms_client import MSG_TYPE, ELF_GENERATION_FORMAT
+from ascii_colors import ASCIIColors
+# Callback send
+def cb(chunk, type: MSG_TYPE):
+    print(chunk,end="", flush=True)
+
+# Initialize the LollmsClient instance
+lc = LollmsClient("http://localhost:9600",default_generation_mode=ELF_GENERATION_FORMAT.OPENAI)
+# Bu_ild inline personality
+p = LollmsPersonality(
+                        lc, 
+                        "./personality/test/work_dir", 
+                        "./personality/test/config_dir", 
+                        cb, 
+                        None,
+                        author="ParisNeo",
+                        name="test_persona",
+                        user_name="user",
+                        category="generic",
+                        category_desc="generic stuff",
+                        language="English",
+                        personality_conditioning="!@>system: Act as a helper to the user.",
+                        welcome_message="Hi, I'm your helper. Let me help you",
+
+                        )
+d = LollmsDiscussion(lc)
+prompt=""
+ASCIIColors.green("To quit press q")
+ASCIIColors.yellow(p.welcome_message)
+while prompt!="q":
+    prompt = input("user:")
+    if prompt=="q":
+        break
+    p.generate(d,prompt,stream=True)
+    print("")

lollms_client-0.13.0/examples/personality_test/chat_with_aristotle.py

@@ -0,0 +1,42 @@
+from lollms_client import LollmsClient, LollmsDiscussion
+from lollms_client import LollmsPersonality
+from lollms_client import MSG_TYPE, ELF_GENERATION_FORMAT
+from ascii_colors import ASCIIColors
+# Callback send
+def cb(chunk, type: MSG_TYPE):
+    print(chunk,end="", flush=True)
+
+# Initialize the LollmsClient instance
+lc = LollmsClient("http://localhost:9600",default_generation_mode=ELF_GENERATION_FORMAT.LOLLMS)
+# Bu_ild inline personality
+aristotle_personality  = LollmsPersonality(
+                        lc, 
+                        "./personality/test/work_dir", 
+                        "./personality/test/config_dir", 
+                        cb, 
+                        None,
+                        author="ParisNeo",
+                        name="test_persona",
+                        user_name="user",
+                        category="generic",
+                        category_desc="generic stuff",
+                        language="English",
+                        personality_conditioning="!@>system: Act as the philosopher Aristotle, sharing wisdom and engaging in logical discussions.",
+                        welcome_message="Greetings, I am Aristotle, your guide in the pursuit of knowledge. How may I assist you in your philosophical inquiries?",
+                    )
+# Create a Discussion instance for Aristotle
+aristotle_discussion = LollmsDiscussion(lc)
+
+# Initialize user prompt
+prompt = ""
+
+# Print welcome message in yellow
+ASCIIColors.yellow(aristotle_personality.welcome_message)
+
+# Interaction loop
+while prompt.lower() != "q":
+    prompt = input("student: ")
+    if prompt.lower() == "q":
+        break
+    aristotle_personality.generate(aristotle_discussion, prompt, stream=True)
+    print("")

lollms_client-0.13.0/examples/personality_test/tesks_test.py

@@ -0,0 +1,62 @@
+from lollms_client import LollmsClient, LollmsDiscussion
+from lollms_client import TasksLibrary
+from ascii_colors import ASCIIColors
+
+lc = LollmsClient("http://localhost:9600")
+tl = TasksLibrary(lc)
+
+# ======================================= Multichoice Q&A ==========================
+# Define a multichoice question
+question = "What is the capital city of France?"
+
+# Define the possible answers
+possible_answers = ["Paris", "Berlin", "London", "Madrid"]
+
+# Call the multichoice_question function with the question and possible answers
+selected_option = tl.multichoice_question(question, possible_answers)
+
+
+ASCIIColors.yellow(question)
+ASCIIColors.green(possible_answers[selected_option])
+
+# ======================================= Yes no  ==========================
+# Define a yes or no question
+question = "Is Paris the capital city of France?"
+
+# Call the yes_no function with the question
+answer = tl.yes_no(question)
+ASCIIColors.yellow(question)
+ASCIIColors.green("Yes" if answer else "No")
+
+
+# ======================================= Code extraction  ==========================
+# Define a text with code blocks
+text = """
+Here is some text with a code block:
+```python
+def hello_world():
+    print("Hello, world!")
+```
+And here is another code block:
+```java
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello, World!");
+    }
+}
+```
+"""
+
+# Call the extract_code_blocks function with the text
+code_blocks = tl.extract_code_blocks(text)
+
+# Print the extracted code blocks
+for i, code_block in enumerate(code_blocks):
+    ASCIIColors.bold(f"Code block {i + 1}:")
+    ASCIIColors.bold(f"Index: {code_block['index']}")
+    ASCIIColors.bold(f"File name: {code_block['file_name']}")
+    ASCIIColors.bold(f"Content: {code_block['content']}")
+    ASCIIColors.bold(f"Type: {code_block['type']}")
+    print()
+
+

lollms_client-0.13.0/examples/simple_text_gen_test.py

@@ -0,0 +1,171 @@
+from lollms_client import LollmsClient, ELF_COMPLETION_FORMAT
+from lollms_client.lollms_types import MSG_TYPE # For callback signature
+from ascii_colors import ASCIIColors, trace_exception
+
+# --- Configuration ---
+# Choose your LLM binding and parameters here
+# Option 1: Default LOLLMS server binding
+BINDING_NAME = "lollms"
+HOST_ADDRESS = "http://localhost:9600"
+MODEL_NAME = None # Server will use its default or last loaded model
+
+# Option 2: Ollama binding
+#ensure you have the right models
+#BINDING_NAME = "ollama"
+#HOST_ADDRESS = "http://localhost:11434" # Default Ollama host
+#MODEL_NAME = "mistral:latest" # Or "llama3:latest", "phi3:latest", etc. - ensure it's pulled in Ollama
+
+# Option 3: OpenAI binding (requires OPENAI_API_KEY environment variable or service_key)
+# BINDING_NAME = "openai"
+# HOST_ADDRESS = None # Defaults to OpenAI API
+# MODEL_NAME = "gpt-3.5-turbo"
+# SERVICE_KEY = "" # Optional, can use env var
+
+# --- Callback for streaming ---
+def simple_streaming_callback(chunk: str, msg_type: MSG_TYPE, params=None, metadata=None) -> bool:
+    """
+    Simple callback function to print streamed text chunks.
+    """
+    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+        print(chunk, end="", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
+        ASCIIColors.error(f"\nStreaming Error: {chunk}")
+    # Return True to continue streaming, False to stop
+    return True
+
+def test_text_generation():
+    ASCIIColors.cyan(f"\n--- Testing Text Generation with '{BINDING_NAME}' binding ---")
+    ASCIIColors.cyan(f"Host: {HOST_ADDRESS or 'Default'}, Model: {MODEL_NAME or 'Default'}")
+
+    try:
+        # Initialize LollmsClient
+        lc_params = {
+            "binding_name": BINDING_NAME,
+            "host_address": HOST_ADDRESS,
+            "model_name": MODEL_NAME,
+            #"service_key": SERVICE_KEY, # Uncomment for OpenAI if needed
+        }
+        # Remove None host_address for bindings that have internal defaults (like OpenAI)
+        if lc_params["host_address"] is None and BINDING_NAME in ["openai"]:
+             del lc_params["host_address"]
+
+
+        lc = LollmsClient(**lc_params)
+
+        # 1. Test basic non-streaming generation
+        ASCIIColors.magenta("\n1. Basic Non-Streaming Generation:")
+        prompt_non_stream = "Tell me a short joke about a programmer."
+        ASCIIColors.yellow(f"Prompt: {prompt_non_stream}")
+        response_non_stream = lc.generate_text(
+            prompt=prompt_non_stream,
+            stream=False,
+            temperature=0.7,
+            n_predict=100 # Max tokens for the joke
+        )
+
+        if isinstance(response_non_stream, str):
+            ASCIIColors.green("Response:")
+            print(response_non_stream)
+        elif isinstance(response_non_stream, dict) and "error" in response_non_stream:
+            ASCIIColors.error(f"Error in non-streaming generation: {response_non_stream['error']}")
+        else:
+            ASCIIColors.warning(f"Unexpected response format: {response_non_stream}")
+
+        # 2. Test streaming generation
+        ASCIIColors.magenta("\n\n2. Streaming Generation:")
+        prompt_stream = "Explain the concept of recursion in one sentence."
+        ASCIIColors.yellow(f"Prompt: {prompt_stream}")
+        ASCIIColors.green("Response (streaming):")
+        response_stream = lc.generate_text(
+            prompt=prompt_stream,
+            stream=True,
+            streaming_callback=simple_streaming_callback,
+            temperature=0.5,
+            n_predict=150
+        )
+        print() # Newline after streaming
+
+        # The 'response_stream' variable will contain the full concatenated text if streaming_callback returns True throughout
+        # or an error dictionary if generation failed.
+        if isinstance(response_stream, str):
+            ASCIIColors.cyan(f"\n(Full streamed text was: {response_stream[:100]}...)") # Show a snippet of full text
+        elif isinstance(response_stream, dict) and "error" in response_stream:
+            ASCIIColors.error(f"Error in streaming generation: {response_stream['error']}")
+
+        print("Testing embedding")
+        emb = lc.embed("hello")
+        print(emb)
+
+        # else: if callback returns False early, response_stream might be partial.
+
+        # 3. Test generation with a specific model (if applicable and different from default)
+        #    This tests the switch_model or model loading mechanism of the binding.
+        #    For 'lollms' binding, this would set the model on the server.
+        #    For 'ollama' or 'openai', it means the next generate_text will use this model.
+        ASCIIColors.magenta("\n\n3. List Available Models & Generate with Specific Model:")
+        available_models = lc.listModels()
+        if isinstance(available_models, list) and available_models:
+            ASCIIColors.green("Available models:")
+            for i, model_info in enumerate(available_models[:5]): # Print first 5
+                model_id = model_info.get('model_name', model_info.get('id', str(model_info)))
+                print(f"  - {model_id}")
+
+            # Try to use the first available model (or a known one if list is too generic)
+            target_model = None
+            if BINDING_NAME == "ollama":
+                # For Ollama, try using a different small model if available, or the same one
+                if "phi3:latest" in [m.get('name') for m in available_models if isinstance(m, dict)]:
+                    target_model = "phi3:latest"
+                elif available_models: # Fallback to first model in list if phi3 not present
+                     first_model_entry = available_models[0]
+                     target_model = first_model_entry.get('name', first_model_entry.get('model_name'))
+
+
+            elif BINDING_NAME == "lollms":
+                # For lollms, this would typically be a path or server-recognized name
+                # This part is harder to make generic without knowing server's models
+                ASCIIColors.yellow("For 'lollms' binding, ensure the target model is known to the server.")
+                if available_models and isinstance(available_models[0], str): # e.g. gptq model paths
+                    target_model = available_models[0]
+
+
+            if target_model and target_model != lc.binding.model_name: # Only if different and valid
+                ASCIIColors.info(f"\nSwitching to model (or using for next gen): {target_model}")
+                # For bindings like ollama/openai, setting model_name on binding directly works.
+                # For 'lollms' server binding, LollmsClient doesn't have a direct 'switch_model_on_server'
+                # but setting lc.binding.model_name will make the next generate_text request it.
+                lc.binding.model_name = target_model # Update the binding's current model_name
+
+                prompt_specific_model = f"What is the main capability of the {target_model.split(':')[0]} language model?"
+                ASCIIColors.yellow(f"Prompt (for {target_model}): {prompt_specific_model}")
+                ASCIIColors.green("Response:")
+                response_specific = lc.generate_text(
+                    prompt=prompt_specific_model,
+                    stream=True, # Keep it streaming for responsiveness
+                    streaming_callback=simple_streaming_callback,
+                    n_predict=200
+                )
+                print()
+            elif target_model == lc.binding.model_name:
+                ASCIIColors.yellow(f"Target model '{target_model}' is already the current model. Skipping specific model test.")
+            else:
+                ASCIIColors.yellow("Could not determine a different target model from the list to test specific model generation.")
+
+        elif isinstance(available_models, dict) and "error" in available_models:
+            ASCIIColors.error(f"Error listing models: {available_models['error']}")
+        else:
+            ASCIIColors.yellow("No models listed by the binding or format not recognized.")
+
+
+    except ValueError as ve:
+        ASCIIColors.error(f"Initialization Error: {ve}")
+        trace_exception(ve)
+    except RuntimeError as re:
+        ASCIIColors.error(f"Runtime Error (binding likely not initialized): {re}")
+        trace_exception(re)
+    except Exception as e:
+        ASCIIColors.error(f"An unexpected error occurred: {e}")
+        trace_exception(e)
+
+if __name__ == "__main__":
+    test_text_generation()