PyPI - impit - Versions diffs - 0.5.0__cp312-cp312-musllinux_1_2_aarch64.whl → 0.9.0__cp312-cp312-musllinux_1_2_aarch64.whl - Mend

impit 0.5.0__cp312-cp312-musllinux_1_2_aarch64.whl → 0.9.0__cp312-cp312-musllinux_1_2_aarch64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

impit/__init__.py +5 -0
impit/impit.cpython-312-aarch64-linux-musl.so +0 -0
impit/impit.pyi +503 -32
{impit-0.5.0.dist-info → impit-0.9.0.dist-info}/METADATA +11 -6
impit-0.9.0.dist-info/RECORD +9 -0
{impit-0.5.0.dist-info → impit-0.9.0.dist-info}/WHEEL +1 -1
impit.libs/{libgcc_s-e52197c3.so.1 → libgcc_s-39080030.so.1} +0 -0
impit-0.5.0.dist-info/RECORD +0 -9

impit/__init__.py CHANGED Viewed

@@ -1,3 +1,4 @@
+from importlib import metadata
 from typing import Literal
 from .cookies import Cookies
@@ -40,9 +41,12 @@ from .impit import (
     patch,
     post,
     put,
+    stream,
     trace,
 )
+__version__ = metadata.version('impit')
 __all__ = [
     'AsyncClient',
     'Browser',
@@ -84,6 +88,7 @@ __all__ = [
     'patch',
     'post',
     'put',
+    'stream',
     'trace',
 ]

impit/impit.cpython-312-aarch64-linux-musl.so CHANGED Viewed

Binary file

impit/impit.pyi CHANGED Viewed

@@ -2,7 +2,7 @@ from __future__ import annotations
 from http.cookiejar import CookieJar
 from .cookies import Cookies
-from typing import Literal
+from typing import Literal, Any
 from collections.abc import Iterator, AsyncIterator
 from contextlib import AbstractAsyncContextManager, AbstractContextManager
@@ -121,63 +121,322 @@ class RequestNotRead(StreamError):
 class StreamClosed(StreamError):
     """Represents an error when a stream is closed."""
 class Response:
-    """Response object returned by impit requests."""
+    """Response object returned by impit clients (:class:`Client` or :class:`AsyncClient` instances).
+    When constructed manually (e.g. for testing purposes), the following parameters can be provided:
+    Args:
+        status_code: HTTP status code of the response (e.g., 200, 404)
+        content: Response body as bytes (or None for empty body)
+        headers: Response headers as a dictionary (or None for empty headers)
+        default_encoding: Default encoding for the response text. Used only if `content-type` header is not present or does not specify a charset.
+        url: Final URL of the response.
+    """
     status_code: int
-    """HTTP status code (e.g., 200, 404)"""
+    """HTTP status code of the response (e.g., 200, 404).
+    .. tip::
+        If the status code indicates an error (4xx or 5xx), you can raise an `HTTPStatusError` exception using the :meth:`raise_for_status` method.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.status_code) # 200
+    """
     reason_phrase: str
-    """HTTP reason phrase (e.g., 'OK', 'Not Found')"""
+    """HTTP reason phrase for the response (e.g., 'OK', 'Not Found'). This maps the numerical :attr:`status_code` to a human-readable string.
+     .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.reason_phrase) # 'OK'
+    """
     http_version: str
-    """HTTP version (e.g., 'HTTP/1.1', 'HTTP/2')"""
+    """HTTP version (e.g., 'HTTP/1.1', 'HTTP/2') negotiated for the response during the TLS handshake.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.http_version) # 'HTTP/2'
+    """
     headers: dict[str, str]
-    """Response headers as a dictionary"""
+    """Response headers as a Python dictionary.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.headers) # {'content-type': 'text/html; charset=utf-8', ... }
+    """
     text: str
-    """Response body as text. Decoded from `content` using `encoding`."""
+    """Response body as text. Decoded from :attr:`content` using :attr:`encoding`.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.text) # '<!DOCTYPE html>...'
+    """
     encoding: str
-    """Response content encoding"""
+    """Response content encoding. Determined from `content-type` header or by bytestream prescan. Falls back to 'utf-8' if not found.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.encoding) # 'utf-8'
+    This can be used to decode the `Response` body manually. By default, :attr:`text` uses this encoding to decode :attr:`content`.
+    """
     is_redirect: bool
-    """Whether the response is a redirect"""
+    """`True` if the response is a redirect (has a 3xx status code), `False` otherwise.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.is_redirect) # False
+    """
     url: str
-    """Final URL"""
+    """The final URL of the response. This may differ from the requested URL if redirects were followed (see the `follow_redirects` parameter in :class:`Client` and :class:`AsyncClient`).
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.url) # 'https://crawlee.dev'
+    """
     content: bytes
-    """Response body as bytes"""
+    """Contains the response body as bytes. If the response was created with `stream=True`, this will be empty until the content is read using :meth:`read` or :meth:`iter_bytes`.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.content) # b'<!DOCTYPE html>...'
+    """
     is_closed: bool
-    """Whether the response is closed"""
+    """
+    True if the response has been closed using the :meth:`close` method, `False` otherwise.
+    Closing a response releases any underlying resources (e.g., network connections).
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev")
+        print(response.is_closed) # False
+        response.close()
+        print(response.is_closed) # True
+    """
     is_stream_consumed: bool
-    """Whether the response stream has been consumed or closed"""
+    """Whether the response stream has been consumed or closed.
+    If this is `True`, calling :meth:`read` or :meth:`iter_bytes` will raise a :class:`StreamConsumed` or :class:`StreamClosed` error.
+    The read response body is still available in the :attr:`content` attribute.
+    .. code-block:: python
+        response = await client.get("https://crawlee.dev", stream=True)
+        print(response.is_stream_consumed) # False
+        for chunk in response.iter_bytes():
+            pass
+        print(response.is_stream_consumed) # True
+        # calling response.read() or response.iter_bytes() again will raise StreamConsumed error
+        # read the content of the response using response.content
+    """
+    def __init__(
+        self,
+        status_code: int,
+        *,
+        content: bytes | None = None,
+        headers: dict[str, str] | None = None,
+        default_encoding: str | None = None,
+        url: str | None = None,
+    ) -> None:
+        """Initialize a Response object.
+        Args:
+            status_code: HTTP status code
+            content: Response body as bytes
+            headers: Response headers as a dictionary
+            default_encoding: Default encoding for the response text. Used only if `content-type` header is not present or does not specify a charset.
+            url: Final URL of the response
+        """
     def read(self) -> bytes:
-        """Read the response content as bytes."""
+        """Read the response content as bytes. Synchronous version of :meth:`aread`.
+        Useful for consuming the entire response body in one go (not chunked).
+        .. code-block:: python
+            with Client() as client:
+                with client.stream("GET", "https://example.com/largefile") as response:
+                    content = response.read()
+                    process(content)  # Process the entire content at once
+        """
     def iter_bytes(self) -> Iterator[bytes]:
-        """Iterate over the response content in chunks."""
+        """Iterate over the response content in chunks. Synchronous version of :meth:`aiter_bytes`.
+        Useful for streaming large responses without loading the entire content into memory.
+        .. code-block:: python
+            with Client() as client:
+                with client.stream("GET", "https://example.com/largefile") as response:
+                    for chunk in response.iter_bytes():
+                        process(chunk)  # Process each chunk as it is received
+        """
     async def aread(self) -> bytes:
-        """Asynchronously read the response content as bytes."""
+        """Asynchronously read the response content as bytes. Asynchronous version of :meth:`read`.
+        Useful for consuming the entire response body in one go (not chunked).
+        .. code-block:: python
+            async with AsyncClient() as client:
+                async with client.stream("GET", "https://example.com/largefile") as response:
+                    content = await response.aread()
+                    process(content)  # Process the entire content at once
+        """
     def aiter_bytes(self) -> AsyncIterator[bytes]:
-        """Asynchronously iterate over the response content in chunks."""
+        """Asynchronously iterate over the response content in chunks. Asynchronous version of :meth:`iter_bytes`.
+        Useful for streaming large responses without loading the entire content into memory.
+        .. code-block:: python
+            async with AsyncClient() as client:
+                async with client.stream("GET", "https://example.com/largefile") as response:
+                    async for chunk in response.aiter_bytes():
+                        process(chunk)  # Process each chunk as it is received
+        """
+    def json(self) -> Any:
+        """Parse the response content as JSON.
+        .. note::
+            This method will raise a `DecodingError` if the response content is not valid JSON.
+        .. code-block:: python
+            response = await client.get("https://api.example.com/data")
+            data = response.json()
+            print(data)  # Parsed JSON data as a Python object (dict, list, etc.)
+        """
     def close(self) -> None:
-        """Close the response and release resources."""
+        """Close the response and release resources.
+        .. warning::
+            You should not need to call this method directly.
+            Use the `with` statement to ensure proper resource management when working with synchronous clients.
+            .. code-block:: python
+                with impit.stream('GET', get_httpbin_url('/')) as response:
+                    assert response.status_code == 200
+                assert response.is_closed is True
+        """
     async def aclose(self) -> None:
-        """Asynchronously close the response and release resources."""
+        """Asynchronously close the response and release resources.
+        .. note::
+            This method is for internal use only.
+            Use the `async with` statement to ensure proper resource management when working with asynchronous clients.
+            .. code-block:: python
+                async with impit.stream('GET', get_httpbin_url('/')) as response:
+                    assert response.status_code == 200
+                assert response.is_closed is True
+        """
 class Client:
-    """Synchronous HTTP client with browser impersonation capabilities."""
+    """Synchronous HTTP client with browser impersonation capabilities.
+        .. note::
+            You can reuse the :class:`Client` instance to make multiple requests.
+            All requests made by the same client will share the same configuration, resources (e.g., cookie jar and connection pool), and other settings.
+        Args:
+            browser: Browser to impersonate (`"chrome"` or `"firefox"`).
+                If this is `None` (default), no impersonation is performed.
+            http3:
+                If set to `True`, Impit will try to connect to the target servers using HTTP/3 protocol (if supported by the server).
+                .. note::
+                    The HTTP/3 support is experimental and may not work with all servers. The impersonation capabilities are limited when using HTTP/3.
+            proxy:
+                The proxy URL to use for all the requests made by this client.
+                This can be an HTTP, HTTPS, or SOCKS proxy.
+            timeout:
+                Default request timeout in seconds.
+                This value can be overridden for individual requests.
+            verify:
+                If set to `False`, impit will not verify SSL certificates.
+                This can be used to ignore TLS errors (e.g., self-signed certificates).
+                True by default.
+            default_encoding:
+                Default encoding for response.text field (e.g., "utf-8", "cp1252").
+                Overrides `content-type` headers and bytestream prescan.
+            follow_redirects:
+                If set to `True` the client will automatically follow HTTP redirects (3xx responses).
+                `False` by default.
+            max_redirects:
+                Maximum number of redirects to follow if the `follow_redirects` option is enabled.
+                Default is 20.
+            cookie_jar:
+                Cookie jar to store cookies in.
+                This is a `http.cookiejar.CookieJar` instance.
+                By default, :class:`Client` doesn't store cookies between requests.
+            cookies: httpx-compatible cookies object.
+                These are the cookies to include in all requests (to the matching servers) made by this client.
+            headers: Default HTTP headers to include in requests.
+                These headers will be included in all requests made by this client.
+                Default is an empty dictionary.
+            local_address:
+                Local address to bind the client to.
+                Useful for testing purposes or when you want to bind the client to a specific network interface.
+                Can be an IP address in the format `xxx.xxx.xxx.xxx` (for IPv4) or `ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff` (for IPv6).
+        """
     def __enter__(self) -> Client:
         """Enter the runtime context related to this object."""
@@ -199,6 +458,7 @@ class Client:
         cookie_jar: CookieJar | None = None,
         cookies: Cookies | None = None,
         headers: dict[str, str] | None = None,
+        local_address: str | None = None,
     ) -> None:
         """Initialize a synchronous HTTP client.
@@ -212,7 +472,11 @@ class Client:
                 header and bytestream prescan.
             follow_redirects: Whether to follow redirects (default: False)
             max_redirects: Maximum number of redirects to follow (default: 20)
-            cookie_jar: Cookie jar to store cookies in
+            cookie_jar: Cookie jar to store cookies in.
+            cookies: httpx-compatible cookies object.
+            headers: Default HTTP headers to include in requests.
+            local_address: Local address to bind the client to. Useful for testing purposes or when you want to bind the client to a specific network interface.
+                Can be an IP address in the format "xxx.xxx.xxx.xxx" (for IPv4) or "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" (for IPv6).
         """
     def get(
@@ -412,6 +676,17 @@ class Client:
     ) -> AbstractContextManager[Response]:
         """Make a streaming request with the specified method.
+        This method returns a context manager that yields a streaming :class:`Response` object.
+        See the following example for usage:
+        .. code-block:: python
+            with Client() as client:
+                with client.stream("GET", "https://example.com/largefile") as response:
+                    for chunk in response.iter_bytes():
+                        process(chunk)  # Process each chunk as it is received
         Args:
             method: HTTP method (e.g., "get", "post")
             url: URL to request
@@ -420,14 +695,79 @@ class Client:
             headers: HTTP headers
             timeout: Request timeout in seconds (overrides default timeout)
             force_http3: Force HTTP/3 protocol
-        Returns:
-            Response object
         """
 class AsyncClient:
