scalebrowser 0.2.0__py3-none-any.whl

scalebrowser/_sync.py

@@ -0,0 +1,604 @@
+"""Synchronous ergonomics over the async core.
+
+A single background daemon thread runs an asyncio loop; the sync client and CDP
+session drive the async implementations through it via
+``run_coroutine_threadsafe``. There is no duplicated endpoint logic — every call
+forwards to :class:`AsyncScalebrowserClient` / :class:`CdpSession`.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from contextlib import contextmanager
+from typing import Any, Coroutine, Iterator, Mapping, Optional, Sequence, TypeVar, Union
+
+import httpx
+
+from .cdp import CdpSession, EventCallback
+from .client import DEFAULT_BASE_URL, AsyncScalebrowserClient
+from .models import (
+    RunStep,
+    CheckProxyConfigBody,
+    CredentialBundle,
+    CredentialImportResult,
+    CredentialMeta,
+    CreateGroupBody,
+    CreatePresetBody,
+    CreateProfileBody,
+    CreateProxyBody,
+    AuditStatus,
+    Extension,
+    ExtensionsResult,
+    Group,
+    Metrics,
+    PersonaConstraintOptions,
+    Preset,
+    Profile,
+    Proxy,
+    ProxyCheckResult,
+    RevealedCredential,
+    SessionExportResult,
+    StartProfileResult,
+    StopProfileResult,
+    UpdatePresetBody,
+    UpdateProfileBody,
+    UpdateProxyBody,
+    VaultStatus,
+)
+
+from .models_control import (
+    Account,
+    ArtifactBytes,
+    ArtifactPutResult,
+    HealthStatus,
+    InterruptionLockView,
+    InterruptionRuleRow,
+    ReadyStatus,
+    SetInterruptionLockBody,
+    SetInterruptionRuleBody,
+)
+from .models_identity import (
+    BindInboxBody,
+    Inbox,
+    InboxBindings,
+    PasskeyRow,
+    PutInboxBody,
+    RevealCookiesBody,
+    RevealCookiesResult,
+)
+from .models_runs import ActivitySnapshot, AgentRun
+
+T = TypeVar("T")
+
+
+class _Portal:
+    """A dedicated event loop running on a background daemon thread."""
+
+    def __init__(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(
+            target=self._loop.run_forever, name="scalebrowser-portal", daemon=True
+        )
+        self._thread.start()
+
+    def run(self, coro: Coroutine[Any, Any, T]) -> T:
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()
+
+    def close(self) -> None:
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        self._thread.join(timeout=5)
+        if not self._loop.is_running():
+            self._loop.close()
+
+
+class SyncCdpSession:
+    """Synchronous wrapper around :class:`CdpSession`."""
+
+    def __init__(self, inner: CdpSession, portal: _Portal) -> None:
+        self._inner = inner
+        self._portal = portal
+
+    @property
+    def session_id(self) -> Optional[str]:
+        return self._inner.session_id
+
+    def send(self, method: str, params: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        return self._portal.run(self._inner.send(method, params))
+
+    def on(self, method: str, callback: EventCallback) -> Any:
+        return self._inner.on(method, callback)
+
+    def attach_to_page(
+        self, target_id: Optional[str] = None, *, create: bool = False, url: Optional[str] = None
+    ) -> "SyncCdpSession":
+        child = self._portal.run(self._inner.attach_to_page(target_id, create=create, url=url))
+        return SyncCdpSession(child, self._portal)
+
+    def navigate(self, url: str, *, wait: bool = True, timeout: float = 30.0) -> dict[str, Any]:
+        return self._portal.run(self._inner.navigate(url, wait=wait, timeout=timeout))
+
+    def evaluate(
+        self,
+        expression: str,
+        *,
+        await_promise: bool = True,
+        return_by_value: bool = True,
+        isolated: bool = False,
+    ) -> Any:
+        return self._portal.run(
+            self._inner.evaluate(
+                expression,
+                await_promise=await_promise,
+                return_by_value=return_by_value,
+                isolated=isolated,
+            )
+        )
+
+    def create_isolated_world(self, frame_id: Optional[str] = None, world_name: str = "__sb") -> int:
+        return self._portal.run(self._inner.create_isolated_world(frame_id, world_name))
+
+    def humanize_move(self, x: float, y: float) -> None:
+        self._portal.run(self._inner.humanize_move(x, y))
+
+    def humanize_click(self, x: float, y: float, *, button: str = "left", click_count: int = 1) -> None:
+        self._portal.run(self._inner.humanize_click(x, y, button=button, click_count=click_count))
+
+    def humanize_type(self, text: str) -> None:
+        self._portal.run(self._inner.humanize_type(text))
+
+    def humanize_scroll(self, x: float, y: float, *, delta_x: float = 0, delta_y: float = 0) -> None:
+        self._portal.run(self._inner.humanize_scroll(x, y, delta_x=delta_x, delta_y=delta_y))
+
+    def close(self) -> None:
+        self._portal.run(self._inner.close())
+
+    def __enter__(self) -> "SyncCdpSession":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+
+class ScalebrowserClient:
+    """Synchronous client — mirrors :class:`AsyncScalebrowserClient` one-to-one."""
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        token: Optional[str] = None,
+        *,
+        timeout: float = 30.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._portal = _Portal()
+        self._async = AsyncScalebrowserClient(
+            base_url, token, timeout=timeout, transport=transport, http_client=http_client
+        )
+
+    @property
+    def async_client(self) -> AsyncScalebrowserClient:
+        return self._async
+
+    def __repr__(self) -> str:
+        masked = "***" if self._async.transport.token else None
+        return f"ScalebrowserClient(base_url={self._async.transport.base_url!r}, token={masked!r})"
+
+    # ── profiles ──────────────────────────────────────────────────────────────
+
+    def list_profiles(
+        self,
+        *,
+        group: Optional[str] = None,
+        state: Optional[str] = None,
+        q: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> list[Profile]:
+        return self._portal.run(
+            self._async.list_profiles(group=group, state=state, q=q, limit=limit, offset=offset)
+        )
+
+    def get_profile(self, profile_id: str) -> Profile:
+        return self._portal.run(self._async.get_profile(profile_id))
+
+    def create_profile(self, body: Union[CreateProfileBody, Mapping[str, Any]]) -> Profile:
+        return self._portal.run(self._async.create_profile(body))
+
+    def update_profile(
+        self, profile_id: str, body: Union[UpdateProfileBody, Mapping[str, Any]]
+    ) -> Profile:
+        return self._portal.run(self._async.update_profile(profile_id, body))
+
+    def delete_profile(self, profile_id: str) -> None:
+        self._portal.run(self._async.delete_profile(profile_id))
+
+    def start_profile(self, profile_id: str, *, headless: Optional[bool] = None) -> StartProfileResult:
+        return self._portal.run(self._async.start_profile(profile_id, headless=headless))
+
+    def stop_profile(self, profile_id: str) -> StopProfileResult:
+        return self._portal.run(self._async.stop_profile(profile_id))
+
+    def list_profile_ids(
+        self,
+        *,
+        group: Optional[str] = None,
+        state: Optional[str] = None,
+        q: Optional[str] = None,
+        sort: Optional[str] = None,
+        order: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Every id matching the filters, unpaged — what "act on all matches" needs."""
+        return self._portal.run(
+            self._async.list_profile_ids(group=group, state=state, q=q, sort=sort, order=order)
+        )
+
+    # ── bulk ──────────────────────────────────────────────────────────────────
+
+    def bulk_create_profiles(
+        self,
+        preset_id: str,
+        count: int,
+        *,
+        name_prefix: Optional[str] = None,
+        group_id: Optional[str] = None,
+    ) -> list[Profile]:
+        return self._portal.run(
+            self._async.bulk_create_profiles(
+                preset_id, count, name_prefix=name_prefix, group_id=group_id
+            )
+        )
+
+    def bulk_start(self, ids: Sequence[str]) -> Any:
+        return self._portal.run(self._async.bulk_start(ids))
+
+    def bulk_stop(self, ids: Sequence[str]) -> Any:
+        return self._portal.run(self._async.bulk_stop(ids))
+
+    def bulk_delete(self, ids: Sequence[str]) -> Any:
+        return self._portal.run(self._async.bulk_delete(ids))
+
+    def bulk_assign_proxy(self, ids: Sequence[str], proxy_id: str) -> Any:
+        return self._portal.run(self._async.bulk_assign_proxy(ids, proxy_id))
+
+    def bulk_assign_extensions(self, ids: Sequence[str], ext_refs: Sequence[str]) -> Any:
+        return self._portal.run(self._async.bulk_assign_extensions(ids, ext_refs))
+
+    # ── groups ────────────────────────────────────────────────────────────────
+
+    def list_groups(self) -> list[Group]:
+        return self._portal.run(self._async.list_groups())
+
+    def create_group(self, body: Union[CreateGroupBody, Mapping[str, Any]]) -> Group:
+        return self._portal.run(self._async.create_group(body))
+
+    def get_group(self, group_id: str) -> Group:
+        return self._portal.run(self._async.get_group(group_id))
+
+    def update_group(self, group_id: str, body: Mapping[str, Any]) -> Group:
+        return self._portal.run(self._async.update_group(group_id, body))
+
+    def delete_group(self, group_id: str) -> None:
+        self._portal.run(self._async.delete_group(group_id))
+
+    # ── presets ───────────────────────────────────────────────────────────────
+
+    def list_presets(self) -> list[Preset]:
+        return self._portal.run(self._async.list_presets())
+
+    def create_preset(self, body: Union[CreatePresetBody, Mapping[str, Any]]) -> Preset:
+        return self._portal.run(self._async.create_preset(body))
+
+    def get_preset(self, preset_id: str) -> Preset:
+        return self._portal.run(self._async.get_preset(preset_id))
+
+    def update_preset(
+        self, preset_id: str, body: Union[UpdatePresetBody, Mapping[str, Any]]
+    ) -> Preset:
+        return self._portal.run(self._async.update_preset(preset_id, body))
+
+    def delete_preset(self, preset_id: str) -> None:
+        self._portal.run(self._async.delete_preset(preset_id))
+
+    def get_persona_constraints(self) -> PersonaConstraintOptions:
+        return self._portal.run(self._async.get_persona_constraints())
+
+    # ── proxies ───────────────────────────────────────────────────────────────
+
+    def list_proxies(self) -> list[Proxy]:
+        return self._portal.run(self._async.list_proxies())
+
+    def create_proxy(self, body: Union[CreateProxyBody, Mapping[str, Any]]) -> Proxy:
+        return self._portal.run(self._async.create_proxy(body))
+
+    def get_proxy(self, proxy_id: str) -> Proxy:
+        return self._portal.run(self._async.get_proxy(proxy_id))
+
+    def update_proxy(self, proxy_id: str, body: Union[UpdateProxyBody, Mapping[str, Any]]) -> Proxy:
+        return self._portal.run(self._async.update_proxy(proxy_id, body))
+
+    def delete_proxy(self, proxy_id: str) -> None:
+        self._portal.run(self._async.delete_proxy(proxy_id))
+
+    def check_proxy(self, proxy_id: str) -> ProxyCheckResult:
+        return self._portal.run(self._async.check_proxy(proxy_id))
+
+    def check_proxy_config(
+        self, body: Union[CheckProxyConfigBody, Mapping[str, Any]]
+    ) -> ProxyCheckResult:
+        return self._portal.run(self._async.check_proxy_config(body))
+
+    # ── live detector audit ───────────────────────────────────────────────────
+
+    def start_audit(self, profile_id: str) -> AuditStatus:
+        return self._portal.run(self._async.start_audit(profile_id))
+
+    def get_audit(self, profile_id: str) -> AuditStatus:
+        return self._portal.run(self._async.get_audit(profile_id))
+
+    # ── extension library (daemon-wide) ───────────────────────────────────────
+
+    def list_library_extensions(self) -> list[Extension]:
+        return self._portal.run(self._async.list_library_extensions())
+
+    def upload_extension(self, crx: bytes) -> Extension:
+        return self._portal.run(self._async.upload_extension(crx))
+
+    def get_library_extension(self, ext_id: str) -> Extension:
+        return self._portal.run(self._async.get_library_extension(ext_id))
+
+    def delete_library_extension(self, ext_id: str) -> None:
+        self._portal.run(self._async.delete_library_extension(ext_id))
+
+    def delete_library_extension_version(self, ext_id: str, version: str) -> None:
+        self._portal.run(self._async.delete_library_extension_version(ext_id, version))
+
+    # ── extensions per profile (ext_ref is a LIBRARY ID, not a path) ──────────
+
+    def list_extensions(self, profile_id: str) -> ExtensionsResult:
+        return self._portal.run(self._async.list_extensions(profile_id))
+
+    def attach_extension(self, profile_id: str, ext_ref: str) -> ExtensionsResult:
+        return self._portal.run(self._async.attach_extension(profile_id, ext_ref))
+
+    def detach_extension(self, profile_id: str, ext_ref: str) -> ExtensionsResult:
+        return self._portal.run(self._async.detach_extension(profile_id, ext_ref))
+
+    # ── platform credentials ──────────────────────────────────────────────────
+
+    def list_credentials(self, profile_id: str) -> list[CredentialMeta]:
+        return self._portal.run(self._async.list_credentials(profile_id))
+
+    def put_credential(
+        self,
+        profile_id: str,
+        platform: str,
+        *,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        totp_secret: Optional[str] = None,
+        login_url: Optional[str] = None,
+    ) -> CredentialMeta:
+        return self._portal.run(
+            self._async.put_credential(
+                profile_id,
+                platform,
+                username=username,
+                password=password,
+                totp_secret=totp_secret,
+                login_url=login_url,
+            )
+        )
+
+    def delete_credential(self, profile_id: str, platform: str) -> None:
+        return self._portal.run(self._async.delete_credential(profile_id, platform))
+
+    def reveal_credential(
+        self, profile_id: str, platform: str, vault_password: str
+    ) -> RevealedCredential:
+        return self._portal.run(
+            self._async.reveal_credential(profile_id, platform, vault_password)
+        )
+
+    def export_credentials(
+        self, profile_id: str, vault_password: str, password: str
+    ) -> CredentialBundle:
+        return self._portal.run(
+            self._async.export_credentials(profile_id, vault_password, password)
+        )
+
+    def import_credentials(
+        self, profile_id: str, vault_password: str, password: str, bundle: str
+    ) -> CredentialImportResult:
+        return self._portal.run(
+            self._async.import_credentials(profile_id, vault_password, password, bundle)
+        )
+
+    def vault_status(self) -> VaultStatus:
+        return self._portal.run(self._async.vault_status())
+
+    def set_vault_password(
+        self, new_password: str, current_password: Optional[str] = None
+    ) -> None:
+        return self._portal.run(
+            self._async.set_vault_password(new_password, current_password)
+        )
+
+    # ── sessions ──────────────────────────────────────────────────────────────
+
+    def export_session(
+        self, profile_id: str, password: str, *, kinds: Optional[Sequence[str]] = None
+    ) -> SessionExportResult:
+        return self._portal.run(self._async.export_session(profile_id, password, kinds=kinds))
+
+    def import_session(self, profile_id: str, password: str, bundle: str) -> Any:
+        return self._portal.run(self._async.import_session(profile_id, password, bundle))
+
+    # ── input / metrics ──────────────────────────────────────────────────────
+
+    def send_input(self, profile_id: str, body: Mapping[str, Any]) -> Any:
+        return self._portal.run(self._async.send_input(profile_id, body))
+
+    def get_metrics(self) -> Metrics:
+        return self._portal.run(self._async.get_metrics())
+
+    # ── agent runs ────────────────────────────────────────────────────────────
+
+    def list_runs(
+        self,
+        *,
+        profile_id: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> list[AgentRun]:
+        return self._portal.run(
+            self._async.list_runs(profile_id=profile_id, limit=limit, offset=offset)
+        )
+
+    def get_run(self, run_id: str) -> AgentRun:
+        return self._portal.run(self._async.get_run(run_id))
+
+    def list_run_steps(
+        self, run_id: str, *, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> list[RunStep]:
+        return self._portal.run(self._async.list_run_steps(run_id, limit=limit, offset=offset))
+
+    def get_run_shot(self, run_id: str, seq: int) -> ArtifactBytes:
+        return self._portal.run(self._async.get_run_shot(run_id, seq))
+
+    def get_activity(self) -> ActivitySnapshot:
+        return self._portal.run(self._async.get_activity())
+
+    # ── mailboxes ─────────────────────────────────────────────────────────────
+
+    def list_inboxes(self) -> list[Inbox]:
+        return self._portal.run(self._async.list_inboxes())
+
+    def create_inbox(self, body: Union[PutInboxBody, Mapping[str, Any]]) -> Inbox:
+        return self._portal.run(self._async.create_inbox(body))
+
+    def update_inbox(self, inbox_id: str, body: Union[PutInboxBody, Mapping[str, Any]]) -> Inbox:
+        return self._portal.run(self._async.update_inbox(inbox_id, body))
+
+    def delete_inbox(self, inbox_id: str) -> None:
+        self._portal.run(self._async.delete_inbox(inbox_id))
+
+    def get_inbox_bindings(self, profile_id: str) -> InboxBindings:
+        return self._portal.run(self._async.get_inbox_bindings(profile_id))
+
+    def bind_inbox(
+        self, profile_id: str, body: Union[BindInboxBody, Mapping[str, Any]]
+    ) -> InboxBindings:
+        return self._portal.run(self._async.bind_inbox(profile_id, body))
+
+    def unbind_inbox(self, profile_id: str, channel: str) -> None:
+        self._portal.run(self._async.unbind_inbox(profile_id, channel))
+
+    # ── passkeys ──────────────────────────────────────────────────────────────
+
+    def list_passkeys(self, profile_id: str) -> list[PasskeyRow]:
+        return self._portal.run(self._async.list_passkeys(profile_id))
+
+    def delete_passkey(self, profile_id: str, credential_id: str) -> None:
+        self._portal.run(self._async.delete_passkey(profile_id, credential_id))
+
+    # ── interruptions ─────────────────────────────────────────────────────────
+
+    def list_interruption_locks(self) -> InterruptionLockView:
+        return self._portal.run(self._async.list_interruption_locks())
+
+    def set_interruption_lock(
+        self, body: Union[SetInterruptionLockBody, Mapping[str, Any]]
+    ) -> None:
+        self._portal.run(self._async.set_interruption_lock(body))
+
+    def list_interruption_rules(self) -> list[InterruptionRuleRow]:
+        return self._portal.run(self._async.list_interruption_rules())
+
+    def set_interruption_rule(
+        self, body: Union[SetInterruptionRuleBody, Mapping[str, Any]]
+    ) -> None:
+        self._portal.run(self._async.set_interruption_rule(body))
+
+    def delete_interruption_rule(
+        self, origin: str, kind: str, profile_id: Optional[str] = None
+    ) -> None:
+        self._portal.run(self._async.delete_interruption_rule(origin, kind, profile_id))
+
+    # ── artifacts ─────────────────────────────────────────────────────────────
+
+    def put_artifact(
+        self, profile_id: str, data: bytes, name: Optional[str] = None
+    ) -> ArtifactPutResult:
+        return self._portal.run(self._async.put_artifact(profile_id, data, name))
+
+    def get_artifact(self, artifact_id: str) -> ArtifactBytes:
+        return self._portal.run(self._async.get_artifact(artifact_id))
+
+    # ── cookies ───────────────────────────────────────────────────────────────
+
+    def reveal_cookies(
+        self, profile_id: str, body: Union[RevealCookiesBody, Mapping[str, Any]]
+    ) -> RevealCookiesResult:
+        return self._portal.run(self._async.reveal_cookies(profile_id, body))
+
+    # ── account + health ──────────────────────────────────────────────────────
+
+    def get_account(self) -> Account:
+        return self._portal.run(self._async.get_account())
+
+    def health(self) -> HealthStatus:
+        return self._portal.run(self._async.health())
+
+    def ready(self) -> ReadyStatus:
+        return self._portal.run(self._async.ready())
+
+    # ── events ────────────────────────────────────────────────────────────────
+
+    def iter_events(self) -> Iterator[Any]:
+        """Yield lifecycle events synchronously (blocks the caller thread)."""
+        agen = self._async.events()
+        try:
+            while True:
+                yield self._portal.run(agen.__anext__())
+        except StopAsyncIteration:
+            return
+
+    # ── direct-CDP ────────────────────────────────────────────────────────────
+
+    def connect_cdp(
+        self,
+        target: Union[StartProfileResult, str],
+        profile_id: Optional[str] = None,
+        *,
+        attach: bool = True,
+    ) -> SyncCdpSession:
+        inner = self._portal.run(self._async.connect_cdp(target, profile_id, attach=attach))
+        return SyncCdpSession(inner, self._portal)
+
+    @contextmanager
+    def launch(self, profile_id: str, *, headless: bool = True) -> Iterator[SyncCdpSession]:
+        result = self.start_profile(profile_id, headless=headless)
+        cdp = self.connect_cdp(result, profile_id=profile_id)
+        try:
+            yield cdp
+        finally:
+            try:
+                cdp.close()
+            finally:
+                self.stop_profile(profile_id)
+
+    # ── lifecycle ─────────────────────────────────────────────────────────────
+
+    def close(self) -> None:
+        try:
+            self._portal.run(self._async.aclose())
+        finally:
+            self._portal.close()
+
+    def __enter__(self) -> "ScalebrowserClient":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()

scalebrowser/_version.py

@@ -0,0 +1,3 @@
+"""Single source of the package version."""
+
+__version__ = "0.2.0"