httpx2-jsfetch-emscripten-forge 0.1.0__tar.gz

httpx2_jsfetch_emscripten_forge-0.1.0/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright © 2026 to present Pydantic Services Inc. and individual contributors.
+Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

httpx2_jsfetch_emscripten_forge-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.5
+Name: httpx2-jsfetch-emscripten-forge
+Version: 0.1.0
+Summary: httpx2 transports for emscripten-forge.
+Project-URL: Source, https://github.com/davidbrochart/httpx2-jsfetch-emscripten-forge
+Project-URL: Issues, https://github.com/davidbrochart/httpx2-jsfetch-emscripten-forge/issues
+Author-email: Hood Chatham <roberthoodchatham@gmail.com>, David Brochart <david.brochart@gmail.com>
+License: Copyright © 2026 to present Pydantic Services Inc. and individual contributors.
+        Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+        
+        * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+[httpx2](https://github.com/pydantic/httpx2) transports for [emscripten-forge](https://github.com/emscripten-forge/recipes).
+
+Originally from [httpx2-jsfetch](https://github.com/hoodmane/httpx2-jsfetch).

httpx2_jsfetch_emscripten_forge-0.1.0/README.md

@@ -0,0 +1,3 @@
+[httpx2](https://github.com/pydantic/httpx2) transports for [emscripten-forge](https://github.com/emscripten-forge/recipes).
+
+Originally from [httpx2-jsfetch](https://github.com/hoodmane/httpx2-jsfetch).

httpx2_jsfetch_emscripten_forge-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "httpx2-jsfetch-emscripten-forge"
+description = "httpx2 transports for emscripten-forge."
+readme = "README.md"
+version = "0.1.0"
+authors = [
+  { name = "Hood Chatham", email = "roberthoodchatham@gmail.com" },
+  { name = "David Brochart", email = "david.brochart@gmail.com" },
+]
+license = {file = "LICENSE.md"}
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Web Environment",
+  "Framework :: AsyncIO",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: BSD License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Internet :: WWW/HTTP",
+  "Typing :: Typed",
+]
+requires-python = ">=3.13"
+
+[project.urls]
+Source = "https://github.com/davidbrochart/httpx2-jsfetch-emscripten-forge"
+Issues = "https://github.com/davidbrochart/httpx2-jsfetch-emscripten-forge/issues"
+
+[tool.hatch.build.targets.wheel]
+ignore-vcs = true
+packages = ["src/httpx2_jsfetch"]

httpx2_jsfetch_emscripten_forge-0.1.0/src/httpx2_jsfetch/__init__.py

@@ -0,0 +1,375 @@
+from __future__ import annotations
+
+import email.parser
+import ssl
+import warnings
+from collections.abc import AsyncIterator, Awaitable, Iterable, Iterator
+from contextlib import contextmanager
+from types import TracebackType
+from typing import (
+    Any,
+    TypeVar,
+)
+
+from httpx2._config import DEFAULT_LIMITS, Limits
+from httpx2._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ReadError,
+    ReadTimeout,
+    RequestError,
+)
+from httpx2._models import Request, Response
+from httpx2._transports.base import AsyncBaseTransport, BaseTransport
+from httpx2._types import AsyncByteStream, CertTypes, ProxyTypes, SyncByteStream
+from pyjs import JsException, JsValue, js, to_js  # type: ignore[import-not-found]
+from typing_extensions import Self
+
+T = TypeVar("T", bound="JavascriptFetchTransport")
+A = TypeVar("A", bound="AsyncJavascriptFetchTransport")
+
+SOCKET_OPTION = (
+    tuple[int, int, int]
+    | tuple[int, int, bytes | bytearray]
+    | tuple[int, int, None, int]
+)
+
+__all__ = ["AsyncJavascriptFetchTransport", "JavascriptFetchTransport"]
+
+"""
+There are some headers that trigger unintended CORS preflight requests.
+See also https://github.com/koenvo/pyodide-http/issues/22
+"""
+HEADERS_TO_IGNORE = ("user-agent",)
+
+
+# Default values of ignored options.
+# If a different value is passed for any of these is passed we'll warn.
+# trust_env and http1 are not listed here because they don't conflict with the
+# JS-fetch behaviour.
+_IGNORED_OPTION_DEFAULTS: dict[str, Any] = {
+    "verify": True,
+    "cert": None,
+    "http2": False,
+    "limits": DEFAULT_LIMITS,
+    "proxy": None,
+    "uds": None,
+    "local_address": None,
+    "retries": 0,
+    "socket_options": None,
+}
+
+
+def _warn_ignored_options(**kwargs: Any) -> None:
+    """Emit a UserWarning naming each option that is ignored on Emscripten."""
+    ignored = [
+        name
+        for name, value in kwargs.items()
+        if name in _IGNORED_OPTION_DEFAULTS and value != _IGNORED_OPTION_DEFAULTS[name]
+    ]
+    if not ignored:
+        return
+    message = (
+        "The following transport option(s) are not supported on Emscripten "
+        f"and will be ignored: {', '.join(ignored)}. "
+        "Networking is handled by the JavaScript runtime, so connection "
+        "pooling, proxies, certificate handling, and low-level socket "
+        "configuration cannot be controlled by httpx2."
+    )
+    warnings.warn(message, stacklevel=3)
+
+
+@contextmanager
+def _timeout(
+    timeout: float,
+    abort_controller_js: JsValue,
+    TimeoutExceptionType: type[RequestError],
+    ErrorExceptionType: type[RequestError],
+) -> Iterator[None]:
+    timer_id = None
+    if timeout > 0:
+        # It looks odd that we have to call bind() here since the JsValue will
+        # automatically remember the receiver. But when we pass it back to
+        # JavaScript, we unwrap it and forget the receiver.
+        abort = abort_controller_js.abort.bind(abort_controller_js)
+        timer_id = js.setTimeout(abort, int(timeout * 1000))
+    try:
+        yield
+    except JsException as err:
+        if err.name == "AbortError":
+            timer_id = None
+            raise TimeoutExceptionType(message="Request timed out") from err
+        else:
+            raise ErrorExceptionType(message=err.message) from err
+    finally:
+        if timer_id is not None:
+            js.clearTimeout(timer_id)
+
+
+async def _run_async_with_timeout(
+    promise: Awaitable[JsValue],
+    timeout: float,
+    abort_controller_js: JsValue,
+    TimeoutExceptionType: type[RequestError],
+    ErrorExceptionType: type[RequestError],
+) -> JsValue:
+    """await a javascript promise asynchronously with a timeout set via the
+       AbortController
+
+    Args:
+        promise (Awaitable): Javascript promise to await
+        timeout (float): Timeout in seconds
+        abort_controller_js (Any): A javascript AbortController object, used on timeout
+        TimeoutExceptionType (type[Exception]): An exception type to raise on timeout
+        ErrorExceptionType (type[Exception]): An exception type to raise on error
+
+    Raises:
+        TimeoutException: If the request times out
+        NetworkError: If the request raises a Javascript exception
+
+    Returns:
+        JsValue: The result of awaiting the promise.
+    """
+    with _timeout(
+        timeout, abort_controller_js, TimeoutExceptionType, ErrorExceptionType
+    ):
+        return await promise
+
+
+def _compute_timeouts(extensions: dict[str, Any]) -> tuple[float, float]:
+    timeout_dict = extensions.get("timeout", {}) or {}
+    conn_timeout = timeout_dict.get("connect", 0.0) or 0.0
+    read_timeout = timeout_dict.get("read", 0.0) or 0.0
+    return (conn_timeout, read_timeout)
+
+
+def _do_fetch(
+    request: Request, request_body: bytes | None, abort_controller_js: Any
+) -> Awaitable[JsValue]:
+    headers = {k: v for k, v in request.headers.items() if k not in HEADERS_TO_IGNORE}
+    fetch_data = {
+        "headers": headers,
+        "body": to_js(request_body),
+        "method": request.method,
+        "signal": abort_controller_js.signal,
+    }
+
+    return js.fetch(  # type: ignore[no-any-return]
+        request.url,
+        to_js(fetch_data),
+    )
+
+
+def _js_response_to_python(
+    Stream: type[AsyncEmscriptenStream],
+    response_js: Any,
+    read_timeout: float,
+    abort_controller_js: Any,
+) -> Response:
+    headers = dict(response_js.headers.entries())
+    # fix content-encoding headers because the javascript fetch handles that
+    headers["content-encoding"] = "identity"
+    status_code = response_js.status
+
+    # get a reader from the fetch response
+    body_stream_js = response_js.body.getReader()
+    return Response(
+        status_code=status_code,
+        headers=headers,
+        stream=Stream(body_stream_js, read_timeout, abort_controller_js),
+    )
+
+
+class JavascriptFetchTransport(BaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        _warn_ignored_options(
+            verify=verify,
+            cert=cert,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+            uds=uds,
+            local_address=local_address,
+            retries=retries,
+            socket_options=socket_options,
+        )
+
+    def __enter__(self) -> Self:  # Use generics for subclass support.
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        pass
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, SyncByteStream)
+        return _no_jspi_fallback(request)
+
+    def close(self) -> None:
+        pass
+
+
+class AsyncEmscriptenStream(AsyncByteStream):
+    def __init__(
+        self,
+        response_stream_js: JsValue,
+        timeout: float,
+        abort_controller_js: JsValue,
+    ) -> None:
+        self._stream_js = response_stream_js
+        self.timeout = timeout
+        self.abort_controller_js = abort_controller_js
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        while self._stream_js is not None:
+            result_js = await _run_async_with_timeout(
+                self._stream_js.read(),
+                self.timeout,
+                self.abort_controller_js,
+                ReadTimeout,
+                ReadError,
+            )
+            if result_js.done:
+                return
+            else:
+                yield result_js.value.to_py()
+
+    async def aclose(self) -> None:
+        self._stream_js = None
+
+
+class AsyncJavascriptFetchTransport(AsyncBaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        _warn_ignored_options(
+            verify=verify,
+            cert=cert,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+            uds=uds,
+            local_address=local_address,
+            retries=retries,
+            socket_options=socket_options,
+        )
+
+    async def __aenter__(self) -> Self:  # Use generics for subclass support.
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        pass
+
+    async def _get_body(self, request: Request) -> bytes | None:
+        assert isinstance(request.stream, AsyncByteStream)
+        body = b"".join([x async for x in request.stream])
+        if not body:
+            return None
+        return body
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        request_body = await self._get_body(request)
+        conn_timeout, read_timeout = _compute_timeouts(request.extensions)
+        abort_controller_js = js.AbortController.new()
+        fetcher_promise_js = _do_fetch(request, request_body, abort_controller_js)
+        response_js = await _run_async_with_timeout(
+            fetcher_promise_js,
+            conn_timeout,
+            abort_controller_js,
+            ConnectTimeout,
+            ConnectError,
+        )
+        return _js_response_to_python(
+            AsyncEmscriptenStream, response_js, read_timeout, abort_controller_js
+        )
+
+    async def aclose(self) -> None:
+        pass
+
+
+# Use XHR to do a sync request without jspi
+def _is_in_browser_main_thread() -> bool:
+    return hasattr(js, "window") and hasattr(js, "self") and js.self == js.window
+
+
+def _no_jspi_fallback(request: Request) -> Response:
+    assert isinstance(request.stream, SyncByteStream)
+    try:
+        js_xhr = js.XMLHttpRequest.new()
+
+        req_body: bytes | None = b"".join(request.stream)
+        if not req_body:
+            req_body = None
+        _, timeout = _compute_timeouts(request.extensions)
+
+        # XMLHttpRequest only supports timeouts and proper
+        # binary file reading in web-workers
+        if not _is_in_browser_main_thread():
+            js_xhr.responseType = "arraybuffer"
+            if timeout > 0.0:
+                js_xhr.timeout = int(timeout * 1000)
+        else:
+            # this is a nasty hack to be able to read binary files on
+            # main browser thread using xmlhttprequest
+            js_xhr.overrideMimeType("text/plain; charset=ISO-8859-15")
+
+        js_xhr.open(request.method, request.url, False)
+
+        for name, value in request.headers.items():
+            if name.lower() not in HEADERS_TO_IGNORE:
+                js_xhr.setRequestHeader(name, value)
+
+        js_xhr.send(to_js(req_body))
+
+        headers = dict(email.parser.Parser().parsestr(js_xhr.getAllResponseHeaders()))
+
+        if not _is_in_browser_main_thread():
+            body = js_xhr.response.to_py().tobytes()
+        else:
+            body = js_xhr.response.encode("ISO-8859-15")
+
+        return Response(status_code=js_xhr.status, headers=headers, content=body)
+    except JsException as err:
+        if err.name == "TimeoutError":
+            raise ConnectTimeout(message="Request timed out") from err
+        else:
+            raise ConnectError(message=err.message) from err