vercel-runtime 0.6.0__tar.gz → 0.7.0__tar.gz

{vercel_runtime-0.6.0 → vercel_runtime-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vercel-runtime
-Version: 0.6.0
+Version: 0.7.0
 License-Expression: Apache-2.0
 License-File: src/vercel_runtime/_vendor/__init__.py
 License-File: src/vercel_runtime/_vendor/click/LICENSE.txt

{vercel_runtime-0.6.0 → vercel_runtime-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vercel-runtime"
-version = "0.6.0"
+version = "0.7.0"
 license = "Apache-2.0"
 license-files = [
   "src/vercel_runtime/_vendor/*/LICEN[CS]E*",

vercel_runtime-0.7.0/src/vercel_runtime/dev.py

@@ -0,0 +1,421 @@
+from __future__ import annotations
+
+import logging
+import logging.config
+import mimetypes
+import os
+import sys
+from typing import TYPE_CHECKING, Any, cast
+
+from vercel_runtime._vendor import uvicorn as vendored_uvicorn
+from vercel_runtime._vendor.uvicorn.config import (
+    LOGGING_CONFIG as UVICORN_LOGGING_CONFIG,
+)
+from vercel_runtime._vendor.werkzeug.serving import run_simple
+from vercel_runtime.resolver import detect_app_type, import_module, resolve_app
+from vercel_runtime.routing import (
+    apply_service_route_prefix_to_asgi_scope,
+    strip_service_route_prefix,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from wsgiref.types import WSGIApplication
+
+    from vercel_runtime.asgi import ASGI
+
+_NO_COLOR = "NO_COLOR" in os.environ
+
+_log = logging.getLogger("vercel.dev")
+
+
+# Used to split DEBUG-WARNING -> stdout and ERROR-CRITICAL -> stderr
+class _MaxLevelFilter(logging.Filter):
+    def __init__(self, max_level: int) -> None:
+        super().__init__()
+        self.max_level = max_level
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno <= self.max_level
+
+
+def _build_log_config(
+    loggers: dict[str, Any],
+    _filter_ref: object | None = None,
+) -> dict[str, Any]:
+    if _filter_ref is None:
+        _filter_ref = "vercel_runtime.dev._MaxLevelFilter"
+
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "max_warning": {
+                "()": _filter_ref,
+                "max_level": logging.WARNING,
+            }
+        },
+        "handlers": {
+            "stdout": {
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+                "filters": ["max_warning"],
+            },
+            "stderr": {
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stderr",
+                "level": "ERROR",
+            },
+        },
+        "loggers": loggers,
+        "root": {
+            "handlers": ["stdout", "stderr"],
+            "level": "INFO",
+        },
+    }
+
+
+def _setup_server_log_routing(logger_name: str | None = None) -> None:
+    loggers: dict[str, Any] = {}
+
+    if logger_name:
+        loggers[logger_name] = {
+            "handlers": ["stdout", "stderr"],
+            "level": "INFO",
+            "propagate": False,
+        }
+
+    logging.config.dictConfig(
+        _build_log_config(
+            loggers=loggers,
+            _filter_ref=_MaxLevelFilter,
+        ),
+    )
+
+
+def _build_uvicorn_log_config(
+    default_fmt: dict[str, Any] | None = None,
+    access_fmt: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    uvicorn_fmts: dict[str, Any] = UVICORN_LOGGING_CONFIG["formatters"]
+
+    cfg = _build_log_config(
+        loggers={
+            "uvicorn": {
+                "handlers": ["stdout", "stderr"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "uvicorn.error": {"level": "INFO"},
+            "uvicorn.access": {
+                "handlers": ["access"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    )
+
+    if default_fmt is None:
+        default_fmt = {
+            **uvicorn_fmts["default"],
+            "use_colors": not _NO_COLOR,
+        }
+
+    if access_fmt is None:
+        access_fmt = {
+            **uvicorn_fmts["access"],
+            "use_colors": not _NO_COLOR,
+        }
+
+    cfg["formatters"] = {"default": default_fmt, "access": access_fmt}
+    cfg["handlers"]["stdout"]["formatter"] = "default"
+    cfg["handlers"]["stderr"]["formatter"] = "default"
+    cfg["handlers"]["access"] = {
+        "class": "logging.StreamHandler",
+        "stream": "ext://sys.stdout",
+        "formatter": "access",
+    }
+
+    return cfg
+
+
+def _patch_fastapi_cli_log_config() -> None:
+    try:
+        import fastapi_cli.cli as _fcli_cli  # type: ignore[import-not-found]  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+        import fastapi_cli.utils.cli as _fcli  # type: ignore[import-not-found]  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+
+        orig_get_config = cast(
+            "Callable[[], dict[str, Any]]",
+            _fcli.get_uvicorn_log_config,  # pyright: ignore[reportUnknownMemberType]
+        )
+
+        # we want to ensure that attr exists
+        # because we're going to patch it as well
+        _fcli_cli.get_uvicorn_log_config  # noqa: B018  # pyright: ignore[reportUnknownMemberType]
+    except (ImportError, AttributeError):
+        return
+
+    def _get_routed_config() -> dict[str, Any]:
+        orig = orig_get_config()
+        return _build_uvicorn_log_config(
+            default_fmt={
+                "()": "fastapi_cli.utils.cli.CustomFormatter",
+                "fmt": orig["formatters"]["default"].get(
+                    "fmt", "%(levelprefix)s %(message)s"
+                ),
+                "use_colors": orig["formatters"]["default"].get("use_colors"),
+            },
+            access_fmt={
+                "()": "fastapi_cli.utils.cli.CustomFormatter",
+                "fmt": orig["formatters"]["access"].get(
+                    "fmt",
+                    "%(levelprefix)s %(client_addr)s - "
+                    "'%(request_line)s' %(status_code)s",
+                ),
+            },
+        )
+
+    _fcli.get_uvicorn_log_config = _get_routed_config
+    _fcli_cli.get_uvicorn_log_config = _get_routed_config
+
+
+PUBLIC_DIR = "public"
+
+
+def _build_static_asgi_app() -> ASGI | None:
+    static_files_cls: type[Any] | None = None
+    try:
+        from fastapi.staticfiles import (  # type: ignore[import-not-found]  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+            StaticFiles,  # pyright: ignore[reportUnknownVariableType]
+        )
+
+        static_files_cls = StaticFiles  # pyright: ignore[reportUnknownVariableType]
+    except Exception:
+        try:
+            from starlette.staticfiles import (  # type: ignore[import-not-found]  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+                StaticFiles,  # pyright: ignore[reportUnknownVariableType]
+            )
+
+            static_files_cls = StaticFiles  # pyright: ignore[reportUnknownVariableType]
+        except Exception:
+            return None
+
+    if static_files_cls is not None:
+        try:
+            try:
+                return cast(
+                    "ASGI",
+                    static_files_cls(directory=PUBLIC_DIR, check_dir=False),
+                )
+            except TypeError:
+                return cast("ASGI", static_files_cls(directory=PUBLIC_DIR))
+        except Exception:
+            return None
+
+    return None
+
+
+def _is_safe_file(base_dir: str, target: str) -> bool:
+    try:
+        base = os.path.realpath(base_dir)
+        tgt = os.path.realpath(target)
+        return (
+            tgt == base or tgt.startswith(base + os.sep)
+        ) and os.path.isfile(tgt)
+    except Exception:
+        return False
+
+
+def _static_wsgi_app(
+    environ: dict[str, Any],
+    start_response: Callable[..., Any],
+) -> list[bytes]:
+    if environ.get("REQUEST_METHOD", "GET") not in ("GET", "HEAD"):
+        return _not_found(start_response)
+
+    req_path = environ.get("PATH_INFO", "/") or "/"
+    safe = os.path.normpath(req_path).lstrip("/")
+    full = os.path.join(PUBLIC_DIR, safe)
+    if not _is_safe_file(PUBLIC_DIR, full):
+        return _not_found(start_response)
+
+    ctype, _ = mimetypes.guess_type(full)
+    headers = [("Content-Type", ctype or "application/octet-stream")]
+    try:
+        if environ.get("REQUEST_METHOD") == "HEAD":
+            start_response("200 OK", headers)
+            return []
+        with open(full, "rb") as f:
+            data = f.read()
+        headers.append(("Content-Length", str(len(data))))
+        start_response("200 OK", headers)
+        return [data]
+    except Exception:
+        return _not_found(start_response)
+
+
+def _not_found(
+    start_response: Callable[..., Any],
+) -> list[bytes]:
+    start_response(
+        "404 Not Found",
+        [("Content-Type", "text/plain; charset=utf-8")],
+    )
+    return [b"Not Found"]
+
+
+static_asgi = _build_static_asgi_app()
+_asgi_user_app: ASGI | None = None
+_wsgi_user_app: WSGIApplication | None = None
+
+
+async def asgi_app(
+    scope: dict[str, Any],
+    receive: Callable[[], Awaitable[Any]],
+    send: Callable[[Any], Awaitable[None]],
+) -> None:
+    effective_scope = dict(scope)
+    apply_service_route_prefix_to_asgi_scope(effective_scope)
+
+    if static_asgi is not None and effective_scope.get("type") == "http":
+        req_path = effective_scope.get("path", "/") or "/"
+        safe = os.path.normpath(req_path).lstrip("/")
+        full = os.path.join(PUBLIC_DIR, safe)
+        try:
+            base = os.path.realpath(PUBLIC_DIR)
+            target = os.path.realpath(full)
+            if (
+                target == base or target.startswith(base + os.path.sep)
+            ) and os.path.isfile(target):
+                await static_asgi(effective_scope, receive, send)
+                return
+        except Exception:
+            pass
+
+    assert _asgi_user_app is not None
+    await _asgi_user_app(effective_scope, receive, send)
+
+
+def wsgi_app(
+    environ: dict[str, Any],
+    start_response: Callable[..., Any],
+) -> Any:
+    path_info, matched_prefix = strip_service_route_prefix(
+        environ.get("PATH_INFO", "/") or "/"
+    )
+    environ["PATH_INFO"] = path_info
+    if matched_prefix:
+        script_name = environ.get("SCRIPT_NAME", "") or ""
+        if script_name and script_name != "/":
+            script_name = script_name.rstrip("/")
+        else:
+            script_name = ""
+        environ["SCRIPT_NAME"] = f"{script_name}{matched_prefix}"
+
+    # Try static first; if 404 then delegate to user app
+    captured_status = ""
+    captured_headers: tuple[tuple[str, str], ...] = ()
+    body_chunks: list[bytes] = []
+
+    def capture_start_response(
+        status: str,
+        headers: list[tuple[str, str]],
+        exc_info: Any = None,
+    ) -> Callable[[bytes], None]:
+        nonlocal captured_status, captured_headers
+        captured_status = status
+        captured_headers = tuple(headers)
+
+        def write(chunk: bytes) -> None:
+            body_chunks.append(chunk)
+
+        return write
+
+    result = _static_wsgi_app(environ, capture_start_response)
+    # If static handler produced 200, forward its response
+    if captured_status.startswith("200 "):
+        # Send headers and any chunks collected
+        writer = start_response(captured_status, list(captured_headers))
+        for chunk in body_chunks:
+            writer(chunk)
+        return result
+
+    # Otherwise, delegate to user's WSGI app
+    assert _wsgi_user_app is not None
+    return _wsgi_user_app(environ, start_response)
+
+
+def _start_wsgi(host: str, port: int) -> None:
+    _setup_server_log_routing("werkzeug")
+    run_simple(host, port, wsgi_app, use_reloader=True, threaded=True)
+
+
+def _start_asgi(host: str, port: int) -> None:
+    # Prefer user-installed fastapi-cli when available
+    try:
+        from fastapi_cli.cli import (  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
+            dev as fastapi_dev,  # pyright: ignore[reportUnknownVariableType]
+        )
+
+        _patch_fastapi_cli_log_config()
+        fastapi_dev(
+            entrypoint="vercel_runtime.dev:asgi_app",
+            host=host,
+            port=port,
+            reload=True,
+        )
+        sys.exit(0)
+    except (ImportError, AttributeError):
+        pass
+
+    vendored_uvicorn.run(
+        "vercel_runtime.dev:asgi_app",
+        host=host,
+        port=port,
+        use_colors=not _NO_COLOR,
+        reload=True,
+        log_config=_build_uvicorn_log_config(),
+    )
+
+
+def _setup_apps() -> None:
+    global _asgi_user_app, _wsgi_user_app  # noqa: PLW0603
+
+    module_name = os.environ["VERCEL_DEV_MODULE_NAME"]
+    entry_abs = os.environ["VERCEL_DEV_ENTRY_ABS"]
+
+    _setup_server_log_routing()
+
+    mod = import_module(module_name, entry_abs)
+    app_name, user_app = resolve_app(mod, module_name)
+    try:
+        result = detect_app_type(user_app, module_name, app_name)
+    except RuntimeError:
+        _log.exception("could not detect application type")
+        sys.exit(1)
+
+    if result[0] == "asgi":
+        _asgi_user_app = result[1]
+    else:
+        _wsgi_user_app = result[1]
+
+
+# Setup apps at import time so that servers reloader can pick them up.
+if os.environ.get("VERCEL_DEV_MODULE_NAME") and os.environ.get(
+    "VERCEL_DEV_ENTRY_ABS"
+):
+    _setup_apps()
+
+
+def main() -> None:
+    host = "127.0.0.1"
+    raw_port = os.environ.get("PORT")
+    if not raw_port:
+        _log.error("PORT environment variable is required")
+        sys.exit(1)
+    port = int(raw_port)
+
+    if _wsgi_user_app is not None:
+        _start_wsgi(host, port)
+    else:
+        _start_asgi(host, port)

vercel_runtime-0.7.0/src/vercel_runtime/resolver.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import inspect
+import sys
+from importlib import util as _importlib_util
+from typing import TYPE_CHECKING, Any, Literal, cast
+
+if TYPE_CHECKING:
+    from types import ModuleType
+    from wsgiref.types import WSGIApplication
+
+    from vercel_runtime.asgi import ASGI
+
+
+# Import relative path
+# https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
+def import_module(name: str, path: str) -> ModuleType:
+    spec = _importlib_util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        msg = f'could not load module spec for "{name}" at {path}'
+        raise RuntimeError(msg)
+    mod = _importlib_util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def resolve_app(mod: ModuleType, module_name: str) -> tuple[str, Any]:
+    for app_var in ("app", "application"):
+        if hasattr(mod, app_var):
+            return app_var, getattr(mod, app_var)
+
+    raise RuntimeError(
+        f"Missing 'app' or 'application' in module '{module_name}': "
+        "define `app = ...` or `application = ...` in your entrypoint"
+    )
+
+
+def _get_positional_param_count(obj: object) -> int | None:
+    try:
+        sig = inspect.signature(obj)  # type: ignore[arg-type]
+        return sum(
+            1
+            for p in sig.parameters.values()
+            if p.default is inspect.Parameter.empty
+            and p.kind
+            in (
+                inspect.Parameter.POSITIONAL_ONLY,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            )
+        )
+    except (ValueError, TypeError):
+        return None
+
+
+def detect_app_type(
+    app_obj: object,
+    module_name: str,
+    app_name: str,
+) -> tuple[Literal["asgi"], ASGI] | tuple[Literal["wsgi"], WSGIApplication]:
+    # Try .asgi attribute if it's available and is callable
+    asgi_attr = getattr(app_obj, "asgi", None)
+    if asgi_attr is not None and callable(asgi_attr):
+        return "asgi", cast("ASGI", asgi_attr)
+
+    # For async detection, check the object itself first
+    # (works for plain functions/methods).
+    # For class instances iscoroutinefunction(obj) is False,
+    # so fall back to __call__.
+    is_async = inspect.iscoroutinefunction(app_obj)
+    if not is_async and callable(app_obj):
+        is_async = inspect.iscoroutinefunction(
+            app_obj.__call__  # pyright: ignore[reportFunctionMemberAccess]
+        )
+
+    param_count = _get_positional_param_count(app_obj)
+
+    # that's ASGI (scope, receive, send)
+    if is_async and param_count == 3:
+        return "asgi", cast("ASGI", app_obj)
+
+    # that's WSGI (environ, start_response)
+    if param_count == 2:
+        return "wsgi", cast("WSGIApplication", app_obj)
+
+    raise RuntimeError(
+        f"Could not determine the application interface for "
+        f"'{module_name}:{app_name}'\n"
+        f"Expected either:\n"
+        f"  - an ASGI app: async callable(scope, receive, send)\n"
+        f"  - a WSGI app: callable(environ, start_response)"
+    )

vercel_runtime-0.7.0/src/vercel_runtime/routing.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+from urllib.parse import urlsplit
+
+
+def normalize_service_route_prefix(raw_prefix: str | None) -> str:
+    """
+    Normalize a configured service prefix into canonical mount-path form.
+
+    Returns an empty string when unset/blank/root ("/"), otherwise:
+      - always starts with "/"
+      - has no trailing slash
+    """
+    if not raw_prefix:
+        return ""
+
+    prefix = raw_prefix.strip()
+    if not prefix:
+        return ""
+
+    if not prefix.startswith("/"):
+        prefix = f"/{prefix}"
+
+    # Treat "/" as an unset mount prefix.
+    return "" if prefix == "/" else prefix.rstrip("/")
+
+
+def is_service_route_prefix_strip_enabled() -> bool:
+    raw = os.environ.get("VERCEL_SERVICE_ROUTE_PREFIX_STRIP")
+    if not raw:
+        return False
+    return raw.lower() in ("1", "true")
+
+
+def get_service_route_prefix() -> str:
+    if not is_service_route_prefix_strip_enabled():
+        return ""
+
+    return normalize_service_route_prefix(
+        os.environ.get("VERCEL_SERVICE_ROUTE_PREFIX")
+    )
+
+
+_service_route_prefix = get_service_route_prefix()
+
+
+def split_request_target(target: str) -> tuple[str, str]:
+    """
+    Split an HTTP request-target into (path, query).
+
+    Supports:
+      - origin-form: "/a/b?x=1"
+      - absolute-form: "https://example.com/a/b?x=1"
+      - asterisk-form: "*"
+    """
+    if not target:
+        return "/", ""
+
+    parsed = urlsplit(target)
+    path = parsed.path
+    query = parsed.query
+
+    # Absolute-form request-target (RFC 7230 section 5.3.2).
+    if parsed.scheme in ("http", "https") and parsed.netloc:
+        return path or "/", query
+
+    # Asterisk-form request-target (RFC 7230 section 5.3.4).
+    if path == "*":
+        return "*", query
+
+    if not path:
+        path = "/"
+    elif not path.startswith("/"):
+        path = f"/{path}"
+
+    return path, query
+
+
+def strip_service_route_prefix(
+    path: str, prefix: str | None = None
+) -> tuple[str, str]:
+    """
+    Strip a service route prefix from a request path.
+
+    Returns a tuple of:
+      - stripped path passed to the user app
+      - matched mount prefix (empty string when no prefix matched)
+
+    When *prefix* is ``None`` (the default), reads the current value
+    from ``get_service_route_prefix()``.
+
+    Example with prefix "/_/backend":
+      "/_/backend/ping" -> ("/ping", "/_/backend")
+      "/foo"            -> ("/foo", "")
+    """
+    if prefix is None:
+        prefix = _service_route_prefix
+
+    if path == "*":
+        return path, ""
+    if not path:
+        path = "/"
+    elif not path.startswith("/"):
+        path = f"/{path}"
+
+    if not prefix:
+        return path, ""
+
+    if path == prefix:
+        return "/", prefix
+
+    if path.startswith(f"{prefix}/"):
+        stripped = path[len(prefix) :]
+        return stripped if stripped else "/", prefix
+
+    return path, ""
+
+
+def apply_service_route_prefix_to_asgi_scope(
+    scope: dict[str, Any], prefix: str | None = None
+) -> None:
+    if prefix is None:
+        prefix = _service_route_prefix
+
+    if not prefix:
+        return
+
+    path = scope.get("path", "/") or "/"
+    stripped_path, matched_prefix = strip_service_route_prefix(path, prefix)
+    if not matched_prefix:
+        return
+
+    scope["path"] = stripped_path
+
+    raw_path = scope.get("raw_path")
+    if isinstance(raw_path, (bytes, bytearray)):
+        try:
+            decoded = bytes(raw_path).decode("utf-8", "surrogateescape")
+            stripped_raw, _ = strip_service_route_prefix(decoded, prefix)
+            scope["raw_path"] = stripped_raw.encode("utf-8", "surrogateescape")
+        except Exception:
+            pass
+
+    existing_root = scope.get("root_path", "") or ""
+    if existing_root and existing_root != "/":
+        existing_root = existing_root.rstrip("/")
+    else:
+        existing_root = ""
+
+    scope["root_path"] = f"{existing_root}{matched_prefix}"
+
+
+def apply_service_route_prefix_to_target(
+    target: str,
+    prefix: str | None = None,
+) -> tuple[str, str]:
+    """
+    Apply service-prefix stripping to a full request target.
+
+    When *prefix* is ``None`` (the default), reads the current value
+    from ``get_service_route_prefix()``.
+
+    Returns:
+      - updated request target (path + optional query)
+      - matched mount prefix for framework metadata (or "")
+    """
+    if prefix is None:
+        prefix = _service_route_prefix
+
+    path, query = split_request_target(target)
+    path, root_path = strip_service_route_prefix(path, prefix)
+    if query:
+        return f"{path}?{query}", root_path
+
+    return path, root_path