npcpy 1.1.28__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/sql/sql_model_compiler.py

@@ -0,0 +1,156 @@
+import os
+import yaml
+import sqlalchemy
+import pandas as pd
+from typing import Dict, Any, Optional
+
+class SQLModelCompiler:
+    """
+    Compile and execute SQL models across different database engines
+    """
+    def __init__(
+        self, 
+        models_dir: str, 
+        engine: Optional[sqlalchemy.engine.base.Engine] = None,
+        engine_type: str = 'sqlite'
+    ):
+        """
+        Initialize SQL Model Compiler
+        
+        :param models_dir: Directory containing SQL model files
+        :param engine: SQLAlchemy database engine
+        :param engine_type: Type of database engine (sqlite, snowflake, bigquery, etc.)
+        """
+        self.models_dir = models_dir
+        self.engine = engine
+        self.engine_type = engine_type.lower()
+        self.models = {}
+        
+        # Discover models
+        self._discover_models()
+    
+    def _discover_models(self):
+        """
+        Discover and load SQL model files
+        """
+        for filename in os.listdir(self.models_dir):
+            if filename.endswith('.sql'):
+                model_name = os.path.splitext(filename)[0]
+                model_path = os.path.join(self.models_dir, filename)
+                
+                with open(model_path, 'r') as f:
+                    model_content = f.read()
+                
+                self.models[model_name] = {
+                    'name': model_name,
+                    'content': model_content,
+                    'path': model_path
+                }
+    
+    def _compile_model(self, model_name: str) -> str:
+        """
+        Compile a SQL model for the specific engine
+        
+        :param model_name: Name of the model to compile
+        :return: Compiled SQL query
+        """
+        model = self.models[model_name]
+        content = model['content']
+        
+        # Engine-specific compilation
+        if self.engine_type == 'snowflake':
+            # Snowflake-specific transformations
+            content = content.replace('{{', 'SNOWFLAKE.').replace('}}', '')
+        elif self.engine_type == 'bigquery':
+            # BigQuery-specific transformations
+            content = content.replace('{{', 'ML.').replace('}}', '')
+        
+        return content
+    
+    def execute_model(
+        self, 
+        model_name: str, 
+        seed_data: Optional[Dict[str, pd.DataFrame]] = None
+    ) -> pd.DataFrame:
+        """
+        Execute a SQL model
+        
+        :param model_name: Name of the model to execute
+        :param seed_data: Optional seed data for the model
+        :return: Result DataFrame
+        """
+        if model_name not in self.models:
+            raise ValueError(f"Model {model_name} not found")
+        
+        # Compile model for specific engine
+        compiled_sql = self._compile_model(model_name)
+        
+        # If seed data is provided, prepare the database
+        if seed_data and self.engine:
+            for table_name, df in seed_data.items():
+                df.to_sql(table_name, self.engine, if_exists='replace', index=False)
+        
+        # Execute the model
+        if self.engine:
+            return pd.read_sql(compiled_sql, self.engine)
+        else:
+            # Fallback to pandas evaluation
+            import sqlite3
+            
+            # Create an in-memory SQLite database for evaluation
+            conn = sqlite3.connect(':memory:')
+            
+            # Load seed data if available
+            if seed_data:
+                for table_name, df in seed_data.items():
+                    df.to_sql(table_name, conn, if_exists='replace', index=False)
+            
+            return pd.read_sql(compiled_sql, conn)
+    
+    def run_all_models(self, seed_data: Optional[Dict[str, pd.DataFrame]] = None):
+        """
+        Run all discovered models
+        
+        :param seed_data: Optional seed data for models
+        :return: Dictionary of model results
+        """
+        results = {}
+        for model_name in self.models:
+            results[model_name] = self.execute_model(model_name, seed_data)
+        return results
+
+# Example usage in a pipeline
+def create_model_compiler(
+    models_dir: str, 
+    engine_type: str = 'sqlite', 
+    connection_params: Optional[Dict[str, Any]] = None
+) -> SQLModelCompiler:
+    """
+    Create a SQL Model Compiler with the specified engine
+    
+    :param models_dir: Directory containing SQL model files
+    :param engine_type: Type of database engine
+    :param connection_params: Connection parameters for the database
+    :return: SQLModelCompiler instance
+    """
+    if engine_type == 'snowflake':
+        from sqlalchemy.dialects.snowflake import base
+        engine = sqlalchemy.create_engine(
+            f"snowflake://{connection_params['username']}:{connection_params['password']}@"
+            f"{connection_params['account']}/{connection_params['database']}/{connection_params['schema']}"
+        )
+    elif engine_type == 'bigquery':
+        from google.cloud import bigquery
+        from sqlalchemy.dialects.bigquery import base
+        engine = sqlalchemy.create_engine(
+            f"bigquery://{connection_params['project_id']}"
+        )
+    else:
+        # Default to SQLite
+        engine = sqlalchemy.create_engine('sqlite:///models.db')
+    
+    return SQLModelCompiler(
+        models_dir=models_dir, 
+        engine=engine, 
+        engine_type=engine_type
+    )

