npcpy 1.3.18__py3-none-any.whl → 1.3.20__py3-none-any.whl

npcpy/memory/memory_processor.py

@@ -4,6 +4,13 @@ from datetime import datetime
 import threading
 import queue
 import time
+import os
+
+try:
+    from termcolor import colored
+except ImportError:
+    def colored(text, color=None, on_color=None, attrs=None):
+        return text
 
 @dataclass
 class MemoryItem:
@@ -17,65 +24,274 @@ class MemoryItem:
     model: str
     provider: str
 
-def memory_approval_ui(memories: List[Dict]) -> List[Dict]:
+
+def _clear_line():
+    """Clear current line in terminal."""
+    print('\r' + ' ' * 80 + '\r', end='')
+
+
+def _print_header(title: str, width: int = 60):
+    """Print a styled header."""
+    print(colored("=" * width, "cyan"))
+    print(colored(f"  {title}", "cyan", attrs=["bold"]))
+    print(colored("=" * width, "cyan"))
+
+
+def _print_memory_box(memory: Dict, index: int, total: int):
+    """Print a memory in a nice box format."""
+    width = 70
+
+    # Header with progress
+    progress = f"[{index}/{total}]"
+    npc_info = f"NPC: {memory.get('npc', 'unknown')}"
+    header = f"{progress} {npc_info}"
+    print(colored("+" + "-" * (width - 2) + "+", "blue"))
+    print(colored(f"| {header:<{width-4}} |", "blue"))
+    print(colored("+" + "-" * (width - 2) + "+", "blue"))
+
+    # Content
+    content = memory.get('content', '')
+    # Wrap content to fit in box
+    lines = []
+    words = content.split()
+    current_line = ""
+    for word in words:
+        if len(current_line) + len(word) + 1 <= width - 6:
+            current_line += (" " if current_line else "") + word
+        else:
+            if current_line:
+                lines.append(current_line)
+            current_line = word
+    if current_line:
+        lines.append(current_line)
+
+    for line in lines[:6]:  # Max 6 lines
+        print(colored(f"|  {line:<{width-5}} |", "white"))
+
+    if len(lines) > 6:
+        print(colored(f"|  {'...':<{width-5}} |", "grey"))
+
+    # Context if available
+    ctx = memory.get('context', '')
+    if ctx:
+        print(colored("+" + "-" * (width - 2) + "+", "blue"))
+        ctx_short = ctx[:width-8] + "..." if len(ctx) > width - 8 else ctx
+        print(colored(f"| {ctx_short:<{width-4}} |", "grey"))
+
+    print(colored("+" + "-" * (width - 2) + "+", "blue"))
+
+
+def _print_options():
+    """Print available options."""
+    print()
+    options = [
+        (colored("a", "green", attrs=["bold"]), "approve"),
+        (colored("r", "red", attrs=["bold"]), "reject"),
+        (colored("e", "yellow", attrs=["bold"]), "edit"),
+        (colored("s", "grey"), "skip"),
+        (colored("A", "green"), "approve all"),
+        (colored("R", "red"), "reject all"),
+        (colored("D", "cyan"), "defer (review later)"),
+    ]
+    print("  " + "  |  ".join([f"({k}) {v}" for k, v in options]))
+
+
+def _print_summary(stats: Dict):
+    """Print approval summary."""
+    print()
+    _print_header("Memory Review Summary")
+    print(f"  {colored('Approved:', 'green')} {stats.get('approved', 0)}")
+    print(f"  {colored('Rejected:', 'red')} {stats.get('rejected', 0)}")
+    print(f"  {colored('Edited:', 'yellow')} {stats.get('edited', 0)}")
+    print(f"  {colored('Skipped:', 'grey')} {stats.get('skipped', 0)}")
+    print(f"  {colored('Deferred:', 'cyan')} {stats.get('deferred', 0)}")
+    print()
+
+
+def memory_approval_ui(memories: List[Dict], show_context: bool = True) -> List[Dict]:
+    """
+    Enhanced memory approval UI with better formatting.
+
+    Args:
+        memories: List of memory dicts with 'memory_id', 'content', 'npc', 'context'
+        show_context: Whether to show context info
+
+    Returns:
+        List of approval dicts with 'memory_id', 'decision', optionally 'final_memory'
+    """
     if not memories:
         return []
