npcpy 1.3.14__tar.gz → 1.3.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.14
+Version: 1.3.16
 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.14 → npcpy-1.3.16}/npcpy/ft/rl.py

@@ -6,27 +6,40 @@ import glob
 import json
 import os
 import pandas as pd
+# Core imports that should always work
 try:
-    from datasets import Dataset
-
-    from peft import LoraConfig, PeftModel
     import torch
-    from transformers import (
-        AutoModelForCausalLM,
-        AutoTokenizer,
-        BitsAndBytesConfig
-    )
-    from trl import DPOTrainer, DPOConfig
-except:
-    Dataset = None
-    PeftModel = None
-    DPOConfig = None
-    DPOTrainer = None
+except ImportError:
     torch = None
+
+try:
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+except ImportError:
     AutoModelForCausalLM = None
     AutoTokenizer = None
+
+try:
+    from transformers import BitsAndBytesConfig
+except ImportError:
     BitsAndBytesConfig = None
 
+try:
+    from datasets import Dataset
+except ImportError:
+    Dataset = None
+
+try:
+    from peft import LoraConfig, PeftModel
+except ImportError:
+    LoraConfig = None
+    PeftModel = None
+
+try:
+    from trl import DPOTrainer, DPOConfig
+except ImportError:
+    DPOTrainer = None
+    DPOConfig = None
+
     
 import random
 from typing import List, Dict, Any, Optional, Callable
@@ -344,7 +357,7 @@ def train_with_dpo(
         args=training_args,
         train_dataset=preference_dataset,
         peft_config=peft_config,
-        tokenizer=tokenizer
+        processing_class=tokenizer
     )
 
     print("Starting DPO training...")

{npcpy-1.3.14 → npcpy-1.3.16}/npcpy/serve.py

@@ -5273,7 +5273,7 @@ def openai_chat_completions():
         current_path = request.headers.get("X-Current-Path", os.getcwd())
 
         # Load team and NPC
-        db_path = app.config.get('DB_PATH') or os.path.expanduser("~/.npcsh/npcsh_history.db")
+        db_path = app.config.get('DB_PATH') or os.path.expanduser("~/npcsh_history.db")
         db_conn = create_engine(f'sqlite:///{db_path}')
 
         npc = None
@@ -6110,8 +6110,8 @@ if __name__ == "__main__":
 
     SETTINGS_FILE = Path(os.path.expanduser("~/.npcshrc"))
 
-    # Use standard npcsh paths
-    db_path = os.path.expanduser("~/.npcsh/npcsh_history.db")
+    # Use environment variable for DB path, or fall back to home directory path (matching Electron app)
+    db_path = os.environ.get('INCOGNIDE_DB_PATH', os.path.expanduser("~/npcsh_history.db"))
     user_npc_directory = os.path.expanduser("~/.npcsh/npc_team")
 
     # Ensure directories exist

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.3.14
+Version: 1.3.16
 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.14 → npcpy-1.3.16}/npcpy.egg-info/SOURCES.txt

@@ -63,16 +63,29 @@ npcpy/work/desktop.py
 npcpy/work/plan.py
 npcpy/work/trigger.py
 tests/test_audio.py
+tests/test_browser.py
+tests/test_build_funcs.py
 tests/test_command_history.py
+tests/test_data_models.py
+tests/test_diff.py
 tests/test_documentation_examples.py
+tests/test_genetic_evolver.py
 tests/test_image.py
 tests/test_llm_funcs.py
 tests/test_load.py
+tests/test_memory_processor.py
+tests/test_ml_funcs.py
+tests/test_model_runner.py
 tests/test_npc_array.py
 tests/test_npc_compiler.py
+tests/test_npc_sysenv.py
 tests/test_npcsql.py
 tests/test_response.py
 tests/test_serve.py
+tests/test_sql_adapters.py
+tests/test_sql_compiler.py
+tests/test_sql_functions.py
 tests/test_text.py
 tests/test_tools.py
+tests/test_video.py
 tests/test_web.py

{npcpy-1.3.14 → npcpy-1.3.16}/setup.py

