hyperbrowser 0.90.1__tar.gz → 0.90.3__tar.gz

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 0.90.1
+Version: 0.90.3
 Summary: Python SDK for hyperbrowser
 License: MIT
 License-File: LICENSE
@@ -156,6 +156,35 @@ client.close()
 
 `cpu`, `memory_mib`, and `disk_mib` are only supported for image launches.
 
+### Manage volumes and mount them in a sandbox
+
+```python
+from hyperbrowser import Hyperbrowser
+from hyperbrowser.models import CreateSandboxParams, CreateVolumeParams, SandboxVolumeMount
+
+client = Hyperbrowser(api_key="test-key")
+
+volume = client.volumes.create(CreateVolumeParams(name="project-cache"))
+all_volumes = client.volumes.list()
+same_volume = client.volumes.get(volume.id)
+
+sandbox = client.sandboxes.create(
+    CreateSandboxParams(
+        image_name="node",
+        mounts={
+            "/workspace/cache": SandboxVolumeMount(
+                id=same_volume.id,
+                type="rw",
+                shared=True,
+            )
+        },
+    )
+)
+
+sandbox.stop()
+client.close()
+```
+
 ### List sandboxes with filters
 
 ```python

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/README.md

@@ -130,6 +130,35 @@ client.close()
 
 `cpu`, `memory_mib`, and `disk_mib` are only supported for image launches.
 
+### Manage volumes and mount them in a sandbox
+
+```python
+from hyperbrowser import Hyperbrowser
+from hyperbrowser.models import CreateSandboxParams, CreateVolumeParams, SandboxVolumeMount
+
+client = Hyperbrowser(api_key="test-key")
+
+volume = client.volumes.create(CreateVolumeParams(name="project-cache"))
+all_volumes = client.volumes.list()
+same_volume = client.volumes.get(volume.id)
+
+sandbox = client.sandboxes.create(
+    CreateSandboxParams(
+        image_name="node",
+        mounts={
+            "/workspace/cache": SandboxVolumeMount(
+                id=same_volume.id,
+                type="rw",
+                shared=True,
+            )
+        },
+    )
+)
+
+sandbox.stop()
+client.close()
+```
+
 ### List sandboxes with filters
 
 ```python

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/client/async_client.py

@@ -14,6 +14,7 @@ from .managers.async_manager.scrape import ScrapeManager
 from .managers.async_manager.session import SessionManager
 from .managers.async_manager.team import TeamManager
 from .managers.async_manager.computer_action import ComputerActionManager
+from .managers.async_manager.volume import VolumeManager
 
 
 class AsyncHyperbrowser(HyperbrowserBase):
@@ -47,6 +48,7 @@ class AsyncHyperbrowser(HyperbrowserBase):
         self.team = TeamManager(self)
         self.computer_action = ComputerActionManager(self)
         self.sandboxes = SandboxManager(self)
+        self.volumes = VolumeManager(self)
 
     async def close(self) -> None:
         await self.transport.close()

hyperbrowser-0.90.3/hyperbrowser/client/managers/async_manager/volume.py

