bas-http 1.0.1__tar.gz → 1.0.3__tar.gz

bas_http-1.0.3/PKG-INFO

@@ -0,0 +1,532 @@
+Metadata-Version: 2.4
+Name: bas-http
+Version: 1.0.3
+Summary: Copy-paste your browser's request, bas handles the rest. No impersonation needed. Zero dependencies.
+Author: bas
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/bas-http/
+Project-URL: Repository, https://pypi.org/project/bas-http/
+Project-URL: Issues, https://pypi.org/project/bas-http/
+Keywords: http,curl,cookie,scraping,browser,devtools,requests
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# bas
+
+Copy-paste your browser's request, bas handles the rest.
+
+No impersonation needed. No fingerprint chasing. No broken cookies. Just grab your headers + cookies from DevTools and go.
+
+## Why bas?
+
+| Problem | bas | bas |
+|---------|----------|-----|
+| Cookies lost during redirects | **BUG** | **Fixed** |
+| Cookies not accumulating across requests | **BUG** | **Fixed** |
+| Manual Cookie header construction | Yes | **Auto-injected** |
+| Requires curl-impersonate | Yes | **No — pure Python** |
+| Browser fingerprint updates | Constant chase | **None — bring your own headers** |
+| External dependencies | Yes | **Zero** |
+
+## Installation
+
+```bash
+pip install bas-http
+```
+
+## Quick Start
+
+### Method 1: Paste a curl command from DevTools (Recommended)
+
+This is the fastest way. Copy a curl command from your browser and bas does the rest.
+
+```
+1. Open browser DevTools (F12) → Network tab
+2. Make a request on the website
+3. Right-click the request → "Copy as cURL"
+4. Paste into Python
+```
+
+```python
+import bas
+
+# Paste your curl command (use r'' raw string to preserve backslashes)
+s = bas.from_curl(r'''curl "https://example.com/page" ^
+  -H "accept: text/html,application/xhtml+xml" ^
+  -H "accept-language: en-US,en;q=0.9" ^
+  -H "user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36" ^
+  -b "cf_clearance=abc123; session_id=xyz; token=def456"''')
+
+# Now make requests — all headers and cookies are auto-injected
+r = s.get("https://example.com/page")
+print(r.status_code)
+print(r.text)
+
+# Follow-up requests keep the same headers and cookies
+r2 = s.get("https://example.com/dashboard")
+print(r2.status_code)
+
+# Add more cookies manually if needed
+s.set_cookie("new_cookie", "value", domain="example.com")
+r3 = s.get("https://example.com/api/data")
+```
+
+### Method 2: Build headers manually
+
+If you have headers copied from DevTools (not as a curl command):
+
+```python
+import bas
+
+s = bas.Session()
+
+# Paste your headers from DevTools → Network → Headers tab
+s.headers = {
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "max-age=0",
+    "sec-ch-ua": '"Chromium";v="137", "Not/A)Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Windows"',
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "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/137.0.0.0 Safari/537.36",
+}
+
+# Add your cookies from DevTools → Application → Cookies
+s.set_cookie("cf_clearance", "abc123", domain="example.com")
+s.set_cookie("session_id", "xyz", domain="example.com")
+s.set_cookie("csrf_token", "def456", domain="example.com")
+
+# Go!
+r = s.get("https://example.com/page")
+print(r.status_code, len(r.text))
+```
+
+### Method 3: Headers + cookies in one call
+
+```python
+import bas
+
+s = bas.from_headers(
+    url="https://example.com",
+    headers={
+        "user-agent": "Mozilla/5.0 ...",
+        "accept": "text/html,...",
+    },
+    cookies={
+        "cf_clearance": "abc123",
+        "session": "xyz",
+    },
+)
+
+r = s.get("https://example.com/page")
+```
+
+## HTTP Methods
+
+```python
+import bas
+
+s = bas.from_curl(r'''curl "https://example.com" -b "session=abc"''')
+
+# GET
+r = s.get("https://example.com/page")
+
+# POST with form data
+r = s.post("https://example.com/login", data={"username": "user", "password": "pass"})
+
+# POST with JSON
+r = s.post("https://example.com/api", json={"key": "value"})
+
+# PUT
+r = s.put("https://example.com/api/123", json={"name": "updated"})
+
+# DELETE
+r = s.delete("https://example.com/api/123")
+
+# PATCH
+r = s.patch("https://example.com/api/123", json={"name": "patched"})
+
+# HEAD
+r = s.head("https://example.com/page")
+```
+
+## Response Object
+
+```python
+r = s.get("https://example.com/page")
+
+# Status code
+print(r.status_code)        # 200
+print(r.ok)                  # True (status < 400)
+print(r.reason_phrase)       # "OK"
+
+# Content
+print(r.text)                # Decoded text
+print(r.body)                # Raw bytes
+print(r.json)                # Parsed JSON
+print(r.content_type)        # "text/html; charset=utf-8"
+
+# Headers
+print(r.headers)             # Case-insensitive headers dict
+print(r.headers["content-type"])
+
+# URL info
+print(r.url)                 # Final URL (after redirects)
+print(r.ip)                  # Server IP
+print(r.http_version)        # "1.1" or "2.0"
+print(r.elapsed)             # Response time in seconds
+
+# Redirect history
+for resp in r.history:
+    print(resp.status_code, resp.url)
+
+# Raise exception on error
+r.raise_for_status()  # Raises HTTPError if status >= 400
+
+# Iterate over content
+for chunk in r.iter_content(chunk_size=8192):
+    process(chunk)
+
+for line in r.iter_lines():
+    print(line)
+```
+
+## Cookie Management
+
+### Auto-injection
+
+bas automatically injects cookies into every request. No manual header construction needed.
+
+```python
+import bas
+
+s = bas.from_curl(r'''curl "https://example.com" -b "session=abc123; token=xyz"''')
+
+# This request automatically has Cookie: session=abc123; token=xyz
+r = s.get("https://example.com/page")
+
+# See what cookies were sent
+print(r.request.headers.get("Cookie"))
+# "session=abc123; token=xyz"
+```
+
+### Set cookies manually
+
+```python
+s = bas.Session()
+s.set_cookie("name", "value", domain="example.com", path="/")
+```
+
+### Get cookies for a URL
+
+```python
+cookies = s.get_cookies("https://example.com/page")
+print(cookies)  # {"session": "abc123", "token": "xyz"}
+```
+
+### Clear all cookies
+
+```python
+s.clear_cookies()
+```
+
+### Save cookies to file
+
+```python
+# JSON format
+s.save_cookies("cookies.json")
+
+# Netscape format (compatible with curl/wget)
+s.save_cookies("cookies.txt", format="netscape")
+```
+
+### Load cookies from file
+
+```python
+s.load_cookies("cookies.json")
+s.load_cookies("cookies.txt", format="netscape")
+```
+
+### Cookie accumulation across requests
+
+When the server sends Set-Cookie headers, bas automatically stores them:
+
+```python
+s = bas.Session()
+
+# Server sets cookies in this response
+r1 = s.get("https://example.com/login")
+# Set-Cookie: session_id=abc123; Path=/
+# Set-Cookie: user=john; Path=/
+
+# These cookies are automatically sent with the next request
+r2 = s.get("https://example.com/dashboard")
+# Cookie: session_id=abc123; user=john
+```
+
+### Cookies survive redirects
+
+```python
+# Server redirects and sets more cookies
+r = s.get("https://example.com/page")
+# 302 → https://example.com/dashboard
+# Set-Cookie: tracking=xyz; Path=/
+
+# ALL cookies are preserved through redirects
+# No cookies lost (unlike bas!)
+```
+
+## Session Persistence
+
+Keep a session alive across multiple script runs:
+
+```python
+import bas
+
+s = bas.Session()
+
+# Try to load previous session
+try:
+    s.load_cookies("my_session.json")
+except FileNotFoundError:
+    pass
+
+# Make requests
+r = s.get("https://example.com/page")
+
+# Save session for next run
+s.save_cookies("my_session.json")
+```
+
+## Parse curl commands
+
+```python
+from bas.curl_parser import parse_curl, print_curl_summary
+
+# See what's in a curl command
+print_curl_summary(r'''curl "https://example.com" -H "User-Agent: ..." -b "cookie=value"''')
+
+# Or get it as a dict
+parsed = parse_curl(r'''curl "https://example.com" -H "User-Agent: ..." -b "cookie=value"''')
+print(parsed["method"])     # "GET"
+print(parsed["url"])        # "https://example.com"
+print(parsed["headers"])    # {"User-Agent": "..."}
+print(parsed["cookies"])    # {"cookie": "value"}
+print(parsed["user_agent"]) # "Mozilla/5.0 ..."
+print(parsed["referer"])    # "..."
+```
+
+## SSL Verification
+
+```python
+# Disable SSL verification (default is enabled)
+s = bas.Session(verify=False)
+
+# Or per-request
+r = s.get("https://self-signed.example.com", verify=False)
+```
+
+## Timeouts
+
+```python
+# Set default timeout (seconds)
+s = bas.Session(timeout=60)
+
+# Or per-request
+r = s.get("https://slow.example.com", timeout=120)
+```
+
+## Redirects
+
+```python
+# Follow redirects (default: True)
+r = s.get("https://example.com/page")
+
+# Don't follow redirects
+r = s.get("https://example.com/page", allow_redirects=False)
+print(r.status_code)  # 302
+print(r.location)     # "https://example.com/dashboard"
+
+# Set max redirects
+s = bas.Session(max_redirects=5)
+```
+
+## Proxy Support
+
+```python
+# TODO: Proxy support coming in v1.1
+```
+
+## Real-World Example: Web Scraping
+
+```python
+import bas
+
+# Step 1: Copy curl from DevTools
+s = bas.from_curl(r'''curl "https://spaceshooter.net/faucet/ltc" ^
+  -H "accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" ^
+  -H "accept-language: en-US,en;q=0.9" ^
+  -H "sec-ch-ua: \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"" ^
+  -H "sec-ch-ua-mobile: ?0" ^
+  -H "sec-ch-ua-platform: \"Windows\"" ^
+  -H "sec-fetch-dest: document" ^
+  -H "sec-fetch-mode: navigate" ^
+  -H "sec-fetch-site: none" ^
+  -H "upgrade-insecure-requests: 1" ^
+  -H "user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36" ^
+  -b "captcha=rscaptcha; cf_clearance=abc123; ci_session=xyz123; uf=def456"''')
+
+# Step 2: Make the request
+r = s.get("https://spaceshooter.net/faucet/ltc")
+
+# Step 3: Parse the response
+if r.ok:
+    print("Success!")
+    print(f"Status: {r.status_code}")
+    print(f"Content length: {len(r.text)}")
+    print(f"Cookies after request: {s.get_cookies('https://spaceshooter.net')}")
+else:
+    print(f"Failed: {r.status_code}")
+```
+
+## Real-World Example: Form Submission
+
+```python
+import bas
+
+# Copy the POST request curl from DevTools
+s = bas.from_curl(r'''curl "https://example.com/login" ^
+  -H "content-type: application/x-www-form-urlencoded" ^
+  -H "user-agent: Mozilla/5.0 ..." ^
+  -H "referer: https://example.com/login" ^
+  -b "csrf_token=abc123" ^
+  --data-raw "username=myuser&password=mypass"''')
+
+r = s.post("https://example.com/login", data={
+    "username": "myuser",
+    "password": "mypass",
+})
+
+print(r.status_code)
+```
+
+## Comparison with bas
+
+### bas (BROKEN)
+
+```python
+from curl_cffi.requests import Session
+
+s = Session(impersonate="chrome131")
+
+# Cookies lost during redirects!
+r1 = s.get("https://example.com/page")  # 302 redirect
+# r1 is missing cookies from Set-Cookie headers!
+
+# Cookies not accumulating!
+r2 = s.get("https://example.com/page")
+# r2 has LOST cookies from r1!
+```
+
+### bas (FIXED)
+
+```python
+import bas
+
+s = bas.from_curl(r'''curl "https://example.com" -b "session=abc"''')
+
+# Cookies survive redirects!
+r1 = s.get("https://example.com/page")  # 302 redirect
+# ALL cookies preserved through redirect
+
+# Cookies accumulate!
+r2 = s.get("https://example.com/dashboard")
+# r2 has ALL cookies from r1 + new ones
+
+# No manual Cookie header needed!
+# bas auto-injects cookies from the jar
+```
+
+## API Reference
+
+### `bas.from_curl(curl_cmd, **kwargs)` → Session
+
+Create a Session from a curl command. Main entry point.
+
+### `bas.from_headers(url, headers, cookies, **kwargs)` → Session
+
+Create a Session from raw headers and cookies.
+
+### `bas.Session(headers, cookies, verify, timeout, allow_redirects, max_redirects)`
+
+Pure Python HTTP session. Zero external dependencies.
+
+**Methods:**
+- `get(url, **kwargs)` → Response
+- `post(url, **kwargs)` → Response
+- `put(url, **kwargs)` → Response
+- `delete(url, **kwargs)` → Response
+- `patch(url, **kwargs)` → Response
+- `head(url, **kwargs)` → Response
+- `set_cookie(name, value, domain, path)` → None
+- `get_cookies(url)` → dict
+- `clear_cookies()` → None
+- `save_cookies(filepath, format)` → None
+- `load_cookies(filepath, format)` → None
+
+### `bas.Cookie(name, value, domain, path, expires, max_age, secure, http_only, same_site)`
+
+Individual cookie object with RFC 6265 compliance.
+
+### `bas.CookieJar`
+
+Thread-safe cookie container. Full RFC 6265 domain/path matching.
+
+**Methods:**
+- `add(cookie)` → None
+- `remove(cookie)` → None
+- `get(name, domain, path)` → Cookie | None
+- `match(url)` → list[Cookie]
+- `to_header(url)` → str
+- `parse_set_cookie(header, url)` → Cookie
+- `save_json(filepath)` → None
+- `load_json(filepath)` → None
+- `save_netscape(filepath)` → None
+- `load_netscape(filepath)` → None
+
+### `bas.Response`
+
+HTTP response object.
+
+**Properties:**
+- `status_code` (int): HTTP status code
+- `ok` (bool): True if status < 400
+- `text` (str): Decoded text content
+- `body` (bytes): Raw bytes
+- `json` (Any): Parsed JSON
+- `headers` (Headers): Response headers
+- `url` (str): Final URL
+- `elapsed` (float): Response time
+- `history` (list): Redirect history
+- `cookies` (CookieJar): Cookie jar
+
+## License
+
+MIT

