solari-browserbase-compat 0.1.0__py3-none-any.whl

solari_browserbase/__init__.py

@@ -0,0 +1,22 @@
+"""Browserbase-style Python SDK surface for Solari Browser. See COMPAT.md for what is and is not supported."""
+from .client import (
+    AsyncBrowserbase,
+    Browserbase,
+    Context,
+    ContextCreateResponse,
+    DEFAULT_BASE_URL,
+    Session,
+    SessionCreateResponse,
+    SessionLiveURLs,
+    SessionRetrieveResponse,
+)
+from .errors import APIError, BrowserbaseError, SolariCompatUnsupported
+from .mapping import map_create_params, map_status
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AsyncBrowserbase", "Browserbase", "APIError", "BrowserbaseError", "SolariCompatUnsupported",
+    "Context", "ContextCreateResponse", "Session", "SessionCreateResponse", "SessionRetrieveResponse",
+    "SessionLiveURLs", "DEFAULT_BASE_URL", "map_create_params", "map_status",
+]

solari_browserbase/client.py

@@ -0,0 +1,378 @@
+from __future__ import annotations
+
+import asyncio
+import gzip
+import json
+import os
+import time
+import uuid
+import warnings as _warnings
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+import httpx
+
+from .errors import APIError, BrowserbaseError, SolariCompatUnsupported
+from .mapping import map_create_params, map_status
+
+DEFAULT_BASE_URL = "https://api.getsolari.com"
+REGION = "us-west-2"  # reported on Browserbase-shaped objects; Solari's single region (us-west)
+
+
+@dataclass
+class Session:
+    id: str
+    created_at: str
+    updated_at: str
+    project_id: str
+    started_at: str
+    expires_at: str
+    status: str
+    proxy_bytes: int
+    keep_alive: bool
+    region: str
+    ended_at: Optional[str] = None
+    context_id: Optional[str] = None
+    user_metadata: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class SessionCreateResponse(Session):
+    # CDP websocket URL: playwright `connect_over_cdp(connect_url)` / any CDP client.
+    connect_url: str = ""
+    selenium_remote_url: str = ""  # always empty: no WebDriver endpoint
+    signing_key: str = ""  # always empty: the session id in the URL is the credential
+    # Solari extension. For a session created with browserSettings.context: the saved cookies/localStorage.
+    # Solari applies a saved context only to a browser context created with it, so create yours with
+    # browser.new_context(storage_state=session.storage_state). None when no context was requested.
+    storage_state: Optional[Dict[str, Any]] = None
+
+
+SessionRetrieveResponse = SessionCreateResponse
+
+
+@dataclass
+class SessionLiveURLs:
+    debugger_fullscreen_url: str
+    debugger_url: str
+    ws_url: str
+    pages: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class Context:
+    id: str
+    name: Optional[str] = None
+    created_at: Optional[str] = None
+
+
+@dataclass
+class ContextCreateResponse:
+    id: str
+    public_key: str = ""  # empty: Solari profiles are stored server-side
+    cipher_algorithm: str = ""
+    initialization_vector_size: int = 0
+
+
+class _Unsupported:
+    """Every attribute is a callable that raises SolariCompatUnsupported."""
+
+    def __init__(self, feature: str, hint: str) -> None:
+        self._feature = feature
+        self._hint = hint
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        if name.startswith("__"):
+            raise AttributeError(name)
+
+        def _raise(*_a: Any, **_k: Any) -> Any:
+            raise SolariCompatUnsupported(f"{self._feature}.{name}", self._hint)
+
+        return _raise
+
+
+def _resolve_api_key(explicit: Optional[str], warn: Callable[[str], None]) -> str:
+    for name, v in (
+        ("api_key", explicit),
+        ("SOLARI_API_KEY", os.environ.get("SOLARI_API_KEY")),
+        ("BROWSERBASE_API_KEY", os.environ.get("BROWSERBASE_API_KEY")),
+    ):
+        if not v:
+            continue
+        if v.startswith("slr_"):
+            return v
+        # Never echo any part of the value: it is probably a Browserbase secret.
+        warn(f"{name} does not look like a Solari key (expected the slr_ prefix); ignoring it. It was not sent anywhere.")
+    raise BrowserbaseError("No Solari API key: pass api_key or set SOLARI_API_KEY (keys start with slr_)")
+
+
+def _default_warn(msg: str) -> None:
+    _warnings.warn(f"[solari-browserbase-compat] {msg}", stacklevel=3)
+
+
+def _session(row: Dict[str, Any], *, status: Optional[str] = None, keep_alive: bool = False, context_id: Optional[str] = None) -> Session:
+    created = row.get("createdAt") or time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    st = status or map_status(row.get("status"))
+    return Session(
+        id=row["id"],
+        created_at=created,
+        updated_at=created,
+        project_id="",
+        started_at=created,
+        ended_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) if st in ("COMPLETED", "TIMED_OUT") else None,
+        expires_at=row.get("expiresAt") or created,
+        status=st,
+        proxy_bytes=0,
+        keep_alive=keep_alive,
+        region=REGION,
+        context_id=context_id,
+    )
+
+
+class _Http:
+    def __init__(self, api_key: str, base_url: str, timeout: float, max_retries: int, transport: Optional[httpx.BaseTransport]) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self.client = httpx.Client(timeout=timeout, transport=transport)
+
+    def request(self, method: str, path: str, body: Any = None, idempotency_key: Optional[str] = None) -> httpx.Response:
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        replay_safe = method in ("GET", "DELETE") or idempotency_key is not None
+        last: Optional[Exception] = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                res = self.client.request(method, f"{self.base_url}{path}", headers=headers, content=None if body is None else json.dumps(body))
+                if res.is_success or not replay_safe or res.status_code not in (502, 503, 504) or attempt == self.max_retries:
+                    return res
+            except httpx.TransportError as e:
+                if not replay_safe or attempt == self.max_retries:
+                    raise
+                last = e
+            time.sleep(0.3 * (attempt + 1))
+        raise last or BrowserbaseError("request failed")
+
+    def json(self, method: str, path: str, body: Any = None, idempotency_key: Optional[str] = None) -> Any:
+        res = self.request(method, path, body, idempotency_key)
+        if res.status_code == 204:
+            return None
+        text = res.text
+        try:
+            parsed = json.loads(text) if text else None
+        except ValueError:
+            parsed = None
+        if not res.is_success:
+            o = parsed if isinstance(parsed, dict) else {}
+            raise APIError(res.status_code, f"Solari {method} {path}: {res.status_code} {o.get('error') or text[:200]}", o.get("code"), parsed)
+        return parsed
+
+
+class _Recording:
+    def __init__(self, http: _Http) -> None:
+        self._http = http
+
+    def retrieve(self, id: str) -> List[Any]:
+        """The session's DOM recording as a list of rrweb events (needs ``recordSession: True``; available a few seconds after release)."""
+        meta = self._http.json("GET", f"/sessions/{id}/replay-url")
+        url = (meta or {}).get("url")
+        if not url:
+            raise BrowserbaseError("Solari returned no replay URL")
+        r = httpx.get(url, timeout=60)
+        if not r.is_success:
+            raise APIError(r.status_code, f"replay download failed: {r.status_code}")
+        data = r.content
+        if data[:2] == b"\x1f\x8b":
+            data = gzip.decompress(data)
+        return [json.loads(line) for line in data.decode("utf-8").split("\n") if line.strip()]
+
+
+class _Sessions:
+    def __init__(self, bb: "Browserbase") -> None:
+        self._bb = bb
+        self.recording = _Recording(bb._http)
+        self.replays = _Unsupported("sessions.replays", "Solari records DOM events, not video; use sessions.recording.retrieve")
+        self.logs = _Unsupported("sessions.logs", "session command logs are not available")
+        self.downloads = _Unsupported("sessions.downloads", "file downloads cannot be retrieved through the API")
+        self.uploads = _Unsupported("sessions.uploads", "use your automation client's set_input_files")
+
+    def create(
+        self,
+        *,
+        project_id: Optional[str] = None,
+        extension_id: Optional[str] = None,
+        browser_settings: Optional[Dict[str, Any]] = None,
+        timeout: Optional[int] = None,
+        keep_alive: Optional[bool] = None,
+        proxies: Any = None,
+        proxy_settings: Optional[Dict[str, Any]] = None,
+        region: Optional[str] = None,
+        user_metadata: Optional[Dict[str, Any]] = None,
+    ) -> SessionCreateResponse:
+        m = map_create_params(
+            extension_id=extension_id, browser_settings=browser_settings, timeout=timeout, keep_alive=keep_alive,
+            proxies=proxies, proxy_settings=proxy_settings, region=region, user_metadata=user_metadata, strict=self._bb._strict,
+        )
+        for w in m.warnings:
+            self._bb._warn(w)
+        data = self._bb._http.json("POST", "/sessions", m.body or None, idempotency_key=str(uuid.uuid4()))
+        if not data or not data.get("sessionId") or not data.get("cdpEndpoint"):
+            raise BrowserbaseError(f"Solari returned an unexpected session response: {data!r}")
+        if m.persist_profile_id:
+            self._bb._persist[data["sessionId"]] = m.persist_profile_id
+        ctx = ((browser_settings or {}).get("context") or {}).get("id")
+        base = _session(
+            {"id": data["sessionId"], "createdAt": None, "expiresAt": data.get("expiresAt")},
+            status="RUNNING", keep_alive=keep_alive is True, context_id=ctx,
+        )
+        out = SessionCreateResponse(**base.__dict__, connect_url=data["cdpEndpoint"])
+        if ctx:
+            state = data.get("storageState")
+            url = (data.get("storageStateUrl") or {}).get("url")
+            if state is None and url:
+                try:
+                    r = self._bb._http.client.get(url, timeout=15)
+                    state = r.json() if r.is_success else None
+                except (httpx.HTTPError, ValueError):
+                    state = None
+                if state is None:
+                    self._bb._warn("could not download the saved context; the session starts without it")
+            out.storage_state = state
+        return out
+
+    def retrieve(self, id: str) -> SessionRetrieveResponse:
+        row = self._bb._http.json("GET", f"/sessions/{id}") or {}
+        row.setdefault("id", id)
+        return SessionCreateResponse(**_session(row).__dict__, connect_url=row.get("cdpEndpoint") or "")
+
+    def list(self, *, status: Optional[str] = None, q: Optional[str] = None) -> List[Session]:
+        if q:
+            raise SolariCompatUnsupported("sessions.list q (user_metadata query)", "metadata is not stored")
+        data = self._bb._http.json("GET", "/sessions") or {}
+        out = [_session(r) for r in data.get("sessions", [])]
+        return [s for s in out if s.status == status] if status else out
+
+    def update(self, id: str, *, status: str, project_id: Optional[str] = None) -> Session:
+        """``status="REQUEST_RELEASE"`` releases the session (saving the context first when it was created with persist)."""
+        if status != "REQUEST_RELEASE":
+            raise SolariCompatUnsupported(f"sessions.update status {status}", "only REQUEST_RELEASE exists")
+        profile_id = self._bb._persist.get(id)
+        if profile_id:
+            self._bb._http.json("POST", f"/sessions/{id}/save-profile", {"profileId": profile_id})
+            self._bb._persist.pop(id, None)
+        self._bb._http.json("DELETE", f"/sessions/{id}")
+        return _session({"id": id, "status": "released"}, status="COMPLETED")
+
+    def debug(self, id: str, *, expires_in: Optional[int] = None) -> SessionLiveURLs:
+        """Live-view links. Both URLs are the same view-only share link; ``pages`` is empty."""
+        share = self._bb._http.json("POST", f"/sessions/{id}/shares", {} if expires_in is None else {"ttlSeconds": expires_in})
+        row = self._bb._http.json("GET", f"/sessions/{id}") or {}
+        return SessionLiveURLs(share["url"], share["url"], row.get("cdpEndpoint") or "", [])
+
+
+class _Contexts:
+    def __init__(self, http: _Http) -> None:
+        self._http = http
+
+    def create(self, *, project_id: Optional[str] = None, name: Optional[str] = None) -> ContextCreateResponse:
+        """A Context is a Solari profile (cookies + localStorage)."""
+        p = self._http.json("POST", "/profiles", {"name": name or f"context-{uuid.uuid4().hex[:8]}"})
+        return ContextCreateResponse(id=p["id"])
+
+    def retrieve(self, id: str) -> Context:
+        for p in self._http.json("GET", "/profiles") or []:
+            if p.get("id") == id:
+                return Context(id=p["id"], name=p.get("name"), created_at=p.get("createdAt"))
+        raise APIError(404, f"context {id} not found", "NotFound")
+
+    def update(self, *_a: Any, **_k: Any) -> Any:
+        raise SolariCompatUnsupported("contexts.update", "contexts are saved when a persist session is released")
+
+    def delete(self, id: str) -> None:
+        self._http.json("DELETE", f"/profiles/{id}")
+
+
+class Browserbase:
+    """Browserbase-shaped client for Solari Browser. ``connect_url`` is a raw CDP websocket URL."""
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        strict: bool = False,
+        on_warning: Optional[Callable[[str], None]] = None,
+        max_retries: int = 2,
+        timeout: float = 60.0,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        self._warn = on_warning or _default_warn
+        self._strict = strict
+        key = _resolve_api_key(api_key, self._warn)
+        self._http = _Http(key, base_url or os.environ.get("SOLARI_BASE_URL") or DEFAULT_BASE_URL, timeout, max_retries, transport)
+        self._persist: Dict[str, str] = {}  # session id -> profile to save on release (in-process only)
+        self._api_key = key
+        self.sessions = _Sessions(self)
+        self.contexts = _Contexts(self._http)
+        self.extensions = _Unsupported("extensions", "browser extensions cannot be loaded")
+        self.projects = _Unsupported("projects", "Solari keys are organisation-scoped; there are no projects")
+        self.agents = _Unsupported("agents", "Browserbase Agents is a separate product")
+        self.fetch_api = _Unsupported("fetch_api", "Browserbase Fetch is a separate product")
+        self.search = _Unsupported("search", "Browserbase Search is a separate product")
+
+    @property
+    def api_key(self) -> str:
+        return self._api_key
+
+    def __repr__(self) -> str:
+        return f"Browserbase(base_url={self._http.base_url!r})"
+
+    def close(self) -> None:
+        self._http.client.close()
+
+    def __enter__(self) -> "Browserbase":
+        return self
+
+    def __exit__(self, *_a: Any) -> None:
+        self.close()
+
+
+class _AsyncProxy:
+    def __init__(self, target: Any) -> None:
+        self._t = target
+
+    def __getattr__(self, name: str) -> Any:
+        v = getattr(self._t, name)
+        if callable(v):
+            async def _call(*a: Any, **k: Any) -> Any:
+                return await asyncio.to_thread(v, *a, **k)
+
+            return _call
+        if v.__class__.__module__.startswith("solari_browserbase") and not hasattr(v, "__dataclass_fields__"):
+            return _AsyncProxy(v)
+        return v
+
+
+class AsyncBrowserbase:
+    """Async twin: every call runs the sync client in a worker thread (no extra dependencies)."""
+
+    @property
+    def api_key(self) -> str:
+        return self._sync.api_key
+
+    def __repr__(self) -> str:
+        return repr(self._sync).replace("Browserbase(", "AsyncBrowserbase(", 1)
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._sync = Browserbase(**kwargs)
+        self.sessions = _AsyncProxy(self._sync.sessions)
+        self.contexts = _AsyncProxy(self._sync.contexts)
+        self.extensions = self._sync.extensions
+        self.projects = self._sync.projects
+        self.agents = self._sync.agents
+        self.fetch_api = self._sync.fetch_api
+        self.search = self._sync.search
+
+    async def close(self) -> None:
+        await asyncio.to_thread(self._sync.close)

