vercel-internal-core-bundle 0.1.0__tar.gz

vercel_internal_core_bundle-0.1.0/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_internal_core_bundle-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: vercel-internal-core-bundle
+Version: 0.1.0
+Summary: Shared internal runtime for Vercel Python packages
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: vercel-internal-shared-vendored-deps>=0.1.0
+Description-Content-Type: text/markdown
+
+# vercel-internal-core-bundle
+
+This is a version of `vercel-internal-core` with third-party dependencies bundled. For normal use, install the unbundled `vercel-internal-core` package instead: https://pypi.org/project/vercel-internal-core/
+
+# Internal Core
+
+`vercel._internal.core` provides the shared runtime used by Vercel Python service
+packages. It is installed as their dependency and is not intended for direct
+installation or direct end-user imports.
+
+The distribution contributes service-neutral namespace portions. Import the
+public session context from `vercel.api` and shared exceptions from
+`vercel.errors`:
+
+```python
+from vercel.api import session
+from vercel.errors import VercelError
+```

vercel_internal_core_bundle-0.1.0/README.md

@@ -0,0 +1,18 @@
+# vercel-internal-core-bundle
+
+This is a version of `vercel-internal-core` with third-party dependencies bundled. For normal use, install the unbundled `vercel-internal-core` package instead: https://pypi.org/project/vercel-internal-core/
+
+# Internal Core
+
+`vercel._internal.core` provides the shared runtime used by Vercel Python service
+packages. It is installed as their dependency and is not intended for direct
+installation or direct end-user imports.
+
+The distribution contributes service-neutral namespace portions. Import the
+public session context from `vercel.api` and shared exceptions from
+`vercel.errors`:
+
+```python
+from vercel.api import session
+from vercel.errors import VercelError
+```