{bas_http-1.0.1 → bas_http-1.0.3}/bas/README.md

@@ -6,7 +6,7 @@ No impersonation needed. No fingerprint chasing. No broken cookies. Just grab yo
 
 ## Why bas?
 
-| Problem | curlcffi | bas |
+| Problem | bas | bas |
 |---------|----------|-----|
 | Cookies lost during redirects | **BUG** | **Fixed** |
 | Cookies not accumulating across requests | **BUG** | **Fixed** |
@@ -265,7 +265,7 @@ r = s.get("https://example.com/page")
 # Set-Cookie: tracking=xyz; Path=/
 
 # ALL cookies are preserved through redirects
-# No cookies lost (unlike curlcffi!)
+# No cookies lost (unlike bas!)
 ```
 
 ## Session Persistence
@@ -402,9 +402,9 @@ r = s.post("https://example.com/login", data={
 print(r.status_code)
 ```
 
-## Comparison with curlcffi
+## Comparison with bas
 
-### curlcffi (BROKEN)
+### bas (BROKEN)
 
 ```python
 from curl_cffi.requests import Session

{bas_http-1.0.1 → bas_http-1.0.3}/bas/__init__.py

@@ -28,7 +28,7 @@ from .curl_parser import parse_curl, curl_to_session, print_curl_summary
 from .cookies import Cookie, CookieJar
 from .models import Headers, PreparedRequest, Response, HTTPError
 
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 __author__ = "bas"
 
 

{bas_http-1.0.1 → bas_http-1.0.3}/bas/_curl.py

@@ -2,7 +2,7 @@
 Low-level ctypes bindings for libcurl with curl-impersonate support.
 
 This module provides Python bindings to libcurl (or curl-impersonate if available)
-using ctypes. It avoids cffi compilation issues that plague curlcffi.
+using ctypes. It avoids cffi compilation issues that plague bas.
 """
 
 import ctypes

{bas_http-1.0.1 → bas_http-1.0.3}/bas/cookies.py

@@ -1,7 +1,7 @@
 """
 RFC 6265 compliant CookieJar.
 
-This module fixes the major cookie issues in curlcffi:
+This module fixes the major cookie issues in bas:
   1. Cookies lost during redirects (#55)
   2. Cookies not accumulating across session requests (#582)
   3. Need for manual cookie header management
@@ -226,7 +226,7 @@ class CookieJar:
     """
     Thread-safe, RFC 6265 compliant cookie jar.
 
-    This is the heart of bas's cookie handling. Unlike curlcffi's
+    This is the heart of bas's cookie handling. Unlike bas's
     approach (which relies on libcurl's internal cookie engine and loses
     cookies during redirects), bas manages cookies entirely in Python.
 

{bas_http-1.0.1 → bas_http-1.0.3}/bas/impersonate.py

@@ -5,7 +5,7 @@ This module provides browser fingerprint profiles that override HTTP/2
 settings and headers to mimic real browsers. When curl-impersonate is
 available, it also enables TLS fingerprint mimicry.
 
-Unlike curlcffi which bundles impersonation in a single enum, bas
+Unlike bas which bundles impersonation in a single enum, bas
 separates the concerns:
   - TLS impersonation (requires curl-impersonate library)
   - HTTP/2 fingerprinting (works with standard libcurl)
@@ -348,7 +348,7 @@ PROFILES: dict[str, BrowserProfile] = {
     "edge131": EDGE131,
 }
 
-# Aliases for curlcffi compatibility
+# Aliases for bas compatibility
 CHROME_ALIASES = {
     "chrome": CHROME131,
     "chrome99": CHROME131,  # closest available
@@ -385,7 +385,7 @@ def get_profile(name: str) -> BrowserProfile:
     """
     Get a browser profile by name.
 
-    Supports both exact names and curlcffi-compatible aliases.
+    Supports both exact names and bas-compatible aliases.
 
     Args:
         name: Profile name (e.g., "chrome131", "firefox120", "chrome")

{bas_http-1.0.1 → bas_http-1.0.3}/bas/session.py

@@ -2,7 +2,7 @@
 Session-based HTTP client with proper cookie management.
 
 This is the main public API of bas. It provides a requests-like
-interface while fixing ALL of curlcffi's cookie bugs:
+interface while fixing ALL of bas's cookie bugs:
 
   Fix #1: Cookies accumulate correctly across requests in a session
   Fix #2: Cookies are inherited during redirects (even cross-domain)
@@ -92,7 +92,7 @@ class Session:
     """
     A persistent HTTP session with automatic cookie management.
 
-    Key improvements over curlcffi.Session:
+    Key improvements over bas.Session:
       - Cookies ALWAYS accumulate across requests (fixes #582)
       - Cookies are inherited during redirects (fixes #55)
       - Automatic Cookie header injection (no manual construction)
@@ -358,7 +358,7 @@ class Session:
         )
 
         # ── CRITICAL: Parse Set-Cookie and update our jar ──
-        # This is what curlcffi gets wrong — it relies on curl's internal
+        # This is what bas gets wrong — it relies on curl's internal
         # cookie engine which loses cookies during redirects.
         self._cookie_jar.parse_set_cookie_headers(
             response_headers,
@@ -485,7 +485,7 @@ class Session:
         3. Re-apply cookies for the next request via our jar
         4. Never lose a single cookie
 
-        This fixes curlcffi issue #55 where cookies were lost during redirects.
+        This fixes bas issue #55 where cookies were lost during redirects.
         """
         if history is None:
             history = []
@@ -508,7 +508,7 @@ class Session:
             redirect_url = urljoin(response.url, location)
 
             # ── COOKIE FIX: Parse Set-Cookie before redirect ──
-            # curlcffi loses cookies here because it switches to curl's
+            # bas loses cookies here because it switches to curl's
             # internal cookie engine for the redirect. We don't.
             # (Already done in _curl_perform above)