blaxel 0.2.35__py3-none-any.whl → 0.2.37__py3-none-any.whl

blaxel/core/sandbox/client/models/find_response.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 if TYPE_CHECKING:
     from ..models.find_match import FindMatch
 
@@ -16,34 +14,33 @@ T = TypeVar("T", bound="FindResponse")
 class FindResponse:
     """
     Attributes:
-        matches (Union[Unset, list['FindMatch']]):
-        total (Union[Unset, int]):  Example: 5.
+        matches (list['FindMatch']):
+        total (int):  Example: 5.
     """
 
-    matches: Union[Unset, list["FindMatch"]] = UNSET
-    total: Union[Unset, int] = UNSET
+    matches: list["FindMatch"]
+    total: int
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        matches: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.matches, Unset):
-            matches = []
-            for matches_item_data in self.matches:
-                if type(matches_item_data) is dict:
-                    matches_item = matches_item_data
-                else:
-                    matches_item = matches_item_data.to_dict()
-                matches.append(matches_item)
+        matches = []
+        for matches_item_data in self.matches:
+            if type(matches_item_data) is dict:
+                matches_item = matches_item_data
+            else:
+                matches_item = matches_item_data.to_dict()
+            matches.append(matches_item)
 
         total = self.total
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if matches is not UNSET:
-            field_dict["matches"] = matches
-        if total is not UNSET:
-            field_dict["total"] = total
+        field_dict.update(
+            {
+                "matches": matches,
+                "total": total,
+            }
+        )
 
         return field_dict
 
@@ -55,13 +52,13 @@ class FindResponse:
             return None
         d = src_dict.copy()
         matches = []
-        _matches = d.pop("matches", UNSET)
-        for matches_item_data in _matches or []:
+        _matches = d.pop("matches")
+        for matches_item_data in _matches:
             matches_item = FindMatch.from_dict(matches_item_data)
 
             matches.append(matches_item)
 
