from __future__ import annotations import http.cookiejar import http.client import json import time import urllib.error import urllib.parse import urllib.request from typing import Any, Callable ErrorFactory = Callable[[str], Exception] def is_csrf_protected_method(method: str) -> bool: return method.upper() not in {"GET", "HEAD", "OPTIONS"} class DroboticflowClient: def __init__( self, api_base_url: str, *, api_token: str = "", error_factory: ErrorFactory = RuntimeError, cookie_jar: http.cookiejar.CookieJar | None = None, opener: urllib.request.OpenerDirector | None = None, ) -> None: self.api_base_url = api_base_url.rstrip("/") self.api_token = api_token.strip() self.error_factory = error_factory self.cookie_jar = cookie_jar or http.cookiejar.CookieJar() self.opener = opener or urllib.request.build_opener(urllib.request.HTTPCookieProcessor(self.cookie_jar)) def csrf_token(self) -> str: for cookie in self.cookie_jar: if cookie.name == "droboticflow_csrf": return urllib.parse.unquote(cookie.value) return "" def request_headers(self, method: str, base_headers: dict[str, str] | None = None) -> dict[str, str]: headers = dict(base_headers or {}) if self.api_token: headers["Authorization"] = f"Bearer {self.api_token}" if is_csrf_protected_method(method): token = self.csrf_token() if token: headers["X-Droboticflow-CSRF-Token"] = token return headers def request_json( self, method: str, path: str, payload: Any | None = None, *, expected: tuple[int, ...] = (200, 201, 202, 204), timeout: int = 60, retries: int = 3, retry_delay_seconds: float = 1.0, ) -> Any: method = method.upper() body = None headers = {"Content-Type": "application/json"} if payload is not None: body = json.dumps(payload, ensure_ascii=False).encode("utf-8") status, raw, _ = self.request_bytes( method, path, body=body, headers=headers, expected=expected, timeout=timeout, retries=retries, retry_delay_seconds=retry_delay_seconds, ) if status == 204 or not raw: return None return json.loads(raw.decode("utf-8", errors="replace")) def request_bytes( self, method: str, path: str, *, body: bytes | None = None, headers: dict[str, str] | None = None, expected: tuple[int, ...] = (200,), timeout: int = 300, retries: int = 3, retry_delay_seconds: float = 1.0, ) -> tuple[int, bytes, dict[str, str]]: method = method.upper() attempts = max(1, retries) last_error: BaseException | None = None for attempt in range(1, attempts + 1): request_headers = self.request_headers(method, headers) req = urllib.request.Request(f"{self.api_base_url}{path}", data=body, headers=request_headers, method=method) try: with self.opener.open(req, timeout=timeout) as resp: status = getattr(resp, "status", resp.getcode()) raw = resp.read() if status not in expected: message = raw.decode("utf-8", errors="replace") raise self.error_factory(f"{method} {path} unexpected {status}: {message}") return status, raw, dict(resp.headers.items()) except urllib.error.HTTPError as err: raw = err.read().decode("utf-8", errors="replace") raise self.error_factory(f"{method} {path} failed {err.code}: {raw}") from err except (urllib.error.URLError, http.client.RemoteDisconnected, http.client.IncompleteRead, TimeoutError) as err: last_error = err if attempt >= attempts: break time.sleep(min(retry_delay_seconds * attempt, 3.0)) if attempts == 1: raise self.error_factory(f"{method} {path} failed: {last_error}") from last_error raise self.error_factory(f"{method} {path} failed after retries: {last_error}") from last_error def login_if_configured(self, email: str, password: str, *, label: str) -> str: if not email: return "" response = self.request_json( "POST", "/api/auth/login", {"email": email, "password": password}, expected=(200,), ) identifier = email if isinstance(response, dict): identifier = str(response.get("email") or response.get("name") or identifier) print(f"logged in {label}: {identifier}") return identifier