-    """Asynchronous HTTP client with browser impersonation capabilities."""
+    """Asynchronous HTTP client with browser impersonation capabilities.
+        .. note::
+            You can reuse the :class:`Client` instance to make multiple requests.
+            All requests made by the same client will share the same configuration, resources (e.g., cookie jar and connection pool), and other settings.
+        Args:
+            browser: Browser to impersonate (`"chrome"` or `"firefox"`).
+                If this is `None` (default), no impersonation is performed.
+            http3:
+                If set to `True`, Impit will try to connect to the target servers using HTTP/3 protocol (if supported by the server).
+                .. note::
+                    The HTTP/3 support is experimental and may not work with all servers. The impersonation capabilities are limited when using HTTP/3.
+            proxy:
+                The proxy URL to use for all the requests made by this client.
+                This can be an HTTP, HTTPS, or SOCKS proxy.
+            timeout:
+                Default request timeout in seconds.
+                This value can be overridden for individual requests.
+            verify:
+                If set to `False`, impit will not verify SSL certificates.
+                This can be used to ignore TLS errors (e.g., self-signed certificates).
+                True by default.
+            default_encoding:
+                Default encoding for response.text field (e.g., "utf-8", "cp1252").
+                Overrides `content-type` headers and bytestream prescan.
+            follow_redirects:
+                If set to `True` the client will automatically follow HTTP redirects (3xx responses).
+                `False` by default.
+            max_redirects:
+                Maximum number of redirects to follow if the `follow_redirects` option is enabled.
+                Default is 20.
+            cookie_jar:
+                Cookie jar to store cookies in.
+                This is a `http.cookiejar.CookieJar` instance.
+                By default, :class:`Client` doesn't store cookies between requests.
+            cookies: httpx-compatible cookies object.
+                These are the cookies to include in all requests (to the matching servers) made by this client.
+            headers: Default HTTP headers to include in requests.
+                These headers will be included in all requests made by this client.
+                Default is an empty dictionary.
+            local_address:
+                Local address to bind the client to.
+                Useful for testing purposes or when you want to bind the client to a specific network interface.
+                Can be an IP address in the format `xxx.xxx.xxx.xxx` (for IPv4) or `ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff` (for IPv6).
+        """
     async def __aenter__(self) -> AsyncClient:
         """Enter the runtime context related to this object."""
