npcpy 1.2.35__py3-none-any.whl → 1.2.37__py3-none-any.whl

npcpy/sql/npcsql.py

@@ -253,56 +253,81 @@ class NPCSQLOperations:
         return None
         
     def execute_ai_function(
-        self, 
-        func_name: str, 
-        df: pd.DataFrame, 
+        self,
+        func_name: str,
+        df: pd.DataFrame,
         **params
     ) -> pd.Series:
         if func_name not in self.function_map:
             raise ValueError(f"Unknown AI function: {func_name}")
-            
+
         func = self.function_map[func_name]
-        
+
         npc_ref = params.get('npc', '')
         resolved_npc = self._resolve_npc_reference(npc_ref)
-        
+
         resolved_team = self._get_team()
         if not resolved_team and hasattr(resolved_npc, 'team'):
             resolved_team = resolved_npc.team
-        
-        def apply_function_to_row(row):
+
+        total_rows = len(df)
+        print(f"NQL: Executing {func_name} on {total_rows} rows with NPC '{npc_ref}'...")
+
+        results = []
+        for idx, (row_idx, row) in enumerate(df.iterrows()):
             query_template = params.get('query', '')
             column_name = params.get('column', '')
-            
+
             column_value = str(row[column_name]) if column_name and column_name in row.index else column_name
 
             if query_template:
                 row_data = {
-                    col: str(row[col]) 
+                    col: str(row[col])
                     for col in df.columns
                 }
-                row_data['column_value'] = column_value 
+                row_data['column_value'] = column_value
                 query = query_template.format(**row_data)
             else:
                 query = column_value
-            
+
+            print(f"  [{idx+1}/{total_rows}] Processing row {row_idx}...", end=" ", flush=True)
+
             sig = py_inspect.signature(func)
+
+            # Extract model/provider from NPC if available
+            npc_model = None
+            npc_provider = None
+            if resolved_npc and hasattr(resolved_npc, 'model'):
+                npc_model = resolved_npc.model
+            if resolved_npc and hasattr(resolved_npc, 'provider'):
+                npc_provider = resolved_npc.provider
+
             func_params = {
                 k: v for k, v in {
-                    'prompt': query, 
-                    'text': query,   
+                    'prompt': query,
+                    'text': query,
                     'npc': resolved_npc,
                     'team': resolved_team,
-                    'context': params.get('context', '')
+                    'context': params.get('context', ''),
+                    'model': npc_model or 'gpt-4o-mini',
+                    'provider': npc_provider or 'openai'
                 }.items() if k in sig.parameters
             }
-            
-            result = func(**func_params)
-            return (result.get("response", "") 
-                    if isinstance(result, dict) 
-                    else str(result))
-        
-        return df.apply(apply_function_to_row, axis=1)
+
+            try:
+                result = func(**func_params)
+                result_value = (result.get("response", "")
+                        if isinstance(result, dict)
+                        else str(result))
+                print(f"OK ({len(result_value)} chars)")
+            except Exception as e:
+                print(f"ERROR: {e}")
+                result_value = None
+
+            results.append(result_value)
+
+        print(f"NQL: Completed {func_name} on {total_rows} rows.")
+        return pd.Series(results, index=df.index)
     
 
 # --- SQL Model Definition ---
@@ -360,11 +385,10 @@ class SQLModel:
     def _extract_ai_functions(self) -> Dict[str, Dict]:
         """Extract AI function calls from SQL content with improved robustness."""
         import types
-        
+
         ai_functions = {}
-        # More robust pattern that handles nested parentheses better
-        # This captures: nql.function_name(args...)
-        pattern = r"nql\.(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)"
+        # Pattern that captures: nql.function_name(args...) as alias
+        pattern = r"nql\.(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)(\s+as\s+(\w+))?"
         
         matches = re.finditer(pattern, self.content, flags=re.DOTALL | re.IGNORECASE)
 
@@ -424,13 +448,17 @@ class SQLModel:
                 if self.npc_directory and npc_param.startswith(self.npc_directory):
                     npc_param = npc_param[len(self.npc_directory):].strip('/')
 
+                # Extract alias if present (group 4 from the pattern)
+                alias = match.group(4) if match.lastindex >= 4 and match.group(4) else f"{func_name}_result"
+
                 ai_functions[func_name] = {
                     "column": column_param,
                     "npc": npc_param,
                     "query": query_param,
                     "context": context_param,
                     "full_call_string": full_call_string,
-                    "original_func_name": match.group(1)  # Store original case
+                    "original_func_name": match.group(1),  # Store original case
+                    "alias": alias
                 }
             else:
                 print(f"DEBUG SQLModel: Function '{func_name}' not found in available LLM funcs ({available_functions}). Skipping this NQL call.")
@@ -546,14 +574,23 @@ class ModelCompiler:
 
         def replace_ref(match):
             model_name = match.group(1)
