lollms-client 1.5.7__tar.gz → 1.10.0__tar.gz

{lollms_client-1.5.7/src/lollms_client.egg-info → lollms_client-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.5.7
+Version: 1.10.0
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License
@@ -222,13 +222,14 @@ License-File: LICENSE
 Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: ascii-colors
-Requires-Dist: pipmaster
+Requires-Dist: pipmaster>=1.0.5
 Requires-Dist: pyyaml
 Requires-Dist: tiktoken
 Requires-Dist: pydantic
 Requires-Dist: numpy
 Requires-Dist: pillow
 Requires-Dist: sqlalchemy
+Requires-Dist: jsonschema
 Dynamic: license-file
 
 # LoLLMs Client Library
@@ -249,7 +250,8 @@ Whether you're connecting to a remote LoLLMs server, an Ollama instance, the Ope
 ## Key Features
 
 *   🔌 **Versatile Binding System:** Seamlessly switch between different LLM backends (LoLLMs, Ollama, OpenAI, Llama.cpp, Transformers, vLLM, OpenLLM, Gemini, Claude, Groq, OpenRouter, Hugging Face Inference API) using a unified `llm_binding_config` dictionary for all parameters.
-*   🗣️ **Multimodal Support:** Interact with models capable of processing images and generate various outputs like speech (TTS), images (TTI), video (TTV), and music (TTM).
+*   🗣️ **Comprehensive Multimodal Support:** Interact with models capable of processing images and generate various outputs like speech (TTS), video (TTV), and music (TTM).
+*   🎨 **Advanced Image Generation and Editing:** A new `diffusers` binding provides powerful text-to-image capabilities. It supports a wide range of models from Hugging Face and Civitai, including specialized models like `Qwen-Image-Edit` for single-image editing and the cutting-edge `Qwen-Image-Edit-2509` for **multi-image fusion, pose transfer, and character swapping**.
 *   🖼️ **Selective Image Activation:** Control which images in a message are active and sent to the model, allowing for fine-grained multimodal context management without deleting the original data.
 *   🤖 **Agentic Workflows with MCP:** Empower LLMs to act as sophisticated agents, breaking down complex tasks, selecting and executing external tools (e.g., internet search, code interpreter, file I/O, image generation) through the Model Context Protocol (MCP) using a robust "observe-think-act" loop.
 *   🎭 **Personalities as Agents:** Personalities can now define their own set of required tools (MCPs) and have access to static or dynamic knowledge bases (`data_source`), turning them into self-contained, ready-to-use agents.
@@ -303,6 +305,7 @@ try:
         llm_binding_config={
             "host_address": "http://localhost:9642", # Default port for LoLLMs server
             # "service_key": "your_lollms_api_key_here" # Get key from LoLLMs UI -> User Settings if security is enabled
+            # "verify_ssl_certificate": True #if false the ssl certifcate verification will be ignored (only used when using https in lollms service address)
         }
     )
 
