hayate-fetch 0.1.0__tar.gz

hayate_fetch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yusuke Hayashi
+
+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.

hayate_fetch-0.1.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: hayate-fetch
+Version: 0.1.0
+Summary: Client-side WHATWG fetch for hayate: the same Request/Response types, pointed outward
+Keywords: hayate,fetch,http-client,workers
+Author: Yusuke Hayashi
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: hayate>=0.8.0
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/hayatepy/hayate-fetch
+Description-Content-Type: text/markdown
+
+# hayate-fetch
+
+Client-side WHATWG fetch for [hayate](https://github.com/hayatepy/hayate):
+the same Request/Response types your server handles, pointed outward.
+
+> **Status: design phase.** Implementation is demand-driven by hayate-auth
+> v0.2 (OAuth token exchange). The design memo (Japanese, per project
+> convention) lives in [DESIGN.md](DESIGN.md).
+
+## License
+
+MIT

hayate_fetch-0.1.0/README.md

@@ -0,0 +1,12 @@
+# hayate-fetch
+
+Client-side WHATWG fetch for [hayate](https://github.com/hayatepy/hayate):
+the same Request/Response types your server handles, pointed outward.
+
+> **Status: design phase.** Implementation is demand-driven by hayate-auth
+> v0.2 (OAuth token exchange). The design memo (Japanese, per project
+> convention) lives in [DESIGN.md](DESIGN.md).
+
+## License
+
+MIT

hayate_fetch-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["uv_build>=0.9,<1"]
+build-backend = "uv_build"
+
+[project]
+name = "hayate-fetch"
+version = "0.1.0"
+description = "Client-side WHATWG fetch for hayate: the same Request/Response types, pointed outward"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Yusuke Hayashi" }]
+keywords = ["hayate", "fetch", "http-client", "workers"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+dependencies = ["hayate>=0.8.0"]
+
+[project.urls]
+Repository = "https://github.com/hayatepy/hayate-fetch"
+
+[dependency-groups]
+dev = [
+  "pytest>=8.3",
+  "pytest-asyncio>=0.25",
+  "ruff>=0.9",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]

hayate_fetch-0.1.0/src/hayate_fetch/__init__.py

@@ -0,0 +1,49 @@
+"""hayate-fetch: client-side WHATWG fetch on hayate's Request/Response."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from hayate import Request, Response
+
+from .backends import FetchBackend, UrllibBackend, WorkersBackend, default_backend
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "FetchBackend",
+    "UrllibBackend",
+    "WorkersBackend",
+    "__version__",
+    "default_backend",
+    "fetch",
+]
+
+_default: FetchBackend | None = None
+
+
+async def fetch(
+    input: str | Request,
+    *,
+    method: str = "GET",
+    headers: Any = None,
+    body: Any = None,
+    backend: FetchBackend | None = None,
+) -> Response:
+    """WHATWG-shaped fetch: pass a URL (plus init) or a prebuilt Request.
+
+    HTTP error statuses resolve to a Response; network failures raise
+    OSError. The documented subset excludes browser-only init fields
+    (mode / credentials / cache — DESIGN §2).
+    """
+    request = (
+        input
+        if isinstance(input, Request)
+        else Request(input, method=method, headers=headers, body=body)
+    )
+    global _default
+    if backend is None:
+        if _default is None:
+            _default = default_backend()
+        backend = _default
+    return await backend.send(request)

hayate_fetch-0.1.0/src/hayate_fetch/backends.py

@@ -0,0 +1,96 @@
+"""The two bundled FetchBackends (DESIGN §3).
+
+CPython: stdlib urllib pushed off-loop. Workers: passthrough to the JS
+global fetch (a subrequest — the platform's one true client). Both consume
+and produce hayate's WHATWG Request/Response, so callers never see the seam.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import urllib.error
+import urllib.request
+from typing import Any, Protocol
+
+from hayate import Headers, Request, Response
+
+
+class FetchBackend(Protocol):
+    async def send(self, request: Request) -> Response: ...
+
+
+class UrllibBackend:
+    """stdlib-only backend: ``urllib.request`` + ``asyncio.to_thread``.
+
+    Fetch semantics: HTTP error statuses come back as Responses, not
+    exceptions; only network/protocol failures raise (OSError). Responses
+    are buffered (DESIGN §3, the v0.1 contract).
+    """
+
+    def __init__(self, *, timeout: float = 30.0, redirect: str = "follow") -> None:
+        if redirect not in ("follow", "manual"):
+            raise ValueError("redirect must be 'follow' or 'manual'")
+        self.timeout = timeout
+        self.redirect = redirect
+
+    async def send(self, request: Request) -> Response:
+        body = await request.bytes() if request.method not in ("GET", "HEAD") else None
+        headers = list(request.headers)
+        url = request.url.href
+        method = request.method
+
+        def run() -> tuple[int, list[tuple[str, str]], bytes]:
+            raw = urllib.request.Request(url, data=body or None, method=method)
+            for name, value in headers:
+                raw.add_header(name, value)
+            opener = self._opener()
+            try:
+                with opener.open(raw, timeout=self.timeout) as res:
+                    return res.status, list(res.headers.items()), res.read()
+            except urllib.error.HTTPError as error:
+                # An HTTP response, just not a 2xx: still a Response.
+                return error.code, list(error.headers.items()), error.read()
+
+        status, header_items, data = await asyncio.to_thread(run)
+        return Response(data, status=status, headers=Headers(header_items))
+
+    def _opener(self) -> urllib.request.OpenerDirector:
+        if self.redirect == "manual":
+            return urllib.request.build_opener(_NoRedirect)
+        return urllib.request.build_opener()
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+
+class WorkersBackend:
+    """Cloudflare Workers backend: the JS global ``fetch`` (a subrequest)."""
+
+    async def send(self, request: Request) -> Response:
+        import js
+        from pyodide.ffi import to_js
+
+        options: dict[str, Any] = {
+            "method": request.method,
+            "headers": list(request.headers),
+        }
+        if request.method not in ("GET", "HEAD"):
+            body = await request.bytes()
+            if body:
+                options["body"] = to_js(body)
+        js_response = await js.fetch(
+            request.url.href, to_js(options, dict_converter=js.Object.fromEntries)
+        )
+        buffer = await js_response.arrayBuffer()
+        data = bytes(js.Uint8Array.new(buffer).to_py())
+        headers = Headers([(k, v) for k, v in js_response.headers.entries()])
+        return Response(data, status=int(js_response.status), headers=headers)
+
+
+def default_backend() -> FetchBackend:
+    if sys.platform == "emscripten":
+        return WorkersBackend()
+    return UrllibBackend()