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

botversion_sdk-2.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: botversion-sdk
+Version: 2.1.0
+Summary: BotVersion SDK — automatically discover and register your API endpoints
+Home-page: https://github.com/botversion/botversion-sdk-python
+Author: BotVersion
+Author-email: support@botversion.com
+Keywords: botversion,api,sdk,fastapi,flask,django
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: starlette; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django; extra == "django"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

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

@@ -158,7 +158,7 @@ def init(app=None, api_key=None, **options):
 
     _client = BotVersionClient({
         "api_key": api_key,
-        "platform_url": options.get("platform_url", "https://botversion.com"),
+        "platform_url": options.get("platform_url", "https://console.botversion.com"),
         "debug": debug,
         "timeout": options.get("timeout", 30),
         "flush_delay": options.get("flush_delay", 3),

botversion_sdk-2.1.0/botversion_sdk/bin/scan_endpoints.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+"""
+Build-time backend endpoint scanner. Run this as part of your deploy
+pipeline (Procfile 'release' step, build.sh, or Dockerfile RUN step) so
+endpoints are reported even on serverless platforms where the live
+interceptor's scan-trigger route may not be reachable.
+"""
+import os
+import sys
+
+from botversion_sdk.client import BotVersionClient
+from botversion_sdk.scanner import scan_routes_static, detect_framework_from_deps
+
+
+def _load_env_files(cwd):
+    try:
+        from dotenv import load_dotenv
+    except ImportError:
+        return
+    for filename in (".env", ".env.local"):
+        filepath = os.path.join(cwd, filename)
+        if os.path.exists(filepath):
+            load_dotenv(filepath, override=False)
+
+
+def main():
+    cwd = os.getcwd()
+    _load_env_files(cwd)
+
+    api_key = os.environ.get("BOTVERSION_API_KEY")
+    platform_url = os.environ.get("BOTVERSION_PLATFORM_URL", "https://console.botversion.com")
+
+    if not api_key:
+        print("[botversion] BOTVERSION_API_KEY environment variable is not set. Skipping backend endpoint scan.")
+        sys.exit(0)
+
+    framework = detect_framework_from_deps(cwd)
+    if not framework:
+        print("[botversion] No supported backend framework detected. Skipping backend endpoint scan.")
+        sys.exit(0)
+
+    endpoints = scan_routes_static(cwd, framework)
+
+    if not endpoints:
+        print(f"[botversion] No backend endpoints found via static scan. detected_framework={framework}")
+        sys.exit(0)
+
+    client = BotVersionClient({"api_key": api_key, "platform_url": platform_url})
+    try:
+        client.register_endpoints_now(endpoints)
+        print(f"[botversion] Reported {len(endpoints)} backend endpoints. detected_framework={framework}")
+    except Exception as e:
+        print(f"[botversion] Failed to report backend endpoints: {e}")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -11,7 +11,7 @@ class BotVersionClient:
 
     def __init__(self, options):
         self.api_key = options["api_key"]
-        platform_url = options.get("platform_url", "https://botversion.com")
+        platform_url = options.get("platform_url", "https://console.botversion.com")
 
         self.platform_url = platform_url
         self.debug = options.get("debug", False)

{botversion_sdk-2.0.0 → botversion_sdk-2.1.0}/botversion_sdk/scanner.py

@@ -31,6 +31,10 @@ def scan_routes(app, framework):
     elif framework == "cherrypy":
         result = scan_cherrypy_routes(app)
 
+    for endpoint in result:
+        if "routeParamMap" not in endpoint:
+            endpoint["routeParamMap"] = build_route_param_map(endpoint.get("path", ""))
+
     return result
 
 
@@ -737,6 +741,37 @@ def build_param_schema(params):
     properties = {p: {"type": "string"} for p in params}
     return {"type": "object", "properties": properties}
 
+def build_route_param_map(route_path):
+    """
+    Gives route params more descriptive names based on their parent
+    segment, mirroring the JS SDK's buildRouteParamMap().
+    e.g. /projects/:id -> {"id": "projectId"}
+    """
+    param_map = {}
+    parts = [p for p in route_path.split("/") if p]
+
+    for i, part in enumerate(parts):
+        match = re.match(r"^:([a-zA-Z_][a-zA-Z0-9_]*)$", part)
+        if not match:
+            continue
+        param_name = match.group(1)
+
+        if param_name not in ("id", "slug", "param"):
+            param_map[param_name] = param_name
+            continue
+
+        parent_segment = parts[i - 1] if i > 0 else None
+        if parent_segment:
+            clean_parent = parent_segment.lstrip(":")
+            singular = re.sub(r"ies$", "y", clean_parent)
+            if singular == clean_parent:
+                singular = re.sub(r"s$", "", clean_parent)
+            param_map[param_name] = singular + "Id"
+        else:
+            param_map[param_name] = "id"
+
+    return param_map
+
 
 def generate_description(method, path, handler_name=None):
     """
@@ -1297,4 +1332,589 @@ def scan_cherrypy_routes(app):
     except Exception:
         pass
 
-    return endpoints
+    return endpoints
+
+# ── Static (build-time) scanning — no live app object required ──────────────
+# Used by the CLI (bin/scan_endpoints.py) since there's no running server
+# at build time. Parses .py files directly instead of introspecting a live
+# app instance.
+
+import os
+
+SKIP_DIRS = {"node_modules", ".git", "venv", "env", ".venv", "__pycache__",
+             "migrations", "dist", "build", ".tox", "site-packages"}
+
+
+def scan_routes_static(cwd, framework):
+    if framework in ("fastapi", "starlette", "sanic"):
+        result = _scan_decorator_style_static(cwd)
+    elif framework == "flask":
+        result = _scan_flask_static(cwd)
+    elif framework == "django":
+        result = _scan_django_static(cwd)
+    elif framework == "falcon":
+        result = _scan_falcon_static(cwd)
+    elif framework == "bottle":
+        result = _scan_bottle_static(cwd)
+    elif framework == "aiohttp":
+        result = _scan_aiohttp_static(cwd)
+    elif framework == "tornado":
+        result = _scan_tornado_static(cwd)
+    elif framework == "pyramid":
+        result = _scan_pyramid_static(cwd)
+    else:
+        # CherryPy's routing is a runtime object tree discovered by
+        # walking live class instances — it can't be approximated
+        # reliably via static text scanning, so it's not supported for
+        # build-time/serverless scans. The live interceptor still works
+        # fine for CherryPy on always-on servers.
+        result = []
+
+    for endpoint in result:
+        if "routeParamMap" not in endpoint:
+            endpoint["routeParamMap"] = build_route_param_map(endpoint.get("path", ""))
+
+    return result
+
+
+def _walk_py_files(cwd):
+    for root, dirs, files in os.walk(cwd):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+        for f in files:
+            if f.endswith(".py"):
+                yield os.path.join(root, f)
+
+
+def _scan_decorator_style_static(cwd):
+    """
+    Handles FastAPI / Starlette / Sanic-style decorators:
+      @app.get("/path")
+      @router.post("/path")
+    """
+    endpoints = []
+    seen = set()
+
+    pattern = re.compile(
+        r"@(?:\w+)\.(get|post|put|delete|patch)\s*\(\s*[\"']([^\"']+)[\"']",
+        re.IGNORECASE,
+    )
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for match in pattern.finditer(content):
+            method = match.group(1).upper()
+            path = match.group(2)
+            normalized = re.sub(r"\{([^}]+)\}", r":\1", path)
+            key = f"{method}:{normalized}"
+            if key in seen:
+                continue
+            seen.add(key)
+
+            body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+            endpoints.append({
+                "method": method,
+                "path": normalized,
+                "description": generate_description(method, normalized, None),
+                "requestBody": body_fields,
+                "detectedBy": "static-scan-file",
+            })
+
+    return endpoints
+
+
+def _find_matching_paren(text, open_idx):
+    """
+    Given the index of an opening '(' in text, return the index of its
+    matching closing ')'. Used to bound a single decorator's argument
+    list precisely, instead of using a regex that can drift across
+    unrelated decorators later in the file.
+    """
+    depth = 0
+    i = open_idx
+    n = len(text)
+    while i < n:
+        c = text[i]
+        if c == "(":
+            depth += 1
+        elif c == ")":
+            depth -= 1
+            if depth == 0:
+                return i
+        i += 1
+    return None
+
+
+def _scan_flask_static(cwd):
+    """
+    Handles Flask-style decorators:
+      @app.route("/path", methods=["POST"])
+      @bp.route("/path")   (Blueprint, defaults to GET)
+
+    Each decorator's argument list is isolated using paren-matching
+    (see _find_matching_paren) rather than a DOTALL regex. The previous
+    DOTALL approach could match "methods=[...]" belonging to a LATER,
+    unrelated @app.route(...) decorator further down the file, which
+    both mis-tagged the earlier route's methods and caused the later
+    route to be skipped entirely.
+    """
+    endpoints = []
+    seen = set()
+
+    decorator_start = re.compile(r"@(?:\w+)\.route\s*\(", re.IGNORECASE)
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for start_match in decorator_start.finditer(content):
+            open_paren_idx = start_match.end() - 1  # index of the '(' itself
+            close_paren_idx = _find_matching_paren(content, open_paren_idx)
+            if close_paren_idx is None:
+                continue
+
+            # Only look inside THIS decorator's own argument list
+            args_text = content[open_paren_idx + 1:close_paren_idx]
+
+            path_match = re.search(r"[\"']([^\"']+)[\"']", args_text)
+            if not path_match:
+                continue
+            path = path_match.group(1)
+
+            methods_match = re.search(r"methods\s*=\s*\[([^\]]*)\]", args_text)
+            if methods_match:
+                methods = [
+                    m.strip().strip("'\"").upper()
+                    for m in methods_match.group(1).split(",")
+                    if m.strip()
+                ]
+                if not methods:
+                    methods = ["GET"]
+            else:
+                methods = ["GET"]
+
+            normalized = normalize_flask_path(path)
+
+            for method in methods:
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": body_fields,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+
+def _scan_django_static(cwd):
+    """
+    Handles Django urls.py:
+      path("users/<int:id>/", views.user_detail)
+      re_path(r"^users/(?P<id>\\d+)/$", views.user_detail)
+    """
+    endpoints = []
+    seen = set()
+
+    pattern = re.compile(
+        r"(?:path|re_path)\s*\(\s*r?[\"']([^\"']+)[\"']",
+        re.IGNORECASE,
+    )
+
+    for filepath in _walk_py_files(cwd):
+        if "urls.py" not in filepath:
+            continue
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for match in pattern.finditer(content):
+            raw_path = match.group(1)
+            normalized = _django_pattern_to_path(raw_path)
+
+            # Static scan can't reliably detect the view's supported HTTP
+            # methods without importing it — default to GET + POST as the
+            # common case (consistent with function-based view fallback
+            # in _detect_django_methods).
+            for method in ["GET", "POST"]:
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": None,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+def _scan_falcon_static(cwd):
+    """
+    Handles Falcon-style route registration:
+      app.add_route('/path', SomeResource())
+    Falcon resources define on_get/on_post/etc as class methods, so we
+    can't perfectly link one add_route() call to its resource's methods
+    without executing the code. As a best-effort approximation, we scan
+    the whole file for any on_<method> definitions and apply that method
+    set to every add_route() path found in the same file.
+    """
+    endpoints = []
+    seen = set()
+
+    route_pattern = re.compile(r"add_route\s*\(\s*[\"']([^\"']+)[\"']", re.IGNORECASE)
+    method_def_pattern = re.compile(r"def\s+on_(get|post|put|delete|patch)\b", re.IGNORECASE)
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        route_matches = list(route_pattern.finditer(content))
+        if not route_matches:
+            continue
+
+        methods_in_file = sorted({m.group(1).upper() for m in method_def_pattern.finditer(content)})
+        if not methods_in_file:
+            methods_in_file = ["GET"]
+
+        for match in route_matches:
+            path = match.group(1)
+            normalized = re.sub(r"\{([^:}]+)(?::[^}]+)?\}", r":\1", path)
+
+            for method in methods_in_file:
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": body_fields,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+
+def _scan_bottle_static(cwd):
+    """
+    Handles Bottle-style routes:
+      @app.route('/path', method='POST')
+      @app.get('/path')  /  @app.post('/path')  (shorthand decorators)
+    """
+    endpoints = []
+    seen = set()
+
+    shorthand_pattern = re.compile(
+        r"@(?:\w+)\.(get|post|put|delete|patch)\s*\(\s*[\"']([^\"']+)[\"']",
+        re.IGNORECASE,
+    )
+    route_decorator_start = re.compile(r"@(?:\w+)\.route\s*\(", re.IGNORECASE)
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for match in shorthand_pattern.finditer(content):
+            method = match.group(1).upper()
+            path = match.group(2)
+            normalized = re.sub(r"<([^:>]+)(?::[^>]+)?>", r":\1", path)
+
+            key = f"{method}:{normalized}"
+            if key in seen:
+                continue
+            seen.add(key)
+
+            body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+            endpoints.append({
+                "method": method,
+                "path": normalized,
+                "description": generate_description(method, normalized, None),
+                "requestBody": body_fields,
+                "detectedBy": "static-scan-file",
+            })
+
+        for start_match in route_decorator_start.finditer(content):
+            open_idx = start_match.end() - 1
+            close_idx = _find_matching_paren(content, open_idx)
+            if close_idx is None:
+                continue
+            args_text = content[open_idx + 1:close_idx]
+
+            path_match = re.search(r"[\"']([^\"']+)[\"']", args_text)
+            if not path_match:
+                continue
+            path = path_match.group(1)
+
+            method_match = re.search(r"method\s*=\s*[\"'](\w+)[\"']", args_text)
+            method = method_match.group(1).upper() if method_match else "GET"
+
+            normalized = re.sub(r"<([^:>]+)(?::[^>]+)?>", r":\1", path)
+
+            key = f"{method}:{normalized}"
+            if key in seen:
+                continue
+            seen.add(key)
+
+            body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+            endpoints.append({
+                "method": method,
+                "path": normalized,
+                "description": generate_description(method, normalized, None),
+                "requestBody": body_fields,
+                "detectedBy": "static-scan-file",
+            })
+
+    return endpoints
+
+
+def _scan_aiohttp_static(cwd):
+    """
+    Handles aiohttp-style route registration:
+      app.router.add_get('/path', handler)
+      app.router.add_post('/path', handler)
+      app.router.add_route('POST', '/path', handler)
+    """
+    endpoints = []
+    seen = set()
+
+    shorthand_pattern = re.compile(
+        r"add_(get|post|put|delete|patch)\s*\(\s*[\"']([^\"']+)[\"']",
+        re.IGNORECASE,
+    )
+    generic_pattern = re.compile(
+        r"add_route\s*\(\s*[\"'](\w+)[\"']\s*,\s*[\"']([^\"']+)[\"']",
+        re.IGNORECASE,
+    )
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for pattern in (shorthand_pattern, generic_pattern):
+            for match in pattern.finditer(content):
+                method = match.group(1).upper()
+                path = match.group(2)
+                normalized = re.sub(r"\{([^:}]+)(?::[^}]+)?\}", r":\1", path)
+
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": body_fields,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+
+def _scan_tornado_static(cwd):
+    """
+    Handles Tornado-style URL specs:
+      (r"/path", SomeHandler)
+    Tornado handler methods (get/post/etc) live on the handler class, so
+    like Falcon, we approximate by scanning the whole file for any
+    get/post/put/delete/patch method definitions and applying that set
+    to every URL spec found in the same file. Only runs on files that
+    look like Tornado app files, to avoid matching unrelated tuples.
+    """
+    endpoints = []
+    seen = set()
+
+    url_spec_pattern = re.compile(r"\(\s*r?[\"']([^\"']+)[\"']\s*,\s*(\w+)\s*\)")
+    method_def_pattern = re.compile(r"def\s+(get|post|put|delete|patch)\s*\(\s*self", re.IGNORECASE)
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        is_tornado_file = "tornado" in content.lower() and (
+            "Application(" in content or "URLSpec" in content
+        )
+        if not is_tornado_file:
+            continue
+
+        url_matches = list(url_spec_pattern.finditer(content))
+        if not url_matches:
+            continue
+
+        methods_in_file = sorted({m.group(1).upper() for m in method_def_pattern.finditer(content)})
+        if not methods_in_file:
+            methods_in_file = ["GET"]
+
+        for match in url_matches:
+            path = match.group(1)
+            normalized = re.sub(r"\(\?P<([^>]+)>[^)]+\)", r":\1", path)
+            normalized = re.sub(r"[\\^$]", "", normalized)
+            if not normalized.startswith("/"):
+                normalized = "/" + normalized
+
+            for method in methods_in_file:
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                body_fields = _extract_body_fields_static(content) if method in ("POST", "PUT", "PATCH") else None
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": body_fields,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+
+def _scan_pyramid_static(cwd):
+    """
+    Handles Pyramid-style route registration:
+      config.add_route('name', '/path')
+    Static scan can't reliably determine which HTTP methods a route's
+    view supports without executing the config, so — consistent with
+    the Django static scanner's fallback — we default to GET + POST.
+    """
+    endpoints = []
+    seen = set()
+
+    pattern = re.compile(r"add_route\s*\(\s*[\"'][^\"']+[\"']\s*,\s*[\"']([^\"']+)[\"']")
+
+    for filepath in _walk_py_files(cwd):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                content = fh.read()
+        except Exception:
+            continue
+
+        for match in pattern.finditer(content):
+            path = match.group(1)
+            normalized = re.sub(r"\{([^:}]+)(?::[^}]+)?\}", r":\1", path)
+            if not normalized.startswith("/"):
+                normalized = "/" + normalized
+
+            for method in ("GET", "POST"):
+                key = f"{method}:{normalized}"
+                if key in seen:
+                    continue
+                seen.add(key)
+
+                endpoints.append({
+                    "method": method,
+                    "path": normalized,
+                    "description": generate_description(method, normalized, None),
+                    "requestBody": None,
+                    "detectedBy": "static-scan-file",
+                })
+
+    return endpoints
+
+
+def _extract_body_fields_static(content):
+    """
+    Best-effort body field extraction from source text — mirrors the JS
+    static file scanner's approach. Looks for common request-body access
+    patterns without needing to import/execute the file.
+    """
+    fields = set()
+
+    for m in re.finditer(r"request\.json(?:\.get\(|\[)\s*['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]", content):
+        fields.add(m.group(1))
+    for m in re.finditer(r"request\.data(?:\.get\(|\[)\s*['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]", content):
+        fields.add(m.group(1))
+    for m in re.finditer(r"request\.form(?:\.get\(|\[)\s*['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]", content):
+        fields.add(m.group(1))
+
+    if not fields:
+        return None
+
+    properties = {f: {"type": infer_field_type(f, content)} for f in fields}
+    return {"type": "object", "properties": properties}
+
+
+def detect_framework_from_deps(cwd):
+    """
+    Detects the backend framework from dependency declarations, since
+    Python has no single 'package.json' convention. Checks requirements.txt,
+    pyproject.toml, and Pipfile, in that order.
+    """
+    FRAMEWORK_PACKAGES = [
+        ("fastapi", "fastapi"),
+        ("flask", "flask"),
+        ("django", "django"),
+        ("starlette", "starlette"),
+        ("sanic", "sanic"),
+        ("falcon", "falcon"),
+        ("bottle", "bottle"),
+        ("aiohttp", "aiohttp"),
+        ("tornado", "tornado"),
+        ("pyramid", "pyramid"),
+        ("cherrypy", "cherrypy"),
+    ]
+
+    candidates = [
+        os.path.join(cwd, "requirements.txt"),
+        os.path.join(cwd, "pyproject.toml"),
+        os.path.join(cwd, "Pipfile"),
+    ]
+
+    combined = ""
+    for filepath in candidates:
+        if os.path.exists(filepath):
+            try:
+                with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
+                    combined += fh.read().lower() + "\n"
+            except Exception:
+                continue
+
+    for pkg_name, framework in FRAMEWORK_PACKAGES:
+        if pkg_name in combined:
+            return framework
+
+    return None

botversion_sdk-2.1.0/botversion_sdk.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: botversion-sdk
+Version: 2.1.0
+Summary: BotVersion SDK — automatically discover and register your API endpoints
+Home-page: https://github.com/botversion/botversion-sdk-python
+Author: BotVersion
+Author-email: support@botversion.com
+Keywords: botversion,api,sdk,fastapi,flask,django
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == "fastapi"
+Requires-Dist: starlette; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask; extra == "flask"
+Provides-Extra: django
+Requires-Dist: django; extra == "django"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{botversion_sdk-2.0.0 → botversion_sdk-2.1.0}/botversion_sdk.egg-info/SOURCES.txt

@@ -7,4 +7,8 @@ botversion_sdk/scanner.py
 botversion_sdk.egg-info/PKG-INFO
 botversion_sdk.egg-info/SOURCES.txt
 botversion_sdk.egg-info/dependency_links.txt
-botversion_sdk.egg-info/top_level.txt
+botversion_sdk.egg-info/entry_points.txt
+botversion_sdk.egg-info/requires.txt
+botversion_sdk.egg-info/top_level.txt
+botversion_sdk/bin/__init__.py
+botversion_sdk/bin/scan_endpoints.py

botversion_sdk-2.1.0/botversion_sdk.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+botversion-scan-endpoints = botversion_sdk.bin.scan_endpoints:main

botversion_sdk-2.1.0/botversion_sdk.egg-info/requires.txt

@@ -0,0 +1,11 @@
+python-dotenv>=1.0.0
+
+[django]
+django
+
+[fastapi]
+fastapi
+starlette
+
+[flask]
+flask

botversion_sdk-2.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

{botversion_sdk-2.0.0 → botversion_sdk-2.1.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="botversion-sdk",
-    version="2.0.0",
+    version="2.1.0",
     description="BotVersion SDK — automatically discover and register your API endpoints",
     long_description=open("README.md").read() if __import__("os").path.exists("README.md") else "",
     long_description_content_type="text/markdown",
@@ -12,9 +12,19 @@ setup(
     packages=find_packages(),
     python_requires=">=3.7",
 
-    # No required dependencies — works with stdlib only.
-    # FastAPI, Flask, Django are optional — detected at runtime.
-    install_requires=[],
+    entry_points={
+        "console_scripts": [
+            "botversion-scan-endpoints=botversion_sdk.bin.scan_endpoints:main",
+        ],
+    },
+
+    # python-dotenv is the only hard dependency, used to auto-load .env /
+    # .env.local for the build-time CLI scanner (see bin/scan_endpoints.py).
+    # FastAPI, Flask, Django, etc. are optional — detected at runtime, not
+    # required to install the SDK itself.
+    install_requires=[
+        "python-dotenv>=1.0.0",
+    ],
 
     extras_require={
         "fastapi": ["fastapi", "starlette"],

botversion_sdk-2.0.0/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.4
-Name: botversion-sdk
-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
-Author-email: Saurav Dhakal <sauravdhakal828@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Dynamic: author
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-python

botversion_sdk-2.0.0/botversion_sdk.egg-info/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.4
-Name: botversion-sdk
-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
-Author-email: Saurav Dhakal <sauravdhakal828@gmail.com>
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-Dynamic: author
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-python

botversion_sdk-2.0.0/pyproject.toml

@@ -1,11 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "botversion-sdk"
-version = "2.0.0"
-description = "BotVersion AI Agent SDK for FastAPI, Flask, and Django"
-authors = [{name = "Saurav Dhakal", email = "sauravdhakal828@gmail.com"}]
-requires-python = ">=3.8"
-dependencies = []