pyqwest 0.2.0__cp313-cp313-win_amd64.whl

pyqwest/testing/_asgi_compatibility.py

@@ -0,0 +1,80 @@
+# Includes work from:
+
+# Copyright (c) Django Software Foundation and individual contributors.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+#    1. Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#
+#    2. 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.
+#
+#    3. Neither the name of Django 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 OWNER 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.
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from asgiref.typing import (
+        ASGI2Application,
+        ASGI3Application,
+        ASGIApplication,
+        ASGIReceiveCallable,
+        ASGISendCallable,
+        Scope,
+    )
+
+# Vendored from https://github.com/django/asgiref/blob/main/asgiref/compatibility.py
+
+if hasattr(inspect, "markcoroutinefunction"):
+    iscoroutinefunction = inspect.iscoroutinefunction
+else:
+    iscoroutinefunction = asyncio.iscoroutinefunction  # type: ignore[assignment]
+
+
+def is_double_callable(application: ASGIApplication) -> bool:
+    if getattr(application, "_asgi_single_callable", False):
+        return False
+    if getattr(application, "_asgi_double_callable", False):
+        return True
+    if inspect.isclass(application):
+        return True
+    if callable(application) and iscoroutinefunction(application.__call__):
+        return False
+    return not iscoroutinefunction(application)
+
+
+def double_to_single_callable(application: ASGI2Application) -> ASGI3Application:
+    async def new_application(
+        scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
+        instance = application(scope)
+        return await instance(receive, send)
+
+    return new_application
+
+
+def guarantee_single_callable(application: ASGIApplication) -> ASGI3Application:
+    if is_double_callable(application):
+        application = double_to_single_callable(cast("ASGI2Application", application))
+    return cast("ASGI3Application", application)

pyqwest/testing/_wsgi.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import contextlib
+import math
+import threading
+import time
+from collections.abc import Callable, Iterator
+from concurrent.futures import Future, ThreadPoolExecutor
+from queue import Empty, Queue
+from typing import TYPE_CHECKING
+from urllib.parse import unquote, urlparse
+
+from pyqwest import (
+    Headers,
+    HTTPVersion,
+    ReadError,
+    SyncRequest,
+    SyncResponse,
+    SyncTransport,
+    WriteError,
+)
+
+if TYPE_CHECKING:
+    import sys
+    from types import TracebackType
+
+    if sys.version_info >= (3, 11):
+        from wsgiref.types import WSGIApplication, WSGIEnvironment
+    else:
+        from _typeshed.wsgi import WSGIApplication, WSGIEnvironment
+
+_UNSET_STATUS = "unset"
+
+
+class WSGITransport(SyncTransport):
+    _app: WSGIApplication
+    _http_version: HTTPVersion
+    _executor: ThreadPoolExecutor
+    _close_executor: bool
+    _closed: bool
+
+    def __init__(
+        self,
+        app: WSGIApplication,
+        http_version: HTTPVersion = HTTPVersion.HTTP2,
+        executor: ThreadPoolExecutor | None = None,
+    ) -> None:
+        self._app = app
+        self._http_version = http_version
+        if executor is None:
+            self._executor = ThreadPoolExecutor()
+            self._close_executor = True
+        else:
+            self._executor = executor
+            self._close_executor = False
+        self._closed = False
+
+    def execute_sync(self, request: SyncRequest) -> SyncResponse:
+        timeout: float | None = request._timeout  # pyright: ignore[reportAttributeAccessIssue]  # noqa: SLF001
+        if timeout is not None and (timeout < 0 or not math.isfinite(timeout)):
+            msg = "Timeout must be non-negative"
+            raise ValueError(msg)
+
+        deadline = time.monotonic() + timeout if timeout is not None else None
+
+        parsed_url = urlparse(request.url)
+        raw_path = parsed_url.path or "/"
+        path = unquote(raw_path).encode().decode("latin-1")
+        query = parsed_url.query.encode().decode("latin-1")
+
+        match self._http_version:
+            case HTTPVersion.HTTP1:
+                server_protocol = "HTTP/1.1"
+            case HTTPVersion.HTTP2:
+                server_protocol = "HTTP/2"
+            case HTTPVersion.HTTP3:
+                server_protocol = "HTTP/3"
+            case _:
+                server_protocol = "HTTP/1.1"
+
+        trailers = Headers()
+        trailers_supported = (
+            self._http_version == HTTPVersion.HTTP2
+            and request.headers.get("te", "") == "trailers"
+        )
+
+        def send_trailers(headers: list[tuple[str, str]]) -> None:
+            if not trailers_supported:
+                return
+            for k, v in headers:
+                trailers.add(k, v)
+
+        request_input = RequestInput(request.content, self._http_version)
+        environ: WSGIEnvironment = {
+            "REQUEST_METHOD": request.method,
+            "SCRIPT_NAME": "",
+            "PATH_INFO": path,
+            "QUERY_STRING": query,
+            "SERVER_NAME": parsed_url.hostname or "",
+            "SERVER_PORT": str(
+                parsed_url.port or (443 if parsed_url.scheme == "https" else 80)
+            ),
+            "SERVER_PROTOCOL": server_protocol,
+            "wsgi.url_scheme": parsed_url.scheme,
+            "wsgi.version": (1, 0),
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": False,
+            "wsgi.run_once": False,
+            "wsgi.input": request_input,
+            "wsgi.ext.http.send_trailers": send_trailers,
+        }
+
+        for k, v in request.headers.items():
+            match k:
+                case "content-type":
+                    environ["CONTENT_TYPE"] = v
+                case "content-length":
+                    environ["CONTENT_LENGTH"] = v
+                case _:
+                    name = f"HTTP_{k.upper().replace('-', '_')}"
+                    value = f"{existing},{v}" if (existing := environ.get(name)) else v
+                    environ[name] = value
+
+        response_queue: Queue[bytes | None | Exception] = Queue()
+
+        status_str: str = _UNSET_STATUS
+        headers: list[tuple[str, str]] = []
+        exc: (
+            tuple[type[BaseException], BaseException, object]
+            | tuple[None, None, None]
+            | None
+        ) = None
+        response_started = threading.Event()
+
+        def start_response(
+            status: str,
+            response_headers: list[tuple[str, str]],
+            exc_info: tuple[type[BaseException], BaseException, object]
+            | tuple[None, None, None]
+            | None = None,
+        ) -> Callable[[bytes], object]:
+            nonlocal status_str, headers, exc
+            status_str = status
+            headers = response_headers
+            exc = exc_info
+
+            def write(body: bytes) -> None:
+                if not response_started.is_set():
+                    response_started.set()
+                if body:
+                    response_queue.put(body)
+
+            return write
+
+        def run_app() -> None:
+            response_iter = self._app(environ, start_response)
+            try:
+                for chunk in response_iter:
+                    if chunk:
+                        if not response_started.is_set():
+                            response_started.set()
+                        response_queue.put(chunk)
+            except Exception as e:
+                response_queue.put(e)
+            else:
+                response_queue.put(None)
+            finally:
+                if not response_started.is_set():
+                    request_input.close()
+                    response_started.set()
+                with contextlib.suppress(Exception):
+                    response_iter.close()  # pyright: ignore[reportAttributeAccessIssue]
+
+        app_future = self._executor.submit(run_app)
+
+        response_started.wait()
+
+        if status_str is _UNSET_STATUS:
+            return SyncResponse(
+                status=500,
+                http_version=self._http_version,
+                headers=Headers((("content-type", "text/plain"),)),
+                content=b"WSGI application did not call start_response",
+            )
+
+        if exc and exc[0]:
+            return SyncResponse(
+                status=500,
+                http_version=self._http_version,
+                headers=Headers((("content-type", "text/plain"),)),
+                content=str(exc[0]).encode(),
+            )
+
+        response_content = ResponseContent(
+            response_queue, request_input, app_future, deadline
+        )
+
+        status = int(status_str.split(" ", 1)[0])
+
+        return SyncResponse(
+            status=status,
+            http_version=self._http_version,
+            headers=Headers(headers),
+            content=response_content,
+            trailers=trailers,
+        )
+
+    def __enter__(self) -> WSGITransport:
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: type[BaseException] | None,
+        _exc_value: BaseException | None,
+        _traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        if self._close_executor:
+            self._executor.shutdown()
+
+
+class RequestInput:
+    def __init__(self, content: Iterator[bytes], http_version: HTTPVersion) -> None:
+        self._content = content
+        self._http_version = http_version
+        self._closed = False
+        self._buffer = bytearray()
+
+    def read(self, size: int = -1) -> bytes:
+        return self._do_read(size)
+
+    def readline(self, size: int = -1) -> bytes:
+        if self._closed or size == 0:
+            return b""
+
+        line = bytearray()
+        while True:
+            sz = size - len(line) if size >= 0 else -1
+            read_bytes = self._do_read(sz)
+            if not read_bytes:
+                return bytes(line)
+            if len(line) + len(read_bytes) == size:
+                return bytes(line + read_bytes)
+            newline_index = read_bytes.find(b"\n")
+            if newline_index == -1:
+                line.extend(read_bytes)
+                continue
+            res = line + read_bytes[: newline_index + 1]
+            self._buffer.extend(read_bytes[newline_index + 1 :])
+            return bytes(res)
+
+    def __iter__(self) -> Iterator[bytes]:
+        return self
+
+    def __next__(self) -> bytes:
+        line = self.readline()
+        if not line:
+            raise StopIteration
+        return line
+
+    def readlines(self, hint: int = -1) -> list[bytes]:
+        return list(self)
+
+    def _do_read(self, size: int) -> bytes:
+        if self._closed or size == 0:
+            return b""
+
+        try:
+            while True:
+                chunk = next(self._content)
+                if size < 0:
+                    self._buffer.extend(chunk)
+                    continue
+                if len(self._buffer) + len(chunk) >= size:
+                    to_read = size - len(self._buffer)
+                    res = self._buffer + chunk[:to_read]
+                    self._buffer.clear()
+                    self._buffer.extend(chunk[to_read:])
+                    return bytes(res)
+                if len(self._buffer) == 0:
+                    return chunk
+                res = self._buffer + chunk
+                self._buffer.clear()
+                return bytes(res)
+        except StopIteration:
+            self.close()
+            res = bytes(self._buffer)
+            self._buffer = bytearray()
+            return res
+        except Exception as e:
+            self.close()
+            if self._http_version != HTTPVersion.HTTP2:
+                msg = f"Request failed: {e}"
+            else:
+                # With HTTP/2, reqwest seems to squash the original error message.
+                msg = "Request failed: stream error sent by user"
+            raise WriteError(msg) from e
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        with contextlib.suppress(Exception):
+            self._content.close()  # pyright: ignore[reportAttributeAccessIssue]
+
+
+class ResponseContent(Iterator[bytes]):
+    def __init__(
+        self,
+        response_queue: Queue[bytes | None | Exception],
+        request_input: RequestInput,
+        app_future: Future,
+        deadline: float | None,
+    ) -> None:
+        self._response_queue = response_queue
+        self._request_input = request_input
+        self._app_future = app_future
+        self._closed = False
+        self._read_pending = False
+        self._deadline = deadline
+
+    def __iter__(self) -> Iterator[bytes]:
+        return self
+
+    def __next__(self) -> bytes:
+        if self._closed:
+            raise StopIteration
+        err: Exception | None = None
+        self._read_pending = True
+        chunk = b""
+        try:
+            if self._deadline:
+                while True:
+                    time_left = self._deadline - time.monotonic()
+                    if time_left <= 0:
+                        msg = "Response read timed out"
+                        message = TimeoutError(msg)
+                        break
+                    try:
+                        message = self._response_queue.get(timeout=time_left)
+                        break
+                    except Empty:
+                        continue
+            else:
+                message = self._response_queue.get()
+        finally:
+            self._read_pending = False
+        if isinstance(message, Exception):
+            match message:
+                case WriteError() | TimeoutError():
+                    err = message
+                case _:
+                    msg = "Request Failed: Error reading response body"
+                    err = ReadError(msg)
+        elif message is None:
+            err = StopIteration()
+        else:
+            chunk = message
+
+        if err:
+            self._closed = True
+            self._request_input.close()
+            with contextlib.suppress(Exception):
+                self._app_future.result()
+            raise err
+        return chunk
+
+    def __del__(self) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._request_input.close()
+        self._response_queue.put(ReadError("Response body read cancelled"))
+        with contextlib.suppress(Exception):
+            self._app_future.result()

pyqwest-0.2.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pyqwest
+Version: 0.2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Internet :: WWW/HTTP
+License-File: LICENSE
+Requires-Python: >=3.10

pyqwest-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pyqwest\__init__.py,sha256=-u46hIqP0IGssz_qZUt2MlH7XZmK4FyRlKic8Tghjvo,860
+pyqwest\_coro.py,sha256=9Kkeyk9gA8fzFpGHhhjAz63msb98J4tuIQMPpDCOm3Y,7636
+pyqwest\_glue.py,sha256=gk--twq1LRc-tsaDVwcIxcwPmaMz5kt94QQGJ0fTNFw,2530
+pyqwest\_pyqwest.cp313-win_amd64.pyd,sha256=DLHi18Xl0Eq1pxCD2Y_-xEEHlrIxcnWzqdNWtUqVjE4,10728960
+pyqwest\_pyqwest.pyi,sha256=RkpFULa9imDZwej6D4v_yprlALlp0ngTcxu5nKWpc6I,38756
+pyqwest\httpx\__init__.py,sha256=4DJZ0AMFfuScGLkd9ktwGMypll7RW6VhAMenwcEWkDw,157
+pyqwest\httpx\_transport.py,sha256=3Os8YB3Wq9dFvvYugMsXKmpM6JmuUSuSbTzBbOSf-Uw,9378
+pyqwest\py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyqwest\testing\__init__.py,sha256=oNW9UbowpENKwUt0QvBzHFWLWq4_7b1LMfMz3QmftQE,148
+pyqwest\testing\_asgi.py,sha256=Jxd2cNG_DbYbUenW2LiV3Uc5x9d5ynUD7YISWiu7owU,12526
+pyqwest\testing\_asgi_compatibility.py,sha256=30rCjvyLg5L9x4vyI0LS8oqPtfY4oLctINJgqMzgLDU,3206
+pyqwest\testing\_wsgi.py,sha256=IgNpv6cGV-z1Mrrn8p2xh8XWsEOPEl5JVtuYyi57LsM,12464
+pyqwest-0.2.0.dist-info\METADATA,sha256=mHLRxgcqJckHC26TYH0gMeTi4_hvhjO5LAhh___pbMk,886
+pyqwest-0.2.0.dist-info\WHEEL,sha256=n_BmF69IyGtioVWE9c3M_zsEfe6-xMZy1v5HCL_6qE0,97
+pyqwest-0.2.0.dist-info\licenses\LICENSE,sha256=e7sDs6pM-apXvhJO1bLtzngKeI1aQ6bDIyJxO7Sgv1E,1085
+pyqwest-0.2.0.dist-info\RECORD,,

pyqwest-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64

pyqwest-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) CurioSwitch (oss@curioswitch.org)
+
+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.