vercel_internal_core_bundle-0.1.0/_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_internal_core_bundle-0.1.0/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_internal_core_bundle-0.1.0/pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["hatchling>=1.27.0,<2"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vercel-internal-core-bundle"
+dynamic = ["version", "dependencies"]
+description = "Shared internal runtime for Vercel Python packages"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = [
+    "LICENSE",
+    "LICENSE.*",
+    "vercel/_internal/core/_vendor/LICEN[CS]E*",
+]
+
+[tool.hatch.metadata.hooks.custom]
+path = "hatch_build.py"
+
+[tool.vercel.release.dependencies]
+dependencies = [
+    "vercel-internal-shared-vendored-deps>=0.1.0",
+]
+
+[tool.hatch.version]
+path = "vercel/_internal/core/version.py"
+
+[tool.hatch.build.targets.sdist]
+force-include = { "_vercel_hatch_build.py" = "/_vercel_hatch_build.py" }
+include = [
+    "/vercel/api/**",
+    "/vercel/errors/**",
+    "/vercel/_internal/core/**",
+    "/README.md",
+    "/pyproject.toml",
+    "/hatch_build.py",
+    "/LICENSE",
+    "/vercel/_internal/core/_vendor/LICEN[CS]E*",
+]
+exclude = [
+    "/**/__pycache__",
+]
+
+[tool.hatch.build.targets.wheel]
+dev-mode-dirs = ["."]
+only-include = [
+    "/vercel/api",
+    "/vercel/errors",
+    "/vercel/_internal/core",
+]
+exclude = [
+    "/**/__pycache__",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+addopts = "--no-header --capture=tee-sys"
+asyncio_mode = "auto"
+
+[tool.poe]
+include = "../../scripts/poe/poe.toml"
+verbosity = -1
+
+[tool.mypy]
+cache_dir = "../../.mypy_cache/vercel-internal-core"
+explicit_package_bases = true
+packages = ["vercel._internal.core"]
+
+[tool.poe.tasks.typecheck]
+cmd = "$MYPY"
+
+[tool.vendoring]
+destination = "vercel/_internal/core/_vendor/"
+requirements = "vercel/_internal/core/_vendor/vendor.txt"
+namespace = "vercel._internal.core._vendor"
+protected-files = [
+    "__init__.py",
+    "vendor.txt",
+]
+
+[tool.vendoring.transformations]
+drop = [
+    "*.so",
+    "*/tests/",
+    "*/__pycache__/",
+]

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/__init__.py

@@ -0,0 +1 @@
+"""Shared internal runtime for Vercel-owned Python packages."""

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/_vendor/__init__.py

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

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/_vendor/vendor.txt

@@ -0,0 +1 @@
+

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/byte_stream.py

@@ -0,0 +1,258 @@
+"""Adapt byte sources for business logic shared by sync and async APIs.
+
+Shared code consumes the async-shaped ``ReadableByteStream`` and
+``StagingByteFile`` protocols. Callers select the runtime matching their public
+API, then use its factories instead of constructing the private adapters directly.
+The sync runtime never suspends, while the async runtime awaits or offloads I/O as
+appropriate.
+"""
+
+import inspect
+import io
+import sys
+import tempfile
+from collections.abc import AsyncIterator
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from typing import Protocol, TypeAlias, cast
+
+from vercel.internal._vendor import anyio
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from vercel.internal._vendor.typing_extensions import Buffer
+
+
+class SyncByteReader(Protocol):
+    """Caller-provided byte source with a blocking ``read`` method."""
+
+    def read(self, size: int = -1, /) -> bytes: ...
+
+
+class AsyncByteReader(Protocol):
+    """Caller-provided byte source with an asynchronous ``read`` method.
+
+    This is structurally identical to ``ReadableByteStream`` but describes an
+    input that has not yet been normalized by a byte-stream runtime.
+    """
+
+    async def read(self, size: int = -1, /) -> bytes: ...
+
+
+BytesLike: TypeAlias = bytes | bytearray | memoryview
+SyncByteSource: TypeAlias = BytesLike | SyncByteReader
+AsyncByteSource: TypeAlias = AsyncByteReader
+RawByteSource: TypeAlias = SyncByteSource | AsyncByteSource
+
+
+class ReadableByteStream(Protocol):
+    """Normalized readable stream consumed by shared internal workflows.
+
+    Its async shape hides whether a runtime performs the read inline, awaits an
+    async source, or moves a blocking read to a worker thread.
+    """
+
+    async def read(self, size: int = -1, /) -> bytes: ...
+
+
+class StagingByteFile(ReadableByteStream, Protocol):
+    """SDK-owned temporary byte file used by shared staging workflows.
+
+    The runtime's temporary-file context manager owns the lifetime of streams
+    implementing this protocol.
+    """
+
+    async def write(self, data: bytes, /) -> int: ...
+
+    async def readinto(self, buffer: Buffer, /) -> int:
+        """Read bytes into a writable buffer.
+
+        ``Buffer`` cannot express mutability, so read-only buffers are rejected
+        at runtime.
+        """
+        ...
+
+    async def flush(self) -> None: ...
+
+    async def tell(self) -> int: ...
+
+    async def seek(self, offset: int, whence: int = 0, /) -> int: ...
+
+    async def truncate(self, size: int | None = None, /) -> int: ...
+
+
+class StagingFileRuntime(Protocol):
+    """Runtime-specific temporary-file capability for shared business logic."""
+
+    def temporary_file(self) -> AbstractAsyncContextManager[StagingByteFile]: ...
+
+
+def _bytes_result(value: object) -> bytes:
+    if isinstance(value, bytes):
+        return value
+    raise TypeError(f"byte stream returned {type(value).__name__}, expected bytes")
+
+
+class _SyncReader:
+    """Expose a blocking reader through an async-shaped, non-suspending method."""
+
+    def __init__(self, source: SyncByteReader) -> None:
+        self._source = source
+
+    async def read(self, size: int = -1, /) -> bytes:
+        return _bytes_result(self._source.read(size))
+
+
+class _MemoryReader:
+    """Give an immutable bytes snapshot a stateful, non-suspending read cursor."""
+
+    def __init__(self, data: BytesLike) -> None:
+        self._data = memoryview(bytes(data))
+        self._offset = 0
+
+    async def read(self, size: int = -1, /) -> bytes:
+        remaining = self._data[self._offset :]
+        if size < 0:
+            self._offset = len(self._data)
+            return bytes(remaining)
+        chunk = bytes(remaining[:size])
+        self._offset += len(chunk)
+        return chunk
+
+
+class _AsyncReader:
+    """Normalize a genuinely asynchronous reader and validate its results."""
+
+    def __init__(self, source: AsyncByteReader) -> None:
+        self._source = source
+
+    async def read(self, size: int = -1, /) -> bytes:
+        return _bytes_result(await self._source.read(size))
+
+
+class _ThreadedSyncReader:
+    """Run a blocking reader on a worker thread for use by async workflows."""
+
+    def __init__(self, source: SyncByteReader) -> None:
+        self._source = source
+
+    async def read(self, size: int = -1, /) -> bytes:
+        return _bytes_result(await anyio.to_thread.run_sync(self._source.read, size))
+
+
+class _SyncTemporaryFile:
+    """Expose a blocking temporary file through non-suspending async methods."""
+
+    def __init__(self) -> None:
+        self._file = cast(io.BufferedRandom, tempfile.TemporaryFile("w+b"))
+
+    def _ensure_open(self) -> None:
+        if self._file.closed:
+            raise anyio.ClosedResourceError
+
+    async def read(self, size: int = -1, /) -> bytes:
+        self._ensure_open()
+        return self._file.read(size)
+
+    async def write(self, data: bytes, /) -> int:
+        self._ensure_open()
+        return self._file.write(data)
+
+    async def readinto(self, buffer: Buffer, /) -> int:
+        """Read bytes into a writable buffer.
+
+        ``Buffer`` cannot express mutability, so read-only buffers are rejected
+        at runtime.
+        """
+        self._ensure_open()
+        return self._file.readinto(buffer)
+
+    async def flush(self) -> None:
+        self._ensure_open()
+        self._file.flush()
+
+    async def tell(self) -> int:
+        self._ensure_open()
+        return self._file.tell()
+
+    async def seek(self, offset: int, whence: int = 0, /) -> int:
+        self._ensure_open()
+        return self._file.seek(offset, whence)
+
+    async def truncate(self, size: int | None = None, /) -> int:
+        self._ensure_open()
+        return self._file.truncate(size)
+
+    def close(self) -> None:
+        self._file.close()
+
+
+@asynccontextmanager
+async def _sync_temporary_file() -> AsyncIterator[StagingByteFile]:
+    file = _SyncTemporaryFile()
+    try:
+        yield file
+    finally:
+        file.close()
+
+
+class SyncByteStreamRuntime:
+    """Adapt blocking byte primitives for shared async-shaped workflows.
+
+    Every operation completes without suspending so sync entry points can drive
+    the shared coroutine with ``iter_coroutine`` and no event loop.
+    """
+
+    @staticmethod
+    def reader(source: SyncByteSource) -> ReadableByteStream:
+        if isinstance(source, (bytes, bytearray, memoryview)):
+            return _MemoryReader(source)
+        read = getattr(source, "read", None)
+        if not callable(read):
+            raise TypeError("byte source must provide a callable read method")
+        if inspect.iscoroutinefunction(read):
+            raise TypeError("sync byte stream runtime does not support async readers")
+        return _SyncReader(cast(SyncByteReader, source))
+
+    def temporary_file(self) -> AbstractAsyncContextManager[StagingByteFile]:
+        return _sync_temporary_file()
+
+
+class AsyncByteStreamRuntime:
+    """Adapt byte primitives for execution under AnyIO.
+
+    Async readers are awaited directly, while blocking readers run on a worker
+    thread so they do not block the event loop.
+    """
+
+    @staticmethod
+    def reader(source: RawByteSource) -> ReadableByteStream:
+        if isinstance(source, (bytes, bytearray, memoryview)):
+            return _MemoryReader(source)
+        read = getattr(source, "read", None)
+        if not callable(read):
+            raise TypeError("byte source must provide a callable read method")
+        if inspect.iscoroutinefunction(read):
+            return _AsyncReader(cast(AsyncByteReader, source))
+        return _ThreadedSyncReader(cast(SyncByteReader, source))
+
+    def temporary_file(self) -> AbstractAsyncContextManager[StagingByteFile]:
+        return cast(
+            AbstractAsyncContextManager[StagingByteFile],
+            anyio.TemporaryFile("w+b"),
+        )
+
+
+__all__ = [
+    "AsyncByteReader",
+    "AsyncByteSource",
+    "AsyncByteStreamRuntime",
+    "BytesLike",
+    "RawByteSource",
+    "ReadableByteStream",
+    "StagingByteFile",
+    "StagingFileRuntime",
+    "SyncByteReader",
+    "SyncByteSource",
+    "SyncByteStreamRuntime",
+]

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/errors.py

@@ -0,0 +1,17 @@
+"""Shared errors for Vercel Python services."""
+
+
+class VercelError(Exception):
+    """Base error for Vercel Python SDK failures."""
+
+
+class VercelSessionError(VercelError):
+    """Base error for SDK session failures."""
+
+
+class VercelSessionClosedError(VercelSessionError):
+    """Raised when code uses an SDK session after it has been closed."""
+
+
+class VercelServiceOptionsError(VercelSessionError):
+    """Raised when SDK session service options are invalid."""

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/http/__init__.py

@@ -0,0 +1,46 @@
+"""Shared HTTP infrastructure for Vercel API clients."""
+
+from vercel._internal.core.http.config import DEFAULT_API_BASE_URL, DEFAULT_TIMEOUT
+from vercel._internal.core.http.httpx import (
+    create_base_async_client,
+    create_base_client,
+)
+from vercel._internal.core.http.retry import (
+    RetryPolicy,
+    SleepFn,
+)
+from vercel._internal.core.http.transport import (
+    AsyncTransport,
+    BaseTransport,
+    BytesBody,
+    JSONBody,
+    RawBody,
+    ReadResponsePolicy,
+    RequestBody,
+    StreamingRequest,
+    StreamingResponse,
+    SyncTransport,
+    TransportOptions,
+    extract_structured_error,
+)
+
+__all__ = [
+    "DEFAULT_API_BASE_URL",
+    "DEFAULT_TIMEOUT",
+    "BaseTransport",
+    "SyncTransport",
+    "AsyncTransport",
+    "TransportOptions",
+    "JSONBody",
+    "BytesBody",
+    "RawBody",
+    "ReadResponsePolicy",
+    "RequestBody",
+    "StreamingRequest",
+    "StreamingResponse",
+    "RetryPolicy",
+    "SleepFn",
+    "create_base_client",
+    "create_base_async_client",
+    "extract_structured_error",
+]

vercel_internal_core_bundle-0.1.0/vercel/_internal/core/http/config.py

@@ -0,0 +1,9 @@
+"""HTTP configuration constants shared by Vercel API clients."""
+
+from datetime import timedelta
+
+DEFAULT_API_BASE_URL = "https://api.vercel.com"
+DEFAULT_TIMEOUT = timedelta(seconds=60)
+
+
+__all__ = ["DEFAULT_API_BASE_URL", "DEFAULT_TIMEOUT"]