pyreqwest 0.5.0__cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl

pyreqwest/request/__init__.pyi

@@ -0,0 +1,200 @@
+from datetime import timedelta
+from typing import Any, Self
+
+from pyreqwest.bytes import Bytes
+from pyreqwest.http import HeaderMap, Url
+from pyreqwest.middleware.types import Middleware, SyncMiddleware
+from pyreqwest.multipart import FormBuilder
+from pyreqwest.response import Response, SyncResponse
+from pyreqwest.types import ExtensionsType, FormParams, HeadersType, QueryParams, Stream, SyncStream
+
+class Request:
+    @property
+    def method(self) -> str:
+        """Get the HTTP method. (e.g. GET, POST)."""
+
+    @method.setter
+    def method(self, value: str) -> None:
+        """Set the HTTP method."""
+
+    @property
+    def url(self) -> Url:
+        """Get the url."""
+
+    @url.setter
+    def url(self, value: Url | str) -> None:
+        """Set the url."""
+
+    @property
+    def headers(self) -> HeaderMap:
+        """Get the headers. This is not a copy. Modifying it modifies the request."""
+
+    @headers.setter
+    def headers(self, headers: HeadersType) -> None:
+        """Replace headers. Given value is copied."""
+
+    @property
+    def body(self) -> "RequestBody | None":
+        """Get the body."""
+
+    @body.setter
+    def body(self, value: "RequestBody | None") -> None:
+        """Set the body or remove body."""
+
+    @property
+    def extensions(self) -> dict[str, Any]:
+        """Arbitrary per-request data storage. Useful for passing through data to middleware and response."""
+
+    @extensions.setter
+    def extensions(self, value: ExtensionsType) -> None:
+        """Replace extensions. Given value is shallow copied."""
+
+    def copy(self) -> Self:
+        """Copy the request. Byte-bodies are zero-copied. Stream bodies are re-created via their own copy logic."""
+
+    def __copy__(self) -> Self: ...
+    def repr_full(self) -> str:
+        """Verbose repr including non-sensitive headers and body summary."""
+
+    @classmethod
+    def from_request_and_body(cls, request: Self, body: "RequestBody | None") -> Self:
+        """Clone request with a new body instance."""
+
+class ConsumedRequest(Request):
+    """Request that will fully read the response body when sent."""
+
+    async def send(self) -> Response:
+        """Execute the request returning a Response with fully read response body."""
+
+class StreamRequest(Request):
+    """Request whose response body is streamed."""
+
+    async def __aenter__(self) -> Response:
+        """Execute the request returning a Response with streaming response body."""
+
+    async def __aexit__(self, *args: object, **kwargs: Any) -> None:
+        """Close streaming response."""
+
+    @property
+    def read_buffer_limit(self) -> int:
+        """Max bytes buffered when reading streamed body."""
+
+class SyncConsumedRequest(Request):
+    """Synchronous request that will fully read the response body when sent."""
+
+    def send(self) -> SyncResponse:
+        """Execute the request returning a Response with fully read response body."""
+
+class SyncStreamRequest(Request):
+    """Synchronous request whose response body is streamed."""
+
+    def __enter__(self) -> SyncResponse:
+        """Execute the request returning a Response with streaming response body."""
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        """Close streaming response."""
+
+    @property
+    def read_buffer_limit(self) -> int:
+        """Max bytes buffered when reading streamed body."""
+
+class RequestBody:
+    """Represents request body content (bytes, text, or async stream). Bodies are single-use."""
+
+    @staticmethod
+    def from_text(body: str) -> "RequestBody":
+        """Create body from text."""
+
+    @staticmethod
+    def from_bytes(body: bytes | bytearray | memoryview) -> "RequestBody":
+        """Create body from raw bytes."""
+
+    @staticmethod
+    def from_stream(stream: Stream) -> "RequestBody":
+        """Create body from async byte stream."""
+
+    def copy_bytes(self) -> Bytes | None:
+        """Return bytes zero-copy. None for stream."""
+
+    def get_stream(self) -> Stream | None:
+        """Return underlying stream if streaming body else None."""
+
+    def __copy__(self) -> Self:
+        """Copy body (Zero-copied bytes. Stream supplies its own copy)."""
+
+class BaseRequestBuilder:
+    def error_for_status(self, enable: bool) -> Self:
+        """Enable automatic HTTP error raising (4xx/5xx)."""
+
+    def header(self, name: str, value: str) -> Self:
+        """Append single header value."""
+
+    def headers(self, headers: HeadersType) -> Self:
+        """Merge multiple headers (mapping or sequence)."""
+
+    def basic_auth(self, username: str, password: str | None) -> Self:
+        """Add Basic Authorization header."""
+
+    def bearer_auth(self, token: str) -> Self:
+        """Add Bearer token Authorization header."""
+
+    def body_bytes(self, body: bytes | bytearray | memoryview) -> Self:
+        """Set body from raw bytes."""
+
+    def body_text(self, body: str) -> Self:
+        """Set body from text."""
+
+    def body_json(self, body: Any) -> Self:
+        """Serialize body as JSON. Sets Content-Type header."""
+
+    def query(self, query: QueryParams) -> Self:
+        """Add/merge query parameters."""
+
+    def timeout(self, timeout: timedelta) -> Self:
+        """Set per-request total timeout."""
+
+    def multipart(self, multipart: FormBuilder) -> Self:
+        """Attach multipart form body builder."""
+
+    def form(self, form: FormParams) -> Self:
+        """Set application/x-www-form-urlencoded body."""
+
+    def extensions(self, extensions: ExtensionsType) -> Self:
+        """Arbitrary per-request data storage. Useful for passing through data to middleware and response."""
+
+    def streamed_read_buffer_limit(self, value: int) -> Self:
+        """Max bytes buffered when reading streamed body."""
+
+    @staticmethod
+    def default_streamed_read_buffer_limit() -> int:
+        """Default max bytes buffered when reading streamed body."""
+
+class RequestBuilder(BaseRequestBuilder):
+    """Request builder. Use `build()` or `build_streamed()` to create the request to send."""
+
+    def build(self) -> ConsumedRequest:
+        """Build request that full reads the response body on send()."""
+
+    def build_streamed(self) -> StreamRequest:
+        """Build request whose response body is streamed."""
+
+    def body_stream(self, stream: Stream) -> Self:
+        """Set streaming request body."""
+
+    def with_middleware(self, middleware: Middleware) -> Self:
+        """Register a middleware component (added after client level middlewares, executed in chain order)."""
+
+class SyncRequestBuilder(BaseRequestBuilder):
+    """Synchronous request builder. Use `build()` or `build_streamed()` to create the request to send."""
+
+    def build(self) -> SyncConsumedRequest:
+        """Build request that full reads the response body on send()."""
+
+    def build_streamed(self) -> SyncStreamRequest:
+        """Build request whose response body is streamed."""
+
+    def body_stream(self, stream: SyncStream) -> Self:
+        """Set streaming request body."""
+
+    def with_middleware(self, middleware: SyncMiddleware) -> Self:
+        """Register a middleware component (added after client level middlewares, executed in chain order)."""