-            if model_name not in self.models:
-                raise ValueError(
-                    f"Model '{model_name}' referenced by '{{{{ ref('{model_name}') }}}}' not found during compilation."
-                )
-            
-            if self.target_schema:
-                return f"{self.target_schema}.{model_name}"
-            return model_name
+
+            # First check if it's a model we're compiling
+            if model_name in self.models:
+                if self.target_schema:
+                    return f"{self.target_schema}.{model_name}"
+                return model_name
+
+            # Otherwise, check if it's an existing table in the database
+            if self._table_exists(model_name):
+                if self.target_schema:
+                    return f"{self.target_schema}.{model_name}"
+                return model_name
+
+            # If neither, raise an error
+            raise ValueError(
+                f"Model or table '{model_name}' referenced by '{{{{ ref('{model_name}') }}}}' not found during compilation."
+            )
 
         replaced_sql = re.sub(ref_pattern, replace_ref, sql_content)
         return replaced_sql
@@ -665,42 +702,42 @@ class ModelCompiler:
             for func_name, params in model.ai_functions.items():
                 try:
                     result_series = self.npc_operations.execute_ai_function(func_name, df, **params)
-                    result_column_name = f"{func_name}_{params.get('column', 'result')}" # Use a more specific alias if possible
+                    # Use the SQL alias if available, otherwise generate one
+                    result_column_name = params.get('alias', f"{func_name}_result")
                     df[result_column_name] = result_series
-                    print(f"DEBUG: Python-driven AI function '{func_name}' executed. Result in column '{result_column_name}'.")
+                    print(f"DEBUG: AI function '{func_name}' result stored in column '{result_column_name}'.")
                 except Exception as e:
-                    print(f"ERROR: Executing Python-driven AI function '{func_name}': {e}. Assigning NULL.")
-                    df[f"{func_name}_{params.get('column', 'result')}"] = None
+                    print(f"ERROR: Executing AI function '{func_name}': {e}. Assigning NULL.")
+                    result_column_name = params.get('alias', f"{func_name}_result")
+                    df[result_column_name] = None
                     
             return df
 
     def _replace_nql_calls_with_null(self, sql_content: str, model: SQLModel) -> str:
         """
-        Replaces specific nql.func(...) as alias calls with NULL as alias.
-        This is used for the fallback path or to clean up any NQL calls missed by native translation.
+        Replaces nql.func(...) calls with NULL placeholders.
+        This is used for the fallback path where we execute SQL first, then apply AI functions in Python.
         """
         modified_sql = sql_content
-        for func_name, params in model.ai_functions.items():
-            original_nql_call = params.get('full_call_string')
-            if not original_nql_call:
-                print(f"WARNING: 'full_call_string' not found for NQL function '{func_name}'. Cannot replace with NULL.")
-                continue
 
-            # Extract alias from the original_nql_call string for NULL replacement
-            alias_match = re.search(r'\s+as\s+(\w+)(?:\W|$)', original_nql_call, re.IGNORECASE)
-            alias_name = alias_match.group(1) if alias_match else f"{func_name}_{params.get('column', 'result')}"
+        # Pattern to match nql.function_name(...) with nested parentheses support
+        # Also captures the 'as alias' part if present
+        nql_pattern = r'nql\.(\w+)\s*\(((?:[^()]|\([^()]*\))*)\)(\s+as\s+(\w+))?'
 
-            # Create a robust pattern for the original NQL call to handle whitespace variability
-            escaped_original_call = re.escape(original_nql_call.strip())
-            pattern_to_sub = re.compile(r"\s*".join(escaped_original_call.split()), flags=re.IGNORECASE)
+        def replace_with_null(match):
+            func_name = match.group(1)
+            alias_part = match.group(3) or ''
+            alias_name = match.group(4)
 
-            # Perform the replacement with NULL as alias
-            old_sql = modified_sql
-            modified_sql, count = pattern_to_sub.subn(f"NULL as {alias_name}", modified_sql)
-            if count == 0:
-                print(f"WARNING: NULL replacement failed for NQL call '{original_nql_call}' (no change to SQL). SQL still contains NQL call.")
-            else:
-                print(f"DEBUG: Replaced NQL call '{original_nql_call}' with 'NULL as {alias_name}'.")
+            # If no alias specified, generate one from function name
+            if not alias_name:
+                alias_name = f"{func_name}_result"
+                alias_part = f" as {alias_name}"
+
+            print(f"DEBUG: Replacing nql.{func_name}(...) with NULL{alias_part}")
+            return f"NULL{alias_part}"
+
+        modified_sql = re.sub(nql_pattern, replace_with_null, modified_sql, flags=re.IGNORECASE | re.DOTALL)
 
         return modified_sql
 

