crosswind-workers 0.1.0__tar.gz

crosswind_workers-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.3
+Name: crosswind-workers
+Version: 0.1.0
+Summary: Typed, Pythonic drop-in replacement for Cloudflare's workers-runtime-sdk
+Author: Viswa Marepalli
+Author-email: Viswa Marepalli <reachvishm@gmail.com>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+

crosswind_workers-0.1.0/purelib/crosswind_workers_patches.pth

@@ -0,0 +1 @@
+import _crosswind_patches

crosswind_workers-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "crosswind-workers"
+version = "0.1.0"
+description = "Typed, Pythonic drop-in replacement for Cloudflare's workers-runtime-sdk"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[[project.authors]]
+name = "Viswa Marepalli"
+email = "reachvishm@gmail.com"
+
+[build-system]
+requires = ["uv_build>=0.12.19,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = [
+    "workers",
+    "_crosswind_patches",
+    "asgi",
+]
+
+[tool.uv.build-backend.data]
+purelib = "purelib"
+
+[tool.ruff.lint]
+extend-select = [
+    "E",
+    "W",
+    "N",
+    "I",
+    "TID251",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"stubs/**" = ["N"]
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api."typing.cast"]
+msg = "Narrow with isinstance or fix the type instead of casting."
+
+[tool.pytest.ini_options]
+addopts = [
+    "-m",
+    "not e2e",
+]
+markers = ["e2e: runs wynd dev from ../wynd; needs uv, Node.js and the network"]
+
+[tool.ty.environment]
+extra-paths = ["stubs"]
+
+[tool.ty.src]
+exclude = [
+    "tests/e2e/entropy",
+    "tests/e2e/asgi",
+    "tests/e2e/wsgi",
+]
+
+[dependency-groups]
+dev = [
+    "pyodide-py>=0.27.8",
+    "pytest>=9.1.1",
+]

crosswind_workers-0.1.0/pyproject.toml.orig