@@ -962,6 +965,7 @@ try:
     config = {
         "host_address": "http://localhost:9642",
         # "service_key": "your_lollms_api_key_here" # Uncomment and replace if security is enabled
+        # "verify_ssl_certificate": True #if false the ssl certifcate verification will be ignored (only used when using https in lollms service address)
     }
 
     lc = LollmsClient(
@@ -1300,9 +1304,113 @@ try:
 
 except Exception as e:
     ASCIIColors.error(f"Error initializing Hugging Face Inference API binding: {e}")
-    ASCIIColors.info("Please ensure your Hugging Face API token is correctly set and you have access to the specified model.")
+    ASCIIColors.info("Please ensure your Hugging Face API token is correctly set and you have access to the specified model.")```
 ```
 
+---
+
+### 4. Local Multimodal and Advanced Bindings
+
+#### **Diffusers (Local Text-to-Image Generation and Editing)**
+
+The `diffusers` binding leverages the Hugging Face `diffusers` library to run a vast array of text-to-image models locally on your own hardware (CPU or GPU). It supports models from Hugging Face and Civitai, providing everything from basic image generation to advanced, state-of-the-art image editing.
+
+**Prerequisites:**
+*   `torch` and `torchvision` must be installed. For GPU acceleration, it's critical to install the version that matches your CUDA toolkit.
+*   The binding will attempt to auto-install other requirements like `diffusers`, `transformers`, and `safetensors`.
+
+**Usage:**
+
+**Example 1: Basic Text-to-Image Generation**
+This example shows how to generate an image from a simple text prompt using a classic Stable Diffusion model.
+
+```python
+from lollms_client import LollmsClient
+from ascii_colors import ASCIIColors
+from pathlib import Path
+
+try:
+    # Initialize the client with the diffusers TTI binding
+    # Let's use a classic Stable Diffusion model for this example
+    lc = LollmsClient(
+        tti_binding_name="diffusers",
+        tti_binding_config={
+            "model_name": "runwayml/stable-diffusion-v1-5",
+            # Other options: "device", "torch_dtype_str", "enable_xformers"
+        }
+    )
+
+    prompt = "A high-quality photograph of an astronaut riding a horse on Mars."
+    ASCIIColors.yellow(f"Generating image for prompt: '{prompt}'")
+
+    # Generate the image. The result is returned as bytes.
+    image_bytes = lc.generate_image(prompt, width=512, height=512)
+
+    if image_bytes:
+        output_path = Path("./astronaut_on_mars.png")
+        with open(output_path, "wb") as f:
+            f.write(image_bytes)
+        ASCIIColors.green(f"Image saved successfully to: {output_path.resolve()}")
+    else:
+        ASCIIColors.error("Image generation failed.")
+
+except Exception as e:
+    ASCIIColors.error(f"An error occurred with the Diffusers binding: {e}")
+    ASCIIColors.info("Please ensure torch is installed correctly for your hardware (CPU/GPU).")
+```
+
+**Example 2: Advanced Multi-Image Fusion with Qwen-Image-Edit-2509**
+This example demonstrates a cutting-edge capability: using a specialized model to fuse elements from multiple input images based on a text prompt. Here, we'll ask the model to take a person from one image and place them in the background of another.
+
+```python
+from lollms_client import LollmsClient
+from ascii_colors import ASCIIColors
+from pathlib import Path
+
+# --- IMPORTANT ---
+# Replace these with actual paths to your local images
+path_to_person_image = "./path/to/your/person.jpg"
+path_to_background_image = "./path/to/your/background.jpg"
+
+if not Path(path_to_person_image).exists() or not Path(path_to_background_image).exists():
+    ASCIIColors.warning("Input images not found. Skipping multi-image fusion example.")
+    ASCIIColors.warning(f"Please update 'path_to_person_image' and 'path_to_background_image'.")
+else:
+    try:
+        # Initialize with the advanced Qwen multi-image editing model
+        lc = LollmsClient(
+            tti_binding_name="diffusers",
+            tti_binding_config={
+                "model_name": "Qwen/Qwen-Image-Edit-2509",
+                "torch_dtype_str": "bfloat16" # Recommended for this model
+            }
+        )
+
+        # The prompt guides how the images are combined
+        prompt = "Place the person from the first image into the scenic background of the second image."
+        ASCIIColors.yellow(f"Fusing images with prompt: '{prompt}'")
+
+        # The edit_image method can accept a list of image paths for fusion
+        fused_image_bytes = lc.edit_image(
+            images=[path_to_person_image, path_to_background_image],
+            prompt=prompt,
+            num_inference_steps=50
+        )
+
+        if fused_image_bytes:
+            output_path = Path("./fused_image_result.png")
+            with open(output_path, "wb") as f:
+                f.write(fused_image_bytes)
+            ASCIIColors.green(f"Fused image saved successfully to: {output_path.resolve()}")
+        else:
+            ASCIIColors.error("Multi-image editing failed.")
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during multi-image fusion: {e}")
+```
+
+This powerful feature allows for complex creative tasks like character swapping, background replacement, and style transfer directly through the `lollms_client` library.
+
 ### Listing Available Models
 
 You can query the active LLM binding to get a list of models it supports or has available. The exact information returned depends on the binding (e.g., Ollama lists local models, OpenAI lists all its API models).
@@ -1323,7 +1431,7 @@ try:
     )
 
     ASCIIColors.yellow("\nListing available models for the current binding:")
-    available_models = lc.listModels()
+    available_models = lc.list_models()
 
     if isinstance(available_models, list):
         for model in available_models:
@@ -1402,6 +1510,257 @@ try:
 except Exception as e:
     ASCIIColors.error(f"An error occurred during long context processing: {e}")
 ```
+## low level text processing
+Here is the **English, README-ready version**, clean and aligned with LOLLMS documentation standards.
+
+---
+
+## 🧠 Lollms Text Processor
+
+The **Lollms Text Processor** is a high-level utility designed to turn raw LLM generations into **production-ready workflows**.
+It handles long documents, structured outputs, robust code generation, intelligent editing, and reliable parsing.
+
+It is directly accessible via:
+
+```python
+lc.llm.tp
+```
+
+---
+
+## 🔧 Initialization
+
+```python
+from lollms_client import LollmsClient
+
+lc = LollmsClient(
+    llm_binding_name="lollms",
+    llm_binding_config={
+        "model_name": "llama3",
+        "host_address": "http://localhost:9642",
+        "service_key": "the service key"
+    }
+)
+
+llm = lc.llm
+tp = lc.llm.tp
+```
+
+* `llm` provides low-level text generation primitives
+* `tp` is the **Text Processor**, ready to use out of the box
+
+---
+
+## 📚 1. Long Context Processing
+
+The Text Processor automatically handles documents that exceed the model’s context window by chunking, synthesizing intermediate results, and producing a final consolidated output.
+
+### Text generation from a very long document
+
+```python
+summary = tp.long_context_processing(
+    text_to_process=long_document,
+    contextual_prompt="Summarize the main findings about climate change",
+    processing_type="text"
+)
+```
+
+### Structured extraction from long context
+
+```python
+result = tp.long_context_processing(
+    text_to_process=long_document,
+    contextual_prompt="Extract all people mentioned with their roles",
+    processing_type="structured",
+    schema={
+        "type": "object",
+        "properties": {
+            "people": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                        "role": {"type": "string"}
+                    }
+                }
+            }
+        }
+    }
+)
+```
+
+### Yes / No question over long documents
+
+```python
+answer = tp.long_context_processing(
+    text_to_process=long_document,
+    contextual_prompt="Does this document mention Marie Curie?",
+    processing_type="yes_no",
+    return_explanation=True
+)
+```
+
+---
+
+## 💻 2. Code Generation and Editing
+
+### Single-file code generation
+
+```python
+code = tp.generate_code(
+    prompt="Create a binary search function",
+    language="python"
+)
+```
+
+### Multi-file project generation
+
+```python
+files = tp.generate_codes(
+    prompt="Create a Flask web app with an HTML frontend"
+)
+```
+
+### Efficient code editing (non-destructive)
+
+```python
+updated_code = tp.edit_code(
+    original_code=existing_code,
+    edit_instruction="Add error handling and logging",
+    language="python"
+)
+```
+
+Unlike naïve prompting, edits are **structural**, not full rewrites.
+
+---
+
+## 🧩 3. Structured Content Generation
+
+### Using JSON Schema
+
+```python
+data = tp.generate_structured_content(
+    prompt="Create a presentation about AI",
+    schema={
+        "type": "object",
+        "properties": {
+            "slides": {
+                "type": "array",
+                "items": {"type": "object"}
+            }
+        }
+    }
+)
+```
+
+### Using Pydantic models
+
+```python
+from pydantic import BaseModel
+
+class Person(BaseModel):
+    name: str
+    age: int
+
+person = tp.generate_structured_content_pydantic(
+    prompt="Create a person named Alice, age 30",
+    pydantic_model=Person
+)
+```
+
+✔ Automatic validation
+✔ Truncation recovery
+✔ Agent-friendly outputs
+
+---
+
+## 🧠 4. LLM Helper Utilities
+
+### Yes / No questions
+
+```python
+answer = tp.yes_no(
+    question="Is Marie Curie a scientist?",
+    context="Marie Curie was a physicist...",
+    return_explanation=True
+)
+```
+
+### Multiple-choice questions
+
+```python
+choice = tp.multichoice_question(
+    question="What field did Marie Curie work in?",
+    possible_answers=["Biology", "Physics", "Chemistry"]
+)
+```
+
+### Text summarization
+
+```python
+summary = tp.summerize_text(text="Long article...")
+```
+
+### Keyword extraction
+
+```python
+keywords = tp.extract_keywords(
+    text="Long article...",
+    num_keywords=5
+)
+```
+
+---
+
+## 🧪 5. Response Parsing and Cleanup
+
+### Extract reasoning / thinking blocks
+
+```python
+thoughts = tp.extract_thinking_blocks(llm_response)
+```
+
+### Remove reasoning blocks
+
+```python
+clean_text = tp.remove_thinking_blocks(llm_response)
+```
+
+### Extract code blocks (legacy support)
+
+```python
+blocks = tp.extract_code_blocks(
+    text=llm_response,
+    format="markdown"
+)
+```
+
+---
+
+## ✨ Key Features
+
+* ✅ Automatic **long-context handling**
+* ✅ XML-based code generation (no fragile backticks)
+* ✅ Truncation recovery for JSON and code
+* ✅ Non-destructive, structured code editing
+* ✅ JSON Schema & Pydantic support
+* ✅ Decision helpers (yes/no, multichoice, ranking)
+* ✅ Graceful fallback strategies
+
+---
+
+## 🏁 Summary
+
+The **Lollms Text Processor** turns a raw LLM into a **reliable production tool**.
+
+> `lc.llm` generates
+> `lc.llm.tp` structures, validates, and secures
+
+A core component of **LOLLMS — one tool to rule them all** 🚀
+
+
 
 ## Contributing