npcpy 1.3.12__py3-none-any.whl → 1.3.14__py3-none-any.whl

npcpy/ft/diff.py

@@ -180,52 +180,66 @@ if TORCH_AVAILABLE:
             noise = torch.randn_like(x)
             return sqrt_alpha * x + sqrt_one_minus * noise, noise
 
-        def train(self, dataloader):
+        def train(self, dataloader, progress_callback=None):
             optimizer = torch.optim.AdamW(
-                self.model.parameters(), 
+                self.model.parameters(),
                 lr=self.config.learning_rate
             )
-            
+
             os.makedirs(self.config.output_model_path, exist_ok=True)
             checkpoint_dir = os.path.join(
-                self.config.output_model_path, 
+                self.config.output_model_path,
                 'checkpoints'
             )
             os.makedirs(checkpoint_dir, exist_ok=True)
-            
+
             global_step = 0
-            
+            total_batches = len(dataloader)
+            loss_history = []
+
             for epoch in range(self.config.num_epochs):
                 self.model.train()
                 epoch_loss = 0.0
-                
+
                 pbar = tqdm(dataloader, desc=f'Epoch {epoch+1}')
                 for batch_idx, (images, captions) in enumerate(pbar):
                     images = images.to(self.device)
                     batch_size = images.shape[0]
-                    
+
                     t = torch.randint(
-                        0, 
-                        self.config.timesteps, 
-                        (batch_size,), 
+                        0,
+                        self.config.timesteps,
+                        (batch_size,),
                         device=self.device
                     ).long()
-                    
+
                     noisy_images, noise = self.add_noise(images, t)
-                    
+
                     predicted_noise = self.model(noisy_images, t)
-                    
+
                     loss = F.mse_loss(predicted_noise, noise)
-                    
+
                     optimizer.zero_grad()
                     loss.backward()
                     optimizer.step()
-                    
+
                     epoch_loss += loss.item()
                     global_step += 1
-                    
+
                     pbar.set_postfix({'loss': loss.item()})
-                    
+
+                    # Report progress via callback
+                    if progress_callback:
+                        progress_callback({
+                            'epoch': epoch + 1,
+                            'total_epochs': self.config.num_epochs,
+                            'batch': batch_idx + 1,
+                            'total_batches': total_batches,
+                            'step': global_step,
+                            'loss': loss.item(),
+                            'loss_history': loss_history[-100:],  # Last 100 losses
+                        })
+
                     if global_step % self.config.checkpoint_frequency == 0:
                         ckpt_path = os.path.join(
                             checkpoint_dir,
@@ -238,8 +252,9 @@ if TORCH_AVAILABLE:
                             'optimizer_state_dict': optimizer.state_dict(),
                             'loss': loss.item(),
                         }, ckpt_path)
-                
+
                 avg_loss = epoch_loss / len(dataloader)