@@ -0,0 +1,49 @@
+[project]
+name = "crosswind-workers"
+version = "0.1.0"
+description = "Typed, Pythonic drop-in replacement for Cloudflare's workers-runtime-sdk"
+readme = "README.md"
+authors = [
+    { name = "Viswa Marepalli", email = "reachvishm@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[build-system]
+requires = ["uv_build>=0.12.19,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+# The distribution is crosswind-workers, but workerd imports the SDK as `workers`.
+module-name = ["workers", "_crosswind_patches", "asgi"]
+# Lands in site-packages itself, where Python runs .pth files at startup. The
+# hook's name sorts after an editable install's crosswind_workers.pth, which
+# must put src/ on the path first.
+data = { purelib = "purelib" }
+
+[tool.ruff.lint]
+extend-select = ["E", "W", "N", "I", "TID251"]
+# Stub names mirror workerd's JS helpers.
+per-file-ignores."stubs/**" = ["N"]
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"typing.cast".msg = "Narrow with isinstance or fix the type instead of casting."
+
+[tool.pytest.ini_options]
+addopts = ["-m", "not e2e"]
+markers = ["e2e: runs wynd dev from ../wynd; needs uv, Node.js and the network"]
+
+[tool.ty.environment]
+# Stubs for modules only workerd provides. They stay out of the wheel.
+extra-paths = ["stubs"]
+
+[tool.ty.src]
+# These fixtures' packages exist only in the Pyodide installs their e2e tests
+# make.
+exclude = ["tests/e2e/entropy", "tests/e2e/asgi", "tests/e2e/wsgi"]
+
+[dependency-groups]
+dev = [
+    "pyodide-py>=0.27.8",
+    "pytest>=9.1.1",
+]

crosswind_workers-0.1.0/src/_crosswind_patches/__init__.py

@@ -0,0 +1,13 @@
+"""Package patches that workerd leaves to the SDK.
+
+With `python_process_pth_files` on, workerd stops bundling its per-package
+entropy patches and runs `.pth` files instead, and `crosswind_workers_patches.pth`
+imports this package at startup. The patches are ported from the stock SDK at
+cb2db3c. They hook imports through workerd's `_cloudflare` package, so a patch
+applies only when its package is imported, and nothing happens outside workerd.
+"""
+
+import importlib.util
+
+if importlib.util.find_spec("_cloudflare") is not None:
+    from . import entropy, runtime  # noqa: F401

crosswind_workers-0.1.0/src/_crosswind_patches/entropy.py

@@ -0,0 +1,259 @@
+"""
+Top level entropy patches for packages
+"""
+
+import sys
+from collections.abc import Sequence
+from contextlib import contextmanager
+from importlib.abc import MetaPathFinder
+from importlib.machinery import ModuleSpec
+from importlib.metadata import PackageNotFoundError, version
+from types import ModuleType
+
+from _cloudflare.allow_entropy import (
+    allow_bad_entropy_calls,
+)
+from _cloudflare.import_patch_manager import (
+    block_calls,
+    register_after_snapshot,
+    register_before_first_request,
+    register_create_patch,
+    register_exec_patch,
+)
+
+
+@contextmanager
+def allow_bad_entropy_calls_for_version(
+    package_name: str,
+    num_calls: int,
+    min_version: tuple[int, ...],
+    max_version: tuple[int, ...] | None = None,
+):
+    try:
+        package_version = tuple(map(int, version(package_name).split(".")))
+    except PackageNotFoundError:
+        yield
+        return
+
+    if package_version < min_version or (
+        max_version is not None and package_version > max_version
+    ):
+        yield
+        return
+
+    with allow_bad_entropy_calls(num_calls):
+        yield
+
+
+class STATE:
+    imported_rust_package = False
+    numpy_random = None
+
+
+@register_create_patch("tiktoken._tiktoken")
+@register_exec_patch("cryptography.exceptions")
+@register_exec_patch("jiter")
+@register_exec_patch("rpds")
+@register_exec_patch("uuid_utils._uuid_utils")
+@contextmanager
+def rust_package_context(module):
+    """Rust packages need one entropy call if they create a rust hash map at
+    init time.
+
+    For reasons I don't entirely understand, in Pyodide 0.28 only the first Rust
+    package to be imported makes the get_entropy call. See gen_rust_import_tests()
+    which tests that importing four rust packages in different permutations works
+    correctly.
+    """
+    if STATE.imported_rust_package:
+        yield
+        return
+
+    STATE.imported_rust_package = True
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("numpy.random")
+@contextmanager
+def numpy_random_context(numpy_random):
+    """numpy.random doesn't call getentropy() itself, but we want to block calls
+    that might use the bad seed.
+
+    TODO: Maybe there are more calls we can whitelist?
+    TODO: Is it not enough to just block numpy.random.mtrand calls?
+    """
+    yield
+    # Calling default_rng() with a given seed is fine, calling it without a seed
+    # will call getentropy() and fail.
+    block_calls(numpy_random, allowlist=("default_rng", "RandomState"))
+
+
+@register_after_snapshot("numpy.random")
+def numpy_random_after_snapshot(numpy_random):
+    r1 = numpy_random.random()
+    numpy_random.set_state(STATE.numpy_random)
+    r2 = numpy_random.random()
+    if r1 != r2:
+        raise RuntimeError("random seed in bad state")
+
+
+@register_before_first_request("numpy.random")
+def numpy_random_before_first_request(numpy_random):
+    numpy_random.seed()
+
+
+@register_exec_patch("numpy.random.mtrand")
+@contextmanager
+def numpy_random_mtrand_context(module):
+    # numpy.random.mtrand calls secrets.randbits at top level to seed itself.
+    # This will fail if we don't let it through.
+    with allow_bad_entropy_calls(1):
+        yield
+    # Block calls until we get a chance to replace the bad random seed.
+    STATE.numpy_random = module.get_state()
+    block_calls(module, allowlist=("RandomState",))
+
+
+@register_exec_patch("pydantic_core")
+@contextmanager
+def pydantic_core_context(module):
+    try:
+        # Initial import needs one entropy call to initialize
+        # std::collections::HashMap hash seed
+        with allow_bad_entropy_calls(1):
+            yield
+    finally:
+        # Build a tiny validator instead so any lazy hash-map seeds are initialized
+        # before the snapshot is captured.
+        with allow_bad_entropy_calls(1):
+            module.SchemaValidator({"type": "any"})
+
+
+@register_exec_patch("aiohttp.http_websocket")
+@contextmanager
+def aiohttp_http_websocket_context(module):
+    import random
+
+    original = random.Random
+    # The module stands in for the Random() aiohttp builds at import time.
+    # setattr, because the stand-in is not a type, so ty rejects an assignment.
+    setattr(random, "Random", lambda: random)  # noqa: B010
+    try:
+        yield
+    finally:
+        random.Random = original
+
+
+class NoSslFinder(MetaPathFinder):
+    def find_spec(
+        self,
+        fullname: str,
+        path: Sequence[str] | None,
+        target: ModuleType | None = None,
+    ) -> ModuleSpec | None:
+        if fullname == "ssl":
+            raise ModuleNotFoundError(
+                f"No module named {fullname!r}", name=fullname
+            ) from None
+        return None
+
+
+@contextmanager
+def no_ssl():
+    """
+    Various packages will call ssl.create_default_context() at top level which uses
+    entropy if they can import ssl. By temporarily making importing ssl raise an
+    import error, we exercise the workaround code and so avoid the entropy calls.
+    After, we put the ssl module back to the normal value.
+    """
+    try:
+        f = NoSslFinder()
+        ssl = sys.modules.pop("ssl", None)
+        sys.meta_path.insert(0, f)
+        yield
+    finally:
+        sys.meta_path.remove(f)
+        if ssl:
+            sys.modules["ssl"] = ssl
+
+
+@register_exec_patch("aiohttp.connector")
+@contextmanager
+def aiohttp_connector_context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("requests.adapters")
+@contextmanager
+def requests_adapters_context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("urllib3.util.ssl_")
+@contextmanager
+def urllib3_util_ssl__context(module):
+    with no_ssl():
+        yield
+
+
+@register_exec_patch("langsmith._internal._constants")
+@contextmanager
+def langsmith__internal__constants_context(module):
+    # Langsmith uses a UUID to communicate with a background thread. This obviously
+    # won't work so we might as well allow it to make a UUID.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("langchain_openai.chat_models.base")
+@contextmanager
+def langchain_openai_chat_models_base_context(module):
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("opentelemetry.context")
+@contextmanager
+def opentelemetry_context(module):
+    # OpenTelemetry creates three UUID-backed keys.
+    with allow_bad_entropy_calls_for_version("opentelemetry-api", 3, (1, 40, 0)):
+        yield
+
+
+@register_exec_patch("opentelemetry.trace.propagation")
+@contextmanager
+def opentelemetry_trace_propagation_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("opentelemetry.baggage")
+@contextmanager
+def opentelemetry_baggage_context(module):
+    # OpenTelemetry creates a UUID-backed key.
+    with allow_bad_entropy_calls(1):
+        yield
+
+
+@register_exec_patch("fastapi.telemetry")
+@contextmanager
+def fastapi_telemetry_context(module):
+    # fastapi 0.142.0 added opentelemetry support
+    # which creates a UUID-backed key.
+    with allow_bad_entropy_calls_for_version("fastapi", 1, (0, 142, 0)):
+        yield
+
+
+@register_exec_patch("litestar.openapi.controller")
+@register_exec_patch("litestar.constants")
+@contextmanager
+def litestar_context(module):
+    # Uses os.urandom() to generate a OPENAPI_JSON_HANDLER_NAME
+    # https://github.com/litestar-org/litestar/blob/e3b6a1d103a9160a575dce01ae34839e6e9bf990/litestar/constants.py#L19
+    # https://github.com/litestar-org/litestar/blob/v2.24.0/litestar/openapi/controller.py#L27
+    with allow_bad_entropy_calls(1):
+        yield

crosswind_workers-0.1.0/src/_crosswind_patches/runtime.py

@@ -0,0 +1,45 @@
+"""
+Top level runtime compatibility patches for packages.
+
+These patches adapt packages that assume capabilities the workers runtime does
+not provide. Unlike the entropy patches, they are not related to snapshotting.
+"""
+
+from contextlib import contextmanager
+
+from _cloudflare.import_patch_manager import (
+    register_exec_patch,
+)
+
+
+@register_exec_patch("anyio.to_thread")
+@contextmanager
+def anyio_to_thread_context(module):
+    """`anyio.to_thread.run_sync` dispatches blocking work to an OS thread, but the
+    workers runtime is single threaded, so starting a thread raises
+    `RuntimeError: can't start new thread`. Run the callable inline instead.
+
+    This function is the only caller of `run_sync_in_worker_thread`, which makes it
+    the single chokepoint for every blocking call anyio makes on behalf of a
+    framework. In starlette/fastapi that covers sync route handlers, sync
+    dependencies, `StaticFiles`, `FileResponse`, `UploadFile`, `BackgroundTask` and
+    `GZipMiddleware`, as well as `anyio.Path` and `anyio.open_file`.
+
+    Patching the module attribute is enough because every caller looks it up at
+    call time (e.g. `starlette.concurrency` and `anyio._core._fileio` both import
+    the module rather than the function).
+
+    We patch `anyio.to_thread` rather than the backend's
+    `run_sync_in_worker_thread` because `anyio._backends._asyncio` is imported
+    lazily by `get_async_backend()` during a request, by which point the import
+    patch manager is no longer installed.
+    """
+    yield
+
+    async def run_sync(func, *args, **kwargs):
+        # Callers pass the function's own arguments positionally and anyio's
+        # options (`limiter`, `abandon_on_cancel`, `cancellable`) as keywords.
+        # None of the options mean anything without threads, so drop them.
+        return func(*args)
+
+    module.run_sync = run_sync

crosswind_workers-0.1.0/src/asgi/__init__.py

@@ -0,0 +1,7 @@
+"""`import asgi`, the stock SDK's older import path for `workers.asgi`."""
+
+import sys
+
+from workers import asgi as _asgi
+
+sys.modules[__name__] = _asgi

crosswind_workers-0.1.0/src/workers/__init__.py

@@ -0,0 +1,88 @@
+from importlib.metadata import PackageNotFoundError as _PackageNotFoundError
+from importlib.metadata import distribution as _distribution
+from typing import Any as _Any
+
+# Both SDKs install the `workers` package, so with both installed one
+# overwrote the other's files. This check survives only if crosswind's did.
+try:
+    _distribution("workers-runtime-sdk")
+except _PackageNotFoundError:
+    pass
+else:
+    raise ImportError(
+        "workers-runtime-sdk is installed beside crosswind-workers, and both "
+        "provide the `workers` package, so one has overwritten the other. "
+        "Remove workers-runtime-sdk. pywrangler always adds it, so build "
+        "crosswind-workers projects with Wynd, which installs only the SDK the "
+        "project declares."
+    )
+
+from .bindings import _EnvWrapper
+from .blob import Blob, BlobEnding, BlobValue, File
+from .context import js_promise as _js_promise
+from .entrypoints import DurableObject, WorkerEntrypoint, WorkflowEntrypoint, handler
+from .fetch import fetch
+from .formdata import FormData, FormDataValue
+from .request import Request
+from .response import FetchResponse, Response
+from .rpc import python_from_rpc, python_to_rpc
+from .types import (
+    Body,
+    Context,
+    FetchKwargs,
+    Headers,
+    JSBody,
+    RequestInitCfProperties,
+)
+from .utils import import_from_javascript, patch_env
+
+__all__ = [
+    "Blob",
+    "BlobEnding",
+    "BlobValue",
+    "Body",
+    "Context",
+    "DurableObject",
+    "FetchKwargs",
+    "FetchResponse",
+    "File",
+    "FormData",
+    "FormDataValue",
+    "Headers",
+    "JSBody",
+    "Request",
+    "RequestInitCfProperties",
+    "Response",
+    "WorkerEntrypoint",
+    "WorkflowEntrypoint",
+    "env",
+    "fetch",
+    "handler",
+    "import_from_javascript",
+    "patch_env",
+    "python_from_rpc",
+    "python_to_rpc",
+    "waitUntil",
+    "wait_until",
+]
+
+
+def _wait_until(awaitable: _Any) -> None:
+    """Hand `awaitable` to cloudflare:workers' waitUntil, as the stock SDK does.
+
+    Under wrangler dev that waitUntil doesn't keep a Python Worker alive past
+    the response, with this or with the stock SDK. `ctx.wait_until` does.
+    """
+    import_from_javascript("cloudflare:workers").waitUntil(_js_promise(awaitable))
+
+
+def __getattr__(name: str) -> _Any:
+    # Served on access, as in the stock SDK: importing workers holds no JS
+    # object, which snapshot creation requires.
+    if name == "env":
+        return _EnvWrapper(import_from_javascript("cloudflare:workers").env)
+    if name in ("wait_until", "waitUntil"):
+        # workerd's own waitUntil drops a coroutine handed to it, so this
+        # passes a promise that follows it, as ctx.wait_until does.
+        return _wait_until
+    raise AttributeError(f"module 'workers' has no attribute {name!r}")

crosswind_workers-0.1.0/src/workers/_adapter.py

@@ -0,0 +1,24 @@
+"""Request and response handling shared by the ASGI and WSGI adapters."""
+
+from collections.abc import Iterable
+from typing import Any
+
+from .request import Request
+
+# 101/103/204/205/304 must not carry a body per the Fetch spec.
+# https://fetch.spec.whatwg.org/#null-body-status
+NULL_BODY_STATUSES = frozenset({101, 103, 204, 205, 304})
+
+
+def request_headers(req: Any) -> Iterable[tuple[str, str]]:
+    """The header pairs of a `workers.Request` or a `js.Request`."""
+    return req.headers.items() if isinstance(req, Request) else req.headers
+
+
+def body_encoding(headers: Iterable[tuple[str, str]]) -> dict[str, str]:
+    """The `Response` init entry for a body the app has already encoded."""
+    if any(name.lower() == "content-encoding" for name, _ in headers):
+        # The app encoded the body already, as GZipMiddleware does. Without
+        # this the runtime encodes it a second time.
+        return {"encodeBody": "manual"}
+    return {}

crosswind_workers-0.1.0/src/workers/_body.py

@@ -0,0 +1,34 @@
+"""What Request and Response share on top of their JS object."""
+
+from typing import TYPE_CHECKING, Any
+
+from ._js import headers_to_message, python_errors
+from .blob import Blob
+from .formdata import FormData
+
+
+class BodyMixin:
+    """Headers and the body readers pyodide's FetchResponse lacks.
+
+    Built on `js_object`, a JS Request or Response, and `_raise_if_failed`.
+    """
+
+    if TYPE_CHECKING:
+
+        @property
+        def js_object(self) -> Any: ...
+
+        def _raise_if_failed(self) -> None: ...
+
+    @property
+    def headers(self) -> Any:
+        return headers_to_message(self.js_object.headers)
+
+    async def form_data(self) -> FormData:
+        self._raise_if_failed()
+        with python_errors():
+            return FormData(await self.js_object.formData())
+
+    async def blob(self) -> Blob:
+        self._raise_if_failed()
+        return Blob(await self.js_object.blob())