bas-http 1.0.0__py3-none-any.whl

bas/simple_session.py

@@ -0,0 +1,299 @@
+"""
+Simple HTTP Session — no curl, no impersonation, no nonsense.
+
+Just give it your browser's headers + cookies and it works.
+Uses Python's built-in urllib — zero external dependencies.
+
+Usage:
+    from bas.simple_session import Session
+
+    s = Session()
+    s.headers = {
+        "User-Agent": "Mozilla/5.0 ...",
+        "Accept": "text/html,...",
+    }
+    s.set_cookie("cf_clearance", "abc123", domain="example.com")
+
+    r = s.get("https://example.com/page")
+    print(r.status_code, r.text)
+"""
+
+import json
+import ssl
+import threading
+import time
+from http.client import HTTPConnection, HTTPSConnection
+from typing import Any, Optional, Union
+from urllib.parse import urlparse, urlencode, urljoin, parse_qs
+
+from .cookies import Cookie, CookieJar
+from .models import Headers, PreparedRequest, Response
+
+
+class Session:
+    """
+    Simple HTTP session with automatic cookie management.
+
+    Uses Python's http.client — no external dependencies needed.
+    Just paste your browser's headers and cookies and go.
+    """
+
+    def __init__(
+        self,
+        headers: Optional[dict] = None,
+        cookies: Optional[dict] = None,
+        verify: bool = True,
+        timeout: float = 30,
+        allow_redirects: bool = True,
+        max_redirects: int = 20,
+        proxies: Optional[dict] = None,
+    ):
+        self._headers = Headers()
+        if headers:
+            self._headers.update(headers)
+
+        self._cookie_jar = CookieJar()
+        if cookies:
+            for name, value in cookies.items():
+                self.set_cookie(name, value)
+
+        self.verify = verify
+        self.timeout = timeout
+        self.allow_redirects = allow_redirects
+        self.max_redirects = max_redirects
+        self.proxies = proxies or {}
+        self._request_count = 0
+        self._lock = threading.Lock()
+
+    @property
+    def headers(self) -> Headers:
+        return self._headers
+
+    @headers.setter
+    def headers(self, value):
+        self._headers = Headers(value)
+
+    @property
+    def cookies(self) -> CookieJar:
+        return self._cookie_jar
+
+    def set_cookie(self, name: str, value: str, domain: str = "", path: str = "/"):
+        """Set a cookie. If domain is empty, it's set for all domains."""
+        self._cookie_jar.add(Cookie(
+            name=name, value=value, domain=domain, path=path,
+        ))
+
+    def clear_cookies(self):
+        self._cookie_jar.clear()
+
+    def _build_ssl_context(self):
+        """Build SSL context."""
+        ctx = ssl.create_default_context()
+        if not self.verify:
+            ctx.check_hostname = False
+            ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+
+    def _make_request(
+        self,
+        method: str,
+        url: str,
+        headers: Optional[dict] = None,
+        body: Optional[bytes] = None,
+    ) -> tuple[int, dict, bytes, str]:
+        """
+        Make a raw HTTP request.
+
+        Returns: (status_code, response_headers, body, effective_url)
+        """
+        parsed = urlparse(url)
+        host = parsed.hostname
+        port = parsed.port
+        path = parsed.path or "/"
+        if parsed.query:
+            path += "?" + parsed.query
+        is_https = parsed.scheme == "https"
+
+        # Build request headers
+        req_headers = Headers(dict(self._headers))
+        if headers:
+            req_headers.update(headers)
+
+        # Auto-inject cookies
+        cookie_header = self._cookie_jar.to_header(url)
+        if cookie_header:
+            req_headers["Cookie"] = cookie_header
+
+        # Remove headers that shouldn't be sent
+        for h in ["Host", "Connection"]:
+            req_headers.pop(h, None)
+
+        # Set Host header
+        if port and port != (443 if is_https else 80):
+            req_headers["Host"] = f"{host}:{port}"
+        else:
+            req_headers["Host"] = host
+
+        # Connection
+        if is_https:
+            conn = HTTPSConnection(
+                host, port, timeout=self.timeout,
+                context=self._build_ssl_context(),
+            )
+        else:
+            conn = HTTPConnection(host, port, timeout=self.timeout)
+
+        try:
+            conn.request(
+                method=method,
+                url=path,
+                body=body,
+                headers=dict(req_headers),
+            )
+
+            resp = conn.getresponse()
+
+            # Read response
+            resp_body = resp.read()
+
+            # Build response headers
+            resp_headers = Headers(dict(resp.getheaders()))
+
+            # Get effective URL
+            effective_url = url
+
+            return resp.status, dict(resp_headers), resp_body, effective_url
+
+        finally:
+            conn.close()
+
+    def _send(
+        self,
+        method: str,
+        url: str,
+        headers: Optional[dict] = None,
+        data: Optional[Union[str, bytes, dict]] = None,
+        json_data: Optional[Any] = None,
+        allow_redirects: Optional[bool] = None,
+    ) -> Response:
+        """Execute a request with redirect handling."""
+        if allow_redirects is None:
+            allow_redirects = self.allow_redirects
+
+        # Prepare body
+        body = None
+        if json_data is not None:
+            body = json.dumps(json_data).encode("utf-8")
+            if headers is None:
+                headers = {}
+            headers["Content-Type"] = "application/json"
+        elif data is not None:
+            if isinstance(data, dict):
+                body = urlencode(data).encode("utf-8")
+                if headers is None:
+                    headers = {}
+                if "Content-Type" not in {k.lower(): v for k, v in (headers or {}).items()}:
+                    headers["Content-Type"] = "application/x-www-form-urlencoded"
+            elif isinstance(data, str):
+                body = data.encode("utf-8")
+            elif isinstance(data, bytes):
+                body = data
+
+        start_time = time.time()
+        history = []
+
+        while True:
+            # Make the request
+            status, resp_headers, resp_body, effective_url = self._make_request(
+                method, url, headers, body,
+            )
+            elapsed = time.time() - start_time
+
+            # Build response
+            response = Response(
+                status_code=status,
+                headers=Headers(resp_headers),
+                body=resp_body,
+                url=effective_url,
+                elapsed=elapsed,
+            )
+
+            # Parse Set-Cookie from response
+            self._cookie_jar.parse_set_cookie_headers(resp_headers, effective_url)
+            response.cookies = self._cookie_jar
+
+            # Handle redirects
+            if not allow_redirects or not response.is_redirect:
+                break
+
+            location = response.location
+            if not location:
+                break
+
+            history.append(response)
+            url = urljoin(effective_url, location)
+
+            # Change method for 301/302/303
+            if status in (301, 302, 303):
+                method = "GET"
+                body = None
+                headers = None
+
+            if len(history) >= self.max_redirects:
+                break
+
+        response.history = history
+        self._request_count += 1
+        return response
+
+    # ── Public API ───────────────────────────────────────────────────────────
+
+    def get(self, url: str, **kwargs) -> Response:
+        return self._send("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs) -> Response:
+        return self._send("POST", url, **kwargs)
+
+    def put(self, url: str, **kwargs) -> Response:
+        return self._send("PUT", url, **kwargs)
+
+    def delete(self, url: str, **kwargs) -> Response:
+        return self._send("DELETE", url, **kwargs)
+
+    def patch(self, url: str, **kwargs) -> Response:
+        return self._send("PATCH", url, **kwargs)
+
+    def head(self, url: str, **kwargs) -> Response:
+        return self._send("HEAD", url, **kwargs)
+
+    def options(self, url: str, **kwargs) -> Response:
+        return self._send("OPTIONS", url, **kwargs)
+
+    # ── Cookie convenience ───────────────────────────────────────────────────
+
+    def get_cookies(self, url: str) -> dict:
+        return self._cookie_jar.get_dict(url)
+
+    def save_cookies(self, filepath: str, format: str = "json"):
+        if format == "netscape":
+            self._cookie_jar.save_netscape(filepath)
+        else:
+            self._cookie_jar.save_json(filepath)
+
+    def load_cookies(self, filepath: str, format: str = "json"):
+        if format == "netscape":
+            self._cookie_jar.load_netscape(filepath)
+        else:
+            self._cookie_jar.load_json(filepath)
+
+    def close(self):
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __repr__(self):
+        return f"<Session(requests={self._request_count})>"