+                loss_history.append(avg_loss)
                 print(f'Epoch {epoch+1} avg loss: {avg_loss:.6f}')
             
             final_path = os.path.join(
@@ -300,35 +315,35 @@ else:
     DiffusionTrainer = None
 
 
-def train_diffusion(image_paths, captions=None, config=None, 
-                    resume_from=None):
+def train_diffusion(image_paths, captions=None, config=None,
+                    resume_from=None, progress_callback=None):
     if not TORCH_AVAILABLE:
         raise ImportError(
             "PyTorch not available. Install: pip install torch torchvision"
         )
-    
+
     if config is None:
         config = DiffusionConfig()
-    
+
     if captions is None:
         captions = [''] * len(image_paths)
-    
+
     dataset = ImageDataset(image_paths, captions, config.image_size)
     dataloader = DataLoader(
-        dataset, 
-        batch_size=config.batch_size, 
+        dataset,
+        batch_size=config.batch_size,
         shuffle=True,
         num_workers=0
     )
-    
+
     trainer = DiffusionTrainer(config)
-    
+
     if resume_from and os.path.exists(resume_from):
         checkpoint = torch.load(resume_from, map_location=trainer.device)
         trainer.model.load_state_dict(checkpoint['model_state_dict'])
         print(f'Resumed from {resume_from}')
-    
-    output_path = trainer.train(dataloader)
+
+    output_path = trainer.train(dataloader, progress_callback=progress_callback)
     
     gc.collect()
     if torch.cuda.is_available():

npcpy/ft/rl.py

@@ -1,4 +1,5 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import List
 
 from datetime import datetime
 import glob
@@ -12,7 +13,8 @@ try:
     import torch
     from transformers import (
         AutoModelForCausalLM,
-        AutoTokenizer
+        AutoTokenizer,
+        BitsAndBytesConfig
     )
     from trl import DPOTrainer, DPOConfig
 except:
@@ -23,6 +25,7 @@ except:
     torch = None
     AutoModelForCausalLM = None
     AutoTokenizer = None
+    BitsAndBytesConfig = None
 
     
 import random
@@ -44,6 +47,24 @@ class RLConfig:
     beta: float = 0.5
     max_length: int = 512
     max_prompt_length: int = 256
+    # Quantization options
+    use_4bit: bool = False
+    use_8bit: bool = False
+    # Precision options
+    fp16: bool = False
+    bf16: bool = False
+    # LoRA configuration
+    lora_r: int = 8
+    lora_alpha: int = 16
+    lora_dropout: float = 0.1
+    lora_target_modules: List[str] = field(
+        default_factory=lambda: ["q_proj", "k_proj", "v_proj", "o_proj"]
+    )
+    # Training options
+    max_pairs: int = 200
+    warmup_steps: int = 5
+    logging_steps: int = 5
+    save_steps: int = 20
 
 
 class TaskExecutor:
@@ -207,8 +228,8 @@ def create_preference_pairs(
             f"Warning: Only {len(pairs)} pairs found. "
             "May overfit."
         )
-    
-    return Dataset.from_list(pairs[:100])
+
+    return Dataset.from_list(pairs)
 
 
 def train_with_dpo(
@@ -218,84 +239,121 @@ def train_with_dpo(
 
     if config is None:
         config = RLConfig()
-    
+
     preference_dataset = create_preference_pairs(
         traces,
         min_reward_gap=config.min_reward_gap
     )
-    
+
     if preference_dataset is None or len(preference_dataset) == 0:
         print("No valid preference pairs. Cannot train.")
         return None
-    
+
+    # Limit pairs if specified
+    if config.max_pairs and len(preference_dataset) > config.max_pairs:
+        preference_dataset = preference_dataset.select(range(config.max_pairs))
+
+    print(f"Training with {len(preference_dataset)} preference pairs")
+
+    # Build model loading kwargs
+    model_kwargs = {
+        "device_map": "auto",
+        "trust_remote_code": True,
+        "low_cpu_mem_usage": True
+    }
+
+    # Handle quantization
+    if config.use_4bit:
+        if BitsAndBytesConfig is None:
+            raise ImportError("bitsandbytes required for 4-bit. pip install bitsandbytes")
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True
+        )
+        print("Using 4-bit quantization")
+    elif config.use_8bit:
+        if BitsAndBytesConfig is None:
+            raise ImportError("bitsandbytes required for 8-bit. pip install bitsandbytes")
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_8bit=True
+        )
+        print("Using 8-bit quantization")
+    else:
+        # Set dtype based on precision config
+        if config.bf16:
+            model_kwargs["torch_dtype"] = torch.bfloat16
+        elif config.fp16:
+            model_kwargs["torch_dtype"] = torch.float16
+        else:
+            model_kwargs["torch_dtype"] = torch.float32
+
     model = AutoModelForCausalLM.from_pretrained(
         config.base_model_name,
-        torch_dtype=torch.float32,
-        device_map="auto",
-        low_cpu_mem_usage=True
+        **model_kwargs
     )
-    
+
     tokenizer = AutoTokenizer.from_pretrained(
         config.base_model_name,
         trust_remote_code=True
     )
-    
+
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
-    
+
     peft_config = LoraConfig(
-        r=8,
-        lora_alpha=16,
-        lora_dropout=0.1,
+        r=config.lora_r,
+        lora_alpha=config.lora_alpha,
+        lora_dropout=config.lora_dropout,
         bias="none",
         task_type="CAUSAL_LM",
-        target_modules=[
-            "q_proj",
-            "k_proj",
-            "v_proj",
-            "o_proj"
-        ]
+        target_modules=config.lora_target_modules
     )
-    
+
+    # Select optimizer based on quantization
+    if config.use_4bit or config.use_8bit:
+        optim = "paged_adamw_8bit"
+    else:
+        optim = "adamw_torch"
+
     training_args = DPOConfig(
         output_dir="./dpo_results",
-        per_device_train_batch_size=(
-            config.per_device_train_batch_size
-        ),
-        gradient_accumulation_steps=(
-            config.gradient_accumulation_steps
-        ),
+        per_device_train_batch_size=config.per_device_train_batch_size,
+        gradient_accumulation_steps=config.gradient_accumulation_steps,
         learning_rate=config.learning_rate,
         num_train_epochs=config.num_train_epochs,
         weight_decay=0.1,
         beta=config.beta,
-        logging_steps=2,
-        save_steps=10,
+        logging_steps=config.logging_steps,
+        save_steps=config.save_steps,
         remove_unused_columns=False,
         max_length=config.max_length,
         max_prompt_length=config.max_prompt_length,
         dataloader_num_workers=0,
-        fp16=False,
-        bf16=False,
-        optim="adamw_torch",
-        warmup_steps=2,
+        fp16=config.fp16 or config.use_4bit,
+        bf16=config.bf16,
+        optim=optim,
+        warmup_steps=config.warmup_steps,
         save_strategy="steps",
-        save_total_limit=3
+        save_total_limit=2
     )
-    
+
     trainer = DPOTrainer(
         model,
         args=training_args,
         train_dataset=preference_dataset,
-        peft_config=peft_config
+        peft_config=peft_config,
+        tokenizer=tokenizer
     )
-    
+
     print("Starting DPO training...")
     trainer.train()
-    
+
+    os.makedirs(config.adapter_path, exist_ok=True)
     trainer.save_model(config.adapter_path)
     print(f"Adapter saved to {config.adapter_path}")
-    
+
     return config.adapter_path
 
 
@@ -333,28 +391,53 @@ def run_rl_training(
 
 def load_rl_model(
     base_model_id: str,
-    adapter_path: str
+    adapter_path: str,
+    use_4bit: bool = False,
+    use_8bit: bool = False,
+    merge_adapter: bool = True
 ):
-
     print(f"Loading base model: {base_model_id}")
+
+    model_kwargs = {
+        "device_map": "auto",
+        "trust_remote_code": True
+    }
+
+    if use_4bit:
+        if BitsAndBytesConfig is None:
+            raise ImportError("bitsandbytes required for 4-bit")
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_use_double_quant=True
+        )
+    elif use_8bit:
+        if BitsAndBytesConfig is None:
+            raise ImportError("bitsandbytes required for 8-bit")
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_8bit=True
+        )
+    else:
+        model_kwargs["torch_dtype"] = torch.float16
+
     model = AutoModelForCausalLM.from_pretrained(
         base_model_id,
-        torch_dtype=torch.float32,
-        device_map="auto",
-        attn_implementation='eager'
+        **model_kwargs
     )
