npcpy 1.3.4__py3-none-any.whl → 1.3.5__py3-none-any.whl

npcpy/sql/npcsql.py

@@ -7,6 +7,12 @@ from collections import defaultdict, deque
 from sqlalchemy import create_engine, text, Engine, inspect
 import inspect as py_inspect
 
+try:
+    from jinja2 import Environment, BaseLoader, DebugUndefined
+    JINJA_AVAILABLE = True
+except ImportError:
+    JINJA_AVAILABLE = False
+
 # --- Explicitly import llm_funcs as a module object ---
 try:
     import npcpy.llm_funcs as llm_funcs
@@ -74,10 +80,8 @@ class DatabaseAIFunctionMapper:
                 'cortex_function': 'COMPLETE',
                 'transformer': lambda prompt, **kwargs: f"SNOWFLAKE.CORTEX.COMPLETE('llama3.1-8b', {prompt})"
             },
-            'extract_facts': {
-                'cortex_function': 'COMPLETE', 
-                'transformer': lambda text, **kwargs: f"SNOWFLAKE.CORTEX.COMPLETE('llama3.1-8b', CONCAT('Extract concise facts from this text. Return JSON with fact_list array. Text: ', {text}))"
-            },
+
+            
             'get_facts': {
                 'cortex_function': 'COMPLETE',
                 'transformer': lambda text, **kwargs: f"""SNOWFLAKE.CORTEX.COMPLETE('llama3.1-8b', 
@@ -189,42 +193,183 @@ class NativeDatabaseAITransformer:
         
         return transformer(**kwargs)
 
+
+# --- NQL Jinja Context ---
+class NQLJinjaContext:
+    """Provides Jinja template context for NQL models with access to NPCs, jinxs, and team."""
+
+    def __init__(self, team=None, npc_operations=None):
+        self.team = team
+        self.npc_operations = npc_operations
+        self._npc_cache = {}
+        self._jinx_cache = {}
+
+    def npc(self, name: str) -> dict:
+        """Get NPC properties by name. Usage: {{ npc('sibiji').model }}"""
+        if name in self._npc_cache:
+            return self._npc_cache[name]
+
+        if not self.team:
+            return {'name': name, 'error': 'No team loaded'}
+
+        npc_obj = self.team.get_npc(name)
+        if not npc_obj:
+            return {'name': name, 'error': f'NPC {name} not found'}
+
+        # Build properties dict
+        props = {
+            'name': getattr(npc_obj, 'name', name),
+            'model': getattr(npc_obj, 'model', 'gpt-4o-mini'),
+            'provider': getattr(npc_obj, 'provider', 'openai'),
+            'directive': getattr(npc_obj, 'primary_directive', ''),
+            'jinxs': getattr(npc_obj, 'jinxs', []),
+        }
+        self._npc_cache[name] = props
+        return props
+
+    def jinx(self, name: str) -> dict:
+        """Get jinx properties by name. Usage: {{ jinx('sample').description }}"""
+        if name in self._jinx_cache:
+            return self._jinx_cache[name]
+
+        if not self.npc_operations or not self.npc_operations.jinx_map:
+            return {'name': name, 'error': 'No jinxs loaded'}
+
+        jinx_info = self.npc_operations.jinx_map.get(name.lower())
+        if not jinx_info:
+            return {'name': name, 'error': f'Jinx {name} not found'}
+
+        props = {
+            'name': jinx_info.get('name', name),
+            'description': jinx_info.get('description', ''),
+            'inputs': jinx_info.get('inputs', []),
+        }
+        self._jinx_cache[name] = props
+        return props
+
+    def get_team_context(self) -> dict:
+        """Get team-level properties. Usage: {{ team.forenpc }}"""
+        if not self.team:
+            return {'error': 'No team loaded'}
+
+        return {
+            'name': getattr(self.team, 'name', 'npc_team'),
+            'forenpc': getattr(self.team, 'forenpc_name', None),
+            'npcs': [getattr(n, 'name', str(n)) for n in getattr(self.team, 'npcs', [])],
+            'jinx_count': len(self.npc_operations.jinx_map) if self.npc_operations else 0,
+        }
+
+    def ref(self, model_name: str) -> str:
+        """Reference another model. Usage: {{ ref('base_stats') }}"""
+        return f"{{{{ ref('{model_name}') }}}}"
+
+    def config(self, **kwargs) -> str:
+        """Model configuration. Usage: {{ config(materialized='table') }}"""
+        config_parts = [f"{k}='{v}'" if isinstance(v, str) else f"{k}={v}"
+                       for k, v in kwargs.items()]
+        return f"{{{{ config({', '.join(config_parts)}) }}}}"
+
+    def env(self, var_name: str, default: str = '') -> str:
+        """Get environment variable. Usage: {{ env('API_KEY') }}"""
+        return os.environ.get(var_name, default)
+
+    def build_jinja_env(self) -> 'Environment':
+        """Build Jinja2 environment with NQL functions."""
+        if not JINJA_AVAILABLE:
+            raise ImportError("Jinja2 is required for template processing. Install with: pip install jinja2")
+
+        env = Environment(
+            loader=BaseLoader(),
+            undefined=DebugUndefined,
+            # Keep {{ ref(...) }} and {{ config(...) }} unprocessed for later
+            variable_start_string='{%',
+            variable_end_string='%}',
+            block_start_string='{%%',
+            block_end_string='%%}',
+        )
+
+        # Add custom functions
+        env.globals['npc'] = self.npc
+        env.globals['jinx'] = self.jinx
+        env.globals['team'] = self.get_team_context()
+        env.globals['env'] = self.env
+
+        return env
+
+    def render_template(self, content: str) -> str:
+        """Render Jinja template in SQL content."""
+        if not JINJA_AVAILABLE:
+            return content
+
+        # Only process if there are NQL Jinja expressions ({% ... %})
+        if '{%' not in content:
+            return content
+
+        try:
+            env = self.build_jinja_env()
+            template = env.from_string(content)
+            return template.render()
+        except Exception as e:
+            print(f"Warning: Jinja template error: {e}")
+            return content
+
+
 # --- NPCSQL Operations ---
 class NPCSQLOperations:
     def __init__(
-        self, 
-        npc_directory: str, 
+        self,
+        npc_directory: str,
         db_engine: Union[str, Engine] = "~/npcsh_history.db"
     ):
         self.npc_directory = npc_directory
-        
+
         if isinstance(db_engine, str):
             self.engine = create_engine_from_path(db_engine)
         else:
             self.engine = db_engine
-            
+
         self.npc_loader = None
+        self.jinx_map = {}  # Maps jinx names to jinx objects
         self.function_map = self._build_function_map()
-        
+
     def _get_team(self):
-        return (self.npc_loader 
-                if hasattr(self.npc_loader, 'npcs') 
+        return (self.npc_loader
+                if hasattr(self.npc_loader, 'npcs')
                 else None)
 
     def _build_function_map(self):
         import types
-        
+
         function_map = {}
         for name in dir(llm_funcs):
             if name.startswith('_'):
                 continue
             obj = getattr(llm_funcs, name)
-            if (isinstance(obj, types.FunctionType) or 
+            if (isinstance(obj, types.FunctionType) or
                 (isinstance(obj, types.MethodType) and obj.__self__ is not None)):
                 function_map[name] = obj
-        
+
         return function_map
 
+    def load_team_jinxs(self, team):
+        """Load jinxs from team to make them available as NQL functions."""
+        if not team:
+            return
+
+        try:
+            # Get all jinxs from the team's jinx catalog
+            if hasattr(team, 'jinx_tool_catalog'):
+                for tool in team.jinx_tool_catalog:
+                    jinx_name = tool.get('name', '').lower()
+                    if jinx_name and jinx_name not in self.function_map:
+                        # Store reference to the jinx
+                        self.jinx_map[jinx_name] = tool
+                        # Add a placeholder to function_map so it's recognized
+                        self.function_map[jinx_name] = f"__jinx__{jinx_name}"
+                        print(f"NQL: Registered team jinx '{jinx_name}' as NQL function")
+        except Exception as e:
+            print(f"Warning: Could not load team jinxs: {e}")
+
     def _resolve_npc_reference(self, npc_ref: str):
         if not npc_ref or not self.npc_loader:
             return None
@@ -252,6 +397,37 @@ class NPCSQLOperations:
                 
         return None
         
+    def _execute_jinx(self, jinx_name: str, query: str, npc_ref: str, context: str = "") -> str:
+        """Execute a team jinx and return the result."""
+        try:
+            from npcpy.npc_compiler import execute_jinx
+
+            jinx_info = self.jinx_map.get(jinx_name)
+            if not jinx_info:
+                return f"Error: Jinx '{jinx_name}' not found"
+
+            # Build context for jinx execution
+            jinx_context = {
+                'input': query,
+                'prompt': query,
+                'text': query,
+                'context': context,
+            }
+
+            # Get the jinx object from team
+            team = self._get_team()
+            if team and hasattr(team, 'get_jinx'):
+                jinx = team.get_jinx(jinx_name)
+                if jinx:
+                    result = execute_jinx(jinx, jinx_context, team=team)
+                    if isinstance(result, dict):
+                        return result.get('output', str(result))
+                    return str(result)
+
+            return f"Error: Could not execute jinx '{jinx_name}'"
+        except Exception as e:
+            return f"Jinx error: {e}"
+
     def execute_ai_function(
         self,
         func_name: str,
@@ -262,6 +438,7 @@ class NPCSQLOperations:
             raise ValueError(f"Unknown AI function: {func_name}")
 
         func = self.function_map[func_name]
+        is_jinx = isinstance(func, str) and func.startswith("__jinx__")
 
         npc_ref = params.get('npc', '')
         resolved_npc = self._resolve_npc_reference(npc_ref)
@@ -271,7 +448,8 @@ class NPCSQLOperations:
             resolved_team = resolved_npc.team
 
         total_rows = len(df)
-        print(f"NQL: Executing {func_name} on {total_rows} rows with NPC '{npc_ref}'...")
+        func_type = "jinx" if is_jinx else "function"
+        print(f"NQL: Executing {func_type} '{func_name}' on {total_rows} rows with NPC '{npc_ref}'...")
 
         results = []
         for idx, (row_idx, row) in enumerate(df.iterrows()):
@@ -292,34 +470,45 @@ class NPCSQLOperations:
 
             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,
-                    'npc': resolved_npc,
-                    'team': resolved_team,
-                    'context': params.get('context', ''),
-                    'model': npc_model or 'gpt-4o-mini',
-                    'provider': npc_provider or 'openai'
-                }.items() if k in sig.parameters
-            }
-
             try:
-                result = func(**func_params)
-                result_value = (result.get("response", "")
-                        if isinstance(result, dict)
-                        else str(result))
-                print(f"OK ({len(result_value)} chars)")
+                if is_jinx:
+                    # Execute as jinx
+                    result_value = self._execute_jinx(
+                        func_name,
+                        query,
+                        npc_ref,
+                        params.get('context', '')
+                    )
+                else:
+                    # Execute as llm_func
+                    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,
+                            'npc': resolved_npc,
+                            'team': resolved_team,
+                            '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)
+                    result_value = (result.get("response", "")
+                            if isinstance(result, dict)
+                            else str(result))
+
+                print(f"OK ({len(str(result_value))} chars)")
             except Exception as e:
                 print(f"ERROR: {e}")
                 result_value = None
@@ -333,20 +522,22 @@ class NPCSQLOperations:
 # --- SQL Model Definition ---
 class SQLModel:
     def __init__(
-        self, 
-        name: str, 
-        content: str, 
-        path: str, 
-        npc_directory: str
+        self,
+        name: str,
+        content: str,
+        path: str,
+        npc_directory: str,
+        additional_functions: Optional[List[str]] = None
     ):
         self.name = name
         self.content = content
         self.path = path
         self.npc_directory = npc_directory
-        
+        self.additional_functions = additional_functions or []
+
         config_match = re.search(
-            r'\{\{[\s]*config\((.*?)\)[\s]*\}\}', 
-            content, 
+            r'\{\{[\s]*config\((.*?)\)[\s]*\}\}',
+            content,
             re.DOTALL
         )
         if config_match:
@@ -356,7 +547,7 @@ class SQLModel:
 
         self.dependencies = self._extract_dependencies()
         self.has_ai_function = self._check_ai_functions()
-        
+
         # DEBUG print to confirm if AI functions are found
         self.ai_functions = self._extract_ai_functions()
         if self.ai_functions:
@@ -397,9 +588,15 @@ class SQLModel:
             if name.startswith('_'):
                 continue
             obj = getattr(llm_funcs, name)
-            if (isinstance(obj, types.FunctionType) or 
+            if (isinstance(obj, types.FunctionType) or
                 (isinstance(obj, types.MethodType) and obj.__self__ is not None)):
                 available_functions.append(name.lower())  # Store as lowercase for comparison
+
+        # Add any additional functions (e.g., team jinxs)
+        for fn in self.additional_functions:
+            fn_lower = fn.lower()
+            if fn_lower not in available_functions:
+                available_functions.append(fn_lower)
         
         for match in matches:
             full_call_string = match.group(0).strip()
@@ -496,9 +693,17 @@ class ModelCompiler:
         try:
             self.npc_team = Team(team_path=npc_directory)
             self.npc_operations.npc_loader = self.npc_team
+            # Load team jinxs as NQL functions
+            self.npc_operations.load_team_jinxs(self.npc_team)
         except Exception as e:
             self.npc_team = None
             print(f"Warning: Could not load NPC team from {npc_directory}. AI functions relying on NPC context might fail: {e}")
+
+        # Initialize Jinja context for template processing
+        self.jinja_context = NQLJinjaContext(
+            team=self.npc_team,
+            npc_operations=self.npc_operations
+        )
             
     def _get_engine(self, source_name: str) -> Engine:
         if source_name.lower() == 'local' or not self.external_engines:
@@ -516,19 +721,27 @@ class ModelCompiler:
     def discover_models(self):
         self.models = {}
         sql_files = list(self.models_dir.glob("**/*.sql"))
-        
+
+        # Get list of available jinx names for NQL function recognition
+        additional_funcs = list(self.npc_operations.jinx_map.keys())
+
         for sql_file in sql_files:
             model_name = sql_file.stem
             with open(sql_file, "r") as f:
                 content = f.read()
-            
+
+            # Process Jinja templates ({% npc(...) %}, {% team.forenpc %}, etc.)
+            if JINJA_AVAILABLE and '{%' in content:
+                content = self.jinja_context.render_template(content)
+
             self.models[model_name] = SQLModel(
-                model_name, 
-                content, 
-                str(sql_file), 
-                str(sql_file.parent) 
+                model_name,
+                content,
+                str(sql_file),
+                str(sql_file.parent),
+                additional_functions=additional_funcs
             )
-            
+
         return self.models
 
     def build_dag(self) -> Dict[str, Set[str]]:

npcpy/work/browser.py

@@ -0,0 +1,30 @@
+"""
+Global browser session storage for selenium automation.
+"""
+
+_sessions = {}
+
+def get_sessions():
+    return _sessions
+
+def get_current_driver():
+    current = _sessions.get('current')
+    if current and current in _sessions:
+        return _sessions[current]
+    return None
+
+def set_driver(session_id, driver):
+    _sessions[session_id] = driver
+    _sessions['current'] = session_id
+
+def close_current():
+    current = _sessions.get('current')
+    if current and current in _sessions:
+        try:
+            _sessions[current].quit()
+        except:
+            pass
+        del _sessions[current]
+        _sessions['current'] = None
+        return True
+    return False

{npcpy-1.3.4.dist-info → npcpy-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.4
+Version: 1.3.5
 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

{npcpy-1.3.4.dist-info → npcpy-1.3.5.dist-info}/RECORD

@@ -1,21 +1,22 @@
 npcpy/__init__.py,sha256=uJcJGjR1mWvE69GySNAufkgiRwJA28zdObDBWaxp0tY,505
-npcpy/llm_funcs.py,sha256=sc-sXA48VpJFy7vWyh8M5ZY2HQ362le_BfAtDA3Gh7Y,76489
+npcpy/build_funcs.py,sha256=vOz6pjV0zS-kYKo0ux-pn9AcppVaR8KIDi2ldOxb3RQ,7479
+npcpy/llm_funcs.py,sha256=E0HCVD98YFG8yMm5Pvlo8AatvxRykaE4DyX5LqrJTM8,75046
 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=X2BjMqKL7hbS37PPkSDGgZSF_PF_GNVGLd92ePRNRwQ,111868
-npcpy/npc_sysenv.py,sha256=rtE3KrXvIuOEpMq1CW5eK5K0o3f6mXagNXCeMnhHob4,36736
+npcpy/npc_compiler.py,sha256=trMvZHZjGDHo0TvjxZc8QJZXit78-rPDpxU0wsxtocw,118139
+npcpy/npc_sysenv.py,sha256=E4_C0UxuIasQ0Ie--CVty3d6OfV9rHP86OhEelVZhLs,36780
 npcpy/npcs.py,sha256=eExuVsbTfrRobTRRptRpDm46jCLWUgbvy4_U7IUQo-c,744
-npcpy/serve.py,sha256=5S3v4lp3fPozsnp_48SuVenf3JTiSiIBRxgfAReovmM,181539
+npcpy/serve.py,sha256=-Aia3kmjozo1aSQzIcEWZP7IcRSHyp5S4qTboX0iYgM,192944
 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
 npcpy/data/data_models.py,sha256=q7xpI4_nK5HvlOE1XB5u5nFQs4SE5zcgt0kIZJF2dhs,682
 npcpy/data/image.py,sha256=UQcioNPDd5HYMLL_KStf45SuiIPXDcUY-dEFHwSWUeE,6564
-npcpy/data/load.py,sha256=7V-YBp_SaMzCfLfvvyRrRkZ4rZWeYFgM0-3qiEYOfcc,9227
+npcpy/data/load.py,sha256=rVe1xSHerIpo6MDaY5eIeqRSm0gssX5sHukNsUNVwJw,9228
 npcpy/data/text.py,sha256=jP0a1qZZaSJdK-LdZTn2Jjdxqmkd3efxDLEoxflJQeY,5010
 npcpy/data/video.py,sha256=H-V3mTu_ktD9u-QhYeo4aW3u9z0AtoAdRZmvRPEpE98,2887
-npcpy/data/web.py,sha256=ARGoVKUlQmaiX0zJbSvvFmRCwOv_Z7Pcan9c5GxYObQ,5117
+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/ge.py,sha256=0VzIiXq2wCzGcK1x0Wd-myJ3xRf-FNaPg0GkHEZegUM,3552
@@ -27,14 +28,15 @@ 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=VflU_wJsKWJarOVwZtL2M8ymDFfKNz8WX66Rwk4obeo,21778
+npcpy/gen/image_gen.py,sha256=SOZYpvlxSiAdDK9j750OEBKjm22OUNdXg1kQ10sJSy0,21853
 npcpy/gen/ocr.py,sha256=rgmXWHrCYX1Po-qG_LrNFbVYEZ8aaupxFTgparcoB_Y,6554
-npcpy/gen/response.py,sha256=lH3fR3Sx1Cm8Zc0MJyHzTuuwTjVPgSJUZVxnkFIhzLE,40643
+npcpy/gen/response.py,sha256=2QRyc8UJQmanUkDlwT09KjmveguNC411eSmdlUhLP04,43372
 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=1488weOYtnm-wyenUvZKHaNgZe5OKOZSaQ35WNeceiM,56226
+npcpy/memory/command_history.py,sha256=EEaBscup0YGA99ZHV8AzYBGUwRiI0nBTOPmLWvCbY-A,60362
 npcpy/memory/kg_vis.py,sha256=TrQQCRh_E7Pyr-GPAHLSsayubAfGyf4HOEFrPB6W86Q,31280
-npcpy/memory/knowledge_graph.py,sha256=2XpIlsyPdAOnzQ6kkwP6MWPGwL3P6V33_3suNJYMMJE,48681
+npcpy/memory/knowledge_graph.py,sha256=FsMptito-wUcYOpRWEUxyTcmXPr-lxgHlMSy9xN7jAA,48677
 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
@@ -44,14 +46,15 @@ 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=YRBbcsMPNWLhzZqoF0wAL2MaT6OOc0wh33Z0hb01rjc,36591
+npcpy/sql/npcsql.py,sha256=5pA2csm1igRSAPGoFYeTHo3dQRIVTvvMH1QMyMhPrcI,44663
 npcpy/sql/sql_model_compiler.py,sha256=G-0dpTlgzc-dXy9YEsdWGjO8xaQ3jFNbc6oUja1Ef4M,5364
 npcpy/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.4.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.3.4.dist-info/METADATA,sha256=-dPHdZlVOsr_QtmxxbLl7W4cSkXH8Ccaf-w-qRB0yAY,37884
-npcpy-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.3.4.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.3.4.dist-info/RECORD,,
+npcpy-1.3.5.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.3.5.dist-info/METADATA,sha256=AvVXykxEQwTkZozgWXKY2YgAUHuoWqZQQxREx_hqyGg,37884
+npcpy-1.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.3.5.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.3.5.dist-info/RECORD,,