npcpy 1.3.12__tar.gz → 1.3.14__tar.gz

{npcpy-1.3.12/npcpy.egg-info → npcpy-1.3.14}/PKG-INFO

@@ -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 → npcpy-1.3.14}/README.md

@@ -209,7 +209,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',
 
 )
@@ -263,7 +263,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'])
 ```
 
@@ -304,7 +304,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 → npcpy-1.3.14}/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-1.3.12 → npcpy-1.3.14}/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-1.3.12 → npcpy-1.3.14}/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-1.3.12 → npcpy-1.3.14}/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-1.3.12 → npcpy-1.3.14}/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