signalpilot-ai-internal 0.2.6__tar.gz → 0.8.13__tar.gz

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalpilot_ai_internal
-Version: 0.2.6
+Version: 0.8.13
 Summary: SignalPilot Agent - Your Jupyter Notebook Assistant
 Project-URL: Homepage, https://signalpilot.ai/
 Author-email: Daniel Schaffield <danielschaffield@gmail.com>
@@ -43,13 +43,23 @@ Classifier: Framework :: Jupyter :: JupyterLab :: Extensions :: Prebuilt
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.6
+Requires-Python: >=3.10
+Requires-Dist: jupyter-server<3,>=2.4.0
+Requires-Dist: openpyxl
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pyarrow
+Requires-Dist: schema-search
+Provides-Extra: test
+Requires-Dist: coverage; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-jupyter[server]>=0.6.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # **SignalPilot Agent — The AI-Powered Assistant for Jupyter Notebooks**

signalpilot_ai_internal-0.8.13/jupyter-config/server-config/signalpilot_ai.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "signalpilot_ai_internal": true
+    }
+  }
+}

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalpilot-ai-internal",
-  "version": "0.2.6",
+  "version": "0.8.13",
   "description": "SignalPilot Agent - Your Jupyter Notebook Assistant",
   "keywords": [
     "jupyter",
@@ -68,6 +68,7 @@
     "@types/hogan.js": "^3.0.5",
     "babel-plugin-transform-remove-console": "^6.9.4",
     "best-effort-json-parser": "^1.1.3",
+    "bluebird": "^3.7.2",
     "bootstrap": "^5.3.7",
     "chalk": "^4.1.2",
     "codemirror": "^6.0.2",
@@ -76,10 +77,12 @@
     "diff": "^8.0.1",
     "diff2html": "^3.4.51",
     "dompurify": "^3.2.5",
+    "driver.js": "^1.3.6",
+    "fuse.js": "^7.1.0",
     "jwt-decode": "^4.0.0",
     "marked": "^15.0.11",
     "partial-json": "^0.1.7",
-    "posthog-js": "^1.268.4",
+    "posthog-js": "^1.268.5",
     "react-bootstrap": "^2.10.10",
     "readline": "^1.3.0",
     "rxjs": "^7.8.2",
@@ -90,6 +93,7 @@
   "devDependencies": {
     "@jupyterlab/builder": "^4.0.0",
     "@jupyterlab/testutils": "^4.0.0",
+    "@types/bluebird": "^3.5.42",
     "@types/jest": "^29.2.0",
     "@types/json-schema": "^7.0.11",
     "@types/react": "^18.0.26",

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "signalpilot_ai_internal"
 readme = "README.md"
 license = { file = "LICENSE" }
-requires-python = ">=3.6"
+requires-python = ">=3.10"
 classifiers = [
     "Framework :: Jupyter",
     "Framework :: Jupyter :: JupyterLab",
@@ -16,7 +16,6 @@ classifiers = [
     "License :: OSI Approved :: BSD License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -24,9 +23,23 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
+    "jupyter_server>=2.4.0,<3",
+    "pandas>=2.0.0",
+    "pyarrow",
+    "schema-search",
+    "openpyxl"
 ]
 dynamic = ["version", "description", "authors", "urls", "keywords"]
 
+[project.optional-dependencies]
+test = [
+    "coverage",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-jupyter[server]>=0.6.0"
+]
+
 [tool.hatch.version]
 source = "nodejs"
 
@@ -40,6 +53,7 @@ exclude = [".github", "binder"]
 [tool.hatch.build.targets.wheel.shared-data]
 "signalpilot_ai_internal/labextension" = "share/jupyter/labextensions/signalpilot-ai-internal"
 "install.json" = "share/jupyter/labextensions/signalpilot-ai-internal/install.json"
+"jupyter-config/server-config" = "etc/jupyter/jupyter_server_config.d"
 
 [tool.hatch.build.hooks.version]
 path = "signalpilot_ai_internal/_version.py"

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/schema/plugin.json

@@ -31,7 +31,7 @@
       "type": "string",
       "title": "Model Name",
       "description": "The name of the Anthropic model to use",
-      "default": "claude-3-5-sonnet-20241022"
+      "default": "claude-sonnet-4-5"
     },
     "darkThemeApplied": {
       "type": "boolean",
@@ -82,7 +82,7 @@
       "type": "string",
       "title": "Claude Model ID",
       "description": "The ID of the Claude model to use",
-      "default": "claude-sonnet-4-20250514"
+      "default": "claude-sonnet-4-5"
     },
     "claudeModelUrl": {
       "type": "string",

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/signalpilot_ai_internal/__init__.py

@@ -7,6 +7,7 @@ except ImportError:
     import warnings
     warnings.warn("Importing 'signalpilot_ai_internal' outside a proper installation.")
     __version__ = "dev"
+from .handlers import setup_handlers
 
 
 def _jupyter_labextension_paths():
@@ -14,3 +15,22 @@ def _jupyter_labextension_paths():
         "src": "labextension",
         "dest": "signalpilot-ai-internal"
     }]
+
+
+def _jupyter_server_extension_points():
+    return [{
+        "module": "signalpilot_ai_internal"
+    }]
+
+
+def _load_jupyter_server_extension(server_app):
+    """Registers the API handler to receive HTTP requests from the frontend extension.
+
+    Parameters
+    ----------
+    server_app: jupyterlab.labapp.LabApp
+        JupyterLab application instance
+    """
+    setup_handlers(server_app.web_app)
+    name = "signalpilot_ai_internal"
+    server_app.log.info(f"Registered {name} server extension")

{signalpilot_ai_internal-0.2.6 → signalpilot_ai_internal-0.8.13}/signalpilot_ai_internal/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.2.6'
+__version__ = VERSION = '0.8.13'

signalpilot_ai_internal-0.8.13/signalpilot_ai_internal/cache_handlers.py

@@ -0,0 +1,383 @@
+"""
+Cache endpoint handlers for SignalPilot AI.
+Provides REST API handlers for chat histories and app values caching.
+"""
+
+import json
+from typing import Any, Dict, Optional
+
+from jupyter_server.base.handlers import APIHandler
+import tornado
+
+from .cache_service import get_cache_service
+
+
+class ChatHistoriesHandler(APIHandler):
+    """Handler for chat histories cache operations"""
+    
+    @tornado.web.authenticated
+    def get(self, chat_id=None):
+        """Get chat histories or specific chat history"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            if chat_id:
+                # Get specific chat history
+                history = cache_service.get_chat_history(chat_id)
+                if history is None:
+                    self.set_status(404)
+                    self.finish(json.dumps({
+                        "error": "Chat history not found",
+                        "chat_id": chat_id
+                    }))
+                else:
+                    self.finish(json.dumps({
+                        "chat_id": chat_id,
+                        "history": history
+                    }))
+            else:
+                # Get all chat histories
+                histories = cache_service.get_chat_histories()
+                self.finish(json.dumps({
+                    "chat_histories": histories,
+                    "count": len(histories)
+                }))
+                
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+    
+    @tornado.web.authenticated
+    def post(self, chat_id=None):
+        """Create or update chat history"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            # Parse request body
+            try:
+                body = json.loads(self.request.body.decode('utf-8'))
+            except json.JSONDecodeError:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "Invalid JSON in request body"
+                }))
+                return
+            
+            if chat_id:
+                # Update specific chat history
+                history_data = body.get('history')
+                if history_data is None:
+                    self.set_status(400)
+                    self.finish(json.dumps({
+                        "error": "Missing 'history' field in request body"
+                    }))
+                    return
+                
+                success = cache_service.set_chat_history(chat_id, history_data)
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "chat_id": chat_id,
+                        "message": "Chat history updated successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to save chat history"
+                    }))
+            else:
+                # Bulk update operation
+                chat_histories = body.get('chat_histories', {})
+                if not isinstance(chat_histories, dict):
+                    self.set_status(400)
+                    self.finish(json.dumps({
+                        "error": "'chat_histories' must be an object"
+                    }))
+                    return
+                
+                # Update each chat history
+                failures = []
+                successes = []
+                
+                for cid, history in chat_histories.items():
+                    if cache_service.set_chat_history(cid, history):
+                        successes.append(cid)
+                    else:
+                        failures.append(cid)
+                
+                self.finish(json.dumps({
+                    "success": len(failures) == 0,
+                    "updated": successes,
+                    "failed": failures,
+                    "message": f"Updated {len(successes)} chat histories, {len(failures)} failed"
+                }))
+                
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+    
+    @tornado.web.authenticated
+    def delete(self, chat_id=None):
+        """Delete chat history or all chat histories"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            if chat_id:
+                # Delete specific chat history
+                success = cache_service.delete_chat_history(chat_id)
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "chat_id": chat_id,
+                        "message": "Chat history deleted successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to delete chat history"
+                    }))
+            else:
+                # Clear all chat histories
+                success = cache_service.clear_chat_histories()
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "message": "All chat histories cleared successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to clear chat histories"
+                    }))
+                    
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+
+class AppValuesHandler(APIHandler):
+    """Handler for app values cache operations"""
+    
+    @tornado.web.authenticated
+    def get(self, key=None):
+        """Get app values or specific app value"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            if key:
+                # Get specific app value
+                default = self.get_argument('default', None)
+                try:
+                    if default:
+                        default = json.loads(default)
+                except json.JSONDecodeError:
+                    pass  # Use string default
+                
+                value = cache_service.get_app_value(key, default)
+                self.finish(json.dumps({
+                    "key": key,
+                    "value": value
+                }))
+            else:
+                # Get all app values
+                values = cache_service.get_app_values()
+                self.finish(json.dumps({
+                    "app_values": values,
+                    "count": len(values)
+                }))
+                
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+    
+    @tornado.web.authenticated
+    def post(self, key=None):
+        """Create or update app value"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            # Parse request body
+            try:
+                body = json.loads(self.request.body.decode('utf-8'))
+            except json.JSONDecodeError:
+                self.set_status(400)
+                self.finish(json.dumps({
+                    "error": "Invalid JSON in request body"
+                }))
+                return
+            
+            if key:
+                # Update specific app value
+                value_data = body.get('value')
+                if value_data is None:
+                    self.set_status(400)
+                    self.finish(json.dumps({
+                        "error": "Missing 'value' field in request body"
+                    }))
+                    return
+                
+                success = cache_service.set_app_value(key, value_data)
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "key": key,
+                        "message": "App value updated successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to save app value"
+                    }))
+            else:
+                # Bulk update operation
+                app_values = body.get('app_values', {})
+                if not isinstance(app_values, dict):
+                    self.set_status(400)
+                    self.finish(json.dumps({
+                        "error": "'app_values' must be an object"
+                    }))
+                    return
+                
+                # Update each app value
+                failures = []
+                successes = []
+                
+                for k, value in app_values.items():
+                    if cache_service.set_app_value(k, value):
+                        successes.append(k)
+                    else:
+                        failures.append(k)
+                
+                self.finish(json.dumps({
+                    "success": len(failures) == 0,
+                    "updated": successes,
+                    "failed": failures,
+                    "message": f"Updated {len(successes)} app values, {len(failures)} failed"
+                }))
+                
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+    
+    @tornado.web.authenticated
+    def delete(self, key=None):
+        """Delete app value or all app values"""
+        try:
+            cache_service = get_cache_service()
+            
+            if not cache_service.is_available():
+                self.set_status(503)
+                self.finish(json.dumps({
+                    "error": "Cache service not available",
+                    "message": "Persistent storage is not accessible"
+                }))
+                return
+            
+            if key:
+                # Delete specific app value
+                success = cache_service.delete_app_value(key)
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "key": key,
+                        "message": "App value deleted successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to delete app value"
+                    }))
+            else:
+                # Clear all app values
+                success = cache_service.clear_app_values()
+                if success:
+                    self.finish(json.dumps({
+                        "success": True,
+                        "message": "All app values cleared successfully"
+                    }))
+                else:
+                    self.set_status(500)
+                    self.finish(json.dumps({
+                        "error": "Failed to clear app values"
+                    }))
+                    
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))
+
+
+class CacheInfoHandler(APIHandler):
+    """Handler for cache service information"""
+    
+    @tornado.web.authenticated
+    def get(self):
+        """Get cache service information and statistics"""
+        try:
+            cache_service = get_cache_service()
+            info = cache_service.get_cache_info()
+            self.finish(json.dumps(info))
+            
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({
+                "error": "Internal server error",
+                "message": str(e)
+            }))