never-primp 1.0.1__tar.gz → 1.0.2__tar.gz

{never_primp-1.0.1 → never_primp-1.0.2}/.gitignore

@@ -1,5 +1,6 @@
 /target
 nul
+.claude
 # Byte-compiled / optimized / DLL files
 __pycache__/
 .pytest_cache/

{never_primp-1.0.1 → never_primp-1.0.2}/Cargo.lock

@@ -725,7 +725,7 @@ dependencies = [
 
 [[package]]
 name = "never_primp"
-version = "1.0.1"
+version = "1.0.2"
 dependencies = [
  "anyhow",
  "encoding_rs",

{never_primp-1.0.1 → never_primp-1.0.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "never_primp"
-version = "1.0.1"
+version = "1.0.2"
 edition = "2024"
 description = "基于原primp 重新优化调整的请求库"
 authors = ["Neverland"]

{never_primp-1.0.1 → never_primp-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: never_primp
-Version: 1.0.1
+Version: 1.0.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{never_primp-1.0.1 → never_primp-1.0.2}/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."""
 
@@ -103,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

{never_primp-1.0.1 → never_primp-1.0.2}/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

{never_primp-1.0.1 → never_primp-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "never_primp"
-version = "1.0.1"
+version = "1.0.2"
 description = "基于原primp 重新优化调整的请求库 - The fastest python HTTP client that can impersonate web browsers"
 readme = "README.md"
 requires-python = ">=3.8"

{never_primp-1.0.1 → never_primp-1.0.2}/src/lib.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::too_many_arguments)]
 use std::sync::{Arc, LazyLock, Mutex};
+use std::collections::HashSet;
 use std::time::Duration;
 
 use anyhow::Result;
@@ -48,6 +49,8 @@ pub struct RClient {
     client: Arc<Mutex<wreq::Client>>,
     // Cookie jar for manual cookie management
     cookie_jar: Arc<wreq::cookie::Jar>,
+    // Track deleted cookies (workaround for wreq not filtering expired cookies in get_all())
+    deleted_cookies: Arc<Mutex<std::collections::HashSet<String>>>,
     #[pyo3(get, set)]
     auth: Option<(String, Option<String>)>,
     #[pyo3(get, set)]
@@ -287,6 +290,7 @@ impl RClient {
         Ok(RClient {
             client,
             cookie_jar,
+            deleted_cookies: Arc::new(Mutex::new(HashSet::new())),
             auth,
             auth_bearer,
             params,
@@ -415,32 +419,136 @@ impl RClient {
         Ok(())
     }
 
-    #[pyo3(signature = (url))]
-    #[allow(unused_variables)]
-    fn get_cookies(&self, url: &str) -> Result<IndexMapSSR> {
+    /// Get all cookies from the jar without requiring a URL.
+    /// Returns a dictionary of cookie names to values.
+    fn get_all_cookies(&self) -> Result<IndexMapSSR> {
         let mut cookies = IndexMap::with_capacity_and_hasher(10, RandomState::default());
+        let deleted = self.deleted_cookies.lock().unwrap();
 
-        // Get all cookies from the jar
-        // Note: wreq's get_all() returns all cookies regardless of URL
-        // To get URL-specific cookies, you would need to filter manually or use get(name, uri) per cookie
         for cookie in self.cookie_jar.get_all() {
-            cookies.insert(cookie.name().to_string(), cookie.value().to_string());
+            let name = cookie.name();
+            // Filter out deleted cookies
+            if !deleted.contains(name) {
+                cookies.insert(name.to_string(), cookie.value().to_string());
+            }
         }
-
         Ok(cookies)
     }
 
-    #[pyo3(signature = (url, cookies))]
-    fn set_cookies(&self, url: &str, cookies: Option<IndexMapSSR>) -> Result<()> {
-        if let Some(cookies) = cookies {
-            let uri: wreq::Uri = url.parse()?;
+    /// Set a single cookie without requiring a URL.
+    ///
+    /// # Arguments
+    /// * `name` - Cookie name
+    /// * `value` - Cookie value
+    /// * `domain` - Optional domain (e.g., ".example.com"). If None, uses a wildcard domain.
+    /// * `path` - Optional path (e.g., "/"). If None, uses "/".
+    #[pyo3(signature = (name, value, domain=None, path=None))]
+    fn set_cookie(
+        &self,
+        name: String,
+        value: String,
+        domain: Option<String>,
+        path: Option<String>,
+    ) -> Result<()> {
+        let domain = domain.unwrap_or_else(|| "0.0.0.0".to_string());
+        let path = path.unwrap_or_else(|| "/".to_string());
+
+        // Construct a URL from domain and path
+        let url = format!("http://{}{}", domain, path);
+        let uri: wreq::Uri = url.parse()?;
+
+        let cookie_str = format!("{}={}", name, value);
+        self.cookie_jar.add_cookie_str(&cookie_str, &uri);
+
+        // Remove from deleted list
+        self.deleted_cookies.lock().unwrap().remove(&name);
+        Ok(())
+    }
 
-            for (name, value) in cookies {
-                // Format as "name=value" cookie string
-                let cookie_str = format!("{}={}", name, value);
-                self.cookie_jar.add_cookie_str(&cookie_str, &uri);
+    /// Get a single cookie value by name.
+    /// Returns None if the cookie doesn't exist.
+    #[pyo3(signature = (name))]
+    fn get_cookie(&self, name: String) -> Result<Option<String>> {
+        // Check if deleted
+        if self.deleted_cookies.lock().unwrap().contains(&name) {
+            return Ok(None);
+        }
+
+        for cookie in self.cookie_jar.get_all() {
+            if cookie.name() == name {
+                return Ok(Some(cookie.value().to_string()));
             }
         }
+        Ok(None)
+    }
+
+    /// Update multiple cookies at once without requiring a URL.
+    ///
+    /// # Arguments
+    /// * `cookies` - Dictionary of cookie names to values
+    /// * `domain` - Optional domain. If None, uses a wildcard domain.
+    /// * `path` - Optional path. If None, uses "/".
+    #[pyo3(signature = (cookies, domain=None, path=None))]
+    fn update_cookies(
+        &self,
+        cookies: IndexMapSSR,
+        domain: Option<String>,
+        path: Option<String>,
+    ) -> Result<()> {
+        let domain = domain.unwrap_or_else(|| "0.0.0.0".to_string());
+        let path = path.unwrap_or_else(|| "/".to_string());
+
+        let url = format!("http://{}{}", domain, path);
+        let uri: wreq::Uri = url.parse()?;
+
+        let mut deleted = self.deleted_cookies.lock().unwrap();
+        for (name, value) in cookies {
+            let cookie_str = format!("{}={}", name, value);
+            self.cookie_jar.add_cookie_str(&cookie_str, &uri);
+            // Remove from deleted list
+            deleted.remove(&name);
+        }
+        Ok(())
+    }
+
+    /// Delete a single cookie by name.
+    /// Sets the cookie to an empty value with Max-Age=0 to delete it.
+    #[pyo3(signature = (name))]
+    fn delete_cookie(&self, name: String) -> Result<()> {
+        // To delete a cookie, set it with an expiration in the past
+        let url = "http://0.0.0.0/";
+        let uri: wreq::Uri = url.parse()?;
+
+        // Set cookie with Max-Age=0 to delete it
+        let cookie_str = format!("{}=; Max-Age=0", name);
+        self.cookie_jar.add_cookie_str(&cookie_str, &uri);
+
+        // Add to deleted list
+        self.deleted_cookies.lock().unwrap().insert(name);
+        Ok(())
+    }
+
+    /// Clear all cookies from the jar.
+    /// Sets all cookies with Max-Age=0 to mark them as expired.
+    fn clear_cookies(&self) -> Result<()> {
+        // Get all cookie names first to avoid borrow issues
+        let cookie_names: Vec<String> = self.cookie_jar
+            .get_all()
+            .map(|c| c.name().to_string())
+            .collect();
+
+        // Set each cookie with Expires in the past to mark as deleted
+        let url = "http://0.0.0.0/";
+        let uri: wreq::Uri = url.parse()?;
+
+        let mut deleted = self.deleted_cookies.lock().unwrap();
+        for name in cookie_names {
+            // Use Expires with a date in the past (Unix epoch)
+            let cookie_str = format!("{}=; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0", name);
+            self.cookie_jar.add_cookie_str(&cookie_str, &uri);
+            // Add to deleted list
+            deleted.insert(name);
+        }
         Ok(())
     }
 

never_primp-1.0.2/test.py

@@ -0,0 +1,53 @@
+from never_primp import Client
+
+headers = {
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "accept-language": "en,zh-CN;q=0.9,zh;q=0.8,zh-HK;q=0.7",
+    "cache-control": "no-cache",
+    "pragma": "no-cache",
+    "priority": "u=0, i",
+    "referer": "https://hisky.aero/",
+    "sec-ch-ua": "\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"",
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": "\"Windows\"",
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "same-site",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"
+}
+cookies = {
+    "_gcl_au": "1.1.223070972.1761814157",
+    "cf_clearance": "sbUF9oZS4pm8XVVNE.dnxxtZA.ZaK_IUE1lAmJTQfME-1761814156-1.2.1.1-0j8chJiO99fUkkj9ScKLe3_NzwwYuNoB_8Y9nZf5GTAa0Fn0l8kcDxngl1aISqK7ZDiJ.YN1cfipphzCIn46LkoBNjVryWuORy4m_tEhJQDlaptDTEoVnYoe4MmrLRcTIFia4sDvJ5CdSiTqewQsawG51.w_thq8MRZ9Z2Obf7SoV6MNC2eyRbCm96orSApfuK2tURiL_0K9EeNfES92Ss8kDoKZXBane0dwO_5vdMY",
+    "_gid": "GA1.2.339976247.1761814157",
+    "_gat_UA-155319482-1": "1",
+    "_fbp": "fb.1.1761814157993.834210106761768202",
+    "ASP.NET_SessionId": "0eme0emlicujjzldxxilfrrh",
+    "_ga": "GA1.2.1350469137.1761814157",
+    "_ga_0KDTF1TCBJ": "GS2.1.s1761814157$o1$g1$t1761814185$j32$l0$h0"
+}
+url = "https://booking.hisky.aero/VARS/Public/deeplink.aspx"
+params = {
+    "TripType": "roundtrip",
+    "UserLanguage": "ro",
+    "Adult": "1",
+    "Child": "0",
+    "InfantLap": "0",
+    "UserCurrency": "USD",
+    "Origin1": "OTP",
+    "Destination2": "OTP",
+    "Destination1": "TSR",
+    "Origin2": "TSR",
+    "DepartureDate1": "31.10.2025",
+    "DepartureDate2": "31.10.2025",
+    "flightvoucher": ""
+}
+session = Client(proxy='http://127.0.0.1:7890')
+
+response = session.get(url, headers=headers, cookies=cookies, params=params)
+
+print(response.url)
+print(response.headers)
+print(response.cookies)
+print(session.get_all_cookies())

never_primp-1.0.1/test.py

@@ -1,20 +0,0 @@
-import never_primp as primp
-
-# Automatic cookie management (default)
-url = 'https://ip.smartdaili-china.com/json'
-client = primp.Client(cookie_store=True,
-                      # proxy="http://127.0.0.1:7890"
-                      )
-client.proxy = 'http://127.0.0.1:7890'
-response = client.get(url)
-print(response.text)
-# Cookies automatically stored and sent in next request
-
-# Manual cookie management
-cookies = client.get_cookies(url)  # Get all cookies
-print(cookies)  # {'session': 'abc123'}
-
-# Set cookies manually
-client.set_cookies(url, {"auth": "token123"})
-cookies = client.get_cookies(url)  # Get all cookies
-print(cookies)  # {'session': 'abc123'}