opencomputer-sdk 0.6.4__tar.gz → 0.6.7__tar.gz

{opencomputer_sdk-0.6.4 → opencomputer_sdk-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencomputer-sdk
-Version: 0.6.4
+Version: 0.6.7
 Summary: Python SDK for OpenComputer - cloud sandbox platform
 Project-URL: Homepage, https://github.com/diggerhq/opensandbox
 Project-URL: Repository, https://github.com/diggerhq/opensandbox

{opencomputer_sdk-0.6.4 → opencomputer_sdk-0.6.7}/opencomputer/__init__.py

@@ -1,6 +1,7 @@
 """OpenComputer Python SDK - cloud sandbox platform."""
 
 from opencomputer.sandbox import Sandbox, ScalingLockedError, PlanLimitError, SandboxFamilyLimitError
+from opencomputer.browser import Browser, BrowserProfile
 from opencomputer.agent import Agent, AgentEvent, AgentSession, AgentSessionInfo
 from opencomputer.filesystem import Filesystem
 from opencomputer.exec import Exec, ProcessResult, ExecSession, ExecSessionInfo
@@ -28,6 +29,8 @@ from opencomputer.usage import (
 
 __all__ = [
     "Sandbox",
+    "Browser",
+    "BrowserProfile",
     "ScalingLockedError",
     "PlanLimitError",
     "SandboxFamilyLimitError",
@@ -65,4 +68,4 @@ __all__ = [
     "TagKeyInfo",
 ]
 
-__version__ = "0.6.3"
+__version__ = "0.6.7"

opencomputer_sdk-0.6.7/opencomputer/browser.py

@@ -0,0 +1,260 @@
+"""Browser entity for OpenComputer's browser API."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+
+DEFAULT_BROWSER_API_URL = "https://browser.opencomputer.dev"
+
+
+def _resolve_browser_api_url(api_url: str | None) -> str:
+    return (api_url or os.environ.get("OPENCOMPUTER_BROWSER_API_URL") or DEFAULT_BROWSER_API_URL).rstrip("/")
+
+
+@dataclass
+class Browser:
+    """Browser session managed through OpenComputer."""
+
+    id: str
+    provider: str
+    provider_session_id: str
+    status: str
+    cdp_ws_url: str
+    webdriver_ws_url: str
+    live_view_url: str | None = None
+    base_url: str | None = None
+    headless: bool | None = None
+    stealth: bool | None = None
+    gpu: bool | None = None
+    timeout_seconds: int | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+    deleted_at: str | None = None
+    _api_url: str = ""
+    _api_key: str = ""
+    _client: httpx.AsyncClient | None = None
+
+    @classmethod
+    async def create(
+        cls,
+        *,
+        api_key: str | None = None,
+        api_url: str | None = None,
+        name: str | None = None,
+        tags: dict[str, str] | None = None,
+        stealth: bool | None = None,
+        headless: bool | None = None,
+        gpu: bool | None = None,
+        timeout_seconds: int | None = None,
+        profile: dict[str, Any] | None = None,
+        extensions: list[dict[str, str]] | None = None,
+        proxy_id: str | None = None,
+        viewport: dict[str, int] | None = None,
+        kiosk_mode: bool | None = None,
+        start_url: str | None = None,
+        chrome_policy: dict[str, Any] | None = None,
+        telemetry: dict[str, Any] | None = None,
+    ) -> Browser:
+        """Create a browser session and return direct connection URLs."""
+        url = _resolve_browser_api_url(api_url)
+        key = api_key or os.environ.get("OPENCOMPUTER_API_KEY", "")
+        client = httpx.AsyncClient(base_url=url, headers=_headers(key), timeout=30.0)
+
+        body = _create_body(
+            name=name,
+            tags=tags,
+            stealth=stealth,
+            headless=headless,
+            gpu=gpu,
+            timeout_seconds=timeout_seconds,
+            profile=profile,
+            extensions=extensions,
+            proxy_id=proxy_id,
+            viewport=viewport,
+            kiosk_mode=kiosk_mode,
+            start_url=start_url,
+            chrome_policy=chrome_policy,
+            telemetry=telemetry,
+        )
+        resp = await client.post("/v1/browsers", json=body)
+        resp.raise_for_status()
+        return cls._from_data(resp.json(), url, key, client)
+
+    @classmethod
+    async def connect(
+        cls,
+        browser_id: str,
+        *,
+        api_key: str | None = None,
+        api_url: str | None = None,
+    ) -> Browser:
+        """Load an existing browser session by OpenComputer browser ID."""
+        url = _resolve_browser_api_url(api_url)
+        key = api_key or os.environ.get("OPENCOMPUTER_API_KEY", "")
+        client = httpx.AsyncClient(base_url=url, headers=_headers(key), timeout=30.0)
+        resp = await client.get(f"/v1/browsers/{browser_id}")
+        resp.raise_for_status()
+        return cls._from_data(resp.json(), url, key, client)
+
+    async def delete(self) -> None:
+        """Delete the browser session."""
+        client = self._client or httpx.AsyncClient(base_url=self._api_url, headers=_headers(self._api_key), timeout=30.0)
+        resp = await client.delete(f"/v1/browsers/{self.id}")
+        resp.raise_for_status()
+
+    async def close(self) -> None:
+        """Close the SDK HTTP client. This does not delete the browser."""
+        if self._client is not None:
+            await self._client.aclose()
+
+    @classmethod
+    def _from_data(
+        cls,
+        data: dict[str, Any],
+        api_url: str,
+        api_key: str,
+        client: httpx.AsyncClient,
+    ) -> Browser:
+        return cls(
+            id=data["id"],
+            provider=data.get("provider", "kernel"),
+            provider_session_id=data["provider_session_id"],
+            status=data.get("status", ""),
+            cdp_ws_url=data["cdp_ws_url"],
+            webdriver_ws_url=data["webdriver_ws_url"],
+            live_view_url=data.get("live_view_url"),
+            base_url=data.get("base_url"),
+            headless=data.get("headless"),
+            stealth=data.get("stealth"),
+            gpu=data.get("gpu"),
+            timeout_seconds=data.get("timeout_seconds"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            deleted_at=data.get("deleted_at"),
+            _api_url=api_url,
+            _api_key=api_key,
+            _client=client,
+        )
+
+
+@dataclass
+class BrowserProfile:
+    """Browser profile metadata managed through OpenComputer."""
+
+    id: str
+    provider: str
+    provider_profile_id: str
+    name: str | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+    deleted_at: str | None = None
+    provider_created_at: str | None = None
+    provider_updated_at: str | None = None
+    provider_last_used_at: str | None = None
+    _api_url: str = ""
+    _api_key: str = ""
+    _client: httpx.AsyncClient | None = None
+
+    @classmethod
+    async def create(
+        cls,
+        *,
+        api_key: str | None = None,
+        api_url: str | None = None,
+        name: str | None = None,
+    ) -> BrowserProfile:
+        """Create a browser profile."""
+        url = _resolve_browser_api_url(api_url)
+        key = api_key or os.environ.get("OPENCOMPUTER_API_KEY", "")
+        client = httpx.AsyncClient(base_url=url, headers=_headers(key), timeout=30.0)
+        body = {"name": name} if name is not None else {}
+        resp = await client.post("/v1/profiles", json=body)
+        resp.raise_for_status()
+        return cls._from_data(resp.json(), url, key, client)
+
+    @classmethod
+    async def list(
+        cls,
+        *,
+        api_key: str | None = None,
+        api_url: str | None = None,
+    ) -> list[BrowserProfile]:
+        """List browser profiles for the authenticated org."""
+        url = _resolve_browser_api_url(api_url)
+        key = api_key or os.environ.get("OPENCOMPUTER_API_KEY", "")
+        client = httpx.AsyncClient(base_url=url, headers=_headers(key), timeout=30.0)
+        resp = await client.get("/v1/profiles")
+        resp.raise_for_status()
+        data = resp.json()
+        return [cls._from_data(item, url, key, client) for item in data.get("profiles", [])]
+
+    @classmethod
+    async def connect(
+        cls,
+        id_or_name: str,
+        *,
+        api_key: str | None = None,
+        api_url: str | None = None,
+    ) -> BrowserProfile:
+        """Load a browser profile by OpenComputer profile ID or name."""
+        url = _resolve_browser_api_url(api_url)
+        key = api_key or os.environ.get("OPENCOMPUTER_API_KEY", "")
+        client = httpx.AsyncClient(base_url=url, headers=_headers(key), timeout=30.0)
+        resp = await client.get(f"/v1/profiles/{id_or_name}")
+        resp.raise_for_status()
+        return cls._from_data(resp.json(), url, key, client)
+
+    async def delete(self) -> None:
+        """Delete the browser profile."""
+        client = self._client or httpx.AsyncClient(base_url=self._api_url, headers=_headers(self._api_key), timeout=30.0)
+        resp = await client.delete(f"/v1/profiles/{self.id}")
+        resp.raise_for_status()
+
+    async def close(self) -> None:
+        """Close the SDK HTTP client. This does not delete the profile."""
+        if self._client is not None:
+            await self._client.aclose()
+
+    @classmethod
+    def _from_data(
+        cls,
+        data: dict[str, Any],
+        api_url: str,
+        api_key: str,
+        client: httpx.AsyncClient,
+    ) -> BrowserProfile:
+        return cls(
+            id=data["id"],
+            provider=data.get("provider", "kernel"),
+            provider_profile_id=data["provider_profile_id"],
+            name=data.get("name"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            deleted_at=data.get("deleted_at"),
+            provider_created_at=data.get("provider_created_at"),
+            provider_updated_at=data.get("provider_updated_at"),
+            provider_last_used_at=data.get("provider_last_used_at"),
+            _api_url=api_url,
+            _api_key=api_key,
+            _client=client,
+        )
+
+
+def _headers(api_key: str) -> dict[str, str]:
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["X-API-Key"] = api_key
+    return headers
+
+
+def _create_body(**kwargs: Any) -> dict[str, Any]:
+    body: dict[str, Any] = {}
+    for key, value in kwargs.items():
+        if value is not None:
+            body[key] = value
+    return body

{opencomputer_sdk-0.6.4 → opencomputer_sdk-0.6.7}/opencomputer/sandbox.py

@@ -288,9 +288,16 @@ class Sandbox:
         which handles readiness waiting and proxies to workers."""
         return self._client
 
-    async def kill(self) -> None:
-        """Kill and remove the sandbox."""
-        resp = await self._client.delete(f"/sandboxes/{self.sandbox_id}")
+    async def kill(self, delete_secret_store: bool = False) -> None:
+        """Kill and remove the sandbox.
+
+        Args:
+            delete_secret_store: Also delete the secret store currently attached
+                to this sandbox. Defaults to ``False``. Only use this for
+                single-use stores that should not outlive the sandbox.
+        """
+        params = {"deleteSecretStore": "true"} if delete_secret_store else None
+        resp = await self._client.delete(f"/sandboxes/{self.sandbox_id}", params=params)
         resp.raise_for_status()
         self.status = "stopped"
 
@@ -606,7 +613,7 @@ class Sandbox:
         self,
         name: str,
         kind: str | None = None,
-        promote_to_full: bool = False,
+        promote_to_full: bool | None = None,
         retention_policy: dict | None = None,
     ) -> dict:
         """Create a named checkpoint of the running sandbox.
@@ -615,9 +622,9 @@ class Sandbox:
             name: A unique name for this checkpoint.
             kind: Optional checkpoint kind. Use "full" for disk, memory, and
                 device state, or "disk_only" for a disk-only checkpoint that
-                restores with a cold boot.
-            promote_to_full: For disk-only checkpoints, asynchronously create
-                a derived full checkpoint so future forks can use warm restore.
+                automatically prepares a full artifact for faster future forks.
+            promote_to_full: Advanced override for disk-only checkpoints.
+                Defaults to server behavior.
             retention_policy: Optional policy such as
                 {"mode": "delete_oldest", "maxCount": 10}. When set, the
                 server may delete older eligible checkpoints before creating
@@ -629,8 +636,8 @@ class Sandbox:
         body = {"name": name}
         if kind is not None:
             body["kind"] = kind
-        if promote_to_full:
-            body["promoteToFull"] = True
+        if promote_to_full is not None:
+            body["promoteToFull"] = promote_to_full
         if retention_policy is not None:
             body["retentionPolicy"] = retention_policy
 

{opencomputer_sdk-0.6.4 → opencomputer_sdk-0.6.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencomputer-sdk"
-version = "0.6.4"
+version = "0.6.7"
 description = "Python SDK for OpenComputer - cloud sandbox platform"
 readme = "README.md"
 requires-python = ">=3.10"