vercel-headers-bundle 0.7.1__tar.gz

vercel_headers_bundle-0.7.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vercel_headers_bundle-0.7.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: vercel-headers-bundle
+Version: 0.7.1
+Summary: Request header helpers for Vercel Python applications
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# vercel-headers-bundle
+
+This is a version of `vercel-headers` with third-party dependencies bundled. For normal use, install the unbundled `vercel-headers` package instead: https://pypi.org/project/vercel-headers/
+
+# Headers
+
+`vercel.headers` stores request headers for Vercel Function helpers and exposes
+IP address and geolocation helpers.
+
+Register request headers once per request:
+
+```python
+from vercel.headers import set_headers
+
+set_headers(request.headers)
+```
+
+OIDC and cache helpers read the same registered header context.

vercel_headers_bundle-0.7.1/README.md

@@ -0,0 +1,18 @@
+# vercel-headers-bundle
+
+This is a version of `vercel-headers` with third-party dependencies bundled. For normal use, install the unbundled `vercel-headers` package instead: https://pypi.org/project/vercel-headers/
+
+# Headers
+
+`vercel.headers` stores request headers for Vercel Function helpers and exposes
+IP address and geolocation helpers.
+
+Register request headers once per request:
+
+```python
+from vercel.headers import set_headers
+
+set_headers(request.headers)
+```
+
+OIDC and cache helpers read the same registered header context.

vercel_headers_bundle-0.7.1/_vercel_hatch_build.py

@@ -0,0 +1,116 @@
+"""Hatch metadata hook for publish-time workspace dependency bounds."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Any
+
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+from packaging.requirements import Requirement
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover - Python < 3.11
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+class WorkspaceDependenciesMetadataHook(MetadataHookInterface):
+    """Generate package dependencies from the repo-owned dependency table."""
+
+    def update(self, metadata: dict[str, Any]) -> None:
+        """Populate dynamic dependencies for Hatchling metadata generation."""
+        pyproject = _load_pyproject(Path(self.root))
+        release = pyproject.get("tool", {}).get("vercel", {}).get("release", {})
+        dependency_table = release.get("dependencies", {})
+        workspace_sources = pyproject.get("tool", {}).get("uv", {}).get("sources", {})
+        workspace_names = {
+            name for name, source in workspace_sources.items() if source.get("workspace") is True
+        }
+        workspace_root = _find_workspace_root(Path(self.root))
+
+        metadata["dependencies"] = [
+            _rewrite_dependency(requirement, workspace_names, workspace_root)
+            for requirement in dependency_table.get("dependencies", [])
+        ]
+
+
+def _load_pyproject(path: Path) -> dict[str, Any]:
+    with (path / "pyproject.toml").open("rb") as fp:
+        return tomllib.load(fp)
+
+
+def _find_workspace_root(start: Path) -> Path | None:
+    for path in [start, *start.parents]:
+        pyproject = path / "pyproject.toml"
+        if not pyproject.exists():
+            continue
+        data = _load_pyproject(path)
+        if "workspace" in data.get("tool", {}).get("uv", {}):
+            return path
+    return None
+
+
+def _rewrite_dependency(
+    requirement: str,
+    workspace_names: set[str],
+    workspace_root: Path | None,
+) -> str:
+    parsed = Requirement(requirement)
+    normalized = parsed.name.lower().replace("_", "-")
+    if normalized not in workspace_names or workspace_root is None:
+        return requirement
+    return _with_lower_bound(parsed, _read_workspace_version(workspace_root, normalized))
+
+
+def _with_lower_bound(requirement: Requirement, version: str) -> str:
+    extras = f"[{','.join(sorted(requirement.extras))}]" if requirement.extras else ""
+    specifiers = [
+        str(specifier) for specifier in requirement.specifier if specifier.operator != ">="
+    ]
+    specifier_text = ",".join([f">={version}", *specifiers])
+    marker = f" ; {requirement.marker}" if requirement.marker else ""
+    return f"{requirement.name}{extras}{specifier_text}{marker}"
+
+
+def _read_workspace_version(workspace_root: Path, package_name: str) -> str:
+    for pattern in ("src/*/pyproject.toml", "integrations/*/pyproject.toml"):
+        for pyproject_path in workspace_root.glob(pattern):
+            version = _version_from_pyproject(pyproject_path, package_name)
+            if version is not None:
+                return version
+    raise RuntimeError(f"unknown workspace dependency {package_name!r}")
+
+
+def _version_from_pyproject(pyproject_path: Path, package_name: str) -> str | None:
+    data = _load_pyproject(pyproject_path.parent)
+    if data.get("project", {}).get("name") != package_name:
+        return None
+    version_path = pyproject_path.parent / data["tool"]["hatch"]["version"]["path"]
+    module = ast.parse(version_path.read_text(encoding="utf-8"), filename=str(version_path))
+    for node in module.body:
+        value = _version_value(node)
+        if value is None:
+            continue
+        if isinstance(value, ast.Constant) and isinstance(value.value, str):
+            return value.value
+    raise RuntimeError(f"could not find __version__ in {version_path}")
+
+
+def _version_value(node: ast.stmt) -> ast.expr | None:
+    if isinstance(node, ast.Assign) and any(
+        isinstance(target, ast.Name) and target.id == "__version__" for target in node.targets
+    ):
+        return node.value
+    if (
+        isinstance(node, ast.AnnAssign)
+        and isinstance(node.target, ast.Name)
+        and node.target.id == "__version__"
+    ):
+        return node.value
+    return None
+
+
+def get_metadata_hook() -> type[MetadataHookInterface]:
+    """Return the hook class used by Hatchling's custom hook loader."""
+    return WorkspaceDependenciesMetadataHook