-    
-    print(f"\n📝 {len(memories)} memories ready for approval:")
-    
+
+    # Stats tracking
+    stats = {'approved': 0, 'rejected': 0, 'edited': 0, 'skipped': 0, 'deferred': 0}
     approvals = []
-    for i, memory in enumerate(memories, 1):
-        print(f"\n--- Memory {i}/{len(memories)} ---")
-        print(f"NPC: {memory['npc']}")
-        content_preview = memory['content'][:200]
-        if len(memory['content']) > 200:
-            content_preview += '...'
-        print(f"Content: {content_preview}")
-        
-        while True:
-            choice = input(
-                "(a)pprove, (r)eject, (e)dit, (s)kip | "
-                "(A)ll approve, (R)all reject, (S)all skip: "
-            ).strip().lower()
-            
-            if choice == 'a':
-                approvals.append({
-                    "memory_id": memory['memory_id'],
-                    "decision": "human-approved"
-                })
-                break
-            elif choice == 'r':
-                approvals.append({
-                    "memory_id": memory['memory_id'],
-                    "decision": "human-rejected"
-                })
-                break
-            elif choice == 'e':
-                edited = input("Edit memory: ").strip()
+
+    print()
+    _print_header(f"Memory Review - {len(memories)} memories")
+    print()
+
+    i = 0
+    while i < len(memories):
+        memory = memories[i]
+        os.system('clear' if os.name == 'posix' else 'cls') if len(memories) > 3 else None
+
+        _print_memory_box(memory, i + 1, len(memories))
+        _print_options()
+
+        try:
+            choice = input("\n  Your choice: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n  Review cancelled.")
+            break
+
+        if choice == 'a':
+            approvals.append({
+                "memory_id": memory['memory_id'],
+                "decision": "human-approved"
+            })
+            stats['approved'] += 1
+            print(colored("  ✓ Approved", "green"))
+            i += 1
+
+        elif choice == 'r':
+            approvals.append({
+                "memory_id": memory['memory_id'],
+                "decision": "human-rejected"
+            })
+            stats['rejected'] += 1
+            print(colored("  ✗ Rejected", "red"))
+            i += 1
+
+        elif choice == 'e':
+            print(colored("\n  Current:", "grey"), memory['content'][:100])
+            print(colored("  Enter new text (or empty to cancel):", "yellow"))
+            try:
+                edited = input("  > ").strip()
                 if edited:
                     approvals.append({
                         "memory_id": memory['memory_id'],
                         "decision": "human-edited",
                         "final_memory": edited
                     })
