bas-http 1.0.0__py3-none-any.whl

bas/async_session.py

@@ -0,0 +1,352 @@
+"""
+Async HTTP session using asyncio.
+
+Provides the same cookie management guarantees as the sync Session,
+but with async/await support using subprocess-based curl execution.
+"""
+
+import asyncio
+import json
+import time
+from typing import Any, Optional, Union
+from urllib.parse import urlencode, urljoin, urlparse
+
+from .cookies import Cookie, CookieJar
+from .impersonate import BrowserProfile, get_profile
+from .models import Headers, PreparedRequest, Response
+
+
+class AsyncSession:
+    """
+    Async HTTP session with proper cookie management.
+
+    Same cookie fixes as sync Session:
+      - Cookies accumulate across requests
+      - Cookies survive redirects
+      - No manual header construction
+    """
+
+    def __init__(
+        self,
+        impersonate: Optional[str] = None,
+        profile: Optional[BrowserProfile] = None,
+        proxies: Optional[dict] = None,
+        verify: bool = True,
+        timeout: Optional[float] = None,
+        cookies: Optional[dict] = None,
+        headers: Optional[dict] = None,
+        allow_redirects: bool = True,
+        max_redirects: int = 20,
+    ):
+        self.profile: Optional[BrowserProfile] = None
+        if profile:
+            self.profile = profile
+        elif impersonate:
+            self.profile = get_profile(impersonate)
+
+        self._cookie_jar = CookieJar()
+        self._headers = Headers()
+        if self.profile and self.profile.http_headers:
+            self._headers.update(self.profile.http_headers)
+        if headers:
+            self._headers.update(headers)
+
+        if cookies:
+            for name, value in cookies.items():
+                self._cookie_jar.add(Cookie(
+                    name=str(name), value=str(value),
+                    domain="", path="/",
+                ))
+
+        self.verify = verify
+        self.timeout = timeout or 30
+        self.allow_redirects = allow_redirects
+        self.max_redirects = max_redirects
+        self.proxies = proxies or {}
+        self._request_count = 0
+
+    @property
+    def cookies(self) -> CookieJar:
+        return self._cookie_jar
+
+    @property
+    def headers(self) -> Headers:
+        return self._headers
+
+    @headers.setter
+    def headers(self, value):
+        self._headers = Headers(value)
+
+    async def _exec_curl(self, args: list[str]) -> tuple[int, str, bytes, str]:
+        """
+        Execute curl as a subprocess. This works without libcurl bindings.
+
+        Returns: (status_code, effective_url, body, raw_headers)
+        """
+        proc = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(
+            proc.communicate(),
+            timeout=self.timeout + 5,
+        )
+        return proc.returncode, "", stdout, stderr.decode("utf-8", errors="replace")
+
+    async def _exec_curl_cffi(
+        self,
+        request: PreparedRequest,
+    ) -> Response:
+        """Execute request using curl_cffi if available (fallback)."""
+        try:
+            from curl_cffi.requests import AsyncSession as CFFIAsyncSession
+        except ImportError:
+            raise ConnectionError(
+                "Neither libcurl bindings nor curl_cffi are available. "
+                "Install one of: libcurl-dev, curl_cffi"
+            )
+
+        # Use curl_cffi as a backend
+        async with CFFIAsyncSession() as s:
+            imp = self.profile.name if self.profile else "chrome131"
+            resp = await s.request(
+                method=request.method,
+                url=request.url,
+                headers=dict(request.headers),
+                data=request.prepare_body(),
+                impersonate=imp,
+                allow_redirects=self.allow_redirects,
+                timeout=self.timeout,
+            )
+
+            # Build our Response and update cookies
+            response = Response(
+                status_code=resp.status_code,
+                headers=Headers(dict(resp.headers)),
+                body=resp.content,
+                url=str(resp.url),
+                request=request,
+                elapsed=0,
+            )
+
+            # Parse cookies from curl_cffi response
+            for name, value in resp.cookies.items():
+                self._cookie_jar.add(Cookie(
+                    name=name, value=value,
+                    domain=urlparse(str(resp.url)).hostname or "",
+                    path="/",
+                ))
+
+            response.cookies = self._cookie_jar
+            self._request_count += 1
+            return response
+
+    async def _do_request(self, request: PreparedRequest) -> Response:
+        """Execute a single request, handling cookies properly."""
+        # Inject cookies from our jar
+        cookie_header = self._cookie_jar.to_header(request.url)
+        if cookie_header:
+            request.headers["Cookie"] = cookie_header
+
+        try:
+            return await self._exec_curl_cffi(request)
+        except ConnectionError:
+            # Fallback: use subprocess curl
+            return await self._exec_curl_subprocess(request)
+
+    async def _exec_curl_subprocess(self, request: PreparedRequest) -> Response:
+        """Execute via subprocess curl as ultimate fallback."""
+        args = ["curl", "-s", "-S", "-D", "-"]
+
+        if not self.verify:
+            args.append("-k")
+
+        args.extend(["--max-time", str(self.timeout)])
+        args.extend(["--connect-timeout", str(min(self.timeout, 10))])
+
+        for key, value in request.headers.items():
+            args.extend(["-H", f"{key}: {value}"])
+
+        args.append("-X")
+        args.append(request.method)
+        args.append(request.url)
+
+        body = request.prepare_body()
+        if body:
+            args.extend(["-d", body.decode("utf-8", errors="replace")])
+
+        proc = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                proc.communicate(),
+                timeout=self.timeout + 5,
+            )
+        except asyncio.TimeoutError:
+            proc.kill()
+            raise Timeout(f"Request timed out: {request.url}")
+
+        output = stdout
+        # Parse headers from -D output
+        header_text = ""
+        body_data = output
+
+        # curl -D dumps headers to stdout mixed with body
+        # We need to split them
+        parts = output.split(b"\r\n\r\n", 1)
+        if len(parts) == 2:
+            header_text = parts[0].decode("utf-8", errors="replace")
+            body_data = parts[1]
+
+        headers = Headers()
+        status_code = 200
+        for line in header_text.split("\r\n"):
+            if line.startswith("HTTP/"):
+                parts2 = line.split(" ", 2)
+                if len(parts2) >= 2:
+                    try:
+                        status_code = int(parts2[1])
+                    except ValueError:
+                        pass
+            elif ":" in line:
+                key, _, value = line.partition(":")
+                headers[key.strip()] = value.strip()
+
+        response = Response(
+            status_code=status_code,
+            headers=headers,
+            body=body_data,
+            url=request.url,
+            request=request,
+        )
+
+        # Update cookies
+        self._cookie_jar.parse_set_cookie_headers(headers, request.url)
+        response.cookies = self._cookie_jar
+        self._request_count += 1
+        return response
+
+    async def request(self, method: str, url: str, **kwargs) -> Response:
+        """Send an async request with redirect handling."""
+        allow_redirects = kwargs.pop("allow_redirects", self.allow_redirects)
+
+        # Merge headers
+        merged = Headers(dict(self._headers))
+        if "headers" in kwargs:
+            merged.update(kwargs.pop("headers"))
+
+        # Build request
+        request = PreparedRequest(
+            method=method.upper(),
+            url=url,
+            headers=merged,
+            json_data=kwargs.pop("json", None),
+        )
+
+        data = kwargs.pop("data", None)
+        if data:
+            if isinstance(data, (dict, list)):
+                request.body = urlencode(data, doseq=True).encode("utf-8")
+            elif isinstance(data, str):
+                request.body = data.encode("utf-8")
+            elif isinstance(data, bytes):
+                request.body = data
+
+        params = kwargs.pop("params", None)
+        if params:
+            sep = "&" if "?" in url else "?"
+            request.url = url + sep + urlencode(params, doseq=True)
+
+        cookies = kwargs.pop("cookies", None)
+        if cookies:
+            for name, value in cookies.items():
+                self._cookie_jar.add(Cookie(
+                    name=str(name), value=str(value),
+                    domain=urlparse(url).hostname or "", path="/",
+                ))
+
+        response = await self._do_request(request)
+
+        # Handle redirects
+        history = []
+        redirect_count = 0
+        while (
+            allow_redirects
+            and response.is_redirect
+            and redirect_count < self.max_redirects
+        ):
+            location = response.location
+            if not location:
+                break
+
+            history.append(response)
+            redirect_url = urljoin(response.url, location)
+            redirect_method = "GET" if response.status_code in (301, 302, 303) else method
+
+            redirect_request = PreparedRequest(
+                method=redirect_method,
+                url=redirect_url,
+                headers=Headers(dict(request.headers)),
+            )
+            redirect_request.headers.pop("Authorization", None)
+            redirect_request.headers.pop("Cookie", None)
+
+            response = await self._do_request(redirect_request)
+            redirect_count += 1
+
+        response.history = history
+        return response
+
+    async def get(self, url: str, **kwargs) -> Response:
+        return await self.request("GET", url, **kwargs)
+
+    async def post(self, url: str, **kwargs) -> Response:
+        return await self.request("POST", url, **kwargs)
+
+    async def put(self, url: str, **kwargs) -> Response:
+        return await self.request("PUT", url, **kwargs)
+
+    async def delete(self, url: str, **kwargs) -> Response:
+        return await self.request("DELETE", url, **kwargs)
+
+    async def patch(self, url: str, **kwargs) -> Response:
+        return await self.request("PATCH", url, **kwargs)
+
+    async def head(self, url: str, **kwargs) -> Response:
+        return await self.request("HEAD", url, **kwargs)
+
+    async def close(self):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()
+
+    # Cookie convenience methods
+    def get_cookies(self, url: str) -> dict:
+        return self._cookie_jar.get_dict(url)
+
+    def set_cookie(self, name: str, value: str, domain: str = "", path: str = "/"):
+        self._cookie_jar.add(Cookie(name=name, value=value, domain=domain, path=path))
+
+    def clear_cookies(self):
+        self._cookie_jar.clear()
+
+    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)