-        total = d.pop("total", UNSET)
+        total = d.pop("total")
 
         find_response = cls(
             matches=matches,

blaxel/core/sandbox/client/models/fuzzy_search_match.py

@@ -1,10 +1,8 @@
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 T = TypeVar("T", bound="FuzzySearchMatch")
 
 
@@ -12,14 +10,14 @@ T = TypeVar("T", bound="FuzzySearchMatch")
 class FuzzySearchMatch:
     """
     Attributes:
-        path (Union[Unset, str]):  Example: src/main.go.
-        score (Union[Unset, int]):  Example: 100.
-        type_ (Union[Unset, str]): "file" or "directory" Example: file.
+        path (str):  Example: src/main.go.
+        score (int):  Example: 100.
+        type_ (str): "file" or "directory" Example: file.
     """
 
-    path: Union[Unset, str] = UNSET
-    score: Union[Unset, int] = UNSET
-    type_: Union[Unset, str] = UNSET
+    path: str
+    score: int
+    type_: str
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -31,13 +29,13 @@ class FuzzySearchMatch:
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if path is not UNSET:
-            field_dict["path"] = path
-        if score is not UNSET:
-            field_dict["score"] = score
-        if type_ is not UNSET:
-            field_dict["type"] = type_
+        field_dict.update(
+            {
+                "path": path,
+                "score": score,
+                "type": type_,
+            }
+        )
 
         return field_dict
 
@@ -46,11 +44,11 @@ class FuzzySearchMatch:
         if not src_dict:
             return None
         d = src_dict.copy()
-        path = d.pop("path", UNSET)
+        path = d.pop("path")
 
-        score = d.pop("score", UNSET)
+        score = d.pop("score")
 
-        type_ = d.pop("type", d.pop("type_", UNSET))
+        type_ = d.pop("type") if "type" in d else d.pop("type_")
 
         fuzzy_search_match = cls(
             path=path,

blaxel/core/sandbox/client/models/fuzzy_search_response.py

@@ -1,10 +1,8 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..types import UNSET, Unset
-
 if TYPE_CHECKING:
     from ..models.fuzzy_search_match import FuzzySearchMatch
 
@@ -16,34 +14,33 @@ T = TypeVar("T", bound="FuzzySearchResponse")
 class FuzzySearchResponse:
     """
     Attributes:
-        matches (Union[Unset, list['FuzzySearchMatch']]):
-        total (Union[Unset, int]):  Example: 5.
+        matches (list['FuzzySearchMatch']):
+        total (int):  Example: 5.
     """
 
-    matches: Union[Unset, list["FuzzySearchMatch"]] = UNSET
-    total: Union[Unset, int] = UNSET
+    matches: list["FuzzySearchMatch"]
+    total: int
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        matches: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.matches, Unset):
-            matches = []
-            for matches_item_data in self.matches:
-                if type(matches_item_data) is dict:
-                    matches_item = matches_item_data
-                else:
-                    matches_item = matches_item_data.to_dict()
-                matches.append(matches_item)
+        matches = []
+        for matches_item_data in self.matches:
+            if type(matches_item_data) is dict:
+                matches_item = matches_item_data
+            else:
+                matches_item = matches_item_data.to_dict()
+            matches.append(matches_item)
 
         total = self.total
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if matches is not UNSET:
-            field_dict["matches"] = matches
-        if total is not UNSET:
-            field_dict["total"] = total
+        field_dict.update(
+            {
+                "matches": matches,
+                "total": total,
+            }
+        )
 
         return field_dict
 
@@ -55,13 +52,13 @@ class FuzzySearchResponse:
             return None
         d = src_dict.copy()
         matches = []
-        _matches = d.pop("matches", UNSET)
-        for matches_item_data in _matches or []:
+        _matches = d.pop("matches")
+        for matches_item_data in _matches:
             matches_item = FuzzySearchMatch.from_dict(matches_item_data)
 
             matches.append(matches_item)
 
-        total = d.pop("total", UNSET)
+        total = d.pop("total")
 
         fuzzy_search_response = cls(
             matches=matches,

blaxel/core/sandbox/client/models/health_response.py

@@ -0,0 +1,159 @@
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.upgrade_status import UpgradeStatus
+
+
+T = TypeVar("T", bound="HealthResponse")
+
+
+@_attrs_define
+class HealthResponse:
+    """
+    Attributes:
+        arch (str):  Example: amd64.
+        build_time (str):  Example: 2026-01-29 17:36:52+00:00.
+        git_commit (str):  Example: abc123.
+        go_version (str):  Example: go1.25.0.
+        last_upgrade (UpgradeStatus):
+        os (str):  Example: linux.
+        started_at (str):  Example: 2026-01-29 18:45:49+00:00.
+        status (str):  Example: ok.
+        upgrade_count (int):
+        uptime (str):  Example: 1h30m.
+        uptime_seconds (float):  Example: 5400.5.
+        version (str):  Example: v0.1.0.
+    """
+
+    arch: str
+    build_time: str
+    git_commit: str
+    go_version: str
+    last_upgrade: "UpgradeStatus"
+    os: str
+    started_at: str
+    status: str
+    upgrade_count: int
+    uptime: str
+    uptime_seconds: float
+    version: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        arch = self.arch
+
+        build_time = self.build_time
+
+        git_commit = self.git_commit
+
+        go_version = self.go_version
+
+        if type(self.last_upgrade) is dict:
+            last_upgrade = self.last_upgrade
+        else:
+            last_upgrade = self.last_upgrade.to_dict()
+
+        os = self.os
+
+        started_at = self.started_at
+
+        status = self.status
+
+        upgrade_count = self.upgrade_count
+
+        uptime = self.uptime
+
+        uptime_seconds = self.uptime_seconds
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "arch": arch,
+                "buildTime": build_time,
+                "gitCommit": git_commit,
+                "goVersion": go_version,
+                "lastUpgrade": last_upgrade,
+                "os": os,
+                "startedAt": started_at,
+                "status": status,
+                "upgradeCount": upgrade_count,
+                "uptime": uptime,
+                "uptimeSeconds": uptime_seconds,
+                "version": version,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        from ..models.upgrade_status import UpgradeStatus
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        arch = d.pop("arch")
+
+        build_time = d.pop("buildTime") if "buildTime" in d else d.pop("build_time")
+
+        git_commit = d.pop("gitCommit") if "gitCommit" in d else d.pop("git_commit")
+
+        go_version = d.pop("goVersion") if "goVersion" in d else d.pop("go_version")
+
+        last_upgrade = UpgradeStatus.from_dict(
+            d.pop("lastUpgrade") if "lastUpgrade" in d else d.pop("last_upgrade")
+        )
+
+        os = d.pop("os")
+
+        started_at = d.pop("startedAt") if "startedAt" in d else d.pop("started_at")
+
+        status = d.pop("status")
+
+        upgrade_count = d.pop("upgradeCount") if "upgradeCount" in d else d.pop("upgrade_count")
+
+        uptime = d.pop("uptime")
+
+        uptime_seconds = d.pop("uptimeSeconds") if "uptimeSeconds" in d else d.pop("uptime_seconds")
+
+        version = d.pop("version")
+
+        health_response = cls(
+            arch=arch,
+            build_time=build_time,
+            git_commit=git_commit,
+            go_version=go_version,
+            last_upgrade=last_upgrade,
+            os=os,
+            started_at=started_at,
+            status=status,
+            upgrade_count=upgrade_count,
+            uptime=uptime,
+            uptime_seconds=uptime_seconds,
+            version=version,
+        )
+
+        health_response.additional_properties = d
+        return health_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/core/sandbox/client/models/process_upgrade_state.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class ProcessUpgradeState(str, Enum):
+    COMPLETED = "completed"
+    FAILED = "failed"
+    IDLE = "idle"
+    RUNNING = "running"
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def _missing_(cls, value: object) -> "ProcessUpgradeState | None":
+        if isinstance(value, str):
+            upper_value = value.upper()
+            for member in cls:
+                if member.value.upper() == upper_value:
+                    return member
+        return None

blaxel/core/sandbox/client/models/upgrade_request.py

@@ -0,0 +1,71 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpgradeRequest")
+
+
+@_attrs_define
+class UpgradeRequest:
+    """
+    Attributes:
+        base_url (Union[Unset, str]): Base URL for releases (useful for forks) Example: https://github.com/blaxel-
+            ai/sandbox/releases.
+        version (Union[Unset, str]): Version to upgrade to: "develop", "main", "latest", or specific tag like "v1.0.0"
+            Example: develop.
+    """
+
+    base_url: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        base_url = self.base_url
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if base_url is not UNSET:
+            field_dict["baseUrl"] = base_url
+        if version is not UNSET:
+            field_dict["version"] = version
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        base_url = d.pop("baseUrl", d.pop("base_url", UNSET))
+
+        version = d.pop("version", UNSET)
+
+        upgrade_request = cls(
+            base_url=base_url,
+            version=version,
+        )
+
+        upgrade_request.additional_properties = d
+        return upgrade_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/core/sandbox/client/models/upgrade_status.py

@@ -0,0 +1,125 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.process_upgrade_state import ProcessUpgradeState
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpgradeStatus")
+
+
+@_attrs_define
+class UpgradeStatus:
+    """
+    Attributes:
+        status (ProcessUpgradeState):
+        step (str): Current/last step (none, starting, download, validate, replace, completed, skipped) Example:
+            download.
+        version (str): Version being upgraded to Example: latest.
+        binary_path (Union[Unset, str]): Path to downloaded binary Example: /tmp/sandbox-api-new.
+        bytes_downloaded (Union[Unset, int]): Bytes downloaded Example: 25034936.
+        download_url (Union[Unset, str]): URL used for download Example: https://github.com/....
+        error (Union[Unset, str]): Error message if failed Example: Failed to download binary.
+        last_attempt (Union[Unset, str]): When the upgrade was attempted
+    """
+
+    status: ProcessUpgradeState
+    step: str
+    version: str
+    binary_path: Union[Unset, str] = UNSET
+    bytes_downloaded: Union[Unset, int] = UNSET
+    download_url: Union[Unset, str] = UNSET
+    error: Union[Unset, str] = UNSET
+    last_attempt: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        step = self.step
+
+        version = self.version
+
+        binary_path = self.binary_path
+
+        bytes_downloaded = self.bytes_downloaded
+
+        download_url = self.download_url
+
+        error = self.error
+
+        last_attempt = self.last_attempt
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "step": step,
+                "version": version,
+            }
+        )
+        if binary_path is not UNSET:
+            field_dict["binaryPath"] = binary_path
+        if bytes_downloaded is not UNSET:
+            field_dict["bytesDownloaded"] = bytes_downloaded
+        if download_url is not UNSET:
+            field_dict["downloadUrl"] = download_url
+        if error is not UNSET:
+            field_dict["error"] = error
+        if last_attempt is not UNSET:
+            field_dict["lastAttempt"] = last_attempt
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        status = ProcessUpgradeState(d.pop("status"))
+
+        step = d.pop("step")
+
+        version = d.pop("version")
+
+        binary_path = d.pop("binaryPath", d.pop("binary_path", UNSET))
+
+        bytes_downloaded = d.pop("bytesDownloaded", d.pop("bytes_downloaded", UNSET))
+
+        download_url = d.pop("downloadUrl", d.pop("download_url", UNSET))
+
+        error = d.pop("error", UNSET)
+
+        last_attempt = d.pop("lastAttempt", d.pop("last_attempt", UNSET))
+
+        upgrade_status = cls(
+            status=status,
+            step=step,
+            version=version,
+            binary_path=binary_path,
+            bytes_downloaded=bytes_downloaded,
+            download_url=download_url,
+            error=error,
+            last_attempt=last_attempt,
+        )
+
+        upgrade_status.additional_properties = d
+        return upgrade_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/core/sandbox/default/__init__.py

