never-primp 1.0.0__cp38-abi3-manylinux_2_28_x86_64.whl → 1.0.2__cp38-abi3-manylinux_2_28_x86_64.whl

never_primp/__init__.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import asyncio
 import sys
 from functools import partial
-from typing import TYPE_CHECKING, TypedDict
+from typing import TYPE_CHECKING, TypedDict, Iterator
+from collections.abc import MutableMapping
 
 if sys.version_info <= (3, 11):
     from typing_extensions import Unpack
@@ -26,6 +27,112 @@ else:
     RequestParams = ClientRequestParams = TypedDict
 
 
+class CookieJar(MutableMapping):
+    """
+    A dict-like container for managing HTTP cookies, compatible with requests.Session.cookies API.
+
+    Examples:
+        client = Client()
+
+        # Set cookies
+        client.cookies['session_id'] = 'abc123'
+        client.cookies['user_token'] = 'xyz789'
+
+        # Get cookies
+        value = client.cookies['session_id']
+        value = client.cookies.get('user_token', 'default')
+
+        # Update multiple cookies
+        client.cookies.update({'key1': 'value1', 'key2': 'value2'})
+
+        # Delete cookies
+        del client.cookies['session_id']
+
+        # Clear all cookies
+        client.cookies.clear()
+
+        # Check existence
+        if 'session_id' in client.cookies:
+            print("Session exists")
+
+        # Convert to dict
+        all_cookies = dict(client.cookies)
+    """
+
+    def __init__(self, client: RClient):
+        """Initialize CookieJar with a reference to the client."""
+        self._client = client
+
+    def __getitem__(self, name: str) -> str:
+        """Get a cookie value by name."""
+        value = self._client.get_cookie(name)
+        if value is None:
+            raise KeyError(name)
+        return value
+
+    def __setitem__(self, name: str, value: str) -> None:
+        """Set a cookie by name."""
+        self._client.set_cookie(name, value)
+
+    def __delitem__(self, name: str) -> None:
+        """Delete a cookie by name."""
+        # Check if cookie exists first
+        if self._client.get_cookie(name) is None:
+            raise KeyError(name)
+        self._client.delete_cookie(name)
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over cookie names."""
+        return iter(self._client.get_all_cookies().keys())
+
+    def __len__(self) -> int:
+        """Return the number of cookies."""
+        return len(self._client.get_all_cookies())
+
+    def __contains__(self, name: object) -> bool:
+        """Check if a cookie exists."""
+        if not isinstance(name, str):
+            return False
+        return self._client.get_cookie(name) is not None
+
+    def __repr__(self) -> str:
+        """Return string representation of cookies."""
+        cookies = self._client.get_all_cookies()
+        return f"CookieJar({cookies})"
+
+    def get(self, name: str, default: str | None = None) -> str | None:
+        """Get a cookie value with a default fallback."""
+        value = self._client.get_cookie(name)
+        return value if value is not None else default
+
+    def update(self, cookies: dict[str, str], domain: str | None = None, path: str | None = None) -> None:
+        """
+        Update multiple cookies at once.
+
+        Args:
+            cookies: Dictionary of cookie names to values
+            domain: Optional domain for the cookies (e.g., ".example.com")
+            path: Optional path for the cookies (e.g., "/")
+        """
+        self._client.update_cookies(cookies, domain=domain, path=path)
+
+    def clear(self) -> None:
+        """Remove all cookies."""
+        self._client.clear_cookies()
+
+    def set(self, name: str, value: str, domain: str | None = None, path: str | None = None) -> None:
+        """
+        Set a single cookie with optional domain and path.
+
+        Args:
+            name: Cookie name
+            value: Cookie value
+            domain: Optional domain (e.g., ".example.com")
+            path: Optional path (e.g., "/")
+        """
+        self._client.set_cookie(name, value, domain=domain, path=path)
+
+
 class Client(RClient):
     """Initializes an HTTP client that can impersonate web browsers."""
 
@@ -35,7 +142,9 @@ class Client(RClient):
             auth_bearer: str | None = None,
             params: dict[str, str] | None = None,
             headers: dict[str, str] | None = None,
+            ordered_headers: dict[str, str] | None = None,
             cookie_store: bool | None = True,
+            split_cookies: bool | None = False,
             referer: bool | None = True,
             proxy: str | None = None,
             timeout: float | None = 30,
@@ -62,8 +171,16 @@ class Client(RClient):
             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. Ignored if `impersonate` is set.
+            ordered_headers: an optional ordered map of HTTP headers with strict order preservation.
+                Takes priority over `headers`. Use this for bypassing anti-bot detection that checks header order.
+                Example: {"User-Agent": "...", "Accept": "...", "Accept-Language": "..."}
+                Note: Python 3.7+ dict maintains insertion order by default.
             cookie_store: enable a persistent cookie store. Received cookies will be preserved and included
                  in additional requests. Default is True.
+            split_cookies: split cookies into multiple `cookie` headers (HTTP/2 style) instead of a single
+                `Cookie` header. Useful for mimicking browser behavior in HTTP/2. Default is False.
+                When True: cookie: a=1 \n cookie: b=2 \n cookie: c=3
+                When False: Cookie: a=1; b=2; c=3
             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.
@@ -93,6 +210,35 @@ class Client(RClient):
             http2_only: if true - use only HTTP/2, if false - use only HTTP/1. Default is False.
         """
         super().__init__()