-                break
-            elif choice == 's':
-                break
-            elif choice == 'A':
-                for remaining_memory in memories[i-1:]:
-                    approvals.append({
-                        "memory_id": remaining_memory['memory_id'],
-                        "decision": "human-approved"
-                    })
-                return approvals
-            elif choice == 'R':
-                for remaining_memory in memories[i-1:]:
-                    approvals.append({
-                        "memory_id": remaining_memory['memory_id'],
-                        "decision": "human-rejected"
-                    })
-                return approvals
-            elif choice == 'S':
-                return approvals
-    
-    return approvals
+                    stats['edited'] += 1
+                    print(colored("  ✎ Edited and approved", "yellow"))
+                    i += 1
+                else:
+                    print(colored("  Edit cancelled", "grey"))
+            except (EOFError, KeyboardInterrupt):
+                print(colored("  Edit cancelled", "grey"))
+
+        elif choice == 's':
+            stats['skipped'] += 1
+            print(colored("  ○ Skipped", "grey"))
+            i += 1
+
+        elif choice == 'A':
+            # Approve all remaining
+            for remaining in memories[i:]:
+                approvals.append({
+                    "memory_id": remaining['memory_id'],
+                    "decision": "human-approved"
+                })
+                stats['approved'] += 1
+            print(colored(f"  ✓ Approved all {len(memories) - i} remaining", "green"))
+            break
+
+        elif choice == 'R':
+            # Reject all remaining
+            for remaining in memories[i:]:
+                approvals.append({
+                    "memory_id": remaining['memory_id'],
+                    "decision": "human-rejected"
+                })
+                stats['rejected'] += 1
+            print(colored(f"  ✗ Rejected all {len(memories) - i} remaining", "red"))
+            break
+
+        elif choice == 'D':
+            # Defer - don't add to approvals, will remain pending
+            stats['deferred'] += len(memories) - i
+            print(colored(f"  ⏸ Deferred {len(memories) - i} memories for later review", "cyan"))
+            break
+
+        elif choice == 'q':
+            print(colored("  Review ended", "grey"))
+            break
+
+        else:
+            print(colored("  Invalid choice. Use a/r/e/s/A/R/D", "red"))
+
+        time.sleep(0.2)  # Brief pause for readability
+
+    _print_summary(stats)
+    return approvals
+
+
+def memory_batch_review_ui(
+    command_history,
+    npc_filter: str = None,
+    team_filter: str = None,
+    limit: int = 50
+) -> Dict[str, int]:
+    """
+    Review pending memories from the database in batch.
+
+    Args:
+        command_history: CommandHistory instance
+        npc_filter: Optional NPC name filter
+        team_filter: Optional team name filter
+        limit: Max memories to review
+
+    Returns:
+        Dict with counts of approved/rejected/etc
+    """
+    # Get pending memories
+    pending = command_history.get_pending_memories(limit=limit)
+
+    if not pending:
+        print(colored("No pending memories to review.", "grey"))
+        return {'approved': 0, 'rejected': 0, 'edited': 0, 'skipped': 0}
+
+    # Filter if specified
+    if npc_filter:
+        pending = [m for m in pending if m.get('npc') == npc_filter]
+    if team_filter:
+        pending = [m for m in pending if m.get('team') == team_filter]
+
+    if not pending:
+        print(colored("No memories match the filter criteria.", "grey"))
+        return {'approved': 0, 'rejected': 0, 'edited': 0, 'skipped': 0}
+
+    # Convert to format expected by approval UI
+    memories_for_ui = []
+    for m in pending:
+        memories_for_ui.append({
+            'memory_id': m.get('id'),
+            'content': m.get('initial_memory', ''),
+            'npc': m.get('npc', 'unknown'),
+            'context': f"Team: {m.get('team', 'unknown')} | Path: {m.get('directory_path', '')[:30]}"
+        })
+
+    # Run approval UI
+    approvals = memory_approval_ui(memories_for_ui)
+
+    # Apply approvals to database
+    stats = {'approved': 0, 'rejected': 0, 'edited': 0, 'skipped': 0}
+
+    for approval in approvals:
+        memory_id = approval['memory_id']
+        decision = approval['decision']
+        final_memory = approval.get('final_memory')
+
+        command_history.update_memory_status(memory_id, decision, final_memory)
+
+        if 'approved' in decision:
+            stats['approved'] += 1
+        elif 'rejected' in decision:
+            stats['rejected'] += 1
+        elif 'edited' in decision:
+            stats['edited'] += 1
+
+    stats['skipped'] = len(pending) - len(approvals)
+
+    return stats

npcpy/npc_compiler.py

@@ -1370,6 +1370,12 @@ class NPC:
                         # Fallback to direct name match if no base dir
                         matched_names = [jinx_spec] if jinx_spec in self.team.jinxs_dict else []
 
+                    if not matched_names:
+                        raise FileNotFoundError(
+                            f"NPC '{self.name}' references jinx '{jinx_spec}' but no matching jinx was found. "
+                            f"Available jinxs: {list(self.team.jinxs_dict.keys())[:20]}..."
+                        )
+
                     for jinx_name in matched_names:
                         if jinx_name in self.team.jinxs_dict:
                             self.jinxs_dict[jinx_name] = self.team.jinxs_dict[jinx_name]

npcpy/serve.py

@@ -58,7 +58,7 @@ import base64
 import shutil
 import uuid
 
-from npcpy.llm_funcs import gen_image, breathe                                                                                                                                                                
+from npcpy.llm_funcs import gen_image, gen_video, breathe                                                                                                                                                                
 
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
@@ -4333,6 +4333,89 @@ def get_image_models_api():
         return jsonify({"models": [], "error": str(e)}), 500
 
 