@@ -7,6 +7,7 @@ from .sandbox import (
     SandboxPreviews,
     SandboxProcess,
 )
+from .system import SandboxSystem
 
 __all__ = [
     "SandboxInstance",
@@ -15,5 +16,6 @@ __all__ = [
     "SandboxPreviews",
     "SandboxProcess",
     "SandboxCodegen",
+    "SandboxSystem",
     "CodeInterpreter",
 ]

blaxel/core/sandbox/default/filesystem.py

@@ -10,6 +10,7 @@ import httpx
 from ...common.settings import settings
 from ..client.models import Directory, FileRequest, SuccessResponse
 from ..types import (
+    AsyncWatchHandle,
     CopyResponse,
     SandboxConfiguration,
     SandboxFilesystemFile,
@@ -327,9 +328,7 @@ class SandboxFileSystem(SandboxAction):
             data = json.loads(await response.aread())
             self.handle_response_error(response)
 
-            from ..client.models.content_search_response import (
-                ContentSearchResponse,
-            )
+            from ..client.models.content_search_response import ContentSearchResponse
 
             return ContentSearchResponse.from_dict(data)
         finally:
@@ -364,8 +363,23 @@ class SandboxFileSystem(SandboxAction):
         path: str,
         callback: Callable[[WatchEvent], None],
         options: Dict[str, Any] | None = None,
-    ) -> Dict[str, Callable]:
-        """Watch for file system changes."""
+    ) -> AsyncWatchHandle:
+        """Watch for file system changes.
+
+        Returns an AsyncWatchHandle that can be used as a context manager:
+
+            async with sandbox.fs.watch(path, callback) as handle:
+                # do something
+            # handle is automatically closed
+
+        Or manually:
+
+            handle = sandbox.fs.watch(path, callback)
+            try:
+                # do something
+            finally:
+                handle.close()
+        """
         path = self.format_path(path)
         closed = False
 
@@ -444,7 +458,7 @@ class SandboxFileSystem(SandboxAction):
             closed = True
             task.cancel()
 
-        return {"close": close}
+        return AsyncWatchHandle(close)
 
     def format_path(self, path: str) -> str:
         """Format path for filesystem operations.