+        self._cookies_jar: CookieJar | None = None
+
+    @property
+    def cookies(self) -> CookieJar:
+        """
+        Access the cookie jar for dict-like cookie management.
+
+        Returns:
+            CookieJar: A dict-like container for managing cookies.
+
+        Examples:
+            # Set cookies
+            client.cookies['session_id'] = 'abc123'
+
+            # Get cookies
+            value = client.cookies['session_id']
+
+            # Update cookies
+            client.cookies.update({'key': 'value'})
+
+            # Delete cookies
+            del client.cookies['session_id']
+
+            # Clear all
+            client.cookies.clear()
+        """
+        if self._cookies_jar is None:
+            self._cookies_jar = CookieJar(self)
+        return self._cookies_jar
 
     def __enter__(self) -> Client:
         return self
@@ -131,7 +277,9 @@ class AsyncClient(Client):
                  auth_bearer: str | None = None,
                  params: dict[str, str] | None = None,
                  headers: dict[str, str] | None = None,
+                 ordered_headers: dict[str, str] | None = None,
                  cookie_store: bool | None = True,
+                 split_cookies: bool | None = False,
                  referer: bool | None = True,
                  proxy: str | None = None,
                  timeout: float | None = 30,
@@ -150,7 +298,8 @@ class AsyncClient(Client):
                  tcp_keepalive: float | None = None,
                  # Retry mechanism
                  retry_count: int | None = None,
-                 retry_backoff: float | None = None):
+                 retry_backoff: float | None = None,
+                 ):
         super().__init__()
 
     async def __aenter__(self) -> AsyncClient:

never_primp/never_primp.pyi

@@ -38,6 +38,7 @@ class RequestParams(TypedDict, total=False):
     auth_bearer: str | None
     params: dict[str, str] | None
     headers: dict[str, str] | None
+    ordered_headers: dict[str, str] | None
     cookies: dict[str, str] | None
     timeout: float | None
     content: bytes | None
@@ -82,8 +83,10 @@ class RClient:
         auth_bearer: str | None = None,
         params: dict[str, str] | None = None,
         headers: dict[str, str] | None = None,
+        ordered_headers: dict[str, str] | None = None,
         timeout: float | None = None,
         cookie_store: bool | None = True,
+        split_cookies: bool | None = False,
         referer: bool | None = True,
         proxy: str | None = None,
         impersonate: IMPERSONATE | None = None,
@@ -94,14 +97,59 @@ class RClient:
         ca_cert_file: str | None = None,
         https_only: bool | None = False,
         http2_only: bool | None = False,
+        pool_idle_timeout: float | None = None,
+        pool_max_idle_per_host: int | None = None,
+        tcp_nodelay: bool | None = None,
+        tcp_keepalive: float | None = None,
+        retry_count: int | None = None,
+        retry_backoff: float | None = None,
     ): ...
     @property
     def headers(self) -> dict[str, str]: ...
     @headers.setter
     def headers(self, headers: dict[str, str]) -> None: ...
     def headers_update(self, headers: dict[str, str]) -> None: ...
-    def get_cookies(self, url: str) -> dict[str, str]: ...
-    def set_cookies(self, url: str, cookies: dict[str, str]) -> None: ...
+    @property
+    def ordered_headers(self) -> dict[str, str]: ...
+    @ordered_headers.setter
+    def ordered_headers(self, ordered_headers: dict[str, str]) -> None: ...
+    def ordered_headers_update(self, ordered_headers: dict[str, str]) -> None: ...
+    # Cookie management methods (no URL required)
+    def get_all_cookies(self) -> dict[str, str]: ...
+    def set_cookie(self, name: str, value: str, domain: str | None = None, path: str | None = None) -> None: ...
+    def get_cookie(self, name: str) -> str | None: ...
+    def update_cookies(self, cookies: dict[str, str], domain: str | None = None, path: str | None = None) -> None: ...
+    def delete_cookie(self, name: str) -> None: ...
+    def clear_cookies(self) -> None: ...
+    # Client properties
+    @property
+    def auth(self) -> tuple[str, str | None] | None: ...
+    @auth.setter
+    def auth(self, auth: tuple[str, str | None] | None) -> None: ...
+    @property
+    def auth_bearer(self) -> str | None: ...
+    @auth_bearer.setter
+    def auth_bearer(self, auth_bearer: str | None) -> None: ...
+    @property
+    def params(self) -> dict[str, str] | None: ...
+    @params.setter
+    def params(self, params: dict[str, str] | None) -> None: ...
+    @property
+    def timeout(self) -> float | None: ...
+    @timeout.setter
+    def timeout(self, timeout: float | None) -> None: ...
+    @property
+    def split_cookies(self) -> bool | None: ...
+    @split_cookies.setter
+    def split_cookies(self, split_cookies: bool | None) -> None: ...
+    @property
+    def retry_count(self) -> int | None: ...
+    @retry_count.setter
+    def retry_count(self, retry_count: int | None) -> None: ...
+    @property
+    def retry_backoff(self) -> float | None: ...
+    @retry_backoff.setter
+    def retry_backoff(self, retry_backoff: float | None) -> None: ...
     @property
     def proxy(self) -> str | None: ...
     @proxy.setter