@@ -0,0 +1,26 @@
+from hyperbrowser.models.volume import CreateVolumeParams, Volume, VolumeListResponse
+
+
+class VolumeManager:
+    def __init__(self, client):
+        self._client = client
+
+    async def create(self, params: CreateVolumeParams) -> Volume:
+        if not isinstance(params, CreateVolumeParams):
+            raise TypeError("params must be a CreateVolumeParams instance")
+
+        response = await self._client.transport.post(
+            self._client._build_url("/volume"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return Volume(**response.data)
+
+    async def list(self) -> VolumeListResponse:
+        response = await self._client.transport.get(self._client._build_url("/volume"))
+        return VolumeListResponse(**response.data)
+
+    async def get(self, volume_id: str) -> Volume:
+        response = await self._client.transport.get(
+            self._client._build_url(f"/volume/{volume_id}")
+        )
+        return Volume(**response.data)

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/client/managers/sandboxes/shared.py

@@ -17,6 +17,7 @@ from ....sandbox_common import (
     RUNTIME_SESSION_REFRESH_BUFFER_MS,
     normalize_network_error,
     parse_error_payload,
+    runtime_base_url_session_id,
 )
 
 DEFAULT_WATCH_TIMEOUT_MS = 60_000
@@ -84,13 +85,31 @@ def _normalize_exec_params(
     return _normalize_legacy_process_fields(normalized)
 
 
+def _resolve_sandbox_runtime_session_host(runtime, base_url) -> str:
+    session_id_from_base_path = runtime_base_url_session_id(base_url.path)
+    if session_id_from_base_path and base_url.hostname:
+        return f"{session_id_from_base_path}.{base_url.hostname}"
+
+    runtime_host = str(getattr(runtime, "host", "") or "").strip()
+    if runtime_host:
+        parsed_host = urlsplit(runtime_host)
+        if parsed_host.hostname:
+            session_id_from_host_path = runtime_base_url_session_id(parsed_host.path)
+            if session_id_from_host_path:
+                return f"{session_id_from_host_path}.{parsed_host.hostname}"
+            return parsed_host.hostname
+        return runtime_host
+
+    return base_url.hostname or ""
+
+
 def _build_sandbox_exposed_url(runtime, port: int) -> str:
     parsed = urlsplit(runtime.base_url)
-    hostname = parsed.hostname
-    if not hostname:
+    session_host = _resolve_sandbox_runtime_session_host(runtime, parsed)
+    if not session_host:
         return runtime.base_url
 
-    exposed_host = f"{port}-{hostname}"
+    exposed_host = f"{port}-{session_host}"
     netloc = exposed_host
     if parsed.port:
         netloc = f"{netloc}:{parsed.port}"
@@ -100,9 +119,7 @@ def _build_sandbox_exposed_url(runtime, port: int) -> str:
             credentials = f"{credentials}:{parsed.password}"
         netloc = f"{credentials}@{netloc}"
 
-    path = parsed.path or "/"
-
-    return urlunsplit((parsed.scheme, netloc, path, parsed.query, parsed.fragment))
+    return urlunsplit((parsed.scheme, netloc, "/", "", ""))
 
 
 def _expires_within_buffer(expires_at: Optional[datetime]) -> bool:

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/client/managers/sync_manager/sandboxes/sandbox_files.py

@@ -292,8 +292,8 @@ class SandboxFilesApi:
             "/sandbox/files",
             params=self._with_run_as_params(
                 {
-                "path": path,
-                "depth": depth,
+                    "path": path,
+                    "depth": depth,
                 }
             ),
         )

hyperbrowser-0.90.3/hyperbrowser/client/managers/sync_manager/volume.py

@@ -0,0 +1,26 @@
+from hyperbrowser.models.volume import CreateVolumeParams, Volume, VolumeListResponse
+
+
+class VolumeManager:
+    def __init__(self, client):
+        self._client = client
+
+    def create(self, params: CreateVolumeParams) -> Volume:
+        if not isinstance(params, CreateVolumeParams):
+            raise TypeError("params must be a CreateVolumeParams instance")
+
+        response = self._client.transport.post(
+            self._client._build_url("/volume"),
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return Volume(**response.data)
+
+    def list(self) -> VolumeListResponse:
+        response = self._client.transport.get(self._client._build_url("/volume"))
+        return VolumeListResponse(**response.data)
+
+    def get(self, volume_id: str) -> Volume:
+        response = self._client.transport.get(
+            self._client._build_url(f"/volume/{volume_id}")
+        )
+        return Volume(**response.data)

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/client/sync.py

@@ -14,6 +14,7 @@ from .managers.sync_manager.scrape import ScrapeManager
 from .managers.sync_manager.session import SessionManager
 from .managers.sync_manager.team import TeamManager
 from .managers.sync_manager.computer_action import ComputerActionManager
+from .managers.sync_manager.volume import VolumeManager
 
 
 class Hyperbrowser(HyperbrowserBase):
@@ -47,6 +48,7 @@ class Hyperbrowser(HyperbrowserBase):
         self.team = TeamManager(self)
         self.computer_action = ComputerActionManager(self)
         self.sandboxes = SandboxManager(self)
+        self.volumes = VolumeManager(self)
 
     def close(self) -> None:
         self.transport.close()

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/models/__init__.py

@@ -173,6 +173,7 @@ from .profile import (
     ProfileListResponse,
     ProfileResponse,
 )
+from .volume import CreateVolumeParams, Volume, VolumeListResponse
 from .scrape import (
     BatchScrapeJobResponse,
     BatchScrapeJobStatusResponse,
@@ -245,6 +246,8 @@ from .sandbox import (
     Sandbox,
     SandboxDetail,
     SandboxRuntimeSession,
+    SandboxVolumeMountType,
+    SandboxVolumeMount,
     CreateSandboxParams,
     StartSandboxFromSnapshotParams,
     SandboxListParams,
@@ -450,6 +453,10 @@ __all__ = [
     "ProfileListParams",
     "ProfileListResponse",
     "ProfileResponse",
+    # volume
+    "CreateVolumeParams",
+    "Volume",
+    "VolumeListResponse",
     # scrape
     "BatchScrapeJobResponse",
     "BatchScrapeJobStatusResponse",
@@ -499,6 +506,8 @@ __all__ = [
     "Sandbox",
     "SandboxDetail",
     "SandboxRuntimeSession",
+    "SandboxVolumeMountType",
+    "SandboxVolumeMount",
     "CreateSandboxParams",
     "StartSandboxFromSnapshotParams",
     "SandboxListParams",

hyperbrowser-0.90.3/hyperbrowser/models/_parsers.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+
+def _parse_optional_int(value: Any):
+    if value is None or isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.strip() == "":
+        return None
+    if isinstance(value, str):
+        return int(value)
+    return value

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/models/sandbox.py

@@ -3,6 +3,7 @@ from typing import Callable, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
+from ._parsers import _parse_optional_int
 from .session import SessionLaunchState, SessionStatus
 
 SandboxStatus = SessionStatus
@@ -29,6 +30,7 @@ SandboxFileEncoding = Literal["utf8", "base64"]
 SandboxFileReadFormat = Literal["text", "bytes", "blob", "stream"]
 SandboxFileWatchRoute = Literal["ws", "stream"]
 SandboxFileSystemEventType = Literal["chmod", "create", "remove", "rename", "write"]
+SandboxVolumeMountType = Literal["rw", "ro"]
 
 
 def _parse_optional_datetime(value):
@@ -37,16 +39,6 @@ def _parse_optional_datetime(value):
     return value
 
 
-def _parse_optional_int(value):
-    if value is None or isinstance(value, int):
-        return value
-    if isinstance(value, str) and value.strip() == "":
-        return None
-    if isinstance(value, str):
-        return int(value)
-    return value
-
-
 def _parse_optional_datetime_from_millis(value):
     if value in (None, ""):
         return None
@@ -95,6 +87,12 @@ class SandboxUnexposeResult(SandboxBaseModel):
     exposed: bool
 
 
+class SandboxVolumeMount(SandboxBaseModel):
+    id: str
+    type: Optional[SandboxVolumeMountType] = None
+    shared: Optional[bool] = None
+
+
 class Sandbox(SandboxBaseModel):
     id: str
     team_id: str = Field(alias="teamId")
@@ -180,6 +178,10 @@ class CreateSandboxParams(SandboxBaseModel):
         default=None,
         serialization_alias="exposedPorts",
     )
+    mounts: Optional[Dict[str, SandboxVolumeMount]] = Field(
+        default=None,
+        serialization_alias="mounts",
+    )
     timeout_minutes: Optional[int] = Field(
         default=None, serialization_alias="timeoutMinutes"
     )

hyperbrowser-0.90.3/hyperbrowser/models/volume.py

@@ -0,0 +1,29 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from ._parsers import _parse_optional_int
+
+
+class VolumeBaseModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class CreateVolumeParams(VolumeBaseModel):
+    name: str
+
+
+class Volume(VolumeBaseModel):
+    id: str
+    name: str
+    size: Optional[int] = None
+    transfer_amount: Optional[int] = Field(default=None, alias="transferAmount")
+
+    @field_validator("size", "transfer_amount", mode="before")
+    @classmethod
+    def parse_optional_int_fields(cls, value):
+        return _parse_optional_int(value)
+
+
+class VolumeListResponse(VolumeBaseModel):
+    volumes: List[Volume]

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/hyperbrowser/sandbox_common.py

@@ -114,13 +114,61 @@ def has_scheme(value: str) -> bool:
     return "://" in value
 
 
+def runtime_base_url_session_id(runtime_base_url: str) -> Optional[str]:
+    parsed_base_url = urlsplit(runtime_base_url.strip())
+    segments = [
+        segment
+        for segment in parsed_base_url.path.strip().strip("/").split("/")
+        if segment
+    ]
+    if len(segments) < 2 or segments[0] != "sandbox" or not segments[1].strip():
+        return None
+    return segments[1].strip()
+
+
+def should_prepend_sandbox_to_runtime_api(runtime_base_url: str) -> bool:
+    return runtime_base_url_session_id(runtime_base_url) is None
+
+
+def normalize_runtime_api_path(pathname: str, prepend_sandbox: bool) -> str:
+    trimmed = pathname.strip()
+    if trimmed == "":
+        return "/sandbox" if prepend_sandbox else "/"
+
+    absolute = trimmed if trimmed.startswith("/") else f"/{trimmed}"
+    if prepend_sandbox:
+        if absolute == "/sandbox" or absolute.startswith("/sandbox/"):
+            return absolute
+        return f"/sandbox{absolute}"
+
+    if absolute == "/sandbox":
+        return "/"
+    if absolute.startswith("/sandbox/"):
+        return f"/{absolute[len('/sandbox/'):]}"
+    return absolute
+
+
+def normalize_runtime_relative_path(base_url: str, path: str) -> str:
+    trimmed = path.strip()
+    if trimmed == "":
+        return ""
+
+    parsed_path = urlsplit(trimmed)
+    prepend_sandbox = should_prepend_sandbox_to_runtime_api(base_url)
+    normalized_path = normalize_runtime_api_path(parsed_path.path, prepend_sandbox)
+    relative_path = normalized_path.lstrip("/")
+    return urlunsplit(
+        ("", "", relative_path, parsed_path.query, parsed_path.fragment)
+    )
+
+
 def resolve_runtime_transport_target(
     base_url: str,
     path: str,
     runtime_proxy_override: Optional[str] = None,
 ) -> RuntimeTransportTarget:
     normalized_base = base_url if base_url.endswith("/") else f"{base_url}/"
-    url = urljoin(normalized_base, path.lstrip("/"))
+    url = urljoin(normalized_base, normalize_runtime_relative_path(base_url, path))
 
     if not runtime_proxy_override:
         return RuntimeTransportTarget(url=url)
@@ -151,7 +199,7 @@ def to_websocket_transport_target(
     runtime_proxy_override: Optional[str] = None,
 ) -> RuntimeTransportTarget:
     normalized_base = base_url if base_url.endswith("/") else f"{base_url}/"
-    url = urljoin(normalized_base, path.lstrip("/"))
+    url = urljoin(normalized_base, normalize_runtime_relative_path(base_url, path))
     parts = urlsplit(url)
     scheme = parts.scheme
     if scheme == "https":

{hyperbrowser-0.90.1 → hyperbrowser-0.90.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "hyperbrowser"
-version = "0.90.1"
+version = "0.90.3"
 description = "Python SDK for hyperbrowser"
 authors = ["Nikhil Shahi <nshahi1998@gmail.com>"]
 license = "MIT"