pyreqwest 0.8.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pyreqwest/request/__init__.pyi

@@ -0,0 +1,218 @@
+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:
+        """Use 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:
+        """Use a middleware component (added after client level middlewares, executed in chain order)."""
+
+class OneOffRequestBuilder(BaseRequestBuilder):
+    """One-off request builder. Use `send()` to execute the request."""
+
+    async def send(self) -> Response:
+        """Execute the request returning a Response with fully read response body."""
+
+    def with_middleware(self, middleware: Middleware) -> Self:
+        """Use a middleware component."""
+
+class SyncOneOffRequestBuilder(BaseRequestBuilder):
+    """Synchronous one-off request builder. Use `send()` to execute the request."""
+
+    def send(self) -> SyncResponse:
+        """Execute the request returning a Response with fully read response body."""
+
+    def with_middleware(self, middleware: SyncMiddleware) -> Self:
+        """Use a middleware component."""

pyreqwest/response/__init__.py

@@ -0,0 +1,19 @@
+"""Response classes and builders."""
+
+from pyreqwest._pyreqwest.response import (
+    BaseResponse,
+    Response,
+    ResponseBodyReader,
+    ResponseBuilder,
+    SyncResponse,
+    SyncResponseBodyReader,
+)
+
+__all__ = [
+    "BaseResponse",
+    "Response",
+    "SyncResponse",
+    "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/simple/__init__.py

@@ -0,0 +1 @@
+"""Simple interfaces for doing one-off requests."""

pyreqwest/simple/request/__init__.py

@@ -0,0 +1,21 @@
+"""Simple async interfaces for doing one-off requests."""
+
+from pyreqwest._pyreqwest.simple.request import (
+    pyreqwest_delete,
+    pyreqwest_get,
+    pyreqwest_head,
+    pyreqwest_patch,
+    pyreqwest_post,
+    pyreqwest_put,
+    pyreqwest_request,
+)
+
+__all__ = [
+    "pyreqwest_request",
+    "pyreqwest_get",
+    "pyreqwest_post",
+    "pyreqwest_put",
+    "pyreqwest_patch",
+    "pyreqwest_delete",
+    "pyreqwest_head",
+]

pyreqwest/simple/request/__init__.pyi

@@ -0,0 +1,29 @@
+from pyreqwest.http import Url
+from pyreqwest.request import OneOffRequestBuilder
+
+def pyreqwest_request(method: str, url: Url | str) -> OneOffRequestBuilder:
+    """Create a simple request with the given HTTP method and URL.
+
+    Returns a request builder, which will allow setting headers and the request body before sending.
+
+    NOTE: This is only recommended for simple scripting use-cases. Usually, the client should be reused for multiple
+    requests to benefit from connection pooling and other optimizations (via ClientBuilder).
+    """
+
+def pyreqwest_get(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("GET", url)`."""
+
+def pyreqwest_post(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("POST", url)`."""
+
+def pyreqwest_put(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("PUT", url)`."""
+
+def pyreqwest_patch(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("PATCH", url)`."""
+
+def pyreqwest_delete(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("DELETE", url)`."""
+
+def pyreqwest_head(url: Url | str) -> OneOffRequestBuilder:
+    """Same as `pyreqwest_request("HEAD", url)`."""

pyreqwest/simple/sync_request/__init__.py

@@ -0,0 +1,21 @@
+"""Simple sync interfaces for doing one-off requests."""
+
+from pyreqwest._pyreqwest.simple.sync_request import (
+    pyreqwest_delete,
+    pyreqwest_get,
+    pyreqwest_head,
+    pyreqwest_patch,
+    pyreqwest_post,
+    pyreqwest_put,
+    pyreqwest_request,
+)
+
+__all__ = [
+    "pyreqwest_request",
+    "pyreqwest_get",
+    "pyreqwest_post",
+    "pyreqwest_put",
+    "pyreqwest_patch",
+    "pyreqwest_delete",
+    "pyreqwest_head",
+]

pyreqwest/simple/sync_request/__init__.pyi

@@ -0,0 +1,29 @@
+from pyreqwest.http import Url
+from pyreqwest.request import SyncOneOffRequestBuilder
+
+def pyreqwest_request(method: str, url: Url | str) -> SyncOneOffRequestBuilder:
+    """Create a simple request with the given HTTP method and URL.
+
+    Returns a request builder, which will allow setting headers and the request body before sending.
+
+    NOTE: This is only recommended for simple scripting use-cases. Usually, the client should be reused for multiple
+    requests to benefit from connection pooling and other optimizations (via ClientBuilder).
+    """
+
+def pyreqwest_get(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("GET", url)`."""
+
+def pyreqwest_post(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("POST", url)`."""
+
+def pyreqwest_put(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("PUT", url)`."""
+
+def pyreqwest_patch(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("PATCH", url)`."""
+
+def pyreqwest_delete(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("DELETE", url)`."""
+
+def pyreqwest_head(url: Url | str) -> SyncOneOffRequestBuilder:
+    """Same as `pyreqwest_request("HEAD", url)`."""

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.8.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: pyreqwest
+Version: 0.8.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>
+
+---
+[![codecov](https://codecov.io/github/markussintonen/pyreqwest/graph/badge.svg?token=OET0CMZYOH)](https://codecov.io/github/markussintonen/pyreqwest)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyreqwest)
+
+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.
+
+#### Mocking in pytest
+
+```python
+from pyreqwest.client import ClientBuilder
+from pyreqwest.pytest_plugin import ClientMocker
+
+async def test_client(client_mocker: ClientMocker) -> None:
+    client_mocker.get(path="/api").with_body_text("Hello Mock")
+
+    async with ClientBuilder().build() as client:
+        response = await client.get("http://example.invalid/api").build().send()
+        assert response.status == 200 and await response.text() == "Hello Mock"
+        assert client_mocker.get_call_count() == 1
+```
+
+Manual mocking is available via `ClientMocker.create_mocker(MonkeyPatch)`.
+
+#### Simple request interface
+
+This is only recommended for simple use-cases such as scripts. Usually, the full client API should be used which reuses
+connections and has other optimizations.
+
+```python
+# Sync example
+from pyreqwest.simple.sync_request import pyreqwest_get
+response = pyreqwest_get("https://httpbun.com/get").query({"q": "val"}).send()
+print(response.json())
+```
+
+```python
+# Async example
+from pyreqwest.simple.request import pyreqwest_get
+response = await pyreqwest_get("https://httpbun.com/get").query({"q": "val"}).send()
+print(await response.json())
+```
+
+## Documentation
+
+See [docs](https://markussintonen.github.io/pyreqwest/pyreqwest.html)
+
+See [examples](https://github.com/MarkusSintonen/pyreqwest/tree/main/examples)
+
+## Compatibility with other libraries
+
+See [compatibility docs](https://markussintonen.github.io/pyreqwest/pyreqwest/compatibility.html)
+