vercel_headers_bundle-0.7.1/hatch_build.py

@@ -0,0 +1,29 @@
+"""Load the shared Vercel Hatch metadata hook."""
+
+from __future__ import annotations
+
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+from types import ModuleType
+
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+
+
+def get_metadata_hook() -> type[MetadataHookInterface]:
+    """Return the shared workspace dependency metadata hook."""
+    return _load_shared_hook().get_metadata_hook()
+
+
+def _load_shared_hook() -> ModuleType:
+    root = Path(__file__).resolve().parent
+    candidates = [root / "../../scripts/hatch_build.py", root / "_vercel_hatch_build.py"]
+    for candidate in candidates:
+        path = candidate.resolve()
+        if path.exists():
+            spec = spec_from_file_location("_vercel_hatch_build", path)
+            if spec is None or spec.loader is None:
+                raise RuntimeError(f"could not load Hatch hook from {path}")
+            module = module_from_spec(spec)
+            spec.loader.exec_module(module)
+            return module
+    raise RuntimeError("could not find shared Vercel Hatch metadata hook")

vercel_headers_bundle-0.7.1/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["hatchling>=1.27.0,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vercel-headers-bundle"
+dynamic = ["version", "dependencies"]
+description = "Request header helpers for Vercel Python applications"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = [
+    "LICENSE",
+    "LICENSE.*",
+    "vercel/headers/_vendor/LICEN[CS]E*",
+]
+
+[tool.hatch.metadata.hooks.custom]
+path = "hatch_build.py"
+
+[tool.vercel.release.dependencies]
+dependencies = []
+
+[tool.hatch.version]
+path = "vercel/headers/version.py"
+
+[tool.hatch.build.targets.sdist]
+force-include = { "_vercel_hatch_build.py" = "/_vercel_hatch_build.py" }
+include = [
+    "/vercel/headers/**/*.py",
+    "/vercel/headers/py.typed",
+    "/README.md",
+    "/pyproject.toml",
+    "/hatch_build.py",
+    "/LICENSE",
+    "/vercel/headers/_vendor/LICEN[CS]E*",
+]
+exclude = [
+    "/**/__pycache__",
+]
+
+[tool.hatch.build.targets.wheel]
+dev-mode-dirs = ["."]
+only-include = [
+    "/vercel/headers",
+]
+exclude = [
+    "/**/__pycache__",
+]
+
+[tool.poe]
+include = "../../scripts/poe/poe.toml"
+verbosity = -1
+
+[tool.poe.tasks.typecheck]
+cmd = "$MYPY"
+
+[tool.poe.tasks.test]
+cmd = "python -c \"pass\""
+
+[tool.vendoring]
+destination = "vercel/headers/_vendor/"
+requirements = "vercel/headers/_vendor/vendor.txt"
+namespace = "vercel.headers._vendor"
+protected-files = [
+    "__init__.py",
+    "vendor.txt",
+]
+
+[tool.vendoring.transformations]
+drop = [
+    "*.so",
+    "*/tests/",
+    "*/__pycache__/",
+]

vercel_headers_bundle-0.7.1/vercel/headers/__init__.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import urllib.parse
+from collections.abc import Callable, Iterator, Mapping
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, ParamSpec, Protocol, TypedDict, TypeVar
+
+__all__ = [
+    "ip_address",
+    "geolocation",
+    "Geo",
+    "HeadersContext",
+    "set_headers",
+    "get_headers",
+    "headers_from_asgi_scope",
+    "headers_from_wsgi_environ",
+]
+
+
+_cv_headers: ContextVar[Mapping[str, str] | None] = ContextVar("vercel_headers", default=None)
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# Header constants (same as TS names)
+CITY_HEADER_NAME = "x-vercel-ip-city"
+COUNTRY_HEADER_NAME = "x-vercel-ip-country"
+IP_HEADER_NAME = "x-real-ip"
+LATITUDE_HEADER_NAME = "x-vercel-ip-latitude"
+LONGITUDE_HEADER_NAME = "x-vercel-ip-longitude"
+REGION_HEADER_NAME = "x-vercel-ip-country-region"
+POSTAL_CODE_HEADER_NAME = "x-vercel-ip-postal-code"
+REQUEST_ID_HEADER_NAME = "x-vercel-id"
+
+EMOJI_FLAG_UNICODE_STARTING_POSITION = 127397
+
+
+def set_headers(headers: Mapping[str, str] | None) -> None:
+    _cv_headers.set(headers)
+
+
+def get_headers() -> Mapping[str, str] | None:
+    return _cv_headers.get()
+
+
+@dataclass(frozen=True)
+class HeadersContext:
+    """Immutable snapshot of the current Vercel request headers."""
+
+    headers: Mapping[str, str] | None
+
+    @contextmanager
+    def use(self) -> Iterator[None]:
+        token = _cv_headers.set(self.headers)
+        try:
+            yield
+        finally:
+            _cv_headers.reset(token)
+
+    def run(self, func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
+        with self.use():
+            return func(*args, **kwargs)
+
+
+class _HeadersLike(Protocol):
+    def get(self, name: str) -> str | None: ...
+
+
+class _RequestLike(Protocol):
+    headers: _HeadersLike
+
+
+class Geo(TypedDict, total=False):
+    city: str | None
+    country: str | None
+    flag: str | None
+    region: str | None
+    countryRegion: str | None
+    latitude: str | None
+    longitude: str | None
+    postalCode: str | None
+
+
+def _get_header(headers: _HeadersLike, key: str) -> str | None:
+    return headers.get(key)
+
+
+def _get_header_decode(req: _RequestLike, key: str) -> str | None:
+    raw = _get_header(req.headers, key)
+    return urllib.parse.unquote(raw) if raw is not None else None
+
+
+def _get_flag(country_code: str | None) -> str | None:
+    if not country_code or len(country_code) != 2 or not country_code.isalpha():
+        return None
+    return "".join(chr(EMOJI_FLAG_UNICODE_STARTING_POSITION + ord(c)) for c in country_code.upper())
+
+
+def headers_from_asgi_scope(scope: Mapping[str, Any]) -> dict[str, str]:
+    """Return request headers decoded from an ASGI scope."""
+    return {
+        name.decode("latin-1"): value.decode("latin-1") for name, value in scope.get("headers", [])
+    }
+
+
+def headers_from_wsgi_environ(environ: Mapping[str, Any]) -> dict[str, str]:
+    """Return request headers decoded from a WSGI environ mapping."""
+    headers: dict[str, str] = {}
+    if "CONTENT_TYPE" in environ:
+        headers["Content-Type"] = str(environ["CONTENT_TYPE"])
+    if "CONTENT_LENGTH" in environ:
+        headers["Content-Length"] = str(environ["CONTENT_LENGTH"])
+    for name, value in environ.items():
+        if not name.startswith("HTTP_"):
+            continue
+        header_name = name[5:].replace("_", "-").title()
+        headers[header_name] = str(value)
+    return headers
+
+
+def ip_address(input: _RequestLike | _HeadersLike) -> str | None:
+    headers = input.headers if hasattr(input, "headers") else input
+    return _get_header(headers, IP_HEADER_NAME)
+
+
+def _region_from_request_id(request_id: str | None) -> str | None:
+    if request_id is None:
+        return "dev1"
+    return request_id.split(":")[0]
+
+
+def geolocation(request: _RequestLike) -> Geo:
+    headers = request.headers
+    return {
+        "city": _get_header_decode(request, CITY_HEADER_NAME),
+        "country": _get_header(headers, COUNTRY_HEADER_NAME),
+        "flag": _get_flag(_get_header(headers, COUNTRY_HEADER_NAME)),
+        "countryRegion": _get_header(headers, REGION_HEADER_NAME),
+        "region": _region_from_request_id(_get_header(headers, REQUEST_ID_HEADER_NAME)),
+        "latitude": _get_header(headers, LATITUDE_HEADER_NAME),
+        "longitude": _get_header(headers, LONGITUDE_HEADER_NAME),
+        "postalCode": _get_header(headers, POSTAL_CODE_HEADER_NAME),
+    }

vercel_headers_bundle-0.7.1/vercel/headers/_vendor/__init__.py

@@ -0,0 +1 @@
+"""Generated vendored dependencies for vercel-headers-bundle."""

vercel_headers_bundle-0.7.1/vercel/headers/version.py

@@ -0,0 +1 @@
+__version__ = "0.7.1"