npcpy 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

npcpy/sql/database_ai_functions.py

@@ -0,0 +1,163 @@
+from typing import Dict, Callable, Any
+
+class DatabaseAIFunctionMapper:
+    @staticmethod
+    def get_snowflake_cortex_mapping() -> Dict[str, Dict[str, Any]]:
+        """
+        Map NPC AI functions to Snowflake Cortex functions
+        
+        Structure:
+        {
+            'npc_function_name': {
+                'cortex_function': 'snowflake_cortex_function_name',
+                'transformer': optional_transformation_function
+            }
+        }
+        """
+        return {
+            # Text Generation Mapping
+            'generate_text': {
+                'cortex_function': 'COMPLETE',
+                'transformer': lambda prompt, **kwargs: f"SNOWFLAKE.CORTEX.COMPLETE('{prompt}')"
+            },
+            
+            # Summarization Mapping
+            'summarize': {
+                'cortex_function': 'SUMMARIZE',
+                'transformer': lambda text, **kwargs: f"SNOWFLAKE.CORTEX.SUMMARIZE('{text}')"
+            },
+            
+            # Sentiment Analysis Mapping
+            'analyze_sentiment': {
+                'cortex_function': 'SENTIMENT',
+                'transformer': lambda text, **kwargs: f"SNOWFLAKE.CORTEX.SENTIMENT('{text}')"
+            },
+            
+            # Translation Mapping
+            'translate': {
+                'cortex_function': 'TRANSLATE',
+                'transformer': lambda text, source_lang='auto', target_lang='en', **kwargs: 
+                    f"SNOWFLAKE.CORTEX.TRANSLATE('{text}', '{source_lang}', '{target_lang}')"
+            },
+            
+            # Named Entity Recognition
+            'extract_entities': {
+                'cortex_function': 'EXTRACT_ENTITIES',
+                'transformer': lambda text, **kwargs: f"SNOWFLAKE.CORTEX.EXTRACT_ENTITIES('{text}')"
+            },
+            
+            # Embedding Generation
+            'generate_embedding': {
+                'cortex_function': 'EMBED_TEXT',
+                'transformer': lambda text, model='snowflake-arctic', **kwargs: 
+                    f"SNOWFLAKE.CORTEX.EMBED_TEXT('{model}', '{text}')"
+            }
+        }
+    
+    @staticmethod
+    def get_databricks_ai_mapping() -> Dict[str, Dict[str, Any]]:
+        """
+        Map NPC AI functions to Databricks AI functions
+        """
+        return {
+            # Databricks uses different function names and approaches
+            'generate_text': {
+                'databricks_function': 'serving.predict',
+                'transformer': lambda prompt, model='databricks-dolly', **kwargs: 
+                    f"serving.predict('{model}', '{prompt}')"
+            },
+            # Add more Databricks-specific mappings
+        }
+    
+    @staticmethod
+    def get_bigquery_ai_mapping() -> Dict[str, Dict[str, Any]]:
+        """
+        Map NPC AI functions to BigQuery AI functions
+        """
+        return {
+            'generate_text': {
+                'bigquery_function': 'ML.GENERATE_TEXT',
+                'transformer': lambda prompt, model='text-bison', **kwargs:
+                    f"ML.GENERATE_TEXT(MODEL `{model}`, '{prompt}')"
+            },
+            # Add more BigQuery-specific mappings
+        }
+
+class NativeDatabaseAITransformer:
+    def __init__(self, database_type: str):
+        self.database_type = database_type
+        self.function_mappings = self._get_database_mappings()
+    
+    def _get_database_mappings(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get the appropriate AI function mapping based on database type
+        """
+        mappings = {
+            'snowflake': DatabaseAIFunctionMapper.get_snowflake_cortex_mapping(),
+            'databricks': DatabaseAIFunctionMapper.get_databricks_ai_mapping(),
+            'bigquery': DatabaseAIFunctionMapper.get_bigquery_ai_mapping()
+        }
+        return mappings.get(self.database_type.lower(), {})
+    
+    def transform_ai_function(self, function_name: str, **kwargs) -> str:
+        """
+        Transform an NPC AI function to a native database AI function
+        """
+        mapping = self.function_mappings.get(function_name)
+        if not mapping:
+            raise ValueError(f"No native mapping found for function: {function_name}")
+        
+        transformer = mapping.get('transformer')
+        if not transformer:
+            raise ValueError(f"No transformer found for function: {function_name}")
+        
+        return transformer(**kwargs)
+
+# Example usage in ModelCompiler
+def _has_native_ai_functions(self, source_name: str) -> bool:
+    """Enhanced method to check native AI function support"""
+    ai_enabled = {
+        'snowflake': True,
+        'databricks': True,
+        'bigquery': True
+    }
+    return ai_enabled.get(source_name.lower(), False)
+
+def _execute_ai_model(self, sql: str, model: SQLModel) -> pd.DataFrame:
+    """
+    Enhanced method to use native AI functions when available
+    """
+    source_pattern = r'FROM\s+(\\w+)\\.(\\w+)'
+    matches = re.findall(source_pattern, sql)
+    
+    if matches:
+        source_name, table_name = matches[0]
+        engine = self._get_engine(source_name)
+        
+        # Check for native AI function support
+        if self._has_native_ai_functions(source_name):
+            # Use native transformer
+            transformer = NativeDatabaseAITransformer(source_name)
+            
+            # Modify SQL to use native AI functions
+            for func_name, params in model.ai_functions.items():
+                try:
+                    native_func_call = transformer.transform_ai_function(
+                        func_name, 
+                        text=params.get('column', ''),
+                        **{k: v for k, v in params.items() if k != 'column'}
+                    )
+                    
+                    # Replace the NQL function with native function
+                    sql = sql.replace(
+                        f"nql.{func_name}({params.get('column', '')})", 
+                        native_func_call
+                    )
+                except ValueError as e:
+                    # Fallback to original method if transformation fails
+                    print(f"Warning: {e}. Falling back to default AI function.")
+            
+            return pd.read_sql(sql.replace(f"{source_name}.", ""), engine)
+    
+    # Fallback to existing AI model execution
+    return super()._execute_ai_model(sql, model)

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-1.2.21.dist-info → npcpy-1.2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.21
+Version: 1.2.23
 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
@@ -399,6 +399,152 @@ the citizens, being directed by simple and incontestable principles, may tend to
 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` includes a built-in Flask server that makes it easy to deploy NPC teams for production use. You can serve teams with tools, jinxs, and complex workflows that frontends can interact with via REST APIs.

{npcpy-1.2.21.dist-info → npcpy-1.2.23.dist-info}/RECORD

@@ -1,5 +1,5 @@
 npcpy/__init__.py,sha256=9imxFtK74_6Rw9rz0kyMnZYl_voPb569tkTlYLt0Urg,131
-npcpy/llm_funcs.py,sha256=tvcZuQEcIUJClwEJQXBF6ArEVjSuXt1jAcZOcnYWsVQ,85101
+npcpy/llm_funcs.py,sha256=UkesCnRmclEoqBZPMZa2hKoSTjFzjxDCzPGKgeDegPQ,85101
 npcpy/main.py,sha256=RWoRIj6VQLxKdOKvdVyaq2kwG35oRpeXPvp1CAAoG-w,81
 npcpy/npc_compiler.py,sha256=10vu-9WUmlVzaFM_hMJH28iNS1IJXQP3Rb5RT1rZmpA,95326
 npcpy/npc_sysenv.py,sha256=lPYlKM_TeR4l4-Jcgiqq3CCge8b2oFHdfISD4L_G7eo,30308
@@ -10,39 +10,45 @@ 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=f3-bgKUq_pnfUhqjZdXwfIEZmMbGJpJfGTBjuiYJos8,4258
+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=R3Qo6v0-6M1iI0wiXhUzyuYI2ja0q_0i9bE0z3coxzU,28
-npcpy/ft/ge.py,sha256=my5LtGyVTT40V0i1h9FR-tFFA1FHSga-PeCCgUX1UUI,61
+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/rl.py,sha256=l3RUkEJe4b2yB6pildveu2LJymtNq0F17COwf_CCq3U,34
-npcpy/ft/sft.py,sha256=i4ENygRPArbLWN4XZZuBnPWaehs8M-J68JB_mewGJHI,62
+npcpy/ft/model_ensembler.py,sha256=BRX4hJ_rvF1vKTzjMhlahZqPttUgc3PqmzUJDqIfIps,10038
+npcpy/ft/rl.py,sha256=EcPD8t5MFg0zYWSS-A7KJ9bWd0qCTsL5SSvDxV556Z4,9245
+npcpy/ft/sft.py,sha256=iPCP4sM2Nfri0rif_oR1uFInhqY8HIILwT-iQGk7f10,6064
+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=ln71jmLoJHekbZYDJpTe5DtOamVte9gjr2BPQ1DzjMQ,14955
-npcpy/gen/response.py,sha256=Rrk3rrSSGode94JJkKyL4n9Dpw9CH7R5l9xyjQSDFxE,28954
+npcpy/gen/response.py,sha256=dK0Ux1_0GHo4gOfSHrrp34Ub4YJ-88NjFZfaG3kSrB0,28940
 npcpy/gen/video_gen.py,sha256=JMp2s2qMp5uy0rOgv6BRZ7nkQI4vdT1hbJ2nSu4s-KA,3243
 npcpy/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-npcpy/memory/command_history.py,sha256=Ww7vZTSjQDuElQXuOjsvu7NTljOLAg07QIFrfKARpVg,45562
+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=bLfzT-uDgwNegs1hVBqW3Hl2fYtdmFQbdc5To_f4i5E,2106
+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=AOffqGK1Jwjf_tgE8qo4KY5KXE21ylm1dhRSKS0Cesw,13587
+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.21.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
-npcpy-1.2.21.dist-info/METADATA,sha256=UoIjUU728VK_7CUbvzVqNnXkK8AjPEPwagfXBIdO1ko,26025
-npcpy-1.2.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-npcpy-1.2.21.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
-npcpy-1.2.21.dist-info/RECORD,,
+npcpy-1.2.23.dist-info/licenses/LICENSE,sha256=j0YPvce7Ng9e32zYOu0EmXjXeJ0Nwawd0RA3uSGGH4E,1070
+npcpy-1.2.23.dist-info/METADATA,sha256=-Q2qDZh5Khizw_PcCZnLCyIkMmFyworeU8gPzgEhBpY,29885
+npcpy-1.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+npcpy-1.2.23.dist-info/top_level.txt,sha256=g1pbSvrOOncB74Bg5-J0Olg4V0A5VzDw-Xz5YObq8BU,6
+npcpy-1.2.23.dist-info/RECORD,,