pyqwest 0.2.0__cp313-cp313-win_amd64.whl

pyqwest/__init__.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+__all__ = [
+    "Client",
+    "FullResponse",
+    "HTTPTransport",
+    "HTTPVersion",
+    "Headers",
+    "ReadError",
+    "Request",
+    "Response",
+    "StreamError",
+    "StreamErrorCode",
+    "SyncClient",
+    "SyncHTTPTransport",
+    "SyncRequest",
+    "SyncResponse",
+    "SyncTransport",
+    "Transport",
+    "WriteError",
+    "get_default_sync_transport",
+    "get_default_transport",
+]
+
+from . import _pyqwest
+from ._coro import Client, Response
+from ._pyqwest import (
+    FullResponse,
+    Headers,
+    HTTPTransport,
+    HTTPVersion,
+    ReadError,
+    Request,
+    StreamError,
+    StreamErrorCode,
+    SyncClient,
+    SyncHTTPTransport,
+    SyncRequest,
+    SyncResponse,
+    SyncTransport,
+    Transport,
+    WriteError,
+    get_default_sync_transport,
+    get_default_transport,
+)
+
+__doc__ = _pyqwest.__doc__

pyqwest/_coro.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
+
+from ._pyqwest import Client as NativeClient
+from ._pyqwest import FullResponse, Headers, Response, Transport
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Iterable, Mapping
+
+# We expose plain-Python wrappers for the async methods as the easiest way
+# of making them coroutines rather than methods that return Futures,
+# which is more Pythonic.
+
+
+class Client:
+    """An asynchronous HTTP client.
+
+    A client is a lightweight wrapper around a Transport, providing convenience methods
+    for common HTTP operations with buffering.
+    """
+
+    _client: NativeClient
+
+    def __init__(self, transport: Transport | None = None) -> None:
+        """Creates a new asynchronous HTTP client.
+
+        Args:
+            transport: The transport to use for requests. If None, the shared default
+                       transport will be used.
+        """
+        self._client = NativeClient(transport=transport)
+
+    async def get(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a GET HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.get(url, headers=headers, timeout=timeout)
+
+    async def post(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        content: bytes | AsyncIterator[bytes] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a POST HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            content: The request content.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.post(
+            url, headers=headers, content=content, timeout=timeout
+        )
+
+    async def delete(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a DELETE HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.delete(url, headers=headers, timeout=timeout)
+
+    async def head(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a HEAD HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.head(url, headers=headers, timeout=timeout)
+
+    async def options(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a OPTIONS HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.options(url, headers=headers, timeout=timeout)
+
+    async def patch(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        content: bytes | AsyncIterator[bytes] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a PATCH HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            content: The request content.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.patch(
+            url, headers=headers, content=content, timeout=timeout
+        )
+
+    async def put(
+        self,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        content: bytes | AsyncIterator[bytes] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes a PUT HTTP request.
+
+        Args:
+            url: The unencoded request URL.
+            headers: The request headers.
+            content: The request content.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.put(
+            url, headers=headers, content=content, timeout=timeout
+        )
+
+    async def execute(
+        self,
+        method: str,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        content: bytes | AsyncIterator[bytes] | None = None,
+        timeout: float | None = None,
+    ) -> FullResponse:
+        """Executes an HTTP request, returning the full buffered response.
+
+        Args:
+            method: The HTTP method.
+            url: The unencoded request URL.
+            headers: The request headers.
+            content: The request content.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        return await self._client.execute(
+            method, url, headers=headers, content=content, timeout=timeout
+        )
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: str,
+        url: str,
+        headers: Headers | Mapping[str, str] | Iterable[tuple[str, str]] | None = None,
+        content: bytes | AsyncIterator[bytes] | None = None,
+        timeout: float | None = None,
+    ) -> AsyncIterator[Response]:
+        """Executes an HTTP request, allowing the response content to be streamed.
+
+        Args:
+            method: The HTTP method.
+            url: The unencoded request URL.
+            headers: The request headers.
+            content: The request content.
+            timeout: The timeout for the request in seconds.
+
+        Raises:
+            ConnectionError: If the connection fails.
+            TimeoutError: If the request times out.
+        """
+        response = await self._client.stream(
+            method, url, headers=headers, content=content, timeout=timeout
+        )
+        async with response:
+            yield response

pyqwest/_glue.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING, Protocol, TypeVar
+
+from ._pyqwest import FullResponse, Headers, Request, Transport
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+
+T_contra = TypeVar("T_contra", contravariant=True)
+U = TypeVar("U")
+
+
+async def wrap_body_gen(
+    gen: AsyncIterator[T_contra], wrap_fn: Callable[[T_contra], U]
+) -> AsyncIterator[U]:
+    try:
+        async for item in gen:
+            yield wrap_fn(item)
+    finally:
+        try:
+            aclose = gen.aclose  # type: ignore[attr-defined]
+        except AttributeError:
+            pass
+        else:
+            await aclose()
+
+
+async def new_full_response(
+    status: int,
+    headers: Headers,
+    content: AsyncIterator[memoryview | bytes | bytearray],
+    trailers: Headers,
+) -> FullResponse:
+    buf = bytearray()
+    try:
+        async for chunk in content:
+            buf.extend(chunk)
+    finally:
+        try:
+            aclose = content.aclose  # type: ignore[attr-defined]
+        except AttributeError:
+            pass
+        else:
+            await aclose()
+    return FullResponse(status, headers, bytes(buf), trailers)
+
+
+async def execute_and_read_full(transport: Transport, request: Request) -> FullResponse:
+    resp = await transport.execute(request)
+    return await new_full_response(
+        resp.status, resp.headers, resp.content, resp.trailers
+    )
+
+
+def read_content_sync(content: Iterator[bytes | memoryview]) -> bytes:
+    buf = bytearray()
+    try:
+        for chunk in content:
+            buf.extend(chunk)
+    finally:
+        try:
+            close = content.close  # type: ignore[attr-defined]
+        except AttributeError:
+            pass
+        else:
+            close()
+    return bytes(buf)
+
+
+# Vendored from pyo3-async-runtimes to apply some fixes
+
+
+class Sender(Protocol[T_contra]):
+    def send(self, item: T_contra | BaseException) -> bool | Awaitable[bool]: ...
+
+    def close(self) -> None: ...
+
+
+async def forward(gen: AsyncIterator[T_contra], sender: Sender[T_contra]) -> None:
+    try:
+        async for item in gen:
+            should_continue = sender.send(item)
+
+            if inspect.isawaitable(should_continue):
+                should_continue = await should_continue
+
+            if should_continue:
+                continue
+            break
+    except Exception as e:
+        res = sender.send(e)
+        if inspect.isawaitable(res):
+            await res
+    finally:
+        sender.close()