httpr 0.1.0__cp39-abi3-win_amd64.whl

httpr/__init__.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from functools import partial
+from typing import TYPE_CHECKING, TypedDict
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import Unpack
+else:
+    from typing import Unpack
+
+
+from .httpr import RClient
+
+if TYPE_CHECKING:
+    from .httpr import ClientRequestParams, HttpMethod, RequestParams, Response
+else:
+
+    class _Unpack:
+        @staticmethod
+        def __getitem__(*args, **kwargs):
+            pass
+
+    Unpack = _Unpack()
+    RequestParams = ClientRequestParams = TypedDict
+
+
+class Client(RClient):
+    """Initializes an HTTP client"""
+
+    def __init__(
+        self,
+        auth: tuple[str, str | None] | None = None,
+        auth_bearer: str | None = None,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        cookie_store: bool | None = True,
+        referer: bool | None = True,
+        proxy: str | None = None,
+        timeout: float | None = 30,
+        follow_redirects: bool | None = True,
+        max_redirects: int | None = 20,
+        verify: bool | None = True,
+        ca_cert_file: str | None = None,
+        client_pem: str | None = None,
+        https_only: bool | None = False,
+        # http2_only: bool | None = False,
+    ):
+        """
+        Args:
+            auth: a tuple containing the username and an optional password for basic authentication. Default is None.
+            auth_bearer: a string representing the bearer token for bearer token authentication. Default is None.
+            params: a map of query parameters to append to the URL. Default is None.
+            headers: an optional map of HTTP headers to send with requests.
+            cookies: an optional map of cookies to send with requests as the `Cookie` header.
+            cookie_store: enable a persistent cookie store. Received cookies will be preserved and included
+                 in additional requests. Default is True.
+            referer: automatic setting of the `Referer` header. Default is True.
+            proxy: proxy URL for HTTP requests, example: "socks5://127.0.0.1:9150". Default is None.
+            timeout: timeout for HTTP requests in seconds. Default is 30.
+            follow_redirects: a boolean to enable or disable following redirects. Default is True.
+            max_redirects: the maximum number of redirects if `follow_redirects` is True. Default is 20.
+            verify: an optional boolean indicating whether to verify SSL certificates. Default is True.
+            ca_cert_file: path to CA certificate store. Default is None.
+            client_pem: path to client certificate file. Default is None.
+            https_only: restrict the Client to be used with HTTPS only requests. Default is False.
+            http2_only: if true - use only HTTP/2, if false - use only HTTP/1. Default is False.
+        """
+        super().__init__()
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *args):
+        del self
+
+    def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        # Validate the HTTP method. Raise an exception if it's not supported.
+        if method not in ["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+        return super().request(method=method, url=url, **kwargs)
+
+    def get(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="GET", url=url, **kwargs)
+
+    def head(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="HEAD", url=url, **kwargs)
+
+    def options(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="OPTIONS", url=url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="DELETE", url=url, **kwargs)
+
+    def post(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="POST", url=url, **kwargs)
+
+    def put(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="PUT", url=url, **kwargs)
+
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        return self.request(method="PATCH", url=url, **kwargs)
+
+
+class AsyncClient(Client):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    async def __aenter__(self) -> AsyncClient:
+        return self
+
+    async def __aexit__(self, *args):
+        del self
+
+    async def _run_sync_asyncio(self, fn, *args, **kwargs):
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, partial(fn, *args, **kwargs))
+
+    async def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self._run_sync_asyncio(super().request, method=method, url=url, **kwargs)
+
+    async def get(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="GET", url=url, **kwargs)
+
+    async def head(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="HEAD", url=url, **kwargs)
+
+    async def options(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="OPTIONS", url=url, **kwargs)
+
+    async def delete(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="DELETE", url=url, **kwargs)
+
+    async def post(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="POST", url=url, **kwargs)
+
+    async def put(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="PUT", url=url, **kwargs)
+
+    async def patch(self, url: str, **kwargs: Unpack[RequestParams]):  # type: ignore
+        return await self.request(method="PATCH", url=url, **kwargs)
+
+
+def request(
+    method: HttpMethod,
+    url: str,
+    verify: bool | None = True,
+    ca_cert_file: str | None = None,
+    client_pem: str | None = None,
+    **kwargs: Unpack[RequestParams],
+):
+    """
+    Args:
+        method: the HTTP method to use (e.g., "GET", "POST").
+        url: the URL to which the request will be made.
+        verify: an optional boolean indicating whether to verify SSL certificates. Default is True.
+        ca_cert_file: path to CA certificate store. Default is None.
+        client_pem: path to client certificate file. Default is None.
+        auth: a tuple containing the username and an optional password for basic authentication. Default is None.
+        auth_bearer: a string representing the bearer token for bearer token authentication. Default is None.
+        params: a map of query parameters to append to the URL. Default is None.
+        headers: an optional map of HTTP headers to send with requests. If `impersonate` is set, this will be ignored.
+        cookies: an optional map of cookies to send with requests as the `Cookie` header.
+        timeout: the timeout for the request in seconds. Default is 30.
+        content: the content to send in the request body as bytes. Default is None.
+        data: the form data to send in the request body. Default is None.
+        json: a JSON serializable object to send in the request body. Default is None.
+        files: a map of file fields to file paths to be sent as multipart/form-data. Default is None.
+    """
+    with Client(
+        verify=verify,
+        ca_cert_file=ca_cert_file,
+        client_pem=client_pem,
+    ) as client:
+        return client.request(method, url, **kwargs)
+
+
+def get(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="GET", url=url, **kwargs)
+
+
+def head(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="HEAD", url=url, **kwargs)
+
+
+def options(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="OPTIONS", url=url, **kwargs)
+
+
+def delete(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="DELETE", url=url, **kwargs)
+
+
+def post(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="POST", url=url, **kwargs)
+
+
+def put(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="PUT", url=url, **kwargs)
+
+
+def patch(url: str, **kwargs: Unpack[ClientRequestParams]):
+    return request(method="PATCH", url=url, **kwargs)

