botversion-sdk 1.1.7__tar.gz → 2.0.0__tar.gz

{botversion_sdk-1.1.7 → botversion_sdk-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: botversion-sdk
-Version: 1.1.7
+Version: 2.0.0
 Summary: BotVersion AI Agent SDK for FastAPI, Flask, and Django
 Home-page: https://github.com/botversion/botversion-sdk-python
 Author: BotVersion

{botversion_sdk-1.1.7 → botversion_sdk-2.0.0}/botversion_sdk/__init__.py

@@ -5,7 +5,7 @@ import builtins
 import os
 
 from .client import BotVersionClient
-from .scanner import scan_routes, scan_frontend_routes
+from .scanner import scan_routes
 from .interceptor import (
     attach_fastapi_interceptor,
     attach_flask_interceptor,
@@ -20,12 +20,64 @@ from .interceptor import (
     attach_cherrypy_interceptor,
 )
 
+def _classify_installation(framework):
+    """
+    Python/PHP SDKs only ever run on a backend server — there is no such
+    thing as a Python or PHP frontend project. So unlike the JS SDK, this
+    is a simple two-way classification: either a supported backend
+    framework was detected, or it wasn't.
+    """
+    if framework:
+        return "backend-only"
+    return "unknown"
+
 _initialized = False
 _client = None
 _options = {}
 _app = None
 
 
+def _run_full_scan(app, framework, cwd, client, debug=False):
+    """
+    Runs a full scan (backend endpoints + frontend routes) and reports
+    results to the platform. This used to run automatically on server
+    start / first request. Now it only runs when the BotVersion dashboard's
+    "Scan" button sends a request to this SDK's scan-trigger endpoint
+    (see interceptor.py). This fixes scans not happening on redeploys
+    (e.g. Vercel/serverless) since there's no "restart" event to hook into.
+    """
+    result = {
+        "endpoint_count": 0,
+        "route_count": 0,
+        "project_type": None,
+        "detected_backend": framework,
+        "detected_frontend": None,
+        "sdk_language": "python",
+    }
+
+    try:
+        endpoints = []
+        if app is not None:
+            endpoints = scan_routes(app, framework)
+        elif framework == "django":
+            endpoints = scan_routes(None, "django")
+
+        result["endpoint_count"] = len(endpoints)
+
+        if endpoints:
+            client.register_endpoints_now(endpoints)
+
+    except Exception:
+        if debug:
+            import traceback
+            traceback.print_exc()
+
+    result["detected_frontend"] = None
+    result["project_type"] = _classify_installation(framework)
+
+    return result
+
+
 def init(app=None, api_key=None, **options):
     """
     Initialize the BotVersion SDK.
@@ -52,10 +104,16 @@ def init(app=None, api_key=None, **options):
         # Re-attach interceptor after hot reload
         framework = _detect_framework(app)
         if framework and _client:
+            _cwd = _options.get("cwd", os.getcwd())
+            _debug = _options.get("debug", False)
             interceptor_options = {
                 "exclude": _options.get("exclude", []),
                 "api_prefix": _options.get("api_prefix", None),
-                "debug": _options.get("debug", False),
+                "debug": _debug,
+                "scan_secret": _options.get("api_key"),
+                "on_scan_requested": lambda: _run_full_scan(
+                    app, framework, _cwd, _client, _debug
+                ),
             }
             if framework == "fastapi":
                 attach_fastapi_interceptor(app, _client, interceptor_options)
@@ -94,6 +152,8 @@ def init(app=None, api_key=None, **options):
 
     if not framework:
         _initialized = False
+        if debug:
+            print("[botversion] No supported framework detected. SDK not initialized.")
         return
 
     _client = BotVersionClient({
@@ -108,10 +168,16 @@ def init(app=None, api_key=None, **options):
     builtins._botversion_client = _client
     builtins._botversion_options = _options
 
+    cwd = options.get("cwd", os.getcwd())
+
     interceptor_options = {
         "exclude": options.get("exclude", []),
         "api_prefix": options.get("api_prefix", None),
         "debug": debug,
+        "scan_secret": api_key,
+        "on_scan_requested": lambda: _run_full_scan(
+            app, framework, cwd, _client, debug
+        ),
     }
 
     # ── Attach runtime interceptor ───────────────────────────────────────────
@@ -141,85 +207,6 @@ def init(app=None, api_key=None, **options):
     else:
         return
 
-    # ── Static scan (delayed 500ms — let app finish registering routes) ──────
-    def _run_scan():
-        try:
-            endpoints = []
-
-            if app is not None:
-                endpoints = scan_routes(app, framework)
-
-            elif framework == "django":
-                endpoints = scan_routes(None, "django")
-
-            # For any other framework with no app object, skip backend scan
-            # but still continue to frontend scan below
-
-            if endpoints:
-                _client.register_endpoints_now(endpoints)
-
-        except Exception as e:
-            if debug:
-                import traceback
-                traceback.print_exc()
-
-        cwd = options.get("cwd", os.getcwd())
-        route_patterns = scan_frontend_routes(cwd)
-        if route_patterns:
-            _client.register_route_patterns(route_patterns)
-
-    if framework == "flask":
-        with app.app_context():
-            t = threading.Thread(target=_run_scan, daemon=False)
-            t.start()
-            t.join(timeout=15)
-            app._botversion_scanned = True
-
-        @app.after_request
-        def _botversion_first_scan(response):
-            if not getattr(app, '_botversion_scanned', False):
-                app._botversion_scanned = True
-                t = threading.Thread(target=_run_scan, daemon=False)
-                t.start()
-                t.join(timeout=15)
-            return response
-
-    elif framework == "fastapi":
-        @app.on_event("startup")
-        async def _botversion_startup_scan():
-            if not getattr(app, '_botversion_scanned', False):
-                app._botversion_scanned = True
-                t = threading.Thread(target=_run_scan, daemon=False)
-                t.start()
-                t.join(timeout=15)
-
-        @app.middleware("http")
-        async def _botversion_first_scan(request, call_next):
-            if not getattr(app, '_botversion_scanned', False):
-                app._botversion_scanned = True
-                t = threading.Thread(target=_run_scan, daemon=False)
-                t.start()
-                t.join(timeout=15)
-            return await call_next(request)
-
-    elif framework == "django":
-        try:
-            from django.apps import apps
-            if apps.ready:
-                t = threading.Thread(target=_run_scan, daemon=False)
-                t.start()
-                t.join(timeout=15)
-        except Exception:
-            t = threading.Timer(3.0, _run_scan)
-            t.daemon = False
-            t.start()
-
-    elif framework in ("starlette", "sanic", "falcon", "bottle",
-                       "aiohttp", "tornado", "pyramid", "cherrypy"):
-        t = threading.Timer(3.0, _run_scan)
-        t.daemon = False
-        t.start()
-
 
 def get_endpoints():
     """Get all registered endpoints for this workspace."""

{botversion_sdk-1.1.7 → botversion_sdk-2.0.0}/botversion_sdk/client.py

@@ -89,13 +89,14 @@ class BotVersionClient:
 
     # ── Register frontend route patterns ─────────────────────────────────────────
 
-    def register_route_patterns(self, patterns):
-        if not patterns:
+    def register_route_patterns(self, patterns, classification=None):
+        if not patterns and not classification:
             return
         try:
             self._post("/api/sdk/register-route-patterns", {
                 "workspaceKey": self.api_key,
-                "patterns": patterns,
+                "patterns": patterns or [],
+                "classification": classification,
             })
         except Exception as e:
             if self.debug:
@@ -121,6 +122,7 @@ class BotVersionClient:
             headers={
                 "Content-Type": "application/json",
                 "Content-Length": str(len(body)),
+                "X-BotVersion-SDK": "1.0.0-python",
             },
         )
 
@@ -150,6 +152,9 @@ class BotVersionClient:
         req = urllib.request.Request(
             url,
             method="GET",
+            headers={
+                "X-BotVersion-SDK": "1.0.0-python",
+            },
         )
 
         try:

{botversion_sdk-1.1.7 → botversion_sdk-2.0.0}/botversion_sdk/interceptor.py

@@ -212,11 +212,34 @@ def attach_fastapi_interceptor(app, client, options):
         from starlette.requests import Request
         import json as _json
 
+        from starlette.responses import JSONResponse
+
         class BotVersionMiddleware(BaseHTTPMiddleware):
             async def dispatch(self, request: Request, call_next):
                 path = request.url.path
                 method = request.method.upper()
 
+                # ── Scan trigger from BotVersion dashboard ───────────────
+                if path == "/__botversion/scan" and method == "POST":
+                    provided_key = request.headers.get("x-botversion-scan-key", "")
+                    if (
+                        options.get("scan_secret")
+                        and provided_key == options["scan_secret"]
+                        and callable(options.get("on_scan_requested"))
+                    ):
+                        try:
+                            result = options["on_scan_requested"]()
+                            return JSONResponse(
+                                {"success": True, "result": result}, status_code=200
+                            )
+                        except Exception as e:
+                            return JSONResponse(
+                                {"success": False, "error": str(e)}, status_code=500
+                            )
+                    return JSONResponse(
+                        {"success": False, "error": "Unauthorized"}, status_code=401
+                    )
+
                 response = await call_next(request)
 
                 if not should_ignore(path, options.get("exclude")):
@@ -259,6 +282,21 @@ def attach_flask_interceptor(app, client, options):
             path = flask_request.path
             method = flask_request.method.upper()
 
+            # ── Scan trigger from BotVersion dashboard ───────────────────
+            if path == "/__botversion/scan" and method == "POST":
+                provided_key = flask_request.headers.get("x-botversion-scan-key", "")
+                if (
+                    options.get("scan_secret")
+                    and provided_key == options["scan_secret"]
+                    and callable(options.get("on_scan_requested"))
+                ):
+                    try:
+                        result = options["on_scan_requested"]()
+                        return {"success": True, "result": result}, 200
+                    except Exception as e:
+                        return {"success": False, "error": str(e)}, 500
+                return {"success": False, "error": "Unauthorized"}, 401
+
             if should_ignore(path, options.get("exclude")):
                 return
             if options.get("api_prefix") and not path.startswith(options["api_prefix"]):
@@ -296,6 +334,23 @@ class BotVersionDjangoMiddleware:
     def __call__(self, request):
         path = request.path
         method = request.method.upper()
+        options = self.__class__._options
+
+        # ── Scan trigger from BotVersion dashboard ───────────────────────
+        if path == "/__botversion/scan" and method == "POST":
+            provided_key = request.META.get("HTTP_X_BOTVERSION_SCAN_KEY", "")
+            from django.http import JsonResponse
+            if (
+                options.get("scan_secret")
+                and provided_key == options["scan_secret"]
+                and callable(options.get("on_scan_requested"))
+            ):
+                try:
+                    result = options["on_scan_requested"]()
+                    return JsonResponse({"success": True, "result": result}, status=200)
+                except Exception as e:
+                    return JsonResponse({"success": False, "error": str(e)}, status=500)
+            return JsonResponse({"success": False, "error": "Unauthorized"}, status=401)
 
         if not should_ignore(path, self.__class__._options.get("exclude")):
             if not self.__class__._options.get("api_prefix") or path.startswith(self.__class__._options["api_prefix"]):
@@ -353,11 +408,34 @@ def attach_starlette_interceptor(app, client, options):
         from starlette.requests import Request
         import json as _json
 
+        from starlette.responses import JSONResponse
+
         class BotVersionStarletteMiddleware(BaseHTTPMiddleware):
             async def dispatch(self, request: Request, call_next):
                 path = request.url.path
                 method = request.method.upper()
 
+                # ── Scan trigger from BotVersion dashboard ───────────────
+                if path == "/__botversion/scan" and method == "POST":
+                    provided_key = request.headers.get("x-botversion-scan-key", "")
+                    if (
+                        options.get("scan_secret")
+                        and provided_key == options["scan_secret"]
+                        and callable(options.get("on_scan_requested"))
+                    ):
+                        try:
+                            result = options["on_scan_requested"]()
+                            return JSONResponse(
+                                {"success": True, "result": result}, status_code=200
+                            )
+                        except Exception as e:
+                            return JSONResponse(
+                                {"success": False, "error": str(e)}, status_code=500
+                            )
+                    return JSONResponse(
+                        {"success": False, "error": "Unauthorized"}, status_code=401
+                    )
+
                 response = await call_next(request)
 
                 if not should_ignore(path, options.get("exclude")):
@@ -395,6 +473,22 @@ def attach_sanic_interceptor(app, client, options):
             path = request.path
             method = request.method.upper()
 
+            # ── Scan trigger from BotVersion dashboard ───────────────────
+            if path == "/__botversion/scan" and method == "POST":
+                from sanic.response import json as sanic_json
+                provided_key = request.headers.get("x-botversion-scan-key", "")
+                if (
+                    options.get("scan_secret")
+                    and provided_key == options["scan_secret"]
+                    and callable(options.get("on_scan_requested"))
+                ):
+                    try:
+                        result = options["on_scan_requested"]()
+                        return sanic_json({"success": True, "result": result}, status=200)
+                    except Exception as e:
+                        return sanic_json({"success": False, "error": str(e)}, status=500)
+                return sanic_json({"success": False, "error": "Unauthorized"}, status=401)
+
             if should_ignore(path, options.get("exclude")):
                 return
             if options.get("api_prefix") and not path.startswith(options["api_prefix"]):
@@ -428,6 +522,27 @@ def attach_falcon_interceptor(app, client, options):
                 path = req.path
                 method = req.method.upper()
 
+                # ── Scan trigger from BotVersion dashboard ───────────────
+                if path == "/__botversion/scan" and method == "POST":
+                    provided_key = req.get_header("x-botversion-scan-key") or ""
+                    if (
+                        options.get("scan_secret")
+                        and provided_key == options["scan_secret"]
+                        and callable(options.get("on_scan_requested"))
+                    ):
+                        try:
+                            result = options["on_scan_requested"]()
+                            resp.media = {"success": True, "result": result}
+                            resp.status = 200
+                        except Exception as e:
+                            resp.media = {"success": False, "error": str(e)}
+                            resp.status = 500
+                    else:
+                        resp.media = {"success": False, "error": "Unauthorized"}
+                        resp.status = 401
+                    resp.complete = True
+                    return
+
                 if should_ignore(path, options.get("exclude")):
                     return
                 if options.get("api_prefix") and not path.startswith(options["api_prefix"]):
@@ -460,12 +575,41 @@ def attach_falcon_interceptor(app, client, options):
 
 def attach_bottle_interceptor(app, client, options):
     try:
-        from bottle import request as bottle_request
+        from bottle import request as bottle_request, HTTPResponse
 
         def botversion_bottle_interceptor():
             path = bottle_request.path
             method = bottle_request.method.upper()
 
+            # ── Scan trigger from BotVersion dashboard ────────────────────
+            if path == "/__botversion/scan" and method == "POST":
+                provided_key = bottle_request.headers.get("x-botversion-scan-key", "")
+                if (
+                    options.get("scan_secret")
+                    and provided_key == options["scan_secret"]
+                    and callable(options.get("on_scan_requested"))
+                ):
+                    try:
+                        result = options["on_scan_requested"]()
+                        raise HTTPResponse(
+                            body=json.dumps({"success": True, "result": result}),
+                            status=200,
+                            headers={"Content-Type": "application/json"},
+                        )
+                    except HTTPResponse:
+                        raise
+                    except Exception as e:
+                        raise HTTPResponse(
+                            body=json.dumps({"success": False, "error": str(e)}),
+                            status=500,
+                            headers={"Content-Type": "application/json"},
+                        )
+                raise HTTPResponse(
+                    body=json.dumps({"success": False, "error": "Unauthorized"}),
+                    status=401,
+                    headers={"Content-Type": "application/json"},
+                )
+
             if should_ignore(path, options.get("exclude")):
                 return
             if options.get("api_prefix") and not path.startswith(options["api_prefix"]):
@@ -503,6 +647,28 @@ def attach_aiohttp_interceptor(app, client, options):
             path = request.path
             method = request.method.upper()
 
+            # ── Scan trigger from BotVersion dashboard ───────────────────
+            if path == "/__botversion/scan" and method == "POST":
+                from aiohttp import web
+                provided_key = request.headers.get("x-botversion-scan-key", "")
+                if (
+                    options.get("scan_secret")
+                    and provided_key == options["scan_secret"]
+                    and callable(options.get("on_scan_requested"))
+                ):
+                    try:
+                        result = options["on_scan_requested"]()
+                        return web.json_response(
+                            {"success": True, "result": result}, status=200
+                        )
+                    except Exception as e:
+                        return web.json_response(
+                            {"success": False, "error": str(e)}, status=500
+                        )
+                return web.json_response(
+                    {"success": False, "error": "Unauthorized"}, status=401
+                )
+
             response = await handler(request)
 
             if not should_ignore(path, options.get("exclude")):
@@ -548,6 +714,41 @@ def attach_tornado_interceptor(app, client, options):
         import tornado.web
         import json as _json
 
+        original_prepare = tornado.web.RequestHandler.prepare
+
+        def patched_prepare(self):
+            try:
+                path = self.request.path
+                method = self.request.method.upper()
+
+                # ── Scan trigger from BotVersion dashboard ───────────────
+                if path == "/__botversion/scan" and method == "POST":
+                    provided_key = self.request.headers.get("x-botversion-scan-key", "")
+                    if (
+                        options.get("scan_secret")
+                        and provided_key == options["scan_secret"]
+                        and callable(options.get("on_scan_requested"))
+                    ):
+                        try:
+                            result = options["on_scan_requested"]()
+                            self.set_status(200)
+                            self.set_header("Content-Type", "application/json")
+                            self.finish(_json.dumps({"success": True, "result": result}))
+                        except Exception as e:
+                            self.set_status(500)
+                            self.set_header("Content-Type", "application/json")
+                            self.finish(_json.dumps({"success": False, "error": str(e)}))
+                    else:
+                        self.set_status(401)
+                        self.set_header("Content-Type", "application/json")
+                        self.finish(_json.dumps({"success": False, "error": "Unauthorized"}))
+                    return
+            except Exception:
+                pass
+            return original_prepare(self)
+
+        tornado.web.RequestHandler.prepare = patched_prepare
+
         original_finish = tornado.web.RequestHandler.finish
 
         def patched_finish(self, chunk=None):
@@ -592,6 +793,25 @@ _pyramid_options = {}
 
 def botversion_pyramid_tween_factory(handler, registry):
     def botversion_tween(request):
+        path = request.path
+        method = request.method.upper()
+
+        # ── Scan trigger from BotVersion dashboard ────────────────────────
+        if path == "/__botversion/scan" and method == "POST":
+            from pyramid.response import Response
+            provided_key = request.headers.get("x-botversion-scan-key", "")
+            if (
+                _pyramid_options.get("scan_secret")
+                and provided_key == _pyramid_options["scan_secret"]
+                and callable(_pyramid_options.get("on_scan_requested"))
+            ):
+                try:
+                    result = _pyramid_options["on_scan_requested"]()
+                    return Response(json_body={"success": True, "result": result}, status=200)
+                except Exception as e:
+                    return Response(json_body={"success": False, "error": str(e)}, status=500)
+            return Response(json_body={"success": False, "error": "Unauthorized"}, status=401)
+
         response = handler(request)
         try:
             import json as _json
@@ -645,6 +865,30 @@ def attach_cherrypy_interceptor(app, client, options):
             path = request.path_info
             method = request.method.upper()
 
+            # ── Scan trigger from BotVersion dashboard ────────────────────
+            if path == "/__botversion/scan" and method == "POST":
+                provided_key = request.headers.get("x-botversion-scan-key", "")
+                if (
+                    options.get("scan_secret")
+                    and provided_key == options["scan_secret"]
+                    and callable(options.get("on_scan_requested"))
+                ):
+                    try:
+                        result = options["on_scan_requested"]()
+                        cherrypy.response.status = 200
+                        body = _json.dumps({"success": True, "result": result})
+                    except Exception as e:
+                        cherrypy.response.status = 500
+                        body = _json.dumps({"success": False, "error": str(e)})
+                else:
+                    cherrypy.response.status = 401
+                    body = _json.dumps({"success": False, "error": "Unauthorized"})
+
+                cherrypy.response.headers["Content-Type"] = "application/json"
+                cherrypy.response.body = body.encode("utf-8")
+                cherrypy.request.handler = None
+                return
+
             if should_ignore(path, options.get("exclude")):
                 return
             if options.get("api_prefix") and not path.startswith(options["api_prefix"]):