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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vercel-runtime
-Version: 0.5.6
+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.5.6 → vercel_runtime-0.7.0}/pyproject.toml

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

{vercel_runtime-0.5.6 → vercel_runtime-0.7.0}/src/vercel_runtime/crons.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import asyncio
 import hmac
+import inspect
 import os
 import traceback
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from vercel_runtime.asgi import ASGI, drain_body, get_header, send_json_response
 from vercel_runtime.utils import (
@@ -13,7 +14,12 @@ from vercel_runtime.utils import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
+    from collections.abc import Awaitable, Callable, Coroutine
+    from types import ModuleType
+
+type SyncCronHandler = Callable[[], None]
+type AsyncCronHandler = Callable[[], Coroutine[Any, Any, None]]
+type CronHandler = SyncCronHandler | AsyncCronHandler
 
 
 def is_cron_service() -> bool:
@@ -21,7 +27,16 @@ def is_cron_service() -> bool:
     return svc_type.strip().lower() == "cron"
 
 
-def bootstrap_cron_service_app(module: object) -> ASGI:
+def bootstrap_cron_service_app(module: ModuleType) -> ASGI:
+    # Check for a named handler function (module:function entrypoint)
+    handler_func = _resolve_handler_function(module)
+    if handler_func is not None:
+        return _make_cron_asgi_app(
+            handler_func,
+            is_async=inspect.iscoroutinefunction(handler_func),
+        )
+
+    # Fall back to __main__ guard execution
     entrypoint_abs = os.environ.get("__VC_HANDLER_ENTRYPOINT_ABS")
     if not entrypoint_abs:
         raise RuntimeError(
@@ -35,6 +50,34 @@ def bootstrap_cron_service_app(module: object) -> ASGI:
             'The entrypoint must define an `if __name__ == "__main__"` block.'
         )
 
+    return _make_cron_asgi_app(
+        lambda: run_entrypoint_as_main(entrypoint_abs),
+        is_async=False,
+    )
+
+
+def _resolve_handler_function(module: ModuleType) -> CronHandler | None:
+    func_name = os.environ.get("__VC_HANDLER_FUNC_NAME")
+    if not func_name:
+        return None
+
+    func = getattr(module, func_name, None)
+    if func is None:
+        raise RuntimeError(
+            f'cron handler function "{func_name}" not found in module'
+        )
+
+    if not callable(func):
+        raise RuntimeError(f'cron handler "{func_name}" is not callable')
+
+    return cast("CronHandler", func)
+
+
+def _make_cron_asgi_app(
+    run_job: CronHandler,
+    *,
+    is_async: bool,
+) -> ASGI:
     async def app(
         scope: dict[str, Any],
         receive: Callable[[], Awaitable[dict[str, Any]]],
@@ -75,7 +118,10 @@ def bootstrap_cron_service_app(module: object) -> ASGI:
         await drain_body(receive)
 
         try:
-            await asyncio.to_thread(run_entrypoint_as_main, entrypoint_abs)
+            if is_async:
+                await cast("AsyncCronHandler", run_job)()
+            else:
+                await asyncio.to_thread(cast("SyncCronHandler", run_job))
         except Exception:
             traceback.print_exc()
             await send_json_response(send, 500, {"error": "internal"})

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)"
+    )