hyperbrowser 0.92.2__tar.gz → 0.93.0__tar.gz

{hyperbrowser-0.92.2 → hyperbrowser-0.93.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperbrowser
-Version: 0.92.2
+Version: 0.93.0
 Summary: Python SDK for hyperbrowser
 License: MIT
 License-File: LICENSE

{hyperbrowser-0.92.2 → hyperbrowser-0.93.0}/hyperbrowser/client/managers/async_manager/sandbox.py

@@ -1,17 +1,28 @@
+import asyncio
+import functools
+import time
 from typing import Dict, Optional, Union
 
 from ....exceptions import HyperbrowserError
 from ....models.sandbox import (
+    CompleteSandboxImageBuildParams,
     CreateSandboxParams,
+    CreateSandboxImageBuildParams,
     SandboxDetail,
     SandboxExecParams,
     SandboxExposeParams,
     SandboxExposeResult,
+    SandboxImageBuild,
+    SandboxImageBuildCreateResult,
+    SandboxImageListParams,
     SandboxImageListResponse,
+    SandboxImageInit,
     SandboxListParams,
     SandboxListResponse,
     SandboxMemorySnapshotParams,
     SandboxMemorySnapshotResult,
+    SandboxNetworkPolicy,
+    SandboxNetworkUpdateResult,
     SandboxRuntimeSession,
     SandboxSnapshotListParams,
     SandboxSnapshotListResponse,
@@ -30,6 +41,15 @@ from ..sandboxes.shared import (
     _copy_model,
     _expires_within_buffer,
 )
+from ..sandboxes.image_build import (
+    IMAGE_BUILD_SOURCE_PLATFORM,
+    build_docker_image_from_dockerfile,
+    is_terminal_image_build_status,
+    make_temp_docker_tag,
+    package_docker_image,
+    remove_docker_image,
+    upload_image_build_artifact,
+)
 from .sandboxes.sandbox_files import (
     DEFAULT_WATCH_TIMEOUT_MS,
     SandboxFileWatchHandle,
@@ -67,6 +87,12 @@ __all__ = [
 ]
 
 
+async def _run_blocking(func, *args, **kwargs):
+    loop = asyncio.get_running_loop()
+    call = functools.partial(func, *args, **kwargs)
+    return await loop.run_in_executor(None, call)
+
+
 class SandboxHandle:
     def __init__(self, service: "SandboxManager", detail: SandboxDetail):
         self._service = service
@@ -130,6 +156,10 @@ class SandboxHandle:
     def exposed_ports(self):
         return self._detail.exposed_ports
 
+    @property
+    def network(self):
+        return self._detail.network
+
     def to_dict(self):
         return self._detail.model_dump()
 
@@ -166,6 +196,25 @@ class SandboxHandle:
             raise TypeError("params must be a SandboxMemorySnapshotParams instance")
         return await self._service.create_memory_snapshot(self.id, normalized)
 
+    async def update_network(
+        self,
+        policy: SandboxNetworkPolicy,
+    ) -> SandboxNetworkUpdateResult:
+        if not isinstance(policy, SandboxNetworkPolicy):
+            raise TypeError("policy must be a SandboxNetworkPolicy instance")
+        result = await self._service.update_network(self.id, policy)
+        self._detail = self._detail.model_copy(update={"network": result.network})
+        return result
+
+    async def clear_network(self) -> SandboxNetworkUpdateResult:
+        return await self.update_network(
+            SandboxNetworkPolicy(
+                allow_internet_access=True,
+                allow_out=[],
+                deny_out=[],
+            )
+        )
+
     async def expose(self, params: SandboxExposeParams) -> SandboxExposeResult:
         if not isinstance(params, SandboxExposeParams):
             raise TypeError("params must be a SandboxExposeParams instance")
@@ -350,8 +399,16 @@ class SandboxManager:
         )
         return SandboxListResponse(**payload)
 
-    async def list_images(self) -> SandboxImageListResponse:
-        payload = await self._request("GET", "/images")
+    async def list_images(
+        self, params: SandboxImageListParams = SandboxImageListParams()
+    ) -> SandboxImageListResponse:
+        if not isinstance(params, SandboxImageListParams):
+            raise TypeError("params must be a SandboxImageListParams instance")
+        payload = await self._request(
+            "GET",
+            "/images",
+            params=params.model_dump(exclude_none=True, by_alias=True),
+        )
         return SandboxImageListResponse(**payload)
 
     async def list_snapshots(
@@ -370,6 +427,170 @@ class SandboxManager:
         payload = await self._request("PUT", f"/sandbox/{sandbox_id}/stop")
         return BasicResponse(**payload)
 
+    async def create_image_build(
+        self,
+        params: CreateSandboxImageBuildParams,
+    ) -> SandboxImageBuildCreateResult:
+        if not isinstance(params, CreateSandboxImageBuildParams):
+            raise TypeError("params must be a CreateSandboxImageBuildParams instance")
+        payload = await self._request(
+            "POST",
+            "/images/builds",
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SandboxImageBuildCreateResult(**payload)
+
+    async def get_image_build(self, build_id: str) -> SandboxImageBuild:
+        payload = await self._request("GET", f"/images/builds/{build_id}")
+        return SandboxImageBuild(**payload["build"])
+
+    async def complete_image_build(
+        self,
+        build_id: str,
+        params: CompleteSandboxImageBuildParams,
+    ) -> SandboxImageBuild:
+        if not isinstance(params, CompleteSandboxImageBuildParams):
+            raise TypeError("params must be a CompleteSandboxImageBuildParams instance")
+        payload = await self._request(
+            "POST",
+            f"/images/builds/{build_id}/complete",
+            data=params.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SandboxImageBuild(**payload["build"])
+
+    async def cancel_image_build(self, build_id: str) -> SandboxImageBuild:
+        payload = await self._request("POST", f"/images/builds/{build_id}/cancel")
+        return SandboxImageBuild(**payload["build"])
+
+    async def wait_for_image_build(
+        self,
+        build_id: str,
+        *,
+        poll_interval: float = 3.0,
+        timeout: Optional[float] = 35 * 60,
+    ) -> SandboxImageBuild:
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while True:
+            build = await self.get_image_build(build_id)
+            if build.status == "completed":
+                return build
+            if build.status == "failed":
+                message = build.error_message or "image build failed"
+                if build.error_code:
+                    message = f"image build failed [{build.error_code}]: {message}"
+                raise RuntimeError(message)
+            if is_terminal_image_build_status(build.status):
+                raise RuntimeError(f"image build {build.status}")
+            if deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError(f"timed out waiting for image build {build_id}")
+            await asyncio.sleep(poll_interval)
+
+    async def build_image_from_docker_image(
+        self,
+        *,
+        docker_image: str,
+        image_name: str,
+        platform: str = IMAGE_BUILD_SOURCE_PLATFORM,
+        image_init: Optional[SandboxImageInit] = None,
+        image_config_user: Optional[str] = None,
+        wait: bool = True,
+        poll_interval: float = 3.0,
+        wait_timeout: Optional[float] = 35 * 60,
+        temp_dir: Optional[str] = None,
+        upload_timeout: Optional[float] = None,
+    ) -> SandboxImageBuild:
+        artifact = await _run_blocking(
+            package_docker_image,
+            docker_image,
+            platform=platform,
+            temp_dir=temp_dir,
+        )
+        try:
+            create_result = await self.create_image_build(
+                CreateSandboxImageBuildParams(
+                    image_name=image_name,
+                    input_sha256=artifact.sha256_hex,
+                    input_size_bytes=artifact.size_bytes,
+                    input_format=artifact.input_format,
+                    source_platform=artifact.source_platform,
+                    image_config_user=(
+                        image_config_user
+                        if image_config_user is not None
+                        else artifact.image_config_user
+                    ),
+                    image_init=image_init
+                    if image_init is not None
+                    else artifact.image_init,
+                )
+            )
+            await _run_blocking(
+                upload_image_build_artifact,
+                create_result.upload,
+                artifact.path,
+                timeout=upload_timeout,
+            )
+            build = await self.complete_image_build(
+                create_result.build.id,
+                CompleteSandboxImageBuildParams(
+                    input_sha256=artifact.sha256_hex,
+                    input_size_bytes=artifact.size_bytes,
+                    input_format=artifact.input_format,
+                ),
+            )
+            if wait:
+                return await self.wait_for_image_build(
+                    build.id,
+                    poll_interval=poll_interval,
+                    timeout=wait_timeout,
+                )
+            return build
+        finally:
+            artifact.cleanup()
+
+    async def build_image_from_dockerfile(
+        self,
+        *,
+        context_path,
+        image_name: str,
+        dockerfile="Dockerfile",
+        docker_tag: Optional[str] = None,
+        platform: str = IMAGE_BUILD_SOURCE_PLATFORM,
+        build_args: Optional[Dict[str, str]] = None,
+        image_init: Optional[SandboxImageInit] = None,
+        image_config_user: Optional[str] = None,
+        wait: bool = True,
+        poll_interval: float = 3.0,
+        wait_timeout: Optional[float] = 35 * 60,
+        temp_dir: Optional[str] = None,
+        upload_timeout: Optional[float] = None,
+    ) -> SandboxImageBuild:
+        tag = docker_tag or make_temp_docker_tag()
+        remove_tag = docker_tag is None
+        try:
+            await _run_blocking(
+                build_docker_image_from_dockerfile,
+                context_path=context_path,
+                dockerfile=dockerfile,
+                tag=tag,
+                platform=platform,
+                build_args=build_args,
+            )
+            return await self.build_image_from_docker_image(
+                docker_image=tag,
+                image_name=image_name,
+                platform=platform,
+                image_init=image_init,
+                image_config_user=image_config_user,
+                wait=wait,
+                poll_interval=poll_interval,
+                wait_timeout=wait_timeout,
+                temp_dir=temp_dir,
+                upload_timeout=upload_timeout,
+            )
+        finally:
+            if remove_tag:
+                await _run_blocking(remove_docker_image, tag)
+
     async def get_runtime_session(self, sandbox_id: str) -> SandboxRuntimeSession:
         detail = await self.get_detail(sandbox_id)
         session = SandboxHandle._to_runtime_session(detail)
@@ -404,6 +625,20 @@ class SandboxManager:
         )
         return SandboxMemorySnapshotResult(**payload)
 
+    async def update_network(
+        self,
+        sandbox_id: str,
+        policy: SandboxNetworkPolicy,
+    ) -> SandboxNetworkUpdateResult:
+        if not isinstance(policy, SandboxNetworkPolicy):
+            raise TypeError("policy must be a SandboxNetworkPolicy instance")
+        payload = await self._request(
+            "PUT",
+            f"/sandbox/{sandbox_id}/network",
+            data=policy.model_dump(exclude_none=True, by_alias=True),
+        )
+        return SandboxNetworkUpdateResult(**payload)
+
     async def expose(
         self,
         sandbox_id: str,

{hyperbrowser-0.92.2 → hyperbrowser-0.93.0}/hyperbrowser/client/managers/async_manager/sandboxes/sandbox_files.py

@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import functools
 import inspect
 import io
 import json
@@ -43,6 +44,42 @@ from ...sandboxes.shared import (
 )
 from .sandbox_transport import RuntimeTransport
 
+DEFAULT_TRANSFER_CHUNK_SIZE = 64 * 1024
+
+
+async def _run_blocking(func, *args, **kwargs):
+    loop = asyncio.get_running_loop()
+    call = functools.partial(func, *args, **kwargs)
+    return await loop.run_in_executor(None, call)
+
+
+async def _aiter_stream_content(stream, chunk_size: int = DEFAULT_TRANSFER_CHUNK_SIZE):
+    if isinstance(stream, str):
+        yield stream.encode("utf-8")
+        return
+    if isinstance(stream, (bytes, bytearray)):
+        yield bytes(stream)
+        return
+    if hasattr(stream, "__aiter__"):
+        async for chunk in stream:
+            if isinstance(chunk, str):
+                chunk = chunk.encode("utf-8")
+            yield bytes(chunk)
+        return
+    if hasattr(stream, "read"):
+        while True:
+            chunk = await _run_blocking(stream.read, chunk_size)
+            if not chunk:
+                break
+            if isinstance(chunk, str):
+                chunk = chunk.encode("utf-8")
+            yield bytes(chunk)
+        return
+    for chunk in stream:
+        if isinstance(chunk, str):
+            chunk = chunk.encode("utf-8")
+        yield bytes(chunk)
+
 
 class SandboxFileWatchHandle:
     def __init__(
@@ -439,12 +476,45 @@ class SandboxFilesApi:
         )
         return SandboxFileTransferResult(**payload)
 
+    async def upload_stream(
+        self,
+        path: str,
+        stream,
+        *,
+        content_length: Optional[int] = None,
+        chunk_size: int = DEFAULT_TRANSFER_CHUNK_SIZE,
+    ):
+        headers = {}
+        if content_length is not None:
+            headers["content-length"] = str(content_length)
+        payload = await self._transport.request_json(
+            "/sandbox/files/upload",
+            method="PUT",
+            params=self._with_run_as_params({"path": path}),
+            content=_aiter_stream_content(stream, chunk_size=chunk_size),
+            headers=headers or None,
+        )
+        return SandboxFileTransferResult(**payload)
+
     async def download(self, path: str) -> bytes:
         return await self._transport.request_bytes(
             "/sandbox/files/download",
             params=self._with_run_as_params({"path": path}),
         )
 
+    async def download_stream(
+        self,
+        path: str,
+        *,
+        chunk_size: int = DEFAULT_TRANSFER_CHUNK_SIZE,
+    ) -> AsyncIterator[bytes]:
+        async for chunk in self._transport.stream_bytes(
+            "/sandbox/files/download",
+            params=self._with_run_as_params({"path": path}),
+            chunk_size=chunk_size,
+        ):
+            yield chunk
+
     async def make_dir(
         self,
         path: str,

{hyperbrowser-0.92.2 → hyperbrowser-0.93.0}/hyperbrowser/client/managers/async_manager/sandboxes/sandbox_transport.py

@@ -1,5 +1,5 @@
 import json
-from typing import AsyncIterator, Dict, Optional, Union
+from typing import Any, AsyncIterator, Dict, Optional
 
 import httpx
 
@@ -11,7 +11,7 @@ from .....sandbox_common import (
     parse_json_response,
     resolve_runtime_transport_target,
 )
-from ...sandboxes.shared import _build_query_path
+from ...sandboxes.shared import _build_query_path, _is_replayable_http_content
 
 
 class RuntimeTransport:
@@ -32,7 +32,7 @@ class RuntimeTransport:
         method: str = "GET",
         params: Optional[Dict[str, object]] = None,
         json_body: Optional[Dict[str, object]] = None,
-        content: Optional[Union[str, bytes]] = None,
+        content: Optional[Any] = None,
         headers: Optional[Dict[str, str]] = None,
     ):
         response = await self._request(
@@ -58,6 +58,29 @@ class RuntimeTransport:
         )
         return response.content
 
+    async def stream_bytes(
+        self,
+        path: str,
+        *,
+        method: str = "GET",
+        params: Optional[Dict[str, object]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        chunk_size: int = 65536,
+    ) -> AsyncIterator[bytes]:
+        client, response = await self._open_binary_stream(
+            path,
+            method=method,
+            params=params,
+            headers=headers,
+        )
+        try:
+            async for chunk in response.aiter_bytes(chunk_size=chunk_size):
+                if chunk:
+                    yield chunk
+        finally:
+            await response.aclose()
+            await client.aclose()
+
     async def stream_sse(
         self, path: str, params: Optional[Dict[str, object]] = None
     ) -> AsyncIterator[Dict[str, object]]:
@@ -127,7 +150,7 @@ class RuntimeTransport:
         method: str = "GET",
         params: Optional[Dict[str, object]] = None,
         json_body: Optional[Dict[str, object]] = None,
-        content: Optional[Union[str, bytes]] = None,
+        content: Optional[Any] = None,
         headers: Optional[Dict[str, str]] = None,
         allow_refresh: bool = True,
     ) -> httpx.Response:
@@ -144,6 +167,12 @@ class RuntimeTransport:
 
         if response.status_code == 401 and allow_refresh:
             await response.aclose()
+            if not _is_replayable_http_content(content):
+                return ensure_response_ok(
+                    response,
+                    "runtime",
+                    "Runtime token expired during a streaming request; retry with a fresh stream.",
+                )
             refreshed = await self._resolve_connection(True)
             retry = await self._send(
                 refreshed,
@@ -178,6 +207,40 @@ class RuntimeTransport:
         ensure_response_ok(response, "runtime")
         return client, response
 
+    async def _open_binary_stream(
+        self,
+        path: str,
+        *,
+        method: str = "GET",
+        params: Optional[Dict[str, object]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        allow_refresh: bool = True,
+    ):
+        connection = await self._resolve_connection(False)
+        client, response = await self._send_binary_stream(
+            connection,
+            path,
+            method=method,
+            params=params,
+            headers=headers,
+        )
+        if response.status_code == 401 and allow_refresh:
+            await response.aclose()
+            await client.aclose()
+            refreshed = await self._resolve_connection(True)
+            client, response = await self._send_binary_stream(
+                refreshed,
+                path,
+                method=method,
+                params=params,
+                headers=headers,
+            )
+
+        if not response.is_success:
+            await response.aread()
+        ensure_response_ok(response, "runtime")
+        return client, response
+
     async def _send(
         self,
         connection: RuntimeConnection,
@@ -186,7 +249,7 @@ class RuntimeTransport:
         method: str,
         params: Optional[Dict[str, object]],
         json_body: Optional[Dict[str, object]],
-        content: Optional[Union[str, bytes]],
+        content: Optional[Any],
         headers: Optional[Dict[str, str]],
     ) -> httpx.Response:
         request_path = _build_query_path(path, params)
@@ -218,6 +281,36 @@ class RuntimeTransport:
         await client.aclose()
         return response
 
+    async def _send_binary_stream(
+        self,
+        connection: RuntimeConnection,
+        path: str,
+        *,
+        method: str,
+        params: Optional[Dict[str, object]],
+        headers: Optional[Dict[str, str]],
+    ):
+        request_path = _build_query_path(path, params)
+        target = resolve_runtime_transport_target(
+            connection.base_url,
+            request_path,
+            self._runtime_proxy_override,
+        )
+        merged_headers = build_headers(connection.token, headers, target.host_header)
+        client = httpx.AsyncClient(timeout=self._timeout)
+
+        try:
+            request = client.build_request(method, target.url, headers=merged_headers)
+            response = await client.send(request, stream=True)
+            return client, response
+        except BaseException as error:
+            await client.aclose()
+            raise normalize_network_error(
+                error,
+                "runtime",
+                "Unknown runtime request error",
+            )
+
     async def _send_stream(
         self,
         connection: RuntimeConnection,