@@ -83,7 +83,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.3.14",
+    version="1.3.16",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={

npcpy-1.3.16/tests/test_browser.py

@@ -0,0 +1,233 @@
+"""Test suite for browser session storage module."""
+
+import pytest
+
+
+class TestBrowserSessions:
+    """Test browser session storage functions."""
+
+    def test_get_sessions_returns_dict(self):
+        """Test get_sessions returns a dictionary"""
+        from npcpy.work import browser
+
+        sessions = browser.get_sessions()
+
+        assert isinstance(sessions, dict)
+
+    def test_get_current_driver_none_initially(self):
+        """Test get_current_driver returns None when no session set"""
+        from npcpy.work import browser
+
+        # Clear any existing sessions
+        browser._sessions.clear()
+
+        driver = browser.get_current_driver()
+
+        assert driver is None
+
+    def test_set_driver_stores_session(self):
+        """Test set_driver stores the driver"""
+        from npcpy.work import browser
+
+        # Clear any existing sessions
+        browser._sessions.clear()
+
+        # Create a mock driver object
+        class MockDriver:
+            pass
+
+        mock_driver = MockDriver()
+
+        browser.set_driver("session-1", mock_driver)
+
+        assert "session-1" in browser._sessions
+        assert browser._sessions["session-1"] is mock_driver
+        assert browser._sessions["current"] == "session-1"
+
+    def test_set_driver_updates_current(self):
+        """Test set_driver updates current session"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            pass
+
+        browser.set_driver("session-1", MockDriver())
+        assert browser._sessions["current"] == "session-1"
+
+        browser.set_driver("session-2", MockDriver())
+        assert browser._sessions["current"] == "session-2"
+
+    def test_get_current_driver_returns_active_session(self):
+        """Test get_current_driver returns the current driver"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            def __init__(self, name):
+                self.name = name
+
+        driver1 = MockDriver("driver1")
+        driver2 = MockDriver("driver2")
+
+        browser.set_driver("session-1", driver1)
+        browser.set_driver("session-2", driver2)
+
+        current = browser.get_current_driver()
+
+        assert current is driver2
+        assert current.name == "driver2"
+
+    def test_close_current_removes_session(self):
+        """Test close_current removes the current session"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            def __init__(self):
+                self.quit_called = False
+
+            def quit(self):
+                self.quit_called = True
+
+        mock_driver = MockDriver()
+        browser.set_driver("session-1", mock_driver)
+
+        result = browser.close_current()
+
+        assert result is True
+        assert "session-1" not in browser._sessions
+        assert browser._sessions.get("current") is None
+
+    def test_close_current_calls_quit(self):
+        """Test close_current calls quit on driver"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        quit_called = {"value": False}
+
+        class MockDriver:
+            def quit(self):
+                quit_called["value"] = True
+
+        browser.set_driver("session-1", MockDriver())
+        browser.close_current()
+
+        assert quit_called["value"] is True
+
+    def test_close_current_handles_quit_error(self):
+        """Test close_current handles quit errors gracefully"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            def quit(self):
+                raise Exception("Browser already closed")
+
+        browser.set_driver("session-1", MockDriver())
+
+        # Should not raise, should return True
+        result = browser.close_current()
+
+        assert result is True
+
+    def test_close_current_no_session(self):
+        """Test close_current returns False when no session"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        result = browser.close_current()
+
+        assert result is False
+
+    def test_multiple_sessions_stored(self):
+        """Test multiple sessions can be stored"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            pass
+
+        browser.set_driver("session-1", MockDriver())
+        browser.set_driver("session-2", MockDriver())
+        browser.set_driver("session-3", MockDriver())
+
+        sessions = browser.get_sessions()
+
+        assert "session-1" in sessions
+        assert "session-2" in sessions
+        assert "session-3" in sessions
+        assert sessions["current"] == "session-3"
+
+    def test_get_current_driver_invalid_current(self):
+        """Test get_current_driver handles invalid current reference"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        # Set current to non-existent session
+        browser._sessions["current"] = "nonexistent"
+
+        driver = browser.get_current_driver()
+
+        assert driver is None
+
+
+class TestBrowserModuleImports:
+    """Test browser module imports correctly."""
+
+    def test_module_imports(self):
+        """Test browser module can be imported"""
+        from npcpy.work import browser
+
+        assert hasattr(browser, "get_sessions")
+        assert hasattr(browser, "get_current_driver")
+        assert hasattr(browser, "set_driver")
+        assert hasattr(browser, "close_current")
+
+    def test_sessions_is_module_level(self):
+        """Test _sessions is module-level dict"""
+        from npcpy.work import browser
+
+        assert hasattr(browser, "_sessions")
+        assert isinstance(browser._sessions, dict)
+
+
+class TestSessionIsolation:
+    """Test session isolation between tests."""
+
+    def test_sessions_can_be_cleared(self):
+        """Test sessions dict can be cleared"""
+        from npcpy.work import browser
+
+        browser._sessions["test"] = "value"
+        browser._sessions.clear()
+
+        assert len(browser._sessions) == 0
+
+    def test_sessions_persist_in_module(self):
+        """Test sessions persist across function calls"""
+        from npcpy.work import browser
+
+        browser._sessions.clear()
+
+        class MockDriver:
+            pass
+
+        browser.set_driver("persistent", MockDriver())
+
+        # Get sessions in separate call
+        sessions = browser.get_sessions()
+
+        assert "persistent" in sessions
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

npcpy-1.3.16/tests/test_build_funcs.py

@@ -0,0 +1,274 @@
+"""Test suite for build_funcs module."""
+
+import os
+import tempfile
+import shutil
+import pytest
+import yaml
+
+
+class TestGetTeamName:
+    """Test get_team_name function."""
+
+    def test_get_team_name_from_ctx_file(self):
+        """Test extracting team name from .ctx file"""
+        from npcpy.build_funcs import get_team_name
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            # Create a .ctx file with team name
+            ctx_content = {"name": "My Awesome Team", "version": "1.0"}
+            ctx_path = os.path.join(temp_dir, "team.ctx")
+            with open(ctx_path, "w") as f:
+                yaml.dump(ctx_content, f)
+
+            name = get_team_name(temp_dir)
+            assert name == "My Awesome Team"
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_get_team_name_from_folder(self):
+        """Test getting team name from folder when no .ctx file"""
+        from npcpy.build_funcs import get_team_name
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            # Create a subfolder to test
+            team_dir = os.path.join(temp_dir, "my_team")
+            os.makedirs(team_dir)
+
+            name = get_team_name(team_dir)
+            assert name == "my_team"
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_get_team_name_npc_team_fallback(self):
+        """Test fallback when folder is named npc_team"""
+        from npcpy.build_funcs import get_team_name
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            npc_team_dir = os.path.join(temp_dir, "npc_team")
+            os.makedirs(npc_team_dir)
+
+            name = get_team_name(npc_team_dir)
+            # Should use parent folder name
+            assert name == os.path.basename(temp_dir)
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestBuildDockerfile:
+    """Test build_dockerfile function."""
+
+    def test_build_dockerfile_default(self):
+        """Test Dockerfile generation with defaults"""
+        from npcpy.build_funcs import build_dockerfile
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+
+            config = {"team_path": team_dir}
+            dockerfile = build_dockerfile(config)
+
+            assert "FROM python:3.11-slim" in dockerfile
+            assert "pip install --no-cache-dir npcsh" in dockerfile
+            assert "EXPOSE 5337" in dockerfile
+            assert "test_team" in dockerfile
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_build_dockerfile_custom_port(self):
+        """Test Dockerfile with custom port"""
+        from npcpy.build_funcs import build_dockerfile
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "my_team")
+            os.makedirs(team_dir)
+
+            config = {"team_path": team_dir, "port": 8080}
+            dockerfile = build_dockerfile(config)
+
+            assert "EXPOSE 8080" in dockerfile
+            assert '"8080"' in dockerfile
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestBuildDockerCompose:
+    """Test build_docker_compose function."""
+
+    def test_build_docker_compose_creates_files(self):
+        """Test docker-compose build creates all expected files"""
+        from npcpy.build_funcs import build_docker_compose
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+            # Create a dummy file in team dir
+            with open(os.path.join(team_dir, "test.npc"), "w") as f:
+                f.write("name: test\n")
+
+            output_dir = os.path.join(temp_dir, "build")
+            config = {"team_path": team_dir, "output_dir": output_dir}
+
+            result = build_docker_compose(config)
+
+            # Check files were created
+            assert os.path.exists(os.path.join(output_dir, "Dockerfile"))
+            assert os.path.exists(os.path.join(output_dir, "docker-compose.yml"))
+            assert os.path.exists(os.path.join(output_dir, ".env.example"))
+            assert os.path.exists(os.path.join(output_dir, "test_team"))
+
+            # Check output message
+            assert "output" in result
+            assert "Docker deployment created" in result["output"]
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_build_docker_compose_with_cors(self):
+        """Test docker-compose with CORS origins"""
+        from npcpy.build_funcs import build_docker_compose
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+
+            output_dir = os.path.join(temp_dir, "build")
+            config = {
+                "team_path": team_dir,
+                "output_dir": output_dir,
+                "cors_origins": ["http://localhost:3000", "https://example.com"],
+            }
+
+            build_docker_compose(config)
+
+            # Check docker-compose.yml contains CORS
+            compose_path = os.path.join(output_dir, "docker-compose.yml")
+            with open(compose_path, "r") as f:
+                content = f.read()
+
+            assert "CORS_ORIGINS" in content
+            assert "localhost:3000" in content
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestBuildFlaskServer:
+    """Test build_flask_server function."""
+
+    def test_build_flask_server_creates_script(self):
+        """Test Flask server script generation"""
+        from npcpy.build_funcs import build_flask_server
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+
+            output_dir = os.path.join(temp_dir, "build")
+            config = {"team_path": team_dir, "output_dir": output_dir, "port": 5000}
+
+            result = build_flask_server(config)
+
+            # Check server.py was created
+            server_path = os.path.join(output_dir, "server.py")
+            assert os.path.exists(server_path)
+
+            # Check content
+            with open(server_path, "r") as f:
+                content = f.read()
+
+            assert "from npcpy.serve import start_flask_server" in content
+            assert "port=5000" in content
+
+            # Check output message
+            assert "Flask server created" in result["output"]
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestBuildCliExecutable:
+    """Test build_cli_executable function."""
+
+    def test_build_cli_executable_creates_scripts(self):
+        """Test CLI script generation for NPCs"""
+        from npcpy.build_funcs import build_cli_executable
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+
+            # Create some .npc files
+            for name in ["assistant", "coder", "reviewer"]:
+                npc_path = os.path.join(team_dir, f"{name}.npc")
+                with open(npc_path, "w") as f:
+                    f.write(f"name: {name}\n")
+
+            output_dir = os.path.join(temp_dir, "build")
+            config = {"team_path": team_dir, "output_dir": output_dir}
+
+            result = build_cli_executable(config)
+
+            # Check scripts were created
+            assert os.path.exists(os.path.join(output_dir, "assistant"))
+            assert os.path.exists(os.path.join(output_dir, "coder"))
+            assert os.path.exists(os.path.join(output_dir, "reviewer"))
+
+            # Check output message
+            assert "CLI scripts created" in result["output"]
+            assert "assistant" in result["output"]
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestBuildStaticSite:
+    """Test build_static_site function."""
+
+    def test_build_static_site_creates_html(self):
+        """Test static site HTML generation"""
+        from npcpy.build_funcs import build_static_site
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            team_dir = os.path.join(temp_dir, "test_team")
+            os.makedirs(team_dir)
+
+            # Create .ctx file with team name
+            ctx_content = {"name": "Documentation Team"}
+            with open(os.path.join(team_dir, "team.ctx"), "w") as f:
+                yaml.dump(ctx_content, f)
+
+            # Create .npc files
+            npc_content = {"name": "writer", "primary_directive": "Write documentation"}
+            with open(os.path.join(team_dir, "writer.npc"), "w") as f:
+                yaml.dump(npc_content, f)
+
+            output_dir = os.path.join(temp_dir, "build")
+            config = {"team_path": team_dir, "output_dir": output_dir}
+
+            result = build_static_site(config)
+
+            # Check index.html was created
+            html_path = os.path.join(output_dir, "index.html")
+            assert os.path.exists(html_path)
+
+            # Check content
+            with open(html_path, "r") as f:
+                content = f.read()
+
+            assert "Documentation Team" in content
+            assert "writer" in content
+            assert "Write documentation" in content
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])