pyreqwest/response/__init__.py

@@ -0,0 +1,19 @@
+"""Response classes and builders."""
+
+from pyreqwest._pyreqwest.response import (
+    BaseResponse,
+    Response,
+    ResponseBodyReader,
+    ResponseBuilder,
+    SyncResponse,
+    SyncResponseBodyReader,
+)
+
+__all__ = [  # noqa: RUF022
+    "Response",
+    "SyncResponse",
+    "BaseResponse",
+    "ResponseBuilder",
+    "ResponseBodyReader",
+    "SyncResponseBodyReader",
+]

pyreqwest/response/__init__.pyi

@@ -0,0 +1,157 @@
+from typing import Any, Self
+
+from pyreqwest.bytes import Bytes
+from pyreqwest.http import HeaderMap, Mime
+from pyreqwest.types import ExtensionsType, HeadersType, Stream
+
+class BaseResponse:
+    @property
+    def status(self) -> int:
+        """HTTP status code (e.g. 200, 404)."""
+
+    @status.setter
+    def status(self, value: int) -> None:
+        """Set HTTP status code."""
+
+    @property
+    def headers(self) -> HeaderMap:
+        """Get the headers. This is not a copy. Modifying it modifies the response.
+        You can also use `get_header` or `get_header_all` to access headers.
+        """
+
+    @headers.setter
+    def headers(self, headers: HeadersType) -> None:
+        """Replace headers. Given value is copied."""
+
+    @property
+    def extensions(self) -> dict[str, Any]:
+        """Arbitrary per-request data storage. This is the data that was passed via request and middlewares.
+        This is not a copy. Modifying it modifies the response.
+        """
+
+    @extensions.setter
+    def extensions(self, value: ExtensionsType) -> None:
+        """Replace extensions. Given value is shallow copied."""
+
+    @property
+    def version(self) -> str:
+        """Used HTTP version (e.g. 'HTTP/1.1', 'HTTP/2.0')."""
+
+    @version.setter
+    def version(self, value: str) -> None:
+        """Set HTTP version."""
+
+    def error_for_status(self) -> None:
+        """Raise StatusError for 4xx/5xx."""
+
+    def get_header(self, key: str) -> str | None:
+        """Return first matching header value else None (case-insensitive)."""
+
+    def get_header_all(self, key: str) -> list[str]:
+        """Return all values for header name (case-insensitive). Empty if absent."""
+
+    def content_type_mime(self) -> Mime | None:
+        """Parsed Content-Type header as Mime or None if absent."""
+
+class Response(BaseResponse):
+    """Asynchronous response with optionally streamed body."""
+
+    async def bytes(self) -> Bytes:
+        """Return entire body as bytes (cached after first read)."""
+
+    async def json(self) -> Any:
+        """Decode body as JSON (underlying bytes cached after first read). Uses serde for decoding.
+        User can provide custom deserializer via `ClientBuilder.json_handler`.
+        """
+
+    async def text(self) -> str:
+        """Decode body to text (underlying bytes cached after first read). Uses charset from Content-Type."""
+
+    @property
+    def body_reader(self) -> "ResponseBodyReader":
+        """Access streaming reader. Using bytes(), json() or text() is not allowed after reading body partially."""
+
+class SyncResponse(BaseResponse):
+    """Synchronous response variant."""
+
+    def bytes(self) -> Bytes:
+        """Return entire body as bytes (cached after first read)."""
+
+    def json(self) -> Any:
+        """Decode body as JSON (underlying bytes cached after first read). Uses serde for decoding.
+        User can provide custom deserializer via `SyncClientBuilder.json_handler`.
+        """
+
+    def text(self) -> str:
+        """Decode body to text (underlying bytes cached after first read). Uses charset from Content-Type."""
+
+    @property
+    def body_reader(self) -> "SyncResponseBodyReader":
+        """Access streaming reader. Using bytes(), json() or text() is not allowed after reading body partially."""
+
+class ResponseBuilder:
+    """Programmatic response construction (for testing, middlewares, manual responses)."""
+
+    def __init__(self) -> None:
+        """Create empty response builder (defaults: 200, HTTP/1.1, empty headers/body)."""
+
+    async def build(self) -> Response:
+        """Build asynchronous response."""
+
+    def build_sync(self) -> SyncResponse:
+        """Build synchronous response (disallows async streams)."""
+
+    def status(self, value: int) -> Self:
+        """Set status code."""
+
+    def version(self, value: str) -> Self:
+        """Set HTTP version string."""
+
+    def header(self, name: str, value: str) -> Self:
+        """Append single header value (multiple allowed)."""
+
+    def headers(self, headers: HeadersType) -> Self:
+        """Merge multiple headers (mapping or sequence)."""
+
+    def extensions(self, extensions: ExtensionsType) -> Self:
+        """Set extensions."""
+
+    def body_bytes(self, body: bytes | bytearray | memoryview) -> Self:
+        """Set fixed byte body (zero-copied where possible)."""
+
+    def body_text(self, body: str) -> Self:
+        """Set text body (UTF-8 encoded)."""
+
+    def body_json(self, body: Any) -> Self:
+        """Serialize body to JSON (sets Content-Type). Uses serde for serialization."""
+
+    def body_stream(self, stream: Stream) -> Self:
+        """Set streaming body. `build_sync` can not be mixed with async streams."""
+
+    def copy(self) -> Self:
+        """Copy builder."""
+    def __copy__(self) -> Self: ...
+
+class ResponseBodyReader:
+    """Streaming body reader."""
+
+    async def bytes(self) -> Bytes:
+        """Read remaining stream fully and return bytes (caches)."""
+
+    async def read(self, amount: int = ...) -> Bytes | None:
+        """Read up to amount bytes (or default chunk size) from stream. None when stream is exhausted."""
+
+    async def read_chunk(self) -> Bytes | None:
+        """Return next raw chunk. Sizes are arbitrary and depend on OS. None when stream is exhausted."""
+
+class SyncResponseBodyReader:
+    """Streaming body reader."""
+
+    def bytes(self) -> Bytes:
+        """Read remaining stream fully and return bytes (caches)."""
+
+    def read(self, amount: int = ...) -> Bytes | None:
+        """Read up to amount bytes (or default chunk size) from stream. None when stream is exhausted."""
+
+    def read_chunk(self) -> Bytes | None:
+        """Return next raw chunk. Sizes are arbitrary and depend on OS. None when stream is exhausted."""

