never-primp 1.0.2__cp38-abi3-win_amd64.whl → 1.1.1__cp38-abi3-win_amd64.whl

never_primp/__init__.py

@@ -142,7 +142,7 @@ 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,
+            cookies: dict[str, str] | None = None,
             cookie_store: bool | None = True,
             split_cookies: bool | None = False,
             referer: bool | None = True,
@@ -155,26 +155,29 @@ class Client(RClient):
             verify: bool | None = True,
             ca_cert_file: str | None = None,
             https_only: bool | None = False,
+            http1_only: bool | None = False,
             http2_only: bool | None = False,
-            # Performance optimization parameters
             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 mechanism
-            retry_count: int | None = None,
-            retry_backoff: float | None = None,
     ):
         """
         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. 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.
+            headers: an optional ordered map of HTTP headers with strict order preservation.
+                Headers will be sent in the exact order specified, with automatic positioning of:
+                - Host (first position)
+                - Content-Length (second position for POST/PUT/PATCH)
+                - Content-Type (third position if auto-calculated)
+                - cookie (second-to-last position)
+                - priority (last position)
                 Example: {"User-Agent": "...", "Accept": "...", "Accept-Language": "..."}
                 Note: Python 3.7+ dict maintains insertion order by default.
+            cookies: initial cookies to set for the client. These cookies will be included in all requests.
+                Can be updated later using client.cookies.update(). Default is None.
             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
@@ -207,11 +210,17 @@ class Client(RClient):
             verify: an optional boolean indicating whether to verify SSL certificates. Default is True.
             ca_cert_file: path to CA certificate store. 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.
+            http1_only: if true - use only HTTP/1.1. Default is False.
+            http2_only: if true - use only HTTP/2. Default is False.
+                Note: http1_only and http2_only are mutually exclusive. If both are true, http1_only takes precedence.
         """
         super().__init__()
         self._cookies_jar: CookieJar | None = None
 
+        # Set initial cookies if provided
+        if cookies:
+            self.update_cookies(cookies)
+
     @property
     def cookies(self) -> CookieJar:
         """
@@ -247,6 +256,79 @@ class Client(RClient):
         del self
 
     def request(self, method: HttpMethod, url: str, **kwargs: Unpack[RequestParams]) -> Response:
+        """
+        Send an HTTP request with support for requests-toolbelt MultipartEncoder.
+
+        Supports both native primp format and requests-toolbelt MultipartEncoder:
+        - Native: request(url, data={...}, files={...})
+        - Toolbelt: request(url, data=MultipartEncoder(...))
+        """
+        # Check if data is a MultipartEncoder from requests-toolbelt
+        data = kwargs.get('data')
+        if data is not None and hasattr(data, 'fields') and hasattr(data, 'content_type'):
+            # This looks like a MultipartEncoder
+            # Extract fields and convert to primp format
+            converted_data = {}
+            converted_files = {}
+
+            try:
+                # MultipartEncoder.fields is a dict-like object
+                for field_name, field_value in data.fields.items():
+                    if isinstance(field_value, tuple):
+                        # File field: (filename, file_obj, content_type)
+                        if len(field_value) >= 2:
+                            filename = field_value[0]
+                            file_obj = field_value[1]
+
+                            # Read the file content
+                            if hasattr(file_obj, 'read'):
+                                file_content = file_obj.read()
+                                # Reset file pointer if possible
+                                if hasattr(file_obj, 'seek'):
+                                    try:
+                                        file_obj.seek(0)
+                                    except:
+                                        pass
+                            else:
+                                file_content = file_obj
+
+                            # Add mime type if provided
+                            if len(field_value) >= 3:
+                                mime_type = field_value[2]
+                                converted_files[field_name] = (filename, file_content, mime_type)
+                            else:
+                                converted_files[field_name] = (filename, file_content)
+                    else:
+                        # Regular field
+                        if isinstance(field_value, bytes):
+                            converted_data[field_name] = field_value.decode('utf-8')
+                        else:
+                            converted_data[field_name] = str(field_value)
+
+                # Replace data and files in kwargs
+                if converted_data:
+                    kwargs['data'] = converted_data
+                else:
+                    kwargs.pop('data', None)
+
+                if converted_files:
+                    kwargs['files'] = converted_files
+
+            except Exception as e:
+                # If conversion fails, fall back to treating it as raw content
+                # Read the encoder as bytes and send as content
+                if hasattr(data, 'read'):
+                    kwargs['content'] = data.read()
+                    kwargs.pop('data', None)
+
+                    # Get content type from encoder
+                    if hasattr(data, 'content_type'):
+                        headers = kwargs.get('headers', {})
+                        if not isinstance(headers, dict):
+                            headers = dict(headers)
+                        headers['Content-Type'] = data.content_type
+                        kwargs['headers'] = headers
+
         return super().request(method=method, url=url, **kwargs)
 
     def get(self, url: str, **kwargs: Unpack[RequestParams]) -> Response:
@@ -277,12 +359,12 @@ 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,
+                 cookies: 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,
+                 timeout: float | None = None,
                  impersonate: IMPERSONATE | None = None,
                  impersonate_os: IMPERSONATE_OS | None = None,
                  follow_redirects: bool | None = True,
@@ -290,17 +372,39 @@ class AsyncClient(Client):
                  verify: bool | None = True,
                  ca_cert_file: str | None = None,
                  https_only: bool | None = False,
+                 http1_only: bool | None = False,
                  http2_only: bool | None = False,
                  # Performance optimization parameters
                  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 mechanism
-                 retry_count: int | None = None,
-                 retry_backoff: float | None = None,
                  ):
-        super().__init__()
+        super().__init__(
+            auth=auth,
+            auth_bearer=auth_bearer,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            cookie_store=cookie_store,
+            split_cookies=split_cookies,
+            referer=referer,
+            proxy=proxy,
+            timeout=timeout,
+            impersonate=impersonate,
+            impersonate_os=impersonate_os,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            verify=verify,
+            ca_cert_file=ca_cert_file,
+            https_only=https_only,
+            http1_only=http1_only,
+            http2_only=http2_only,
+            pool_idle_timeout=pool_idle_timeout,
+            pool_max_idle_per_host=pool_max_idle_per_host,
+            tcp_nodelay=tcp_nodelay,
+            tcp_keepalive=tcp_keepalive,
+        )
 
     async def __aenter__(self) -> AsyncClient:
         return self

never_primp/never_primp.pyi

@@ -38,7 +38,6 @@ 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
@@ -83,12 +82,12 @@ 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,
+        cookies: 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 = None,
         impersonate: IMPERSONATE | None = None,
         impersonate_os: IMPERSONATE_OS | None = None,
         follow_redirects: bool | None = True,
@@ -96,24 +95,18 @@ class RClient:
         verify: bool | None = True,
         ca_cert_file: str | None = None,
         https_only: bool | None = False,
+        http1_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: ...
-    @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: ...
@@ -143,14 +136,6 @@ class RClient:
     @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
     def proxy(self, proxy: str) -> None: ...