-    
+
     tokenizer = AutoTokenizer.from_pretrained(
         base_model_id,
         trust_remote_code=True
     )
-    
+
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
-    
+
     if adapter_path and os.path.exists(adapter_path):
         print(f"Loading adapter: {adapter_path}")
         model = PeftModel.from_pretrained(model, adapter_path)
-        model = model.merge_and_unload()
-    
+        if merge_adapter and not (use_4bit or use_8bit):
+            model = model.merge_and_unload()
+
     return model, tokenizer

npcpy/gen/response.py

@@ -259,6 +259,24 @@ def get_ollama_response(
                                 prompt = f"Content from CSV: {os.path.basename(attachment)} (first 100 rows):\n{csv_sample} \n csv description: {csv_data.describe()}"
                     except Exception:
                         pass
+                else:
+                    # Handle text-based files
+                    text_extensions = {'.txt', '.text', '.log', '.md', '.markdown', '.rst', '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.xml', '.html', '.htm', '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.h', '.cpp', '.hpp', '.go', '.rs', '.rb', '.php', '.sh', '.bash', '.sql', '.css', '.scss'}
+                    filename = os.path.basename(attachment)
+                    if ext in text_extensions or ext == '':
+                        try:
+                            with open(attachment, 'r', encoding='utf-8', errors='replace') as f:
+                                text_content = f.read()
+                            max_chars = 50000
+                            if len(text_content) > max_chars:
+                                text_content = text_content[:max_chars] + f"\n\n... [truncated]"
+                            if text_content.strip():
+                                if prompt:
+                                    prompt += f"\n\nContent from {filename}:\n```\n{text_content}\n```"
+                                else:
+                                    prompt = f"Content from {filename}:\n```\n{text_content}\n```"
+                        except Exception:
+                            pass
 
 
     if prompt:
@@ -797,6 +815,24 @@ def get_litellm_response(
                                 prompt = f"Content from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
                     except Exception:
                         pass
+                else:
+                    # Handle text-based files
+                    text_extensions = {'.txt', '.text', '.log', '.md', '.markdown', '.rst', '.json', '.yaml', '.yml', '.toml', '.ini', '.conf', '.cfg', '.xml', '.html', '.htm', '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.h', '.cpp', '.hpp', '.go', '.rs', '.rb', '.php', '.sh', '.bash', '.sql', '.css', '.scss'}
+                    filename = os.path.basename(attachment)
+                    if ext in text_extensions or ext == '':
+                        try:
+                            with open(attachment, 'r', encoding='utf-8', errors='replace') as f:
+                                text_content = f.read()
+                            max_chars = 50000
+                            if len(text_content) > max_chars:
+                                text_content = text_content[:max_chars] + f"\n\n... [truncated]"
+                            if text_content.strip():
+                                if prompt:
+                                    prompt += f"\n\nContent from {filename}:\n```\n{text_content}\n```"
+                                else:
+                                    prompt = f"Content from {filename}:\n```\n{text_content}\n```"
+                        except Exception:
+                            pass
 
     if prompt:
         if result['messages'] and result['messages'][-1]["role"] == "user":

npcpy/memory/knowledge_graph.py

@@ -344,7 +344,6 @@ def kg_evolve_incremental(existing_kg,
 
     current_gen = existing_kg.get('generation', 0)
     next_gen = current_gen + 1
-    print(f"\n--- ABSORBING INFO: Gen {current_gen} -> Gen {next_gen} ---")
 
     newly_added_concepts = []
     concept_links = list(existing_kg.get('concept_links', []))
@@ -359,8 +358,7 @@ def kg_evolve_incremental(existing_kg,
     all_concept_names = list(existing_concept_names)
     
     all_new_facts = []
-    print(npc, npc.model, npc.provider)
-    
+
     if new_facts:
         all_new_facts = new_facts
         print(f'using pre-approved facts: {len(all_new_facts)}')

npcpy/npc_compiler.py

@@ -7,6 +7,41 @@ import sqlite3
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
+import matplotlib as mpl
+
+# Professional plot styling (from kg-research matplotlibrc)
+mpl.rcParams.update({
+    'font.family': 'serif',
+    'axes.labelsize': 20,
+    'axes.grid.axis': 'both',
+    'axes.grid.which': 'major',
+    'axes.prop_cycle': mpl.cycler('color', ['k', 'b', 'r', 'g', 'c', 'm', 'y', 'k']),
+    'xtick.top': True,
+    'xtick.direction': 'in',
+    'xtick.major.size': 10,
+    'xtick.minor.size': 5,
+    'xtick.labelsize': 20,
+    'xtick.minor.visible': True,
+    'xtick.major.top': True,
+    'xtick.major.bottom': True,
+    'xtick.minor.top': True,
+    'xtick.minor.bottom': True,
+    'ytick.left': True,
+    'ytick.right': True,
+    'ytick.direction': 'in',
+    'ytick.major.size': 10,
+    'ytick.minor.size': 5,
+    'ytick.labelsize': 20,
+    'ytick.minor.visible': True,
+    'ytick.major.left': True,
+    'ytick.major.right': True,
+    'ytick.minor.left': True,
+    'ytick.minor.right': True,
+    'legend.frameon': False,
+    'legend.fontsize': 12,
+    'image.cmap': 'plasma',
+    'errorbar.capsize': 1,
+})
 import re
 import random
 from datetime import datetime
@@ -31,9 +66,31 @@ from npcpy.npc_sysenv import (
 from npcpy.memory.command_history import CommandHistory, generate_message_id
 
 class SilentUndefined(Undefined):
+    """Undefined that silently returns empty string instead of raising errors"""
     def _fail_with_undefined_error(self, *args, **kwargs):
         return ""
 
+    def __str__(self):
+        return ""
+
+    def __repr__(self):
+        return ""
+
+    def __bool__(self):
+        return False
+
+    def __eq__(self, other):
+        return other == "" or other is None or isinstance(other, Undefined)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __iter__(self):
+        return iter([])
+
+    def __len__(self):
+        return 0
+
 import math
 from PIL import Image
 from jinja2 import Environment, ChainableUndefined
@@ -152,11 +209,35 @@ def get_log_entries(entity_id, entry_type=None, limit=10, db_path="~/npcsh_histo
         ]
 
 
+def _json_dumps_with_undefined(obj, **kwargs):
+    """Custom JSON dumps that handles SilentUndefined objects"""
+    def default_handler(o):
+        if isinstance(o, Undefined):
+            return ""
+        raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+    return json.dumps(obj, default=default_handler, **kwargs)
+
+
 def load_yaml_file(file_path):
-    """Load a YAML file with error handling"""
+    """Load a YAML file with error handling, rendering Jinja2 first"""
     try:
         with open(os.path.expanduser(file_path), 'r') as f:
-            return yaml.safe_load(f)
+            content = f.read()
+
+        # Check if file has Jinja2 control structures that need pre-rendering
+        # Only render if there are {% %} blocks, otherwise parse directly
+        if '{%' not in content:
+            return yaml.safe_load(content)
+
+        # First pass: render Jinja2 templates to produce valid YAML
+        # This allows {% if %} and other control structures to work
+        jinja_env = Environment(undefined=SilentUndefined)
+        # Configure tojson filter to handle SilentUndefined
+        jinja_env.policies['json.dumps_function'] = _json_dumps_with_undefined
+        template = jinja_env.from_string(content)
+        rendered_content = template.render({})
+
+        return yaml.safe_load(rendered_content)
     except Exception as e:
         print(f"Error loading YAML file {file_path}: {e}")
         return None

npcpy/serve.py

@@ -46,10 +46,12 @@ from npcsh._state import ShellState, initialize_base_npcs_if_needed
 from npcsh.config import NPCSH_DB_PATH
 
 
-from npcpy.memory.knowledge_graph import load_kg_from_db
+from npcpy.memory.knowledge_graph import load_kg_from_db, find_similar_facts_chroma
+from npcpy.memory.command_history import setup_chroma_db
 from npcpy.memory.search import execute_rag_command, execute_brainblast_command
 from npcpy.data.load import load_file_contents
 from npcpy.data.web import search_web
+from npcpy.data.image import capture_screenshot
 
 
 import base64
@@ -67,12 +69,14 @@ from npcpy.memory.command_history import (
     save_conversation_message,
     generate_message_id,
 )
-from npcpy.npc_compiler import  Jinx, NPC, Team, load_jinxs_from_directory, build_jinx_tool_catalog, initialize_npc_project
+from npcpy.npc_compiler import  Jinx, NPC, Team, load_jinxs_from_directory, build_jinx_tool_catalog, initialize_npc_project, load_yaml_file
 
 from npcpy.llm_funcs import (
     get_llm_response, check_llm_command
 )
+from npcpy.gen.embeddings import get_embeddings
 from termcolor import cprint
+
 from npcpy.tools import auto_tools
 
 import json
@@ -712,6 +716,265 @@ def get_centrality_data():
     concept_degree = {node: cent for node, cent in nx.degree_centrality(G).items() if node in concepts_df['name'].values}
     return jsonify(centrality={'degree': concept_degree})
 
+@app.route('/api/kg/search')
+def search_kg():
+    """Search facts and concepts by keyword"""
+    try:
+        q = request.args.get('q', '').strip().lower()
+        generation = request.args.get('generation', type=int)
+        search_type = request.args.get('type', 'both')  # fact, concept, or both
+        limit = request.args.get('limit', 50, type=int)
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        concepts_df, facts_df, links_df = load_kg_data(generation)
+        results = {"facts": [], "concepts": [], "query": q}
+
+        # Search facts
+        if search_type in ('both', 'fact'):
+            for _, row in facts_df.iterrows():
+                statement = str(row.get('statement', '')).lower()
+                source_text = str(row.get('source_text', '')).lower()
+                if q in statement or q in source_text:
+                    results["facts"].append({
+                        "statement": row.get('statement'),
+                        "source_text": row.get('source_text'),
+                        "type": row.get('type'),
+                        "generation": row.get('generation'),
+                        "origin": row.get('origin')
+                    })
+                    if len(results["facts"]) >= limit:
+                        break
+
+        # Search concepts
+        if search_type in ('both', 'concept'):
+            for _, row in concepts_df.iterrows():
+                name = str(row.get('name', '')).lower()
+                description = str(row.get('description', '')).lower()
+                if q in name or q in description:
+                    results["concepts"].append({
+                        "name": row.get('name'),
+                        "description": row.get('description'),
+                        "generation": row.get('generation'),
+                        "origin": row.get('origin')
+                    })
+                    if len(results["concepts"]) >= limit:
+                        break
+
+        return jsonify(results)
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/embed', methods=['POST'])
+def embed_kg_facts():
+    """Embed existing facts from SQL to Chroma for semantic search"""
+    try:
+        data = request.get_json() or {}
+        generation = data.get('generation')
+        batch_size = data.get('batch_size', 10)
+
+        # Load facts from SQL
+        _, facts_df, _ = load_kg_data(generation)
+
+        if facts_df.empty:
+            return jsonify({"message": "No facts to embed", "count": 0})
+
+        # Setup Chroma
+        chroma_db_path = os.path.expanduser('~/npcsh_chroma_db')
+        _, chroma_collection = setup_chroma_db(
+            "knowledge_graph",
+            "Facts extracted from various sources",
+            chroma_db_path
+        )
+
+        # Process in batches
+        from npcpy.memory.knowledge_graph import store_fact_with_embedding
+        import hashlib
+
+        embedded_count = 0
+        skipped_count = 0
+
+        statements = facts_df['statement'].dropna().tolist()
+
+        for i in range(0, len(statements), batch_size):
+            batch = statements[i:i + batch_size]
+
+            # Get embeddings for batch
+            try:
+                embeddings = get_embeddings(batch)
+            except Exception as e:
+                print(f"Failed to get embeddings for batch {i}: {e}")
+                continue
+
+            for j, statement in enumerate(batch):
+                fact_id = hashlib.md5(statement.encode()).hexdigest()
+
+                # Check if already exists
+                try:
+                    existing = chroma_collection.get(ids=[fact_id])
+                    if existing and existing.get('ids'):
+                        skipped_count += 1
+                        continue
+                except:
+                    pass
+
+                # Get metadata from dataframe
+                row = facts_df[facts_df['statement'] == statement].iloc[0] if len(facts_df[facts_df['statement'] == statement]) > 0 else None
+                metadata = {
+                    "generation": int(row.get('generation', 0)) if row is not None and pd.notna(row.get('generation')) else 0,
+                    "origin": str(row.get('origin', '')) if row is not None else '',
+                    "type": str(row.get('type', '')) if row is not None else '',
+                }
+
+                # Store with embedding
+                result = store_fact_with_embedding(
+                    chroma_collection, statement, metadata, embeddings[j]
+                )
+                if result:
+                    embedded_count += 1
+
+        return jsonify({
+            "message": f"Embedded {embedded_count} facts, skipped {skipped_count} existing",
+            "embedded": embedded_count,
+            "skipped": skipped_count,
+            "total_facts": len(statements)
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/search/semantic')
+def search_kg_semantic():
+    """Semantic search for facts using vector similarity"""
+    try:
+        q = request.args.get('q', '').strip()
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 10, type=int)
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        # Setup Chroma connection
+        chroma_db_path = os.path.expanduser('~/npcsh_chroma_db')
+        try:
+            _, chroma_collection = setup_chroma_db(
+                "knowledge_graph",
+                "Facts extracted from various sources",
+                chroma_db_path
+            )
+        except Exception as e:
+            return jsonify({
+                "error": f"Chroma DB not available: {str(e)}",
+                "facts": [],
+                "query": q
+            }), 200
+
+        # Get query embedding
+        try:
+            query_embedding = get_embeddings([q])[0]
+        except Exception as e:
+            return jsonify({
+                "error": f"Failed to generate embedding: {str(e)}",
+                "facts": [],
+                "query": q
+            }), 200
+
+        # Build metadata filter for generation if specified
+        metadata_filter = None
+        if generation is not None:
+            metadata_filter = {"generation": generation}
+
+        # Search Chroma
+        similar_facts = find_similar_facts_chroma(
+            chroma_collection,
+            q,
+            query_embedding=query_embedding,
+            n_results=limit,
+            metadata_filter=metadata_filter
+        )
+
+        # Format results
+        results = {
+            "facts": [
+                {
+                    "statement": f["fact"],
+                    "distance": f.get("distance"),
+                    "metadata": f.get("metadata", {}),
+                    "id": f.get("id")
+                }
+                for f in similar_facts
+            ],
+            "query": q,
+            "total": len(similar_facts)
+        }
+
+        return jsonify(results)
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/facts')
+def get_kg_facts():
+    """Get facts, optionally filtered by generation"""
+    try:
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 100, type=int)
+        offset = request.args.get('offset', 0, type=int)
+
+        _, facts_df, _ = load_kg_data(generation)
+
+        facts = []
+        for i, row in facts_df.iloc[offset:offset+limit].iterrows():
+            facts.append({
+                "statement": row.get('statement'),
+                "source_text": row.get('source_text'),
+                "type": row.get('type'),
+                "generation": row.get('generation'),
+                "origin": row.get('origin')
+            })
+
+        return jsonify({
+            "facts": facts,
+            "total": len(facts_df),
+            "offset": offset,
+            "limit": limit
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/kg/concepts')
+def get_kg_concepts():
+    """Get concepts, optionally filtered by generation"""
+    try:
+        generation = request.args.get('generation', type=int)
+        limit = request.args.get('limit', 100, type=int)
+
+        concepts_df, _, _ = load_kg_data(generation)
+
+        concepts = []
+        for _, row in concepts_df.head(limit).iterrows():
+            concepts.append({
+                "name": row.get('name'),
+                "description": row.get('description'),
+                "generation": row.get('generation'),
+                "origin": row.get('origin')
+            })
+
+        return jsonify({
+            "concepts": concepts,
+            "total": len(concepts_df)
+        })
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
 
 
 @app.route("/api/attachments/<message_id>", methods=["GET"])
@@ -746,7 +1009,7 @@ def get_attachment(attachment_id):
 @app.route("/api/capture_screenshot", methods=["GET"])
 def capture():
     
-    screenshot = capture_screenshot(None, full=True)
+    screenshot = capture_screenshot(full=True)
 
     
     if not screenshot:
@@ -853,10 +1116,9 @@ def get_available_jinxs():
         def get_jinx_name_from_file(filepath):
             """Read jinx_name from file, fallback to filename."""
             try:
-                with open(filepath, 'r') as f:
-                    data = yaml.safe_load(f)
-                    if data and 'jinx_name' in data:
-                        return data['jinx_name']
+                data = load_yaml_file(filepath)
+                if data and 'jinx_name' in data:
+                    return data['jinx_name']
             except:
                 pass
             return os.path.basename(filepath)[:-5]
@@ -1634,10 +1896,26 @@ def finetune_diffusers():
         'output_dir': output_dir,
         'epochs': num_epochs,
         'current_epoch': 0,
+        'current_batch': 0,
+        'total_batches': 0,
+        'current_loss': None,
+        'loss_history': [],
+        'step': 0,
         'start_time': datetime.datetime.now().isoformat()
     }
     print(f"🌋 Finetuning job {job_id} initialized. Output directory: {output_dir}")
-    
+
+    def progress_callback(progress_data):
+        """Callback to update job progress from training loop."""
+        finetune_jobs[job_id]['current_epoch'] = progress_data.get('epoch', 0)
+        finetune_jobs[job_id]['epochs'] = progress_data.get('total_epochs', num_epochs)
+        finetune_jobs[job_id]['current_batch'] = progress_data.get('batch', 0)
+        finetune_jobs[job_id]['total_batches'] = progress_data.get('total_batches', 0)
+        finetune_jobs[job_id]['step'] = progress_data.get('step', 0)
+        finetune_jobs[job_id]['current_loss'] = progress_data.get('loss')
+        if progress_data.get('loss_history'):
+            finetune_jobs[job_id]['loss_history'] = progress_data['loss_history']
+
     def run_training_async():
         print(f"🌋 Finetuning job {job_id}: Starting asynchronous training thread...")
         try:
@@ -1647,16 +1925,15 @@ def finetune_diffusers():
                 learning_rate=learning_rate,
                 output_model_path=output_dir
             )
-            
+
             print(f"🌋 Finetuning job {job_id}: Calling train_diffusion with config: {config}")
-            # Assuming train_diffusion might print its own progress or allow callbacks
-            # For more granular logging, you'd need to modify train_diffusion itself
             model_path = train_diffusion(
                 expanded_images,
                 captions,
-                config=config
+                config=config,
+                progress_callback=progress_callback
             )
-            
+
             finetune_jobs[job_id]['status'] = 'complete'
             finetune_jobs[job_id]['model_path'] = model_path
             finetune_jobs[job_id]['end_time'] = datetime.datetime.now().isoformat()
@@ -1686,21 +1963,32 @@ def finetune_diffusers():
 def finetune_status(job_id):
     if job_id not in finetune_jobs:
         return jsonify({'error': 'Job not found'}), 404
-    
+
     job = finetune_jobs[job_id]
-    
+
     if job['status'] == 'complete':
         return jsonify({
+            'status': 'complete',
             'complete': True,
-            'outputPath': job.get('model_path', job['output_dir'])
+            'outputPath': job.get('model_path', job['output_dir']),
+            'loss_history': job.get('loss_history', [])
         })
     elif job['status'] == 'error':
-        return jsonify({'error': job.get('error_msg', 'Unknown error')})
-    
+        return jsonify({
+            'status': 'error',
+            'error': job.get('error_msg', 'Unknown error')
+        })
+
     return jsonify({
-        'step': job.get('current_epoch', 0),
-        'total': job['epochs'],
-        'status': 'running'
+        'status': 'running',
+        'epoch': job.get('current_epoch', 0),
+        'total_epochs': job.get('epochs', 0),
+        'batch': job.get('current_batch', 0),
+        'total_batches': job.get('total_batches', 0),
+        'step': job.get('step', 0),
+        'loss': job.get('current_loss'),
+        'loss_history': job.get('loss_history', []),
+        'start_time': job.get('start_time')
     })
 
 @app.route("/api/ml/train", methods=["POST"])
@@ -1924,9 +2212,10 @@ def get_jinxs_global():
         for file in files:
             if file.endswith(".jinx"):
                 jinx_path = os.path.join(root, file)
-                with open(jinx_path, 'r') as f:
-                    raw_data = yaml.safe_load(f)
-                
+                raw_data = load_yaml_file(jinx_path)
+                if raw_data is None:
+                    continue
+
                 # Preserve full input definitions including defaults
                 inputs = raw_data.get("inputs", [])
                 
@@ -1960,9 +2249,10 @@ def get_jinxs_project():
         for file in files:
             if file.endswith(".jinx"):
                 jinx_path = os.path.join(root, file)
-                with open(jinx_path, 'r') as f:
-                    raw_data = yaml.safe_load(f)
-                
+                raw_data = load_yaml_file(jinx_path)
+                if raw_data is None:
+                    continue
+
                 # Preserve full input definitions including defaults
                 inputs = raw_data.get("inputs", [])
                 
@@ -2118,8 +2408,9 @@ def get_npc_team_global():
     for file in os.listdir(global_npc_directory):
         if file.endswith(".npc"):
             npc_path = os.path.join(global_npc_directory, file)
-            with open(npc_path, 'r') as f:
-                raw_data = yaml.safe_load(f)
+            raw_data = load_yaml_file(npc_path)
+            if raw_data is None:
+                continue
             
             npc_data.append({
                 "name": raw_data.get("name", file[:-4]),
@@ -2154,8 +2445,9 @@ def get_npc_team_project():
     for file in os.listdir(project_npc_directory):
         if file.endswith(".npc"):
             npc_path = os.path.join(project_npc_directory, file)
-            with open(npc_path, 'r') as f:
-                raw_npc_data = yaml.safe_load(f)
+            raw_npc_data = load_yaml_file(npc_path)
+            if raw_npc_data is None:
+                continue
             
             serialized_npc = {
                 "name": raw_npc_data.get("name", file[:-4]),
@@ -2433,8 +2725,7 @@ def get_package_contents():
                 if f.endswith('.npc'):
                     npc_path = os.path.join(package_npc_team_dir, f)
                     try:
-                        with open(npc_path, 'r') as file:
-                            npc_data = yaml.safe_load(file) or {}
+                        npc_data = load_yaml_file(npc_path) or {}
                         npcs.append({
                             "name": npc_data.get("name", f[:-4]),
                             "primary_directive": npc_data.get("primary_directive", ""),
@@ -2453,8 +2744,7 @@ def get_package_contents():
                             jinx_path = os.path.join(root, f)
                             rel_path = os.path.relpath(jinx_path, jinxs_dir)
                             try:
-                                with open(jinx_path, 'r') as file:
-                                    jinx_data = yaml.safe_load(file) or {}
+                                jinx_data = load_yaml_file(jinx_path) or {}
                                 jinxs.append({
                                     "name": f[:-5],
                                     "path": rel_path[:-5],
@@ -4392,21 +4682,105 @@ def approve_memories():
     try:
         data = request.json
         approvals = data.get("approvals", [])
-        
+
         command_history = CommandHistory(app.config.get('DB_PATH'))
-        
+
         for approval in approvals:
             command_history.update_memory_status(
                 approval['memory_id'],
                 approval['decision'],
                 approval.get('final_memory')
             )
-        
+
         return jsonify({"success": True, "processed": len(approvals)})
-        
+
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
+@app.route("/api/memory/search", methods=["GET"])
+def search_memories():
+    """Search memories with optional scope filtering"""
+    try:
+        q = request.args.get("q", "")
+        npc = request.args.get("npc")
+        team = request.args.get("team")
+        directory_path = request.args.get("directory_path")
+        status = request.args.get("status")
+        limit = int(request.args.get("limit", 50))
+
+        if not q:
+            return jsonify({"error": "Query parameter 'q' is required"}), 400
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.search_memory(
+            query=q,
+            npc=npc,
+            team=team,
+            directory_path=directory_path,
+            status_filter=status,
+            limit=limit
+        )
+
+        return jsonify({"memories": results, "count": len(results)})
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/memory/pending", methods=["GET"])
+def get_pending_memories():
+    """Get memories awaiting approval"""
+    try:
+        limit = int(request.args.get("limit", 50))
+        npc = request.args.get("npc")
+        team = request.args.get("team")
+        directory_path = request.args.get("directory_path")
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.get_pending_memories(limit=limit)
+
+        # Filter by scope if provided
+        if npc or team or directory_path:
+            filtered = []
+            for mem in results:
+                if npc and mem.get('npc') != npc:
+                    continue
+                if team and mem.get('team') != team:
+                    continue
+                if directory_path and mem.get('directory_path') != directory_path:
+                    continue
+                filtered.append(mem)
+            results = filtered
+
+        return jsonify({"memories": results, "count": len(results)})
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/memory/scope", methods=["GET"])
+def get_memories_by_scope():
+    """Get memories for a specific scope (npc/team/directory)"""
+    try:
+        npc = request.args.get("npc", "")
+        team = request.args.get("team", "")
+        directory_path = request.args.get("directory_path", "")
+        status = request.args.get("status")
+
+        command_history = CommandHistory(app.config.get('DB_PATH'))
+        results = command_history.get_memories_for_scope(
+            npc=npc,
+            team=team,
+            directory_path=directory_path,
+            status=status
+        )
+
+        return jsonify({"memories": results, "count": len(results)})
+
+    except Exception as e:
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
 
 
 
@@ -5419,7 +5793,7 @@ def text_to_speech_endpoint():
         import base64
         from npcpy.gen.audio_gen import (
             text_to_speech, get_available_engines,
-            pcm16_to_wav, KOKORO_VOICES
+            pcm16_to_wav
         )
 
         data = request.json or {}

{npcpy-1.3.12.dist-info → npcpy-1.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.12
+Version: 1.3.14
 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
@@ -305,7 +305,7 @@ ggm = NPC(
 isabel = NPC(
     name='Isabel Allende',
     primary_directive='You are Isabel Allende, weaving stories with emotion and history. Analyze texts and provide insight.',
-    model='llama3.2:8b',
+    model='llama3.2',
     provider='ollama',
 
 )
@@ -359,7 +359,7 @@ LLM responses can be obtained without NPCs as well.
 
 ```python
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("Who was the celtic Messenger god?", model='mistral:7b', provider='ollama')
+response = get_llm_response("Who was the celtic Messenger god?", model='qwen3:4b', provider='ollama')
 print(response['response'])
 ```
 
@@ -400,7 +400,7 @@ Return structured outputs by specifying `format='json'` or passing a Pydantic sc
 
 ```python
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='claude-4-5-haiku-latest', provider='deepseek', format='json')
+response = get_llm_response("What is the sentiment of the american people towards the repeal of Roe v Wade? Return a json object with `sentiment` as the key and a float value from -1 to 1 as the value", model='deepseek-chat', provider='deepseek', format='json')
 
 print(response['response'])
 ```

{npcpy-1.3.12.dist-info → npcpy-1.3.14.dist-info}/RECORD

@@ -4,10 +4,10 @@ npcpy/llm_funcs.py,sha256=M7GSSjqpcO2kxh7G2sGRBU34lmdW7Imd5KxYqc1PiO0,75114
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
 npcpy/ml_funcs.py,sha256=UI7k7JR4XOH_VXR-xxLaO4r9Kyx_jBaEnp3TUIY7ZLQ,22657
 npcpy/npc_array.py,sha256=fVTxcMiXV-lvltmuwaRnTU9D3ikPq3-7k5wzp7MA5OY,40224
-npcpy/npc_compiler.py,sha256=9U6_F7qweURaL2nQgrF7I9OQEmYjOENmkBV-YChr3oM,118402
+npcpy/npc_compiler.py,sha256=W1umvhsbyCYoRYajPUKa642FcsX5Fcadh78n-Vzu2hM,120983
 npcpy/npc_sysenv.py,sha256=VH7le3xwxHvO55ZYCG1e-gj8X5YTSIqbIiU6ifSqhss,38917
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=0jV4O-6j7efFDk1T_rrx-ZUom1c-dh0zNANlYMMKDYI,231461
+npcpy/serve.py,sha256=wx5pG5SRQbB3WBH1KAoOG1twpd4qtDh29c8TMvt9xT8,244481
 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
@@ -18,11 +18,11 @@ npcpy/data/text.py,sha256=jP0a1qZZaSJdK-LdZTn2Jjdxqmkd3efxDLEoxflJQeY,5010
 npcpy/data/video.py,sha256=H-V3mTu_ktD9u-QhYeo4aW3u9z0AtoAdRZmvRPEpE98,2887
 npcpy/data/web.py,sha256=pcjCLVAoqfw9enV5a7Dg1A_V7USG0302e6C7wUz2UgE,5235
 npcpy/ft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcpy/ft/diff.py,sha256=2-NbY0p0CP5Qr9mnnncxRBwzmxRq9NKcl8B5BeT1vQ4,12319
+npcpy/ft/diff.py,sha256=0ScRR4AxXtVX2bgZ-Jr_dSwv3LAlU1JXDUq4F4n1Ea4,12839
 npcpy/ft/ge.py,sha256=0VzIiXq2wCzGcK1x0Wd-myJ3xRf-FNaPg0GkHEZegUM,3552
 npcpy/ft/memory_trainer.py,sha256=QZPznxEEwXbOGroHdMUMa5xpqlNwgV6nqOazI2xgrnQ,6635
 npcpy/ft/model_ensembler.py,sha256=BRX4hJ_rvF1vKTzjMhlahZqPttUgc3PqmzUJDqIfIps,10038
-npcpy/ft/rl.py,sha256=EcPD8t5MFg0zYWSS-A7KJ9bWd0qCTsL5SSvDxV556Z4,9245
+npcpy/ft/rl.py,sha256=uhK4M4Bxw4dqh9lv5fakiPvy8P_FcdBu_z83i24vlvw,12226
 npcpy/ft/sft.py,sha256=74gRaJTTrZcO4np4DqRMr79ADkGhPcDKutR74rag03E,6659
 npcpy/ft/usft.py,sha256=O025GGYGZQf2ZVLowyAmBwh5bJyuy2dUAM6v03YcboY,3435
 npcpy/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,13 +30,13 @@ npcpy/gen/audio_gen.py,sha256=RoSElPUGfQimPBUcl9SP-ziIJxeI6XAr0A1882BZxXE,20646
 npcpy/gen/embeddings.py,sha256=QStTJ2ELiC379OEZsLEgGGIIFD267Y8zQchs7HRn2Zg,2089
 npcpy/gen/image_gen.py,sha256=SOZYpvlxSiAdDK9j750OEBKjm22OUNdXg1kQ10sJSy0,21853
 npcpy/gen/ocr.py,sha256=rgmXWHrCYX1Po-qG_LrNFbVYEZ8aaupxFTgparcoB_Y,6554
-npcpy/gen/response.py,sha256=Pw01M0UxjsXOPJlvShAbq9n6IVnvEqxT6MQaLyEwJFs,48505
+npcpy/gen/response.py,sha256=fLd-ORRMI_s3yRNMH1TQodGk17u_G0xofS1lqfqH4r0,51121
 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=pjqcSBHXzdQTViSjHsBP2ohRSYnJ33h2bYARGcLvBfs,62253
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
-npcpy/memory/knowledge_graph.py,sha256=pjqcHjAh-Bfe6Q9fvNkBpg-TMjPTgynB6PhLSWWtPzI,48720
+npcpy/memory/knowledge_graph.py,sha256=X3qqlDcuzGUjRgQWleQzafGKgNw8QRz2ar2gYuCvUq8,48600
 npcpy/memory/memory_processor.py,sha256=6PfVnSBA9ag5EhHJinXoODfEPTlDDoaT0PtCCuZO6HI,2598
 npcpy/memory/search.py,sha256=glN6WYzaixcoDphTEHAXSMX3vKZGjR12Jx9YVL_gYfE,18433
 npcpy/mix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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.12.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.3.12.dist-info/METADATA,sha256=PowYAWEVkhhzpbRWFKJcntLCy8zseMTIccfLlTb7Cw0,37885
-npcpy-1.3.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.3.12.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.3.12.dist-info/RECORD,,
+npcpy-1.3.14.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.3.14.dist-info/METADATA,sha256=awVWA8mQYm1F3pPqVCDjAyuFrdB1hyks_8I8JjQMPr8,37870
+npcpy-1.3.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.3.14.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.3.14.dist-info/RECORD,,