lollms-client 1.4.0__py3-none-any.whl → 1.4.5__py3-none-any.whl

lollms_client/lollms_discussion.py

@@ -1707,21 +1707,25 @@ class LollmsDiscussion:
             )
 
             if memory_json and memory_json.get("title") and memory_json.get("content"):
-                title = memory_json["title"]
-                self.add_memory(
-                    title=title,
-                    content=memory_json["content"]
-                )
-                # Automatically load the newly created memory into the context
-                self.load_memory_into_context(title)
                 print(f"[INFO] Memorize: New memory created and loaded into context: '{title}'.")
+                return memory_json
             else:
                 print("[WARNING] Memorize: Failed to generate a valid memory from the discussion.")
-                
+                return None
         except Exception as e:
             trace_exception(e)
             print(f"[ERROR] Memorize: Failed to create memory. {e}")
 
+        def set_memory(self, memory_text: str):
+            """Sets the discussion's memory content.
+            This memory is included in the system context during exports and can be
+            used to provide background information or retain important details across turns.
+            Args:
+                memory_text: The text to set as the discussion's memory.
+            """       
+            self.memory = memory_text.strip()
+            self.touch()
+
     def count_discussion_tokens(self, format_type: str, branch_tip_id: Optional[str] = None) -> int:
         """Counts the number of tokens in the exported discussion content.
 
@@ -2363,7 +2367,7 @@ class LollmsDiscussion:
         
         return self.add_artefact(
             title, content=new_content, images=new_images,
-            audios=latest_artefact.get("audios", []), videos=latest_artefact.get("videos", []),
+            audios=latest_artefact.get("audios", []),videos=latest_artefact.get("videos", []),
             zip_content=latest_artefact.get("zip"), version=latest_version + 1, **extra_data
         )
 
@@ -2489,148 +2493,6 @@ class LollmsDiscussion:
             
         return removed_count
 
-    # Memories management system
-    def list_memories(self) -> List[Dict[str, Any]]:
-        """
-        Lists all memories stored in the discussion's metadata.
-        """
-        metadata = self.metadata or {}
-        memories = metadata.get("_memories", [])
-        now = datetime.utcnow().isoformat()
-        
-        upgraded = []
-        dirty = False
-        for memory in memories:
-            fixed = memory.copy()
-            if "title" not in fixed: fixed["title"] = "untitled"; dirty = True
-            if "content" not in fixed: fixed["content"] = ""; dirty = True
-            if "created_at" not in fixed: fixed["created_at"] = now; dirty = True
-            
-            section_start = f"--- Memory: {fixed['title']} ---"
-            fixed["is_loaded"] = section_start in (self.memory or "")
-            upgraded.append(fixed)
-
-        if dirty:
-            metadata["_memories"] = upgraded
-            self.metadata = metadata
-            self.commit()
-
-        return upgraded
-
-    def add_memory(self, title: str, content: str, **extra_data) -> Dict[str, Any]:
-        """
-        Adds or overwrites a memory in the discussion.
-        """
-        new_metadata = (self.metadata or {}).copy()
-        memories = new_metadata.get("_memories", [])
-        
-        memories = [m for m in memories if m.get('title') != title]
-
-        new_memory = {
-            "title": title, "content": content,
-            "created_at": datetime.utcnow().isoformat(),
-            **extra_data
-        }
-        memories.append(new_memory)
-        
-        new_metadata["_memories"] = memories
-        self.metadata = new_metadata
-        self.commit()
-        return new_memory
-
-    def get_memory(self, title: str) -> Optional[Dict[str, Any]]:
-        """
-        Retrieves a memory by title.
-        """
-        memories = self.list_memories()
-        return next((m for m in memories if m.get('title') == title), None)
-
-    def load_memory_into_context(self, title: str):
-        """
-        Loads a memory's content into the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            raise ValueError(f"Memory '{title}' not found.")
-
-        if memory.get('content'):
-            section = (
-                f"--- Memory: {memory['title']} ---\n"
-                f"{memory['content']}\n"
-                f"--- End Memory: {memory['title']} ---\n\n"
-            )
-            if section not in (self.memory or ""):
-                current_memory_zone = self.memory or ""
-                self.memory = current_memory_zone.rstrip() + "\n\n" + section
-                self.touch()
-                self.commit()
-                print(f"Loaded memory '{title}' into context.")
-
-    def unload_memory_from_context(self, title: str):
-        """
-        Removes a memory's content from the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            raise ValueError(f"Memory '{title}' not found.")
-
-        if self.memory and memory.get('content'):
-            section_start = f"--- Memory: {memory['title']} ---"
-            pattern = rf"\n*\s*{re.escape(section_start)}.*?--- End Memory: {re.escape(memory['title'])} ---\s*\n*"
-            self.memory = re.sub(pattern, "", self.memory, flags=re.DOTALL).strip()
-            self.touch()
-            self.commit()
-            print(f"Unloaded memory '{title}' from context.")
-
-    def is_memory_loaded(self, title: str) -> bool:
-        """
-        Checks if a memory is currently loaded in the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            return False
-
-        section_start = f"--- Memory: {memory['title']} ---"
-        return section_start in (self.memory or "")
-
-    def purge_memories(self) -> bool:
-        """
-        Removes all memories from the discussion.
-        
-        Returns:
-            The number of memories removed (0 or 1).
-        """
-        new_metadata = (self.metadata or {}).copy()
-        new_metadata["_memories"] = []
-        self.metadata = new_metadata
-        self.commit()
-        print(f"Removed memory titled.")
-        return True
-
-    def remove_memory(self, title: str) -> int:
-        """
-        Removes a memory by title.
-        
-        Returns:
-            The number of memories removed (0 or 1).
-        """
-        new_metadata = (self.metadata or {}).copy()
-        memories = new_metadata.get("_memories", [])
-        if not memories:
-            return 0
-
-        initial_count = len(memories)
-        kept_memories = [m for m in memories if m.get('title') != title]
-
-        if len(kept_memories) < initial_count:
-            new_metadata["_memories"] = kept_memories
-            self.metadata = new_metadata
-            self.commit()
-            print(f"Removed memory titled '{title}'.")
-            return 1
-            
-        return 0
-
     def clone_without_messages(self) -> 'LollmsDiscussion':
         """
         Creates a new discussion with the same context but no message history.

lollms_client/tti_bindings/diffusers/__init__.py

@@ -131,7 +131,28 @@ CIVITAI_MODELS = {
         "filename": "papercut.safetensors",
         "description": "Paper cutout SD1.5.",
         "owned_by": "civitai"
-    }
+    },
+    "fantassifiedIcons": {
+        "display_name": "Fantassified Icons",
+        "url": "https://civitai.com/api/download/models/67584?type=Model&format=SafeTensor&size=pruned&fp=fp16",
+        "filename": "fantassifiedIcons_fantassifiedIconsV20.safetensors",
+        "description": "Flat, modern Icons.",
+        "owned_by": "civitai"
+    },
+    "game_icon_institute": {
+        "display_name": "Game icon institute",
+        "url": "https://civitai.com/api/download/models/158776?type=Model&format=SafeTensor&size=full&fp=fp16",
+        "filename": "gameIconInstituteV10_v10.safetensors",
+        "description": "Flat, modern game Icons.",
+        "owned_by": "civitai"
+    },
+    "M4RV3LS_DUNGEONS": {
+        "display_name": "M4RV3LS & DUNGEONS",
+        "url": "https://civitai.com/api/download/models/139417?type=Model&format=SafeTensor&size=pruned&fp=fp16",
+        "filename": "M4RV3LSDUNGEONSNEWV40COMICS_mD40.safetensors",
+        "description": "comics.",
+        "owned_by": "civitai"
+    },
 }
 
 TORCH_DTYPE_MAP_STR_TO_OBJ = {
@@ -453,8 +474,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         "safety_checker_on": True,
         "num_inference_steps": 25,
         "guidance_scale": 7.0,
-        "default_width": 512,
-        "default_height": 512,
+        "width": 512,
+        "height": 512,
         "seed": -1,
         "enable_cpu_offload": False,
         "enable_sequential_cpu_offload": False,
@@ -484,6 +505,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         self.config = self.DEFAULT_CONFIG.copy()
         self.config.update(kwargs)
         self.model_name = self.config.get("model_name", "")
+        
         models_path_str = kwargs.get("models_path", str(Path(__file__).parent / "models"))
         self.models_path = Path(models_path_str)
         self.models_path.mkdir(parents=True, exist_ok=True)
@@ -600,11 +622,11 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         generator = self._prepare_seed(kwargs)
         pipeline_args = {
             "prompt": prompt,
-            "negative_prompt": negative_prompt or None,
-            "width": width if width is not None else self.config["default_width"],
-            "height": height if height is not None else self.config["default_height"],
-            "num_inference_steps": kwargs.pop("num_inference_steps", self.config["num_inference_steps"]),
-            "guidance_scale": kwargs.pop("guidance_scale", self.config["guidance_scale"]),
+            "negative_prompt": negative_prompt or self.config.get("negative_prompt", ""),
+            "width": width if width is not None else self.config.get("width", 512),
+            "height": height if height is not None else self.config.get("height", 512),
+            "num_inference_steps": kwargs.pop("num_inference_steps", self.config.get("num_inference_steps",25)),
+            "guidance_scale": kwargs.pop("guidance_scale", self.config.get("guidance_scale",6.5)),
             "generator": generator
         }
         pipeline_args.update(kwargs)
@@ -646,8 +668,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
             self._acquire_manager()
         imgs = [images] if isinstance(images, str) else list(images)
         pil_images = [self._decode_image_input(s) for s in imgs]
-        out_w = width if width is not None else self.config["default_width"]
-        out_h = height if height is not None else self.config["default_height"]
+        out_w = width if width is not None else self.config["width"]
+        out_h = height if height is not None else self.config["height"]
         generator = self._prepare_seed(kwargs)
         steps = kwargs.pop("num_inference_steps", self.config["num_inference_steps"])
         guidance = kwargs.pop("guidance_scale", self.config["guidance_scale"])
@@ -756,8 +778,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
             {"name": "enable_cpu_offload", "type": "bool", "value": self.config["enable_cpu_offload"], "description": "Enable model CPU offload (saves VRAM, slower)."},
             {"name": "enable_sequential_cpu_offload", "type": "bool", "value": self.config["enable_sequential_cpu_offload"], "description": "Enable sequential CPU offload."},
             {"name": "enable_xformers", "type": "bool", "value": self.config["enable_xformers"], "description": "Enable xFormers memory efficient attention."},
-            {"name": "default_width", "type": "int", "value": self.config["default_width"], "description": "Default image width."},
-            {"name": "default_height", "type": "int", "value": self.config["default_height"], "description": "Default image height."},
+            {"name": "width", "type": "int", "value": self.config["width"], "description": "Default image width."},
+            {"name": "height", "type": "int", "value": self.config["height"], "description": "Default image height."},
             {"name": "num_inference_steps", "type": "int", "value": self.config["num_inference_steps"], "description": "Default inference steps."},
             {"name": "guidance_scale", "type": "float", "value": self.config["guidance_scale"], "description": "Default guidance scale (CFG)."},
             {"name": "seed", "type": "int", "value": self.config["seed"], "description": "Default seed (-1 for random)."},

lollms_client/tti_bindings/leonardo_ai/__init__.py

@@ -0,0 +1,124 @@
+import os
+import requests
+import time
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests", "Pillow"])
+from PIL import Image
+
+BindingName = "LeonardoAITTIBinding"
+
+# Sourced from https://docs.leonardo.ai/docs/models
+LEONARDO_AI_MODELS = [
+    {"model_name": "ac4f3991-8a40-42cd-b174-14a8e33738e4", "display_name": "Leonardo Phoenix", "description": "Fast, high-quality photorealism."},
+    {"model_name": "1e65d070-22c9-4aed-a5be-ce58a1b65b38", "display_name": "Leonardo Diffusion XL", "description": "The flagship general-purpose SDXL model."},
+    {"model_name": "b24e16ff-06e3-43eb-a255-db4322b0f345", "display_name": "AlbedoBase XL", "description": "Versatile model for photorealism and artistic styles."},
+    {"model_name": "6bef9f1b-29cb-40c7-b9df-32b51c1f67d3", "display_name": "Absolute Reality v1.6", "description": "Classic photorealistic model."},
+    {"model_name": "f3296a34-a868-4665-8b2f-f4313f8c8533", "display_name": "RPG v5", "description": "Specialized in RPG characters and assets."},
+    {"model_name": "2067ae58-a02e-4318-9742-2b55b2a4c813", "display_name": "DreamShaper v7", "description": "Popular versatile artistic model."},
+]
+
+class LeonardoAITTIBinding(LollmsTTIBinding):
+    """Leonardo.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("LEONARDO_API_KEY")
+        if not self.api_key:
+            raise ValueError("Leonardo.ai API key is required.")
+        self.model_name = self.config.get("model_name", "ac4f3991-8a40-42cd-b174-14a8e33738e4")
+        self.base_url = "https://cloud.leonardo.ai/api/rest/v1"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        # You could also fetch this dynamically from /models endpoint
+        return LEONARDO_AI_MODELS
+    
+    def _wait_for_generation(self, generation_id: str) -> List[bytes]:
+        while True:
+            url = f"{self.base_url}/generations/{generation_id}"
+            response = requests.get(url, headers=self.headers)
+            response.raise_for_status()
+            data = response.json().get("generations_by_pk", {})
+            status = data.get("status")
+
+            if status == "COMPLETE":
+                ASCIIColors.green("Generation complete.")
+                images_data = []
+                for img in data.get("generated_images", []):
+                    img_url = img.get("url")
+                    if img_url:
+                        img_response = requests.get(img_url)
+                        img_response.raise_for_status()
+                        images_data.append(img_response.content)
+                return images_data
+            elif status == "FAILED":
+                raise Exception("Leonardo.ai generation failed.")
+            else:
+                ASCIIColors.info(f"Generation status: {status}. Waiting...")
+                time.sleep(3)
+
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/generations"
+        payload = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "modelId": self.model_name,
+            "width": width,
+            "height": height,
+            "num_images": 1,
+            "guidance_scale": kwargs.get("guidance_scale", 7),
+            "seed": kwargs.get("seed"),
+            "sd_version": "SDXL" # Most models are SDXL based
+        }
+        
+        try:
+            ASCIIColors.info(f"Submitting generation job to Leonardo.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            generation_id = response.json()["sdGenerationJob"]["generationId"]
+            ASCIIColors.info(f"Job submitted with ID: {generation_id}")
+            images = self._wait_for_generation(generation_id)
+            return images[0]
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Leonardo.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Leonardo.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Leonardo.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Leonardo.ai TTI Binding Test ---")
+    if "LEONARDO_API_KEY" not in os.environ:
+        ASCIIColors.error("LEONARDO_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = LeonardoAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A majestic lion wearing a crown, hyperrealistic, 8k"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_leonardo_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Leonardo.ai binding test failed: {e}")

lollms_client/tti_bindings/novita_ai/__init__.py

@@ -0,0 +1,102 @@
+import os
+import requests
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from ascii_colors import trace_exception, ASCIIColors
+import pipmaster as pm
+
+pm.ensure_packages(["requests"])
+
+BindingName = "NovitaAITTIBinding"
+
+# Sourced from https://docs.novita.ai/image-generation/models
+NOVITA_AI_MODELS = [
+    {"model_name": "sd_xl_base_1.0.safetensors", "display_name": "Stable Diffusion XL 1.0", "description": "Official SDXL 1.0 Base model."},
+    {"model_name": "dreamshaper_xl_1_0.safetensors", "display_name": "DreamShaper XL 1.0", "description": "Versatile artistic SDXL model."},
+    {"model_name": "juggernaut_xl_v9_rundiffusion.safetensors", "display_name": "Juggernaut XL v9", "description": "High-quality realistic and cinematic model."},
+    {"model_name": "realistic_vision_v5.1.safetensors", "display_name": "Realistic Vision v5.1", "description": "Popular photorealistic SD1.5 model."},
+    {"model_name": "absolutereality_v1.8.1.safetensors", "display_name": "Absolute Reality v1.8.1", "description": "General-purpose realistic SD1.5 model."},
+    {"model_name": "meinamix_meina_v11.safetensors", "display_name": "MeinaMix v11", "description": "High-quality anime illustration model."},
+]
+
+class NovitaAITTIBinding(LollmsTTIBinding):
+    """Novita.ai TTI binding for LoLLMS"""
+
+    def __init__(self, **kwargs):
+        super().__init__(binding_name=BindingName)
+        self.config = kwargs
+        self.api_key = self.config.get("api_key") or os.environ.get("NOVITA_API_KEY")
+        if not self.api_key:
+            raise ValueError("Novita.ai API key is required.")
+        self.model_name = self.config.get("model_name", "juggernaut_xl_v9_rundiffusion.safetensors")
+        self.base_url = "https://api.novita.ai/v3"
+        self.headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+    def listModels(self) -> list:
+        return NOVITA_AI_MODELS
+    
+    def generate_image(self, prompt: str, negative_prompt: str = "", width: int = 1024, height: int = 1024, **kwargs) -> bytes:
+        url = f"{self.base_url}/text2img"
+        payload = {
+            "model_name": self.model_name,
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "width": width,
+            "height": height,
+            "sampler_name": "DPM++ 2M Karras",
+            "cfg_scale": kwargs.get("guidance_scale", 7.0),
+            "steps": kwargs.get("num_inference_steps", 25),
+            "seed": kwargs.get("seed", -1),
+            "n_iter": 1,
+            "batch_size": 1
+        }
+        
+        try:
+            ASCIIColors.info(f"Requesting image from Novita.ai ({self.model_name})...")
+            response = requests.post(url, json=payload, headers=self.headers)
+            response.raise_for_status()
+            data = response.json()
+            if "images" not in data or not data["images"]:
+                raise Exception(f"API returned no images. Response: {data}")
+            
+            b64_image = data["images"][0]["image_base64"]
+            return base64.b64decode(b64_image)
+            
+        except Exception as e:
+            trace_exception(e)
+            try:
+                error_msg = response.json()
+                raise Exception(f"Novita.ai API error: {error_msg}")
+            except:
+                raise Exception(f"Novita.ai API request failed: {e}")
+
+    def edit_image(self, **kwargs) -> bytes:
+        ASCIIColors.warning("Novita.ai edit_image (inpainting/img2img) is not yet implemented in this binding.")
+        raise NotImplementedError("This binding does not yet support image editing.")
+
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- Novita.ai TTI Binding Test ---")
+    if "NOVITA_API_KEY" not in os.environ:
+        ASCIIColors.error("NOVITA_API_KEY environment variable not set. Cannot run test.")
+        exit(1)
+        
+    try:
+        binding = NovitaAITTIBinding()
+        
+        ASCIIColors.cyan("\n--- Test: Text-to-Image ---")
+        prompt = "A cute capybara wearing a top hat, sitting in a field of flowers, painterly style"
+        img_bytes = binding.generate_image(prompt, width=1024, height=1024, num_inference_steps=30)
+        
+        assert len(img_bytes) > 1000
+        output_path = Path(__file__).parent / "tmp_novita_t2i.png"
+        with open(output_path, "wb") as f:
+            f.write(img_bytes)
+        ASCIIColors.green(f"Text-to-Image generation OK. Image saved to {output_path}")
+
+    except Exception as e:
+        trace_exception(e)
+        ASCIIColors.error(f"Novita.ai binding test failed: {e}")