npcpy/tools.py

@@ -11,17 +11,17 @@ from docstring_parser import parse as parse_docstring
 
 def python_type_to_json_schema(py_type: type) -> Dict[str, Any]:
     """Convert Python type hints to JSON schema types."""
-    # Handle Union types (including Optional)
+    
     if get_origin(py_type) is Union:
         args = get_args(py_type)
-        # Check if it's Optional (Union with None)
+        
         if len(args) == 2 and type(None) in args:
             non_none_type = args[0] if args[1] is type(None) else args[1]
             return python_type_to_json_schema(non_none_type)
-        # For other unions, just use the first type for now
+        
         return python_type_to_json_schema(args[0])
     
-    # Handle List types
+    
     if get_origin(py_type) is list:
         item_type = get_args(py_type)[0] if get_args(py_type) else str
         return {
@@ -29,11 +29,11 @@ def python_type_to_json_schema(py_type: type) -> Dict[str, Any]:
             "items": python_type_to_json_schema(item_type)
         }
     
-    # Handle Dict types
+    
     if get_origin(py_type) is dict:
         return {"type": "object"}
     
-    # Basic type mappings
+    
     type_mapping = {
         str: {"type": "string"},
         int: {"type": "integer"},
@@ -48,16 +48,16 @@ def python_type_to_json_schema(py_type: type) -> Dict[str, Any]:
 
 def extract_function_info(func: Callable) -> Dict[str, Any]:
     """Extract function information including name, description, and parameters."""
-    # Get function signature
+    
     sig = inspect.signature(func)
     
-    # Get type hints
+    
     try:
         type_hints = get_type_hints(func)
     except Exception:
         type_hints = {}
     
-    # Parse docstring
+    
     docstring = inspect.getdoc(func)
     parsed_doc = None
     if docstring:
@@ -66,7 +66,7 @@ def extract_function_info(func: Callable) -> Dict[str, Any]:
         except Exception:
             pass
     
-    # Extract function name and description
+    
     func_name = func.__name__
     description = ""
     
@@ -75,31 +75,31 @@ def extract_function_info(func: Callable) -> Dict[str, Any]:
         if hasattr(parsed_doc, 'long_description') and parsed_doc.long_description:
             description += f". {parsed_doc.long_description}"
     elif docstring:
-        # Fallback to first line of docstring
+        
         description = docstring.split('\n')[0].strip()
     
-    # Extract parameters
+    
     properties = {}
     required = []
     param_descriptions = {}
     
-    # Get parameter descriptions from docstring
+    
     if parsed_doc and hasattr(parsed_doc, 'params'):
         for param in parsed_doc.params:
             param_descriptions[param.arg_name] = param.description or ""
     
     for param_name, param in sig.parameters.items():
-        # Skip self parameter
+        
         if param_name == 'self':
             continue
             
-        # Get parameter type
+        
         param_type = type_hints.get(param_name, str)
         
-        # Convert to JSON schema
+        
         param_schema = python_type_to_json_schema(param_type)
         
-        # Add description if available
+        
         if param_name in param_descriptions:
             param_schema["description"] = param_descriptions[param_name]
         else:
@@ -107,7 +107,7 @@ def extract_function_info(func: Callable) -> Dict[str, Any]:
         
         properties[param_name] = param_schema
         
-        # Check if parameter is required (no default value)
+        
         if param.default is inspect.Parameter.empty:
             required.append(param_name)
     
@@ -165,10 +165,10 @@ def auto_tools(functions: List[Callable]) -> tuple[List[Dict[str, Any]], Dict[st
             except:
                 return "Invalid mathematical expression"
         
-        # Automatically generate schema and map
+        
         tools_schema, tool_map = auto_tools([get_weather, calculate_math])
         
-        # Use with get_llm_response
+        
         response = get_llm_response(
             "What's the weather in Paris and what's 15 * 23?",
             model='gpt-4o-mini',

npcpy/work/plan.py

@@ -23,22 +23,22 @@ def execute_plan_command(
     request = parts[1]
     platform_system = platform.system()
 
-    # Create standard directories
+    
     jobs_dir = os.path.expanduser("~/.npcsh/jobs")
     logs_dir = os.path.expanduser("~/.npcsh/logs")
     os.makedirs(jobs_dir, exist_ok=True)
     os.makedirs(logs_dir, exist_ok=True)
 
-    # First part - just the request formatting
+    
     linux_request = f"""Convert this scheduling request into a crontab-based script:
     Request: {request}
 
     """
 
-    # Second part - the static prompt with examples and requirements
+    
     linux_prompt_static = """Example for "record CPU usage every 10 minutes":
     {
-        "script": "#!/bin/bash
+        "script": "
 set -euo pipefail
 IFS=$'\\n\\t'
 
@@ -79,7 +79,7 @@ record_cpu",
 
     mac_prompt_static = """Example for "record CPU usage every 10 minutes":
     {
-        "script": "#!/bin/bash
+        "script": "
 set -euo pipefail
 IFS=$'\\n\\t'
 
@@ -176,7 +176,7 @@ Get-CpuUsage",
 
     log_path = os.path.join(logs_dir, f"{job_name}.log")
 
-    # Write the script
+    
     with open(script_path, "w") as f:
         f.write(schedule_info["script"])
     os.chmod(script_path, 0o755)
@@ -244,7 +244,7 @@ Get-CpuUsage",
     elif platform_system == "Windows":
         task_name = f"NPCSH_{job_name}"
 
-        # Parse schedule_info['schedule'] into individual parameters
+        
         schedule_params = schedule_info["schedule"].split()
 
         cmd = (
@@ -258,7 +258,7 @@ Get-CpuUsage",
             ]
             + schedule_params
             + ["/f"]
-        )  # /f forces creation if task exists
+        )  
 
         subprocess.run(cmd, check=True)
 

npcpy/work/trigger.py

@@ -215,7 +215,7 @@ Status:
 
         task_name = f"NPCSH_{trigger_name}"
 
-        # Create a scheduled task that runs at startup
+        
         cmd = [
             "schtasks",
             "/create",
@@ -227,12 +227,12 @@ Status:
             "onstart",
             "/ru",
             "System",
-            "/f",  # Force creation
+            "/f",  
         ]
 
         subprocess.run(cmd, check=True)
 
-        # Start the task immediately
+        
         subprocess.run(["schtasks", "/run", "/tn", task_name])
 
         output = f"""Trigger service created:

{npcpy-1.1.28.dist-info → npcpy-1.2.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.1.28
+Version: 1.2.32
 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
@@ -16,6 +16,8 @@ Requires-Dist: scipy
 Requires-Dist: numpy
 Requires-Dist: requests
 Requires-Dist: docx
+Requires-Dist: exa-py
+Requires-Dist: elevenlabs
 Requires-Dist: matplotlib
 Requires-Dist: markdown
 Requires-Dist: networkx
@@ -53,6 +55,7 @@ Requires-Dist: kuzu; extra == "local"
 Requires-Dist: chromadb; extra == "local"
 Requires-Dist: diffusers; extra == "local"
 Requires-Dist: torch; extra == "local"
+Requires-Dist: datasets; extra == "local"
 Provides-Extra: yap
 Requires-Dist: pyaudio; extra == "yap"
 Requires-Dist: gtts; extra == "yap"
@@ -72,6 +75,7 @@ Requires-Dist: kuzu; extra == "all"
 Requires-Dist: chromadb; extra == "all"
 Requires-Dist: diffusers; extra == "all"
 Requires-Dist: torch; extra == "all"
+Requires-Dist: datasets; extra == "all"
 Requires-Dist: pyaudio; extra == "all"
 Requires-Dist: gtts; extra == "all"
 Requires-Dist: playsound==1.2.2; extra == "all"
@@ -91,19 +95,15 @@ Dynamic: requires-python
 Dynamic: summary
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/cagostino/npcpy/main/npcpy.png" alt="npcpy logo of a solarpunk sign">
+  <a href= "https://github.com/cagostino/npcpy/blob/main/docs/npcpy.md"> 
+  <img src="https://raw.githubusercontent.com/cagostino/npcpy/main/npcpy/npc-python.png" alt="npc-python logo" width=250></a>
 </p>
 
-
 # npcpy
 
 Welcome to `npcpy`, the core library of the NPC Toolkit that supercharges natural language processing pipelines and agent tooling. `npcpy` is a flexible framework for building state-of-the-art applications and conducting novel research with LLMs.
 
 
-<p align="center">
-  <a href= "https://github.com/cagostino/npcpy/blob/main/docs/npcpy.md"> 
-  <img src="https://raw.githubusercontent.com/cagostino/npcpy/main/npcpy/npc-python.png" alt="npc-python logo" width=250></a>
-</p>
 
 
 Here is an example for getting responses for a particular agent:
@@ -330,7 +330,7 @@ Users are not required to pass agents to get_llm_response, so you can work with
 ```python
 from npcpy.npc_sysenv import print_and_process_stream
 from npcpy.llm_funcs import get_llm_response
-response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen2.5:14b', provider='ollama', stream = True)
+response = get_llm_response("When did the united states government begin sending advisors to vietnam?", model='qwen3:latest', provider='ollama', stream = True)
 
 full_response = print_and_process_stream(response['response'], 'llama3.2', 'ollama')
 ```
@@ -338,7 +338,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='deepseek-coder', 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='claude-4-5-haiku-latest', provider='deepseek', format='json')
 
 print(response['response'])
 ```
@@ -384,6 +384,166 @@ from npcpy.llm_funcs import gen_video
 video = gen_video("make a video of the moon in the summer of marco polo", model='runwayml/stable-diffusion-v1-5', provider='diffusers')
 ```
 
+Or audio TTS and STT:
+```
+from npcpy.gen.audio_gen import tts_elevenlabs
+audio = tts_elevenlabs('''The representatives of the people of France, formed into a National Assembly,
+considering that ignorance, neglect, or contempt of human rights, are the sole causes of
+public misfortunes and corruptions of Government, have resolved to set forth in a solemn
+declaration, these natural, imprescriptible, and inalienable rights: that this declaration
+being constantly present to the minds of the members of the body social, they may be for
+ever kept attentive to their rights and their duties; that the acts of the legislative and
+executive powers of government, being capable of being every moment compared with
+the end of political institutions, may be more respected; and also, that the future claims of
+the citizens, being directed by simple and incontestable principles, may tend to the
+maintenance of the Constitution, and the general happiness. ''')
+# it will play the audio automatically.
+```
+## Fine-Tuning and Evolution
+
+`npcpy` provides modular tools for building adaptive AI systems through supervised fine-tuning, reinforcement learning, and genetic algorithms.
+
+See examples/fine_tuning_demo.py for a complete working example.
+
+
+### Supervised Fine-Tuning (SFT)
+
+Train models on specific tasks using simple X, y pairs:
+```python
+from npcpy.ft.sft import run_sft, load_sft_model, predict_sft
+
+X_train = ["translate to french: hello", "translate to french: goodbye"]
+y_train = ["bonjour", "au revoir"]
+
+model_path = run_sft(X_train, y_train)
+
+model, tokenizer = load_sft_model(model_path)
+response = predict_sft(model, tokenizer, "translate to french: thanks")
+```
+### Unsupervised Fine-Tuning (USFT)
+Adapt models to domain-specific text corpora without labels:
+```python
+from npcpy.ft.usft import run_usft, load_corpus_from_hf
+
+texts = load_corpus_from_hf("tiny_shakespeare", split="train[:1000]")
+
+model_path = run_usft(
+    texts,
+    config=USFTConfig(
+        output_model_path="models/shakespeare",
+        num_train_epochs=3
+    )
+)
+Train on your own text corpus:
+pythondomain_texts = [
+    "Your domain-specific text 1",
+    "Your domain-specific text 2",
+] * 100
+
+model_path = run_usft(domain_texts)
+```
+### Diffusion Fine-tuning
+```
+from npcpy.ft.diff import train_diffusion, generate_image
+
+image_paths = ["img1.png", "img2.png", "img3.png"]
+captions = ["a cat", "a dog", "a bird"]
+
+model_path = train_diffusion(
+    image_paths,
+    captions,
+    config=DiffusionConfig(
+        num_epochs=100,
+        batch_size=4
+    )
+)
+
+generated = generate_image(
+    model_path,
+    prompt="a white square",
+    image_size=128
+)
+Resume training from checkpoint:
+pythonmodel_path = train_diffusion(
+    image_paths,
+    captions,
+    config,
+    resume_from="models/diffusion/checkpoints/checkpoint-epoch10-step1000.pt"
+)
+```
+
+
+### Reinforcement Learning (RL)
+Collect agent traces and train with DPO based on reward signals:
+```python
+from npcpy.ft.rl import collect_traces, run_rl_training
+from npcpy.npc_compiler import NPC
+
+tasks = [
+    {'prompt': 'Solve 2+2', 'expected': '4'},
+    {'prompt': 'Solve 5+3', 'expected': '8'}
+]
+
+agents = [
+    NPC(name="farlor", primary_directive="Be concise", 
+        model="qwen3:0.6b", provider="ollama"),
+    NPC(name="tedno", primary_directive="Show your work",
+        model="qwen3:0.6b", provider="ollama")
+]
+
+def reward_fn(trace):
+    if trace['task_metadata']['expected'] in trace['final_output']:
+        return 1.0
+    return 0.0
+
+adapter_path = run_rl_training(tasks, agents, reward_fn)
+```
+### Genetic Evolution
+
+Evolve populations of knowledge graphs or model ensembles:
+```python
+from npcpy.ft.ge import GeneticEvolver, GAConfig
+
+config = GAConfig(
+    population_size=20,
+    generations=50,
+    mutation_rate=0.15
+)
+
+evolver = GeneticEvolver(
+    fitness_fn=your_fitness_function,
+    mutate_fn=your_mutation_function,
+    crossover_fn=your_crossover_function,
+    initialize_fn=your_init_function,
+    config=config
+)
+
+best_individual = evolver.run()
+```
+
+### Smart Model Ensembler and response router 
+Build fast intuitive responses with fallback to reasoning:
+```python
+from npcpy.ft.model_ensembler import (
+    ResponseRouter,
+    create_model_genome
+)
+
+genome = create_model_genome(['math', 'code', 'factual'])
+router = ResponseRouter(fast_threshold=0.8)
+
+result = router.route_query("What is 2+2?", genome)
+
+if result['used_fast_path']:
+    print("Fast gut reaction")
+elif result['used_ensemble']:
+    print("Ensemble voting")
+else:
+    print("Full reasoning")
+```
+The intention for this model ensembler system is to mimic human cognition: pattern-matched gut reactions (System 1 of Kahneman) for familiar queries, falling back to deliberate reasoning (System 2 of Kahneman) for novel problems. Genetic algorithms evolve both knowledge structures and model specializations over time.
+
+
 
 ## Serving an NPC Team
 

npcpy-1.2.32.dist-info/RECORD

@@ -0,0 +1,54 @@
+npcpy/__init__.py,sha256=9imxFtK74_6Rw9rz0kyMnZYl_voPb569tkTlYLt0Urg,131
+npcpy/llm_funcs.py,sha256=qC-WmNvUl3YAS1u-xPXh1YDlr2e9cv80_wXK6wCr7TA,85546
+npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
+npcpy/npc_compiler.py,sha256=j3JYZPKPLi42HAEA_i3Cp5GBGGUcpzBk8OEzZEvxzY4,89458
+npcpy/npc_sysenv.py,sha256=t9AswM-9_P2NaGsnlzTMc2hUfdSthi9ofbud6F1G7LM,35974
+npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
+npcpy/serve.py,sha256=P01tYsY1ctq408nn-t3sLPGuGJg5KoaApy4gNECDRgo,118007
+npcpy/tools.py,sha256=A5_oVmZkzGnI3BI-NmneuxeXQq-r29PbpAZP4nV4jrc,5303
+npcpy/data/__init__.py,sha256=1tcoChR-Hjn905JDLqaW9ElRmcISCTJdE7BGXPlym2Q,642
+npcpy/data/audio.py,sha256=goon4HfsYgx0bI-n1lhkrzWPrJoejJlycXcB0P62pyk,11280
+npcpy/data/data_models.py,sha256=q7xpI4_nK5HvlOE1XB5u5nFQs4SE5zcgt0kIZJF2dhs,682
+npcpy/data/image.py,sha256=UQcioNPDd5HYMLL_KStf45SuiIPXDcUY-dEFHwSWUeE,6564
+npcpy/data/load.py,sha256=7Ay-TYNhCvjJLwdQ5qAgxXSrGwow9ZrazHFVPqMw_cI,4274
+npcpy/data/text.py,sha256=jP0a1qZZaSJdK-LdZTn2Jjdxqmkd3efxDLEoxflJQeY,5010
+npcpy/data/video.py,sha256=aPUgj0fA_lFQ7Jf94-PutggCF4695FVCh3q5mnVthvI,574
+npcpy/data/web.py,sha256=ARGoVKUlQmaiX0zJbSvvFmRCwOv_Z7Pcan9c5GxYObQ,5117
+npcpy/ft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+npcpy/ft/diff.py,sha256=wYFRY_2p-B5xVqO7NDyhJbjQsUt4PrwOfgpE1Icghmk,2906
+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/sft.py,sha256=74gRaJTTrZcO4np4DqRMr79ADkGhPcDKutR74rag03E,6659
+npcpy/ft/usft.py,sha256=O025GGYGZQf2ZVLowyAmBwh5bJyuy2dUAM6v03YcboY,3435
+npcpy/gen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+npcpy/gen/audio_gen.py,sha256=w4toESu7nmli1T5FOwRRCGC_QK9W-SMWknYYkbRv9jE,635
+npcpy/gen/embeddings.py,sha256=QStTJ2ELiC379OEZsLEgGGIIFD267Y8zQchs7HRn2Zg,2089
+npcpy/gen/image_gen.py,sha256=mAlLG9jo9RnuuMU0jJVV0CpIgHqdizU9sfC6A0w5kKE,15599
+npcpy/gen/response.py,sha256=6iAOi4hxUxkTZ1d2suBUASOssT6pQnr3HFwZWrvmATg,31925
+npcpy/gen/video_gen.py,sha256=RFi3Zcq_Hn3HIcfoF3mijQ6G7RYFZaM_9pjPTh-8E64,3239
+npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+npcpy/memory/command_history.py,sha256=2VdmNW5VRpMrOkbdrMsgn5p3mvuJHNnzGHnIUEM8XMI,46279
+npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
+npcpy/memory/knowledge_graph.py,sha256=2XpIlsyPdAOnzQ6kkwP6MWPGwL3P6V33_3suNJYMMJE,48681
+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
+npcpy/mix/debate.py,sha256=lQXxC7nl6Rwyf7HIYrsVQILMUmYYx55Tjt2pkTg56qY,9019
+npcpy/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+npcpy/sql/ai_function_tools.py,sha256=ZCpjVHtaMRdL2dXxbQy5NhhjtPrVViGT1wyEl8ADrks,7755
+npcpy/sql/database_ai_adapters.py,sha256=CMlNGOhmJZhGB47RPvLIMqB61m_eYPVg1lwx42_b0jQ,6865
+npcpy/sql/database_ai_functions.py,sha256=XQCmaFOE1lNCnwrLTNpotYOlv6sx41bb8hxZI_sqpy8,6335
+npcpy/sql/model_runner.py,sha256=hJZ7hx2mwI-8DAh47Q6BwOsRjx30-HzebL4ajEUO4HA,5734
+npcpy/sql/npcsql.py,sha256=-PmV7AXSKwRog4gPHTeHzmvPrnDZOiccjgkUGv4DwEU,35614
+npcpy/sql/sql_model_compiler.py,sha256=G-0dpTlgzc-dXy9YEsdWGjO8xaQ3jFNbc6oUja1Ef4M,5364
+npcpy/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.2.32.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.2.32.dist-info/METADATA,sha256=Bii6xZThq-8YL-AByfstXOd6xYhtzH4deF4QQZ44LAk,29895
+npcpy-1.2.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.2.32.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.2.32.dist-info/RECORD,,