pyqwest 0.3.0__cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.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,373 @@
+from __future__ import annotations
+
+import contextlib
+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,
+)
+from pyqwest._pyqwest import get_sync_timeout
+
+if TYPE_CHECKING:
+    import sys
+
+    if sys.version_info >= (3, 11):
+        from wsgiref.types import WSGIApplication, WSGIEnvironment
+    else:
+        from _typeshed.wsgi import WSGIApplication, WSGIEnvironment
+
+_UNSET_STATUS = "unset"
+
+_DEFAULT_EXECUTOR: ThreadPoolExecutor | None = None
+
+
+def get_default_executor() -> ThreadPoolExecutor:
+    global _DEFAULT_EXECUTOR  # noqa: PLW0603
+    if _DEFAULT_EXECUTOR is None:
+        _DEFAULT_EXECUTOR = ThreadPoolExecutor()
+    return _DEFAULT_EXECUTOR
+
+
+class WSGITransport(SyncTransport):
+    """Transport implementation that directly invokes a WSGI application. Useful for testing."""
+
+    _app: WSGIApplication
+    _http_version: HTTPVersion
+    _closed: bool
+
+    def __init__(
+        self,
+        app: WSGIApplication,
+        http_version: HTTPVersion = HTTPVersion.HTTP2,
+        executor: ThreadPoolExecutor | None = None,
+    ) -> None:
+        """Creates a new WSGI transport.
+
+        Args:
+            app: The WSGI application to invoke for requests.
+            http_version: The HTTP version to simulate for requests.
+            executor: An optional ThreadPoolExecutor to use for running the WSGI app.
+                      If not provided, a default executor will be used.
+        """
+        self._app = app
+        self._http_version = http_version
+        self._executor = executor or get_default_executor()
+        self._closed = False
+
+    def execute_sync(self, request: SyncRequest) -> SyncResponse:
+        deadline = None
+        if (to := get_sync_timeout()) is not None:
+            deadline = time.monotonic() + to.total_seconds()
+
+        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,
+        )
+
+
+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.3.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: pyqwest
+Version: 0.3.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.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pyqwest/__init__.py,sha256=TqZ4ioJhL_RsgALEnb3iChY7gb9ysWc4cUA0k9rsjXI,902
+pyqwest/_coro.py,sha256=k5vVz1zeg9HQYvbbhAg9WnYiBHskkJ3Qdqfmx16HcVs,7867
+pyqwest/_glue.py,sha256=gk--twq1LRc-tsaDVwcIxcwPmaMz5kt94QQGJ0fTNFw,2530
+pyqwest/_pyqwest.cpython-314-aarch64-linux-gnu.so,sha256=9hmyTuskWBMy7p9Utuofc4xft6-vpFJD2RNzLWEn_SY,13161488
+pyqwest/_pyqwest.pyi,sha256=QFGjqouSggefDP6lZH-bJ2aQbEJbJI7dTuREdLOwaIc,45175
+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=SXYcCTmND2b-SDn18Kf8qDcBwjhh2SejD_fEs6Zz2Qs,12203
+pyqwest/testing/_asgi_compatibility.py,sha256=30rCjvyLg5L9x4vyI0LS8oqPtfY4oLctINJgqMzgLDU,3206
+pyqwest/testing/_wsgi.py,sha256=I8IZ8Dekwj_-OxiHqGZqPJP0sZs4-EywU2GELcWo_Bg,12313
+pyqwest-0.3.0.dist-info/METADATA,sha256=9g9EE8GB_Qbyl-BRDYHmNsylvR0u1jrZookvPz9CLQ4,886
+pyqwest-0.3.0.dist-info/WHEEL,sha256=Fx-7UOgjfhtK3XXmysArRGq3lEQiAORUMl6jtPUmCMs,149
+pyqwest-0.3.0.dist-info/licenses/LICENSE,sha256=e7sDs6pM-apXvhJO1bLtzngKeI1aQ6bDIyJxO7Sgv1E,1085
+pyqwest-0.3.0.dist-info/RECORD,,

pyqwest-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_17_aarch64
+Tag: cp314-cp314-manylinux2014_aarch64

pyqwest-0.3.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.