{npcpy-1.2.35.dist-info → npcpy-1.2.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.35
+Version: 1.2.37
 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
@@ -607,6 +607,178 @@ else:
 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.
 
 
+## NPCArray - NumPy for AI
+
+`npcpy` provides `NPCArray`, a NumPy-like interface for working with populations of models (LLMs, sklearn, PyTorch) at scale. Think of it as vectorized operations over AI models.
+
+### Core Concepts
+- Model arrays support vectorized operations
+- Operations are lazy until `.collect()` is called (like Spark)
+- Same interface works for single models (treated as length-1 arrays)
+- Supports ensemble voting, consensus, evolution, and more
+
+### Basic Usage
+
+```python
+from npcpy.npc_array import NPCArray
+
+# Create array of LLMs
+models = NPCArray.from_llms(
+    ['llama3.2', 'gemma3:1b'],
+    providers='ollama'
+)
+
+print(f"Model array shape: {models.shape}")  # (2,)
+
+# Inference across all models - returns shape (n_models, n_prompts)
+result = models.infer("What is 2+2? Just the number.").collect()
+
+print(f"Model 1: {result.data[0, 0]}")
+print(f"Model 2: {result.data[1, 0]}")
+```
+
+### Lazy Chaining & Ensemble Operations
+
+```python
+from npcpy.npc_array import NPCArray
+
+models = NPCArray.from_llms(['llama3.2', 'gemma3:1b', 'mistral:7b'])
+
+# Build lazy computation graph - nothing executed yet
+result = (
+    models
+    .infer("Is Python compiled or interpreted? One word.")
+    .map(lambda r: r.strip().lower())  # Clean responses
+    .vote(axis=0)  # Majority voting across models
+)
+
+# Show the computation plan
+result.explain()
+
+# Now execute
+answer = result.collect()
+print(f"Consensus: {answer.data[0]}")
+```
+
+### Parameter Sweeps with Meshgrid
+
+```python
+from npcpy.npc_array import NPCArray
+
+# Cartesian product over parameters
+configs = NPCArray.meshgrid(
+    models=['llama3.2', 'gemma3:1b'],
+    temperatures=[0.0, 0.5, 1.0]
+)
+
+print(f"Config array shape: {configs.shape}")  # (6,) = 2 models × 3 temps
+
+# Run inference with each config
+result = configs.infer("Complete: The quick brown fox").collect()
+```
+
+### Matrix Sampling with get_llm_response
+
+The `get_llm_response` function supports `matrix` and `n_samples` parameters for exploration:
+
+```python
+from npcpy.llm_funcs import get_llm_response
+
+# Matrix parameter - cartesian product over specified params
+result = get_llm_response(
+    "Write a creative opening line.",
+    matrix={
+        'model': ['llama3.2', 'gemma3:1b'],
+        'temperature': [0.5, 1.0]
+    }
+)
+print(f"Number of runs: {len(result['runs'])}")  # 4 = 2×2
+
+# n_samples - multiple samples from same config
+result = get_llm_response(
+    "Pick a random number 1-100.",
+    model='llama3.2',
+    n_samples=5
+)
+print(f"Samples: {[r['response'] for r in result['runs']]}")
+
+# Combine both for full exploration
+result = get_llm_response(
+    "Flip a coin: heads or tails?",
+    matrix={'model': ['llama3.2', 'gemma3:1b']},
+    n_samples=3  # 2 models × 3 samples = 6 runs
+)
+```
+
+### sklearn Integration
+
+```python
+from npcpy.npc_array import NPCArray
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+import numpy as np
+
+# Create sample data
+X_train = np.random.randn(100, 4)
+y_train = (X_train[:, 0] > 0).astype(int)
+
+# Pre-fit models
+rf = RandomForestClassifier(n_estimators=10).fit(X_train, y_train)
+lr = LogisticRegression().fit(X_train, y_train)
+
+# Create array from fitted models
+models = NPCArray.from_sklearn([rf, lr])
+
+# Vectorized prediction
+X_test = np.random.randn(20, 4)
+predictions = models.predict(X_test).collect()
+
+print(f"RF predictions: {predictions.data[0]}")
+print(f"LR predictions: {predictions.data[1]}")
+```
+
+### ML Functions with Grid Search
+
+```python
+from npcpy.ml_funcs import fit_model, score_model, ensemble_predict
+
+# Grid search via matrix parameter
+result = fit_model(
+    X_train, y_train,
+    model='RandomForestClassifier',
+    matrix={
+        'n_estimators': [10, 50, 100],
+        'max_depth': [3, 5, 10]
+    }
+)
+
+print(f"Fitted {len(result['models'])} model configurations")
+
+# Ensemble voting with multiple models
+predictions = ensemble_predict(X_test, result['models'], method='vote')
+```
+
+### Quick Utilities
+
+```python
+from npcpy.npc_array import infer_matrix, ensemble_vote
+
+# Quick matrix inference
+result = infer_matrix(
+    prompts=["Hello", "Goodbye"],
+    models=['llama3.2', 'gemma3:1b']
+)
+
+# Quick ensemble vote
+answer = ensemble_vote(
+    "What is the capital of France? One word.",
+    models=['llama3.2', 'gemma3:1b']
+)
+print(f"Voted answer: {answer}")
+```
+
+See `examples/npc_array_examples.py` for more comprehensive examples.
+
 
 ## Serving an NPC Team
 

{npcpy-1.2.35.dist-info → npcpy-1.2.37.dist-info}/RECORD

@@ -1,10 +1,12 @@
-npcpy/__init__.py,sha256=9imxFtK74_6Rw9rz0kyMnZYl_voPb569tkTlYLt0Urg,131
-npcpy/llm_funcs.py,sha256=RtZAtX1_nvfn-X3IHVyQggDBXDzGxKEix_sS_iliNN0,87172
+npcpy/__init__.py,sha256=uJcJGjR1mWvE69GySNAufkgiRwJA28zdObDBWaxp0tY,505
+npcpy/llm_funcs.py,sha256=KJpjN6q5iW_qdUfgt4tzYENCAu86376io8eFZ7wp76Y,78081
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
-npcpy/npc_compiler.py,sha256=lF0uhByMly5L-TJbsfPNavxSYFLVM9OdwoVMv6Ci2ko,99493
-npcpy/npc_sysenv.py,sha256=t9AswM-9_P2NaGsnlzTMc2hUfdSthi9ofbud6F1G7LM,35974
+npcpy/ml_funcs.py,sha256=UI7k7JR4XOH_VXR-xxLaO4r9Kyx_jBaEnp3TUIY7ZLQ,22657
+npcpy/npc_array.py,sha256=fVTxcMiXV-lvltmuwaRnTU9D3ikPq3-7k5wzp7MA5OY,40224
+npcpy/npc_compiler.py,sha256=oGSn9-X-Miq-K37QfNo8_TFcWbOl8WTNHBPtkf6paws,104619
+npcpy/npc_sysenv.py,sha256=rtE3KrXvIuOEpMq1CW5eK5K0o3f6mXagNXCeMnhHob4,36736
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=lXVIxkGj69C0hV2L9X0OfzDCqfMtgF38S2SJUkiJqLk,148478
+npcpy/serve.py,sha256=wbIXUFlmfKg72ZYoX_cBJ8FVDFabHsGnbMwMIj-412Y,174839
 npcpy/tools.py,sha256=A5_oVmZkzGnI3BI-NmneuxeXQq-r29PbpAZP4nV4jrc,5303
 npcpy/data/__init__.py,sha256=1tcoChR-Hjn905JDLqaW9ElRmcISCTJdE7BGXPlym2Q,642
 npcpy/data/audio.py,sha256=3qryGXnWHa4JFMonjuX-lf0fCrF8jmbHe7mHAuOdua0,12397
@@ -25,9 +27,9 @@ 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=PFaJAjMB0P1DV_x4tWXh25qGyjkntRejFLBnVPKSsqY,21730
+npcpy/gen/image_gen.py,sha256=VflU_wJsKWJarOVwZtL2M8ymDFfKNz8WX66Rwk4obeo,21778
 npcpy/gen/ocr.py,sha256=rgmXWHrCYX1Po-qG_LrNFbVYEZ8aaupxFTgparcoB_Y,6554
-npcpy/gen/response.py,sha256=6iAOi4hxUxkTZ1d2suBUASOssT6pQnr3HFwZWrvmATg,31925
+npcpy/gen/response.py,sha256=xSFHNZTDsebFo_nptWwSahpCU9_4pbCqabMFZ3X4_Bg,39979
 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=vWzZ4F4o0XOSHn50SkdP885jG1aZIZvfcPAh8EZWlQk,54497
@@ -42,14 +44,14 @@ npcpy/sql/ai_function_tools.py,sha256=ZCpjVHtaMRdL2dXxbQy5NhhjtPrVViGT1wyEl8ADrk
 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/npcsql.py,sha256=YRBbcsMPNWLhzZqoF0wAL2MaT6OOc0wh33Z0hb01rjc,36591
 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.35.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.2.35.dist-info/METADATA,sha256=_Ic5v_Q2AzFXGX13twz6tOcjhePm7OlVZZUZruHsebU,33537
-npcpy-1.2.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.2.35.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.2.35.dist-info/RECORD,,
+npcpy-1.2.37.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.2.37.dist-info/METADATA,sha256=xviLiFxgZ1uK876GGrIIm-P3uEJlwBvCtbbgn0vFUP4,37940
+npcpy-1.2.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.2.37.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.2.37.dist-info/RECORD,,