pyreqwest/types.py

@@ -0,0 +1,12 @@
+"""Common types and interfaces used in the library."""
+
+from collections.abc import AsyncIterable, Iterable, Mapping, Sequence
+from typing import Any, TypeAlias
+
+HeadersType: TypeAlias = Mapping[str, str] | Sequence[tuple[str, str]]
+QueryParams: TypeAlias = Mapping[str, Any] | Sequence[tuple[str, Any]]
+FormParams: TypeAlias = Mapping[str, Any] | Sequence[tuple[str, Any]]
+ExtensionsType: TypeAlias = Mapping[str, Any] | Sequence[tuple[str, Any]]
+
+SyncStream: TypeAlias = Iterable[bytes] | Iterable[bytearray] | Iterable[memoryview]
+Stream: TypeAlias = AsyncIterable[bytes] | AsyncIterable[bytearray] | AsyncIterable[memoryview] | SyncStream

pyreqwest-0.5.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: pyreqwest
+Version: 0.5.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Implementation :: GraalPy
+Classifier: Programming Language :: Rust
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Typing :: Typed
+License-File: LICENSE
+Summary: Powerful and fast Rust based HTTP client
+Author-email: Markus Sintonen <pyreqwest@gmail.com>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/MarkusSintonen/pyreqwest
+Project-URL: Source, https://github.com/MarkusSintonen/pyreqwest
+
+<p align="center">
+    <img width="250" alt="logo" src="https://raw.githubusercontent.com/MarkusSintonen/pyreqwest/refs/heads/main/docs/logo.png" />
+</p>
+
+---
+
+pyreqwest - Powerful and fast Rust based HTTP client. Built on top of and inspired by [reqwest](https://github.com/seanmonstar/reqwest).
+
+## Why
+
+- No reinvention of the wheel - built on top of widely used reqwest and other Rust HTTP crates
+- Secure and fast - no C-extension code, no Python code/dependencies, no `unsafe` code
+- Ergonomic and easy to use - similar API as in reqwest, fully type-annotated
+- Testing ergonomics - mocking included, can also connect into ASGI apps
+
+Using this is a good choice when:
+
+- You care about throughput and latency, especially in high concurrency scenarios
+- You want a single solution to serve all your HTTP client needs
+
+This is not a good choice when:
+
+- You want a pure Python solution allowing debugging of the HTTP client internals
+- You use alternative Python implementations or Python version older than 3.11
+
+## Features
+
+- High performance, see [notes](https://github.com/MarkusSintonen/pyreqwest/blob/main/docs/performance.md) and [benchmarks](https://github.com/MarkusSintonen/pyreqwest/blob/main/docs/benchmarks.md)
+- Asynchronous and synchronous HTTP clients
+- Customizable via middlewares and custom JSON serializers
+- Ergonomic as `reqwest`
+- HTTP/1.1 and HTTP/2 support (also HTTP/3 when it [stabilizes](https://docs.rs/reqwest/latest/reqwest/#unstable-features))
+- Mocking and testing utilities (can also connect to ASGI apps)
+- Fully type-safe with Python type hints
+- Full test coverage
+- Free threading, see [notes](https://github.com/MarkusSintonen/pyreqwest/blob/main/docs/performance.md#python-313-free-threading)
+
+### Standard HTTP features you would expect
+
+- HTTPS support (using [rustls](https://github.com/rustls/rustls))
+- Request and response body streaming
+- Connection pooling
+- JSON, URLs, Headers, Cookies etc. (all serializers in Rust)
+- Automatic decompression (zstd, gzip, brotli, deflate)
+- Automatic response decoding (charset detection)
+- Multipart form support
+- Proxy support
+- Redirects
+- Timeouts
+- Authentication (Basic, Bearer)
+- Cookie management
+
+## Quickstart
+
+```python
+# uv add pyreqwest
+
+from pyreqwest.client import ClientBuilder, SyncClientBuilder
+
+async def example_async():
+    async with ClientBuilder().error_for_status(True).build() as client:
+        response = await client.get("https://httpbun.com/get").query({"q": "val"}).build().send()
+        print(await response.json())        
+
+def example_sync():
+    with SyncClientBuilder().error_for_status(True).build() as client:
+        print(client.get("https://httpbun.com/get").query({"q": "val"}).build().send().json())
+```
+
+Context manager usage is optional, but recommended. Also `close()` methods are available.
+
+## Documentation
+
+See [docs](https://markussintonen.github.io/pyreqwest/pyreqwest.html)
+
+See [examples](https://github.com/MarkusSintonen/pyreqwest/tree/main/examples)
+

pyreqwest-0.5.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+pyreqwest-0.5.0.dist-info/METADATA,sha256=13eNxIuH0GIxErPMVAR-j7iZG2MC7U3XYlzg8jJR1Sw,4315
+pyreqwest-0.5.0.dist-info/WHEEL,sha256=uV83QoQqnjBLzFJhqOOim9LCucwNpoYmeL9jKwT6K0E,131
+pyreqwest-0.5.0.dist-info/entry_points.txt,sha256=x6BM9g8m805tw6VqKvSe_Kgd2qp4Eq3moyIoFnETeoE,61
+pyreqwest-0.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyreqwest/__init__.py,sha256=AqtJmAtOEQ6kYGY2_Qzw2f_q5K3Q5PN-TpOmIKaeiEM,86
+pyreqwest/__init__.pyi,sha256=Y25n44pyE3vp92MiABKrcK3IWRyQ1JG1rZ4Ufqy2nC0,17
+pyreqwest/_pyreqwest.cpython-311-powerpc64le-linux-gnu.so,sha256=tVckJTQhW7QtN85QZCuLOg00nsk79HcBWllcesWUMyc,7811888
+pyreqwest/bytes/__init__.py,sha256=uzB8cxWbBizu0kyrdXhmnwWKWdwBcVIv4mgEhCR1LMs,465
+pyreqwest/bytes/__init__.pyi,sha256=bttN8uCg7K3gW90FBgPP4vbtNrBCOwqX4v7LAK-T1pU,4569
+pyreqwest/client/__init__.py,sha256=tPfCyh-HJJEepvGMvLSLjKkZySTKsATsnbJziT_P4IM,369
+pyreqwest/client/__init__.pyi,sha256=y9AfLH2Dhw8UOnnia1hk1qVGjAGW43LGT3dwqZfEVm4,14231
+pyreqwest/client/types.py,sha256=CpfplqBGOyvpZNpwbOqal89dBztZlZTYuX-nM1Qrwrg,1475
+pyreqwest/cookie/__init__.py,sha256=whcJaTtVHgqH2n_lvGYXYHP7D9BolDU6SvKjuKpewAs,128
+pyreqwest/cookie/__init__.pyi,sha256=YCOI79evRpc7xmSpY6q1MsQMCHSucGDpLmsk0ZqfXN4,6401
+pyreqwest/exceptions/__init__.py,sha256=LWD8I6hFsw0ogHwpobPVcO5tfFRhRg0rPF2Bs64XjuI,5319
+pyreqwest/http/__init__.py,sha256=cXbHvSjZhMc7Zi_8JWjEn9GVzT6HG6BBbuk0xwSqMiA,334
+pyreqwest/http/__init__.pyi,sha256=xmG6eD1Uz0Y1nRgPb_zxUMKc57rgxWq58W5nsCRg9V0,13798
+pyreqwest/middleware/__init__.py,sha256=0i12zyrey3OmmKLtYRLTK4goC7QHWi0Di5erhe4VYHw,118
+pyreqwest/middleware/__init__.pyi,sha256=dkrwXkePVkvQNa4xe0l0-L-4WL3VsrNdJOO1-zNGApo,476
+pyreqwest/middleware/asgi/__init__.py,sha256=jLj4n6F4O2SKOl6HyufmSEvldDOQ1seWtcZPLOxZCyw,95
+pyreqwest/middleware/asgi/asgi.py,sha256=-sfreLfoAvfLxTFGaxJwsQ8wKDJnUZ8LdYe8N_37weA,6464
+pyreqwest/middleware/types.py,sha256=eeJ69Tqt0lr7k0XJncnYrvdkGdc_jgcytRMHKfNz260,1011
+pyreqwest/multipart/__init__.py,sha256=3UFqwbotg9XICgMW40UsaHoqZSQCcmgOl18oPMnIN94,146
+pyreqwest/multipart/__init__.pyi,sha256=aUh8Ubc4EHc5IYXjJKhfldpd9oN752kgdFrDWNmfuGI,2669
+pyreqwest/proxy/__init__.py,sha256=cMc1OIXi8c1_aauFNECcQI1kVoNyJHqLwVi_xHSsIs4,102
+pyreqwest/proxy/__init__.pyi,sha256=bcPG1KqlCWYI4eNewZBt1MFmV1vZAefr5meLtu4KJZs,1653
+pyreqwest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyreqwest/pytest_plugin/__init__.py,sha256=gFpygM4ekWY51fmQqsrIhTUf_qtaC1MIazcdE0JtOnU,140
+pyreqwest/pytest_plugin/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyreqwest/pytest_plugin/internal/assert_eq.py,sha256=j4bEJPHWZvLAvSKqS3eCFViI0X8phvyfiBu_N4GBNsw,171
+pyreqwest/pytest_plugin/internal/assert_message.py,sha256=oRkvzpIFw69rOaGTYBFGd8gP1Piut_RpG8G51OhYbes,4853
+pyreqwest/pytest_plugin/internal/matcher.py,sha256=aB08rUdI3rLQL2pMxerYAD-S8p1TeFUl36i0G2-tdgs,1221
+pyreqwest/pytest_plugin/internal/plugin.py,sha256=NkneUC5Ui-1ATlrG0q-R4_xdkA_Ou3UEF3t6qAlhS_M,448
+pyreqwest/pytest_plugin/mock.py,sha256=f3Zdy0CAlPc4RVZcSktPU6WfrhAmCtbzZnZyxizizqI,20315
+pyreqwest/pytest_plugin/types.py,sha256=_PvM5c7pkjf0tmC_ozE8wO1ssMNTy7ZX49AWY9zCo1E,884
+pyreqwest/request/__init__.py,sha256=D5JI5nbfJgBgnGK_2fxCR1bPjGhy-yr1U4PoPY_RtsM,504
+pyreqwest/request/__init__.pyi,sha256=UB9IMIep6xwCvinv7OD9lNTNYLw-kkxdVMEqvVDRFkk,7149
+pyreqwest/response/__init__.py,sha256=u1M-aMKJdS3EQ9NqANnpnZ4S2XeWsM2ncd73Oj7T1_E,373
+pyreqwest/response/__init__.pyi,sha256=8hebHvfuWadg4zi0esEMJikTrXE296DlWHbYGGkLNfQ,5737
+pyreqwest/types.py,sha256=10lGx5uugbo5awMz6nNOcuIsyeG3NIB7DqQHiPbOHLk,643
+pyreqwest-0.5.0.dist-info/RECORD,,

pyreqwest-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le

pyreqwest-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pyreqwest=pyreqwest.pytest_plugin.internal.plugin