@@ -448,6 +788,7 @@ class AsyncClient:
         cookie_jar: CookieJar | None = None,
         cookies: Cookies | None = None,
         headers: dict[str, str] | None = None,
+        local_address: str | None = None,
     ) -> None:
         """Initialize an asynchronous HTTP client.
@@ -461,7 +802,11 @@ class AsyncClient:
                 header and bytestream prescan.
             follow_redirects: Whether to follow redirects (default: False)
             max_redirects: Maximum number of redirects to follow (default: 20)
-            cookie_jar: Cookie jar to store cookies in
+            cookie_jar: Cookie jar to store cookies in.
+            cookies: httpx-compatible cookies object.
+            headers: Default HTTP headers to include in requests.
+            local_address: Local address to bind the client to. Useful for testing purposes or when you want to bind the client to a specific network interface.
+                Can be an IP address in the format "xxx.xxx.xxx.xxx" (for IPv4) or "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" (for IPv6).
         """
     async def get(
@@ -502,6 +847,7 @@ class AsyncClient:
             headers: HTTP headers
             timeout: Request timeout in seconds (overrides default timeout)
             force_http3: Force HTTP/3 protocol
         """
     async def put(
@@ -660,6 +1006,17 @@ class AsyncClient:
     ) -> AbstractAsyncContextManager[Response]:
         """Make an asynchronous streaming request with the specified method.
+        This method returns a AsyncContextManager that yields a streaming :class:`Response` object.
+        See the following example for usage:
+        .. code-block:: python
+            with Client() as client:
+                with client.stream("GET", "https://example.com/largefile") as response:
+                    for chunk in response.iter_bytes():
+                        process(chunk)  # Process each chunk as it is received
         Args:
             method: HTTP method (e.g., "get", "post")
             url: URL to request
@@ -671,6 +1028,40 @@ class AsyncClient:
         """
+def stream(
+    method: str,
+    url: str,
+    content: bytes | bytearray | list[int] | None = None,
+    data: dict[str, str] | None = None,
+    headers: dict[str, str] | None = None,
+    timeout: float | None = None,
+    force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
+) -> AbstractContextManager[Response]:
+    """Make a streaming request without creating a client instance.
+    Args:
+        method: HTTP method (e.g., "get", "post")
+        url: URL to request
+        content: Raw content to send
+        data: Form data to send in request body
+        headers: HTTP headers
+        timeout: Request timeout in seconds
+        force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
+    Returns:
+        Response object
+    """
 def get(
     url: str,
     content: bytes | bytearray | list[int] | None = None,
@@ -678,6 +1069,11 @@ def get(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a GET request without creating a client instance.
@@ -688,6 +1084,11 @@ def get(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -701,6 +1102,11 @@ def post(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a POST request without creating a client instance.
@@ -711,6 +1117,11 @@ def post(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -724,6 +1135,11 @@ def put(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a PUT request without creating a client instance.
@@ -734,6 +1150,11 @@ def put(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -747,6 +1168,11 @@ def patch(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a PATCH request without creating a client instance.
@@ -757,6 +1183,11 @@ def patch(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -770,6 +1201,11 @@ def delete(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a DELETE request without creating a client instance.
@@ -780,6 +1216,11 @@ def delete(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -793,6 +1234,11 @@ def head(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a HEAD request without creating a client instance.
@@ -803,6 +1249,11 @@ def head(
         headers: HTTP headers
         timeout: Request timeout in seconds
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     Returns:
         Response object
@@ -816,6 +1267,11 @@ def options(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make an OPTIONS request without creating a client instance.
@@ -826,6 +1282,11 @@ def options(
         headers: HTTP headers
         timeout: Request timeout in seconds (overrides default timeout)
         force_http3: Force HTTP/3 protocol
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
     """
@@ -836,6 +1297,11 @@ def trace(
     headers: dict[str, str] | None = None,
     timeout: float | None = None,
     force_http3: bool | None = None,
+    follow_redirects: bool | None = None,
+    max_redirects: int | None = None,
+    cookie_jar: CookieJar | None = None,
+    cookies: Cookies | None = None,
+    proxy: str | None = None,
 ) -> Response:
     """Make a TRACE request without creating a client instance.
@@ -846,4 +1312,9 @@ def trace(
         headers: HTTP headers
         timeout: Request timeout in seconds (overrides default timeout)
         force_http3: Force HTTP/3 protocol
-    """
+        follow_redirects: Whether to follow redirects (default: False)
+        max_redirects: Maximum number of redirects to follow (default: 20)
+        cookie_jar: Cookie jar to store cookies in.
+        cookies: httpx-compatible cookies object.
+        proxy: Proxy URL to use to make the request.
+    """

{impit-0.5.0.dist-info → impit-0.9.0.dist-info}/METADATA RENAMED Viewed

@@ -1,30 +1,35 @@
 Metadata-Version: 2.4
 Name: impit
-Version: 0.5.0
+Version: 0.9.0
 Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-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 :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Summary: A library for making HTTP requests through browser impersonation
 Keywords: apify,http,requests,browser,impersonation
 Author: Jindřich Bär
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Homepage, https://apify.github.io/impit/
+Project-URL: Homepage, https://apify.github.io/impit/python
 Project-URL: Apify homepage, https://apify.com
-Project-URL: Changelog, https://github.com/apify/impit/blob/master/CHANGELOG.md
-Project-URL: Documentation, https://apify.github.io/impit/
+Project-URL: Changelog, https://github.com/apify/impit/blob/master/impit-python/CHANGELOG.md
+Project-URL: Documentation, https://apify.github.io/impit/python
 Project-URL: Issue tracker, https://github.com/apify/impit/issues
 Project-URL: Repository, https://github.com/apify/impit
 # `impit` for Python
+> This documents the `impit` Python package, which provides bindings for the `impit` library.
+>
+> See documentation for the JavaScript/TypeScript version of `impit` [here](https://apify.github.io/impit/js/).
 `impit` is a Python package that provides bindings for the [`impit`](https://github.com/apify/impit) library.
 It allows you to switch the TLS fingerprints and the HTTP headers of your requests, while still using the same API as `httpx` or `requests`.

impit-0.9.0.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,9 @@
+impit-0.9.0.dist-info/METADATA,sha256=rUem-pBLg6yAp-5ARgqksLUOut5yrVmou21VKAv3Qy0,2833
+impit-0.9.0.dist-info/WHEEL,sha256=Ybp1oDkJBU8Ab2KYc9w5pff1H2QW76YQNrhpVtngYLU,109
+impit.libs/libgcc_s-39080030.so.1,sha256=fIO6GHOh8Ft9CR0Geu7wSUb9Xnl122iTtrxQQ9TAkTQ,789673
+impit/__init__.py,sha256=uZsD0XMFOt7QwVUgNcnVQkDF85y9n5slxoxR0wim7ug,1664
+impit/cookies.py,sha256=bfNPkMk2Y0bG-RqqMMJxIfvCMZp_fDclYAnSlsCwkIg,7009
+impit/impit.cpython-312-aarch64-linux-musl.so,sha256=AI1xdQe5SzTukDAFyF9dk_lGD0HB7zfv4_w5QrWTh9U,12849873
+impit/impit.pyi,sha256=IxLCuSkx3mHQcwcSS65lveoM5QYvMeJcU-Mhhdelyng,45730
+impit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impit-0.9.0.dist-info/RECORD,,

{impit-0.5.0.dist-info → impit-0.9.0.dist-info}/WHEEL RENAMED Viewed

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.2)
+Generator: maturin (1.10.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-musllinux_1_2_aarch64

impit.libs/{libgcc_s-e52197c3.so.1 → libgcc_s-39080030.so.1} RENAMED Viewed

Binary file

impit-0.5.0.dist-info/RECORD DELETED Viewed

@@ -1,9 +0,0 @@
-impit-0.5.0.dist-info/METADATA,sha256=jAR2pd38pzVyDF5_FcJBLb8wQ0T09Uo4hhlc0EATk2s,2562
-impit-0.5.0.dist-info/WHEEL,sha256=yzMofySxBd_sCC6GdUFsLvTUQBdsMACo3giXnMZiTjw,108
-impit.libs/libgcc_s-e52197c3.so.1,sha256=vkPW1Auw6CH9Bjk7frmX3hry_1H9c0tRI0Ncyg71WUI,724137
-impit/__init__.py,sha256=NDkCeC_CQn9xqqN2fFSWmvkN9oM-ysMnB1WDkvX-Pbc,1566
-impit/cookies.py,sha256=bfNPkMk2Y0bG-RqqMMJxIfvCMZp_fDclYAnSlsCwkIg,7009
-impit/impit.cpython-312-aarch64-linux-musl.so,sha256=e5ARcUXimjYKG2vCwj7P4dlxPEfucUgeaUxIgVWz_BA,12653057
-impit/impit.pyi,sha256=zcqv2dQQ6YsH7DrPSxNh0A4_U5yWi0LnNc5eJAxQF4I,25969
-impit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-impit-0.5.0.dist-info/RECORD,,