solari_browserbase/errors.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class BrowserbaseError(Exception):
+    """Base class for everything this package raises."""
+
+
+class APIError(BrowserbaseError):
+    """The gateway answered with a non-2xx status. ``code`` is Solari's machine-readable error code when present."""
+
+    def __init__(self, status: int, message: str, code: Optional[str] = None, body: Any = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.status_code = status
+        self.code = code
+        self.body = body
+
+
+class SolariCompatUnsupported(BrowserbaseError):
+    """A Browserbase feature Solari Browser does not offer (see COMPAT.md)."""
+
+    def __init__(self, feature: str, hint: Optional[str] = None) -> None:
+        super().__init__(f"Not supported by Solari Browser: {feature}" + (f" — {hint}" if hint else ""))
+        self.feature = feature
+        self.hint = hint

solari_browserbase/mapping.py

@@ -0,0 +1,128 @@
+"""Browserbase ``sessions.create`` params -> Solari ``POST /sessions`` body. Pure functions, no I/O."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from .errors import SolariCompatUnsupported
+
+_REGIONS = {"us-west-2", "us-west"}
+
+
+@dataclass
+class MappedCreate:
+    body: Dict[str, Any]
+    persist_profile_id: Optional[str] = None
+    warnings: List[str] = field(default_factory=list)
+
+
+def _proxy_body(proxies: Any, ca_certs: Any) -> Any:
+    if ca_certs:
+        raise SolariCompatUnsupported("proxy_settings.caCertificates", "custom CA certificates are not supported")
+    if proxies is None or proxies is False:
+        return None
+    if proxies is True:
+        return {"country": "us"}
+    if not isinstance(proxies, (list, tuple)) or len(proxies) == 0:
+        return None
+    if len(proxies) > 1:
+        raise SolariCompatUnsupported(
+            "multiple proxies / domain routing rules",
+            "pass at most one managed proxy; per-domain routing is not supported",
+        )
+    p = proxies[0]
+    if p.get("domainPattern"):
+        raise SolariCompatUnsupported("proxies[].domainPattern", "per-domain proxy routing is not supported")
+    t = p.get("type")
+    if t == "external":
+        raise SolariCompatUnsupported(
+            "external proxy", "bring-your-own proxy servers are not supported; use a managed proxy"
+        )
+    if t == "none":
+        return None  # no proxy, same as not asking for one
+    if t != "browserbase":
+        raise SolariCompatUnsupported(f"proxy type {t!r}")
+    g = p.get("geolocation")
+    if not g:
+        return {"country": "us"}
+    out: Dict[str, Any] = {"country": str(g["country"]).lower()}
+    if g.get("state"):
+        out["state"] = str(g["state"]).lower()
+    if g.get("city"):
+        out["city"] = g["city"]
+    return out
+
+
+def map_create_params(
+    *,
+    extension_id: Optional[str] = None,
+    browser_settings: Optional[Dict[str, Any]] = None,
+    timeout: Optional[int] = None,
+    keep_alive: Optional[bool] = None,
+    proxies: Any = None,
+    proxy_settings: Optional[Dict[str, Any]] = None,
+    region: Optional[str] = None,
+    user_metadata: Optional[Dict[str, Any]] = None,
+    strict: bool = False,
+) -> MappedCreate:
+    bs = browser_settings or {}
+    warnings: List[str] = []
+
+    def soft(feature: str, why: str) -> None:
+        if strict:
+            raise SolariCompatUnsupported(feature, why)
+        warnings.append(f"{feature}: {why}")
+
+    # hard gaps
+    if extension_id or bs.get("extensionId"):
+        raise SolariCompatUnsupported("extensions", "browser extensions cannot be loaded")
+    if bs.get("ignoreCertificateErrors") is True:
+        raise SolariCompatUnsupported("browserSettings.ignoreCertificateErrors")
+    if bs.get("captchaImageSelector") or bs.get("captchaInputSelector"):
+        raise SolariCompatUnsupported("custom CAPTCHA selectors")
+    if bs.get("os") in ("mobile", "tablet"):
+        raise SolariCompatUnsupported(f"browserSettings.os={bs['os']}", "only desktop browsers")
+    if region is not None and region not in _REGIONS:
+        raise SolariCompatUnsupported(f"region {region}", "Solari Browser runs in one region (us-west)")
+
+    # soft gaps
+    if timeout is not None:
+        soft("timeout", "sessions end at your plan's maximum session length, not at this value; call sessions.update to release earlier")
+    if keep_alive is True:
+        soft("keep_alive", "a disconnected session is released about 45 s after the socket closes; reconnect inside that window or hold the connection")
+    if user_metadata is not None:
+        soft("user_metadata", "metadata is not stored or queryable")
+    if bs.get("viewport") is not None:
+        soft("browserSettings.viewport", "set the viewport from your automation client (page.set_viewport_size)")
+    if bs.get("blockAds") is True:
+        soft("browserSettings.blockAds", "ad blocking is not available")
+    if bs.get("logSession") is True:
+        soft("browserSettings.logSession", "session command logs are not available")
+    if bs.get("os") in ("windows", "mac", "linux"):
+        soft("browserSettings.os", "the operating system profile cannot be chosen")
+
+    proxy = _proxy_body(proxies, (proxy_settings or {}).get("caCertificates"))
+    allowed = bs.get("allowedDomains") or None
+    captcha = bs.get("solveCaptchas") is True
+    stealth = bool(bs.get("verified") is True or bs.get("advancedStealth") is True or captcha or proxy is not None or allowed)
+
+    body: Dict[str, Any] = {}
+    if stealth:
+        body["stealth"] = True
+    if captcha:
+        body["captcha"] = True
+    if bs.get("recordSession") is True:
+        body["recording"] = True
+    if proxy is not None:
+        body["proxy"] = proxy
+    if allowed:
+        body["allowedDomains"] = list(allowed)
+    ctx = bs.get("context") or {}
+    if ctx.get("id"):
+        body["profileId"] = ctx["id"]
+    persist = ctx["id"] if ctx.get("id") and ctx.get("persist") is True else None
+    return MappedCreate(body=body, persist_profile_id=persist, warnings=warnings)
+
+
+def map_status(s: Optional[str]) -> str:
+    return {"active": "RUNNING", "released": "COMPLETED", "expired": "TIMED_OUT"}.get(s or "", "ERROR")

solari_browserbase_compat-0.1.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.5
+Name: solari-browserbase-compat
+Version: 0.1.0
+Summary: Browserbase-style Python SDK surface for Solari Browser: sessions, connect_url (CDP), contexts, live view, replay events.
+Project-URL: Homepage, https://getsolari.com
+Author: Solari
+License: MIT
+License-File: LICENSE
+Keywords: browser,browserbase,cdp,compat,playwright,solari
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# solari-browserbase-compat
+
+A Browserbase-shaped Python SDK for [Solari Browser](https://getsolari.com): change the import and the key, keep your code.
+
+```bash
+pip install solari-browserbase-compat
+```
+
+```python
+import os
+from solari_browserbase import Browserbase
+from playwright.sync_api import sync_playwright
+
+bb = Browserbase(api_key=os.environ["SOLARI_API_KEY"])  # slr_… key
+session = bb.sessions.create()
+with sync_playwright() as p:
+    browser = p.chromium.connect_over_cdp(session.connect_url)
+    page = browser.contexts[0].pages[0] if browser.contexts[0].pages else browser.contexts[0].new_page()
+    page.goto("https://example.com")
+    browser.close()
+bb.sessions.update(session.id, status="REQUEST_RELEASE")
+```
+
+Sessions, contexts, live view and recording are supported; extensions, downloads/uploads APIs, video replays,
+bring-your-own proxies and Selenium raise `SolariCompatUnsupported`. See [COMPAT.md](./COMPAT.md) for the full list
+and every difference. Python 3.9+. No Playwright version pin is needed: `connect_url` is a plain CDP endpoint.
+
+Licence: MIT.

solari_browserbase_compat-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+solari_browserbase/__init__.py,sha256=XPBOmaislUlruGe64vIJXK4MZLMmUsTCWaDkg4aiKBA,766
+solari_browserbase/client.py,sha256=PgDwqA-d7geG9WIOwaIf2j0pBNDM4BH_Y1e1f72v_Xw,15654
+solari_browserbase/errors.py,sha256=bzma6ijnhafgweOlDDcH05OvJBZldPRuE-R0Cm3ECkE,937
+solari_browserbase/mapping.py,sha256=RA_KKzd9YkAsWOWE18SXzCvbsYzIMUwSAqDW8RyFJDw,5244
+solari_browserbase_compat-0.1.0.dist-info/METADATA,sha256=eoCsNGWGHtjVolto-w2BUPMO1N8nWYL-b9yHhu1C6R8,1633
+solari_browserbase_compat-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+solari_browserbase_compat-0.1.0.dist-info/licenses/LICENSE,sha256=k0WAH-cVo7vh3feyXnpOAySy92HrdreySyQa9JbRCdU,1063
+solari_browserbase_compat-0.1.0.dist-info/RECORD,,

solari_browserbase_compat-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

solari_browserbase_compat-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Solari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.