httpr/httpr.pyi

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Literal, TypedDict
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import Unpack
+else:
+    from typing import Unpack
+
+HttpMethod = Literal["GET", "HEAD", "OPTIONS", "DELETE", "POST", "PUT", "PATCH"]
+
+class RequestParams(TypedDict, total=False):
+    auth: tuple[str, str | None] | None
+    auth_bearer: str | None
+    params: dict[str, str] | None
+    headers: dict[str, str] | None
+    cookies: dict[str, str] | None
+    timeout: float | None
+    content: bytes | None
+    data: dict[str, Any] | None
+    json: Any | None
+    files: dict[str, str] | None
+
+class ClientRequestParams(RequestParams):
+    verify: bool | None
+    ca_cert_file: str | None
+    client_pem: str | None
+
+class Response:
+    @property
+    def content(self) -> bytes: ...
+    @property
+    def cookies(self) -> dict[str, str]: ...
+    @property
+    def headers(self) -> dict[str, str]: ...
+    @property
+    def status_code(self) -> int: ...
+    @property
+    def url(self) -> str: ...
+    @property
+    def encoding(self) -> str: ...
+    @property
+    def text(self) -> str: ...
+    def json(self) -> Any: ...
+    @property
+    def text_markdown(self) -> str: ...
+    @property
+    def text_plain(self) -> str: ...
+    @property
+    def text_rich(self) -> str: ...
+
+class RClient:
+    def __init__(
+        self,
+        auth: tuple[str, str | None] | None = None,
+        auth_bearer: str | None = None,
+        params: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        timeout: float | None = None,
+        cookie_store: bool | None = True,
+        referer: bool | None = True,
+        proxy: str | None = None,
+        follow_redirects: bool | None = True,
+        max_redirects: int | None = 20,
+        verify: bool | None = True,
+        ca_cert_file: str | None = None,
+        client_pem: str | None = None,
+        https_only: bool | None = False,
+        http2_only: bool | None = False,
+    ): ...
+    @property
+    def headers(self) -> dict[str, str]: ...
+    @headers.setter
+    def headers(self, headers: dict[str, str]) -> None: ...
+    @property
+    def cookies(self) -> dict[str, str]: ...
+    @cookies.setter
+    def cookies(self, cookies: dict[str, str]) -> None: ...
+    @property
+    def proxy(self) -> str | None: ...
+    @proxy.setter
+    def proxy(self, proxy: str) -> None: ...
+    def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def get(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def head(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def options(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def delete(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def post(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def put(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+    def patch(self, url: str, **kwargs: Unpack[RequestParams]) -> Response: ...
+
+def request(method: HttpMethod, url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def get(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def head(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def options(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def delete(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def post(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def put(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...
+def patch(url: str, **kwargs: Unpack[ClientRequestParams]) -> Response: ...

httpr-0.1.0.dist-info/METADATA

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: httpr
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: certifi ; extra == 'dev'
+Requires-Dist: pytest>=8.1.1 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25.3 ; extra == 'dev'
+Requires-Dist: typing-extensions ; python_full_version < '3.12' and extra == 'dev'
+Requires-Dist: mypy>=1.14.1 ; extra == 'dev'
+Requires-Dist: ruff>=0.9.2 ; extra == 'dev'
+Requires-Dist: maturin ; extra == 'dev'
+Requires-Dist: trustme ; extra == 'dev'
+Requires-Dist: mkdocs-material ; extra == 'docs'
+Requires-Dist: httpr[dev] ; extra == 'scratch'
+Requires-Dist: matplotlib ; extra == 'scratch'
+Requires-Dist: pandas ; extra == 'scratch'
+Requires-Dist: jupyter ; extra == 'scratch'
+Requires-Dist: ipykernel ; extra == 'scratch'
+Requires-Dist: httpx ; extra == 'scratch'
+Requires-Dist: gunicorn ; extra == 'scratch'
+Requires-Dist: uvicorn ; extra == 'scratch'
+Requires-Dist: trustme ; extra == 'scratch'
+Requires-Dist: starlette ; extra == 'scratch'
+Requires-Dist: fastapi ; extra == 'scratch'
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: scratch
+License-File: LICENSE
+Summary: Fast HTTP client for Python
+Keywords: python,request
+Author: thomasht86
+License: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# httpr
+
+**Blazing fast http-client** for Python in Rust 🦀 that can be used as drop-in replacement for `httpx` in most cases.
+
+- **Fast**: httpr is built on top of `reqwests` which is a blazing fast http client in Rust. Check out the [benchmark](#benchmark).
+- **Both async and sync**: httpr provides both a sync and async client.
+- **Lightweight**: httpr is a lightweight http client with 0 python-dependencies.
+- **Async**: first-class support for async/await. 
+- **http2**: httpr supports http2.
+- **mTLS**: httpr supports mTLS.
+- **Zero python dependencies**: httpr is a pure rust library with no python dependencies.
+
+## Table of Contents
+
+- [httpr](#httpr)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+    - [Install with uv](#install-with-uv)
+    - [Install from PyPI](#install-from-pypi)
+  - [Benchmark](#benchmark)
+  - [Usage](#usage)
+    - [I. Client](#i-client)
+      - [Client methods](#client-methods)
+      - [Response object](#response-object)
+      - [Examples](#examples)
+    - [II. AsyncClient](#ii-asyncclient)
+  - [Precompiled wheels](#precompiled-wheels)
+  - [Acknowledgements](#acknowledgements)
+
+## Installation
+
+### Install with uv
+
+```python
+uv add httpr
+```
+
+or
+
+```python
+uv pip install httpr
+```
+
+### Install from PyPI
+
+```python
+pip install -U httpr
+```
+
+## Benchmark
+
+![](https://github.com/thomasht86/httpr/blob/main/benchmark.jpg?raw=true)
+
+## Usage
+
+### I. Client
+
+```python
+class Client:
+    """Initializes an HTTP client.
+
+    Args:
+        auth (tuple[str, str| None] | None): Username and password for basic authentication. Default is None.
+        auth_bearer (str | None): Bearer token for authentication. Default is None.
+        params (dict[str, str] | None): Default query parameters to include in all requests. Default is None.
+        headers (dict[str, str] | None): Default headers to send with requests. 
+        cookies (dict[str, str] | None): - Map of cookies to send with requests as the `Cookie` header.
+        timeout (float | None): HTTP request timeout in seconds. Default is 30.
+        cookie_store (bool | None): Enable a persistent cookie store. Received cookies will be preserved and included
+            in additional requests. Default is True.
+        referer (bool | None): Enable or disable automatic setting of the `Referer` header. Default is True.
+        proxy (str | None): Proxy URL for HTTP requests. Example: "socks5://127.0.0.1:9150". Default is None.
+        follow_redirects (bool | None): Whether to follow redirects. Default is True.
+        max_redirects (int | None): Maximum redirects to follow. Default 20. Applies if `follow_redirects` is True.
+        verify (bool | None): Verify SSL certificates. Default is True.
+        ca_cert_file (str | None): Path to CA certificate store. Default is None.
+        https_only` (bool | None): Restrict the Client to be used with HTTPS only requests. Default is `false`.
+        http2_only` (bool | None): If true - use only HTTP/2; if false - use only HTTP/1. Default is `false`.
+
+    """
+```
+
+#### Client methods
+
+The `Client` class provides a set of methods for making HTTP requests: `get`, `head`, `options`, `delete`, `post`, `put`, `patch`, each of which internally utilizes the `request()` method for execution. The parameters for these methods closely resemble those in `httpx`.
+```python
+def get(
+    url: str,
+    params: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: dict[str, str] | None = None,
+    auth: tuple[str, str| None] | None = None,
+    auth_bearer: str | None = None,
+    timeout: float | None = 30,
+):
+    """Performs a GET request to the specified URL.
+
+    Args:
+        url (str): The URL to which the request will be made.
+        params (dict[str, str] | None): A map of query parameters to append to the URL. Default is None.
+        headers (dict[str, str] | None): A map of HTTP headers to send with the request. Default is None.
+        cookies (dict[str, str] | None): - An optional map of cookies to send with requests as the `Cookie` header.
+        auth (tuple[str, str| None] | None): A tuple containing the username and an optional password
+            for basic authentication. Default is None.
+        auth_bearer (str | None): A string representing the bearer token for bearer token authentication. Default is None.
+        timeout (float | None): The timeout for the request in seconds. Default is 30.
+
+    """
+```
+```python
+def post(
+    url: str,
+    params: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: dict[str, str] | None = None,
+    content: bytes | None = None,
+    data: dict[str, Any] | None = None,
+    json: Any | None = None,
+    files: dict[str, str] | None = None,
+    auth: tuple[str, str| None] | None = None,
+    auth_bearer: str | None = None,
+    timeout: float | None = 30,
+):
+    """Performs a POST request to the specified URL.
+
+    Args:
+        url (str): The URL to which the request will be made.
+        params (dict[str, str] | None): A map of query parameters to append to the URL. Default is None.
+        headers (dict[str, str] | None): A map of HTTP headers to send with the request. Default is None.
+        cookies (dict[str, str] | None): - An optional map of cookies to send with requests as the `Cookie` header.
+        content (bytes | None): The content to send in the request body as bytes. Default is None.
+        data (dict[str, Any] | None): The form data to send in the request body. Default is None.
+        json (Any | None): A JSON serializable object to send in the request body. Default is None.
+        files (dict[str, str] | None): A map of file fields to file paths to be sent as multipart/form-data. Default is None.
+        auth (tuple[str, str| None] | None): A tuple containing the username and an optional password
+            for basic authentication. Default is None.
+        auth_bearer (str | None): A string representing the bearer token for bearer token authentication. Default is None.
+        timeout (float | None): The timeout for the request in seconds. Default is 30.
+
+    """
+```
+
+#### Response object
+
+The `Client` class returns a `Response` object that contains the following attributes and methods:
+
+```python
+resp.content
+resp.cookies
+resp.encoding
+resp.headers
+resp.json()
+resp.status_code
+resp.text
+resp.text_markdown  # html is converted to markdown text using html2text-rs
+resp.text_plain  # html is converted to plain text
+resp.text_rich  # html is converted to rich text
+resp.url
+```
+
+#### Examples
+
+```python
+import httpr
+
+# Initialize the client
+client = httpr.Client() 
+
+# GET request
+resp = client.get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# GET request with passing params and setting timeout
+params = {"param1": "value1", "param2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", params=params, timeout=10)
+print(r.text)
+
+# POST Binary Request Data
+content = b"some_data"
+resp = client.post(url="https://httpbin.org/anything", content=content)
+print(r.text)
+
+# POST Form Encoded Data
+data = {"key1": "value1", "key2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", data=data)
+print(r.text)
+
+# POST JSON Encoded Data
+json = {"key1": "value1", "key2": "value2"}
+resp = client.post(url="https://httpbin.org/anything", json=json)
+print(r.text)
+
+# POST Multipart-Encoded Files
+files = {'file1': '/home/root/file1.txt', 'file2': 'home/root/file2.txt'}
+r = client.post("https://httpbin.org/post", files=files)
+print(r.text)
+
+# Authentication using user/password
+auth = ("user", "password")
+resp = client.post(url="https://httpbin.org/anything", auth=auth)
+print(r.text)
+
+# Authentication using auth bearer
+auth_bearer = "bearerXXXXXXXXXXXXXXXXXXXX"
+resp = client.post(url="https://httpbin.org/anything", auth_bearer=auth_bearer)
+print(r.text)
+
+# Using proxy or env var HTTPR_PROXY
+resp = httpr.Client(proxy="http://127.0.0.1:8080").get("https://tls.peet.ws/api/all")
+print(resp.json())
+export HTTPR_PROXY="socks5://127.0.0.1:1080"
+resp = httpr.Client().get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# Using custom CA certificate store: env var HTTPR_CA_BUNDLE
+resp = httpr.Client(ca_cert_file="/cert/cacert.pem").get("https://tls.peet.ws/api/all")
+print(resp.json())
+resp = httpr.Client(ca_cert_file=certifi.where()).get("https://tls.peet.ws/api/all")
+print(resp.json())
+export HTTPR_CA_BUNDLE="/home/user/Downloads/cert.pem"
+resp = httpr.Client().get("https://tls.peet.ws/api/all")
+print(resp.json())
+
+# You can also use convenience functions that use a default Client instance under the hood:
+# httpr.get() | httpr.head() | httpr.options() | httpr.delete() | httpr.post() | httpr.patch() | httpr.put()
+resp = httpr.get("https://httpbin.org/anything")
+print(r.text)
+```
+
+### II. AsyncClient
+
+`httpr.AsyncClient()` is an asynchronous wrapper around the `httpr.Client` class, offering the same functions, behavior, and input arguments.
+
+```python
+import asyncio
+import logging
+
+import httpr
+
+async def aget_text(url):
+    async with httpr.AsyncClient() as client:
+        resp = await client.get(url)
+        return resp.text
+
+async def main():
+    urls = ["https://nytimes.com/", "https://cnn.com/", "https://abcnews.go.com/"]
+    tasks = [aget_text(u) for u in urls]
+    results = await asyncio.gather(*tasks)
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    asyncio.run(main())
+```
+
+## Precompiled wheels
+
+Provides precompiled wheels for the following platforms:
+
+- 🐧 linux: `amd64`, `aarch64`, `armv7` (aarch64 and armv7 builds are `manylinux_2_34` compatible. `ubuntu>=22.04`, `debian>=12`)
+- 🐧 musllinux: `amd64`, `aarch64`
+- 🪟 windows: `amd64`
+- 🍏 macos: `amd64`, `aarch64`.
+  
+## Acknowledgements
+
+- [PRIMP](https://github.com/deedy5/primp): *A lot* of code is borrowed from PRIMP, that wraps rust library `rquest` for python in a similar way.
+- [reqwests](https://github.com/seanmonstar/reqwest): The rust library that powers httpr.
+- [pyo3](https://github.com/PyO3/pyo3)
+- [maturin](https://github.com/PyO3/maturin)

httpr-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+httpr-0.1.0.dist-info/METADATA,sha256=QCm1NtyBhldWbNhFEZwp6KaOuoUlIYVQ5f_lu6OLT28,12325
+httpr-0.1.0.dist-info/WHEEL,sha256=R8ZEnni7m2eO5M7FTZ3FjvjlbxsclsOWT9kw6XK1Agc,94
+httpr-0.1.0.dist-info/licenses/LICENSE,sha256=O15TIxUAXq6sSpPu0K3CJu_dT5ZzCgIk7hQtZsf0lEk,1084
+httpr/httpr.pyi,sha256=VbROFo3ZXTacg2Fe0kvQWZ0RXXrAK08F4ivUL0cvGtY,3830
+httpr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpr/__init__.py,sha256=mJu6IccmRh6mzdliCqwFnQtpsYuKYPpeTvvcuYqQBdw,8833
+httpr/httpr.pyd,sha256=fuRxnteKqCmw5LP4iCo13HS-AY8Gjhjsv9iJRdRSwLw,4543488
+httpr-0.1.0.dist-info/RECORD,,

httpr-0.1.0.dist-info/WHEEL

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

httpr-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 deedy5
+
+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.