+@app.route("/api/generate_video", methods=["POST"])
+def generate_video_api():
+    """
+    API endpoint for video generation.
+    """
+    try:
+        data = request.get_json()
+        prompt = data.get("prompt", "")
+        model = data.get("model", "veo-3.1-generate-preview")
+        provider = data.get("provider", "gemini")
+        duration = data.get("duration", 5)
+        output_dir = data.get("output_dir")  # Optional user-specified path
+        negative_prompt = data.get("negative_prompt", "")
+        reference_image = data.get("reference_image")  # Optional base64 image
+
+        if not prompt:
+            return jsonify({"error": "Prompt is required"}), 400
+
+        # Create output directory - use user-specified path or default to ~/.npcsh/videos
+        if output_dir:
+            save_dir = os.path.expanduser(output_dir)
+        else:
+            save_dir = os.path.expanduser("~/.npcsh/videos")
+        os.makedirs(save_dir, exist_ok=True)
+
+        # Generate unique filename
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_filename = f"video_{timestamp}.mp4"
+        output_path = os.path.join(save_dir, output_filename)
+
+        # Calculate num_frames based on duration (assuming ~25fps for diffusers)
+        num_frames = int(duration * 25) if provider == "diffusers" else 25
+
+        print(f"Generating video with model={model}, provider={provider}, duration={duration}s")
+
+        result = gen_video(
+            prompt=prompt,
+            model=model,
+            provider=provider,
+            output_path=output_path,
+            num_frames=num_frames,
+            negative_prompt=negative_prompt,
+        )
+
+        if result and "output" in result:
+            # Read the generated video file and encode to base64
+            video_path = output_path
+            if os.path.exists(video_path):
+                with open(video_path, "rb") as f:
+                    video_data = f.read()
+                video_base64 = base64.b64encode(video_data).decode("utf-8")
+
+                return jsonify({
+                    "success": True,
+                    "video_path": video_path,
+                    "video_base64": f"data:video/mp4;base64,{video_base64}",
+                    "message": result.get("output", "Video generated successfully")
+                })
+            else:
+                return jsonify({"error": "Video file was not created"}), 500
+        else:
+            return jsonify({"error": result.get("output", "Video generation failed")}), 500
+
+    except Exception as e:
+        print(f"Error generating video: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/video_models", methods=["GET"])
+def get_video_models_api():
+    """
+    API endpoint to retrieve available video generation models.
+    """
+    video_models = [
+        # Google Veo via Gemini API (requires GEMINI_API_KEY)
+        {"value": "veo-3.1-generate-preview", "display_name": "Veo 3.1 | gemini", "provider": "gemini", "max_duration": 8},
+        {"value": "veo-3.1-fast-generate-preview", "display_name": "Veo 3.1 Fast | gemini", "provider": "gemini", "max_duration": 8},
+        {"value": "veo-2.0-generate-001", "display_name": "Veo 2 | gemini", "provider": "gemini", "max_duration": 8},
+        # Diffusers - damo-vilab/text-to-video-ms-1.7b (local)
+        {"value": "damo-vilab/text-to-video-ms-1.7b", "display_name": "ModelScope 1.7B (Local) | diffusers", "provider": "diffusers", "max_duration": 4},
+    ]
+    return jsonify({"models": video_models, "error": None})
 
 
 
@@ -4561,6 +4644,17 @@ def stream():
     frontend_assistant_message_id = data.get("assistantMessageId", None)
     # For sub-branches: the parent of the user message (points to an assistant message)
     user_parent_message_id = data.get("userParentMessageId", None)
+    # LLM generation parameters - build params dict if any are provided
+    params = {}
+    if data.get("temperature") is not None:
+        params["temperature"] = data.get("temperature")
+    if data.get("top_p") is not None:
+        params["top_p"] = data.get("top_p")
+    if data.get("top_k") is not None:
+        params["top_k"] = data.get("top_k")
+    if data.get("max_tokens") is not None:
+        params["max_tokens"] = data.get("max_tokens")
+    params = params if params else None
 
     if current_path:
         loaded_vars = load_project_env(current_path)
@@ -4684,6 +4778,16 @@ def stream():
                     if os.path.exists(file_path):
                         with open(file_path, "rb") as f:
                             file_content_bytes = f.read()
+                    else:
+                        print(f"Warning: Attachment file does not exist: {file_path}")
+                        # Try data fallback if path doesn't exist
+                        if "data" in attachment and attachment["data"]:
+                            file_content_bytes = base64.b64decode(attachment["data"])
+                            import tempfile
+                            temp_dir = tempfile.mkdtemp()
+                            file_path = os.path.join(temp_dir, file_name)
+                            with open(file_path, "wb") as f:
+                                f.write(file_content_bytes)
 
                 # Fall back to base64 data if no path
                 elif "data" in attachment and attachment["data"]:
@@ -4695,7 +4799,8 @@ def stream():
                     with open(file_path, "wb") as f:
                         f.write(file_content_bytes)
 
-                if not file_path:
+                if not file_path or file_content_bytes is None:
+                    print(f"Warning: Skipping attachment {file_name} - no valid path or data")
                     continue
 
                 attachment_paths_for_llm.append(file_path)
@@ -5092,6 +5197,7 @@ def stream():
             attachments=attachments_for_db,
             message_id=message_id,
             parent_message_id=user_parent_message_id,  # For sub-branches: points to assistant message
+            gen_params=params,
         )
 
 
@@ -5389,6 +5495,7 @@ def stream():
                 tool_calls=accumulated_tool_calls if accumulated_tool_calls else None,
                 tool_results=tool_results_for_db if tool_results_for_db else None,
                 parent_message_id=parent_message_id,
+                gen_params=params,
             )
 
             # Start background tasks for memory extraction and context compression

{npcpy-1.3.18.dist-info → npcpy-1.3.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.18
+Version: 1.3.20
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino
@@ -45,6 +45,7 @@ Requires-Dist: mcp
 Provides-Extra: lite
 Requires-Dist: anthropic; extra == "lite"
 Requires-Dist: openai; extra == "lite"
+Requires-Dist: ollama; extra == "lite"
 Requires-Dist: google-generativeai; extra == "lite"
 Requires-Dist: google-genai; extra == "lite"
 Provides-Extra: local
@@ -66,6 +67,7 @@ Requires-Dist: pyttsx3; extra == "yap"
 Provides-Extra: all
 Requires-Dist: anthropic; extra == "all"
 Requires-Dist: openai; extra == "all"
+Requires-Dist: ollama; extra == "all"
 Requires-Dist: google-generativeai; extra == "all"
 Requires-Dist: google-genai; extra == "all"
 Requires-Dist: sentence_transformers; extra == "all"

{npcpy-1.3.18.dist-info → npcpy-1.3.20.dist-info}/RECORD

@@ -1,13 +1,13 @@
 npcpy/__init__.py,sha256=uJcJGjR1mWvE69GySNAufkgiRwJA28zdObDBWaxp0tY,505
 npcpy/build_funcs.py,sha256=vOz6pjV0zS-kYKo0ux-pn9AcppVaR8KIDi2ldOxb3RQ,7479
-npcpy/llm_funcs.py,sha256=M7GSSjqpcO2kxh7G2sGRBU34lmdW7Imd5KxYqc1PiO0,75114
+npcpy/llm_funcs.py,sha256=ghi0y0qlngwc5BZLa-aiFpa0GT7qLe56UboI2dLu75U,75055
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
 npcpy/ml_funcs.py,sha256=smgeOLnjxGWjmDngE-bcA2ozXX_IzY_7_pS9h2iocEg,24249
 npcpy/npc_array.py,sha256=5qjaA9KjmJ_Zk_VxLrCyVrj73aDXpm3iJf0ngq1yIJk,45721
-npcpy/npc_compiler.py,sha256=6-SYOddpi2jTJ1KtbMxtNGC7ksaiuuLd59bmc0eiOUA,121619
+npcpy/npc_compiler.py,sha256=s_67cyvoao0UwUa4N-jrceWDadvBB9TWYpxcjNPfO18,121941
 npcpy/npc_sysenv.py,sha256=1E2zwMj7aPrtRJuJSowGkvNApi07Vue3FhXsipi1XDs,45251
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=3aCJe7i1eOg5w0mTLhz0JXTZpUcWnZXlmaogPGyO1Ko,275693
+npcpy/serve.py,sha256=P71oa4eVvG0SePkOoeeQ44LkRAfnlgElxZi9GUVG7qg,280598
 npcpy/tools.py,sha256=A5_oVmZkzGnI3BI-NmneuxeXQq-r29PbpAZP4nV4jrc,5303
 npcpy/data/__init__.py,sha256=1tcoChR-Hjn905JDLqaW9ElRmcISCTJdE7BGXPlym2Q,642
 npcpy/data/audio.py,sha256=o4auV8DQrAmZ4y84U3SofiwEuq5-ZBjGEZipQ9zPpGQ,22816
@@ -16,7 +16,7 @@ npcpy/data/image.py,sha256=UQcioNPDd5HYMLL_KStf45SuiIPXDcUY-dEFHwSWUeE,6564
 npcpy/data/load.py,sha256=rVe1xSHerIpo6MDaY5eIeqRSm0gssX5sHukNsUNVwJw,9228
 npcpy/data/text.py,sha256=jP0a1qZZaSJdK-LdZTn2Jjdxqmkd3efxDLEoxflJQeY,5010
 npcpy/data/video.py,sha256=H-V3mTu_ktD9u-QhYeo4aW3u9z0AtoAdRZmvRPEpE98,2887
-npcpy/data/web.py,sha256=cc4ikPZWMYsSz6itWI19ZkM_g5nQE3lPI-AJZEcoA04,5193
+npcpy/data/web.py,sha256=qmioqCxxWddRnNm2ke39_SWXXNSqRZ1Nx86_-1JGq_A,9139
 npcpy/ft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/ft/diff.py,sha256=0ScRR4AxXtVX2bgZ-Jr_dSwv3LAlU1JXDUq4F4n1Ea4,12839
 npcpy/ft/ge.py,sha256=0VzIiXq2wCzGcK1x0Wd-myJ3xRf-FNaPg0GkHEZegUM,3552
@@ -34,10 +34,10 @@ npcpy/gen/response.py,sha256=EYsIOvNOmn6dBs-4j3SyZNMvDf5N9lW-QxMbpjnF7Kw,57081
 npcpy/gen/video_gen.py,sha256=RFi3Zcq_Hn3HIcfoF3mijQ6G7RYFZaM_9pjPTh-8E64,3239
 npcpy/gen/world_gen.py,sha256=_8ytE7E3QVQ5qiX8DmOby-xd0d9zV20rRI6Wkpf-qcY,18922
 npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcpy/memory/command_history.py,sha256=AXHrtP4GKObSVtiWNGZJ16rUyJD5FLor4EuaDEvsku0,62707
+npcpy/memory/command_history.py,sha256=_2ygoMO4EwX8H2f5G2Q62hrgqMwL7weOI8CTaFPn-I0,66258
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
-npcpy/memory/knowledge_graph.py,sha256=X3qqlDcuzGUjRgQWleQzafGKgNw8QRz2ar2gYuCvUq8,48600
-npcpy/memory/memory_processor.py,sha256=6PfVnSBA9ag5EhHJinXoODfEPTlDDoaT0PtCCuZO6HI,2598
+npcpy/memory/knowledge_graph.py,sha256=RHznD_Dt5Ka_eD015QuXnh3aG61c0Tf4oRIfY_JzPDQ,67554
+npcpy/memory/memory_processor.py,sha256=T6VAeLYNfwP1jjDDY4x6Me_l5xcVShIcU95I1ye5nEM,9453
 npcpy/memory/search.py,sha256=glN6WYzaixcoDphTEHAXSMX3vKZGjR12Jx9YVL_gYfE,18433
 npcpy/mix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 npcpy/mix/debate.py,sha256=lQXxC7nl6Rwyf7HIYrsVQILMUmYYx55Tjt2pkTg56qY,9019
@@ -53,8 +53,8 @@ npcpy/work/browser.py,sha256=p2PeaoZdAXipFuAgKCCB3aXXLE_p3yIRqC87KlZKZWc,679
 npcpy/work/desktop.py,sha256=F3I8mUtJp6LAkXodsh8hGZIncoads6c_2Utty-0EdDA,2986
 npcpy/work/plan.py,sha256=QyUwg8vElWiHuoS-xK4jXTxxHvkMD3VkaCEsCmrEPQk,8300
 npcpy/work/trigger.py,sha256=P1Y8u1wQRsS2WACims_2IdkBEar-iBQix-2TDWoW0OM,9948
-npcpy-1.3.18.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.3.18.dist-info/METADATA,sha256=FBBa4cRcrD0tfenjd5nGxtxk-P8bRc-dRlR6s8PSXkM,37870
-npcpy-1.3.18.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-npcpy-1.3.18.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.3.18.dist-info/RECORD,,
+npcpy-1.3.20.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.3.20.dist-info/METADATA,sha256=quc7U-oA3yF-Kp_lb9N-EReQCfcfO8YBBqp2pqrbnTU,37947
+npcpy-1.3.20.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+npcpy-1.3.20.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.3.20.dist-info/RECORD,,

{npcpy-1.3.18.dist-info → npcpy-1.3.20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any