scalebox-sdk 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

scalebox/__init__.py

@@ -9,7 +9,7 @@ A multi-language code execution sandbox with support for:
 - Real-time callbacks and monitoring
 """
 
-__version__ = "0.1.22"
+__version__ = "0.1.24"
 __author__ = "ScaleBox Team"
 __email__ = "dev@scalebox.dev"
 

scalebox/api/client/models/new_sandbox.py

@@ -31,7 +31,7 @@ class NewSandbox:
     timeout: Union[Unset, int] = 15
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
     is_async: Union[Unset, bool] = False
-    storage_gb: Union[Unset, int] = 10
+    storage_gb: Union[Unset, int] = UNSET
 
     def to_dict(self) -> dict[str, Any]:
         template_id = self.template_id

scalebox/sandbox_sync/filesystem/filesystem.py

@@ -1,543 +1,543 @@
-from io import IOBase
-from typing import IO, Iterator, List, Literal, Optional, Union, overload
-
-import httpcore
-import httpx
-import urllib3
-from packaging.version import Version
-
-from ... import csx_connect
-from ...connection_config import (
-    KEEPALIVE_PING_HEADER,
-    KEEPALIVE_PING_INTERVAL_SEC,
-    ConnectionConfig,
-    Username,
-)
-from ...exceptions import InvalidArgumentException, TemplateException
-from ...generated import api_pb2, api_pb2_connect
-from ...generated.api import (
-    ENVD_API_DOWNLOAD_FILES_ROUTE,
-    ENVD_API_UPLOAD_FILES_ROUTE,
-    handle_envd_api_exception,
-)
-from ...generated.rpc import authentication_header, handle_rpc_exception
-from ...generated.versions import ENVD_VERSION_RECURSIVE_WATCH
-from ...sandbox.filesystem.filesystem import (
-    EntryInfo,
-    FileType,
-    WriteEntry,
-    WriteInfo,
-    map_file_type,
-)
-from ...sandbox_sync.filesystem.watch_handle import WatchHandle
-
-
-class Filesystem:
-    """
-    Module for interacting with the filesystem in the sandbox.
-    """
-
-    def __init__(
-        self,
-        envd_api_url: str,
-        envd_version: Optional[str],
-        connection_config: ConnectionConfig,
-        pool: urllib3.PoolManager,
-        envd_api: httpx.Client,
-    ) -> None:
-        self._envd_api_url = envd_api_url
-        self._envd_version = envd_version
-        self._connection_config = connection_config
-        self._pool = pool
-        self._envd_api = envd_api
-
-        self._rpc = api_pb2_connect.FilesystemClient(
-            envd_api_url,
-            http_client=pool
-        )
-        self._headers = self._connection_config.headers
-
-    @overload
-    def read(
-        self,
-        path: str,
-        format: Literal["text"] = "text",
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> str:
-        """
-        Read file content as a `str`.
-
-        :param path: Path to the file
-        :param user: Run the operation as this user
-        :param format: Format of the file content—`text` by default
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: File content as a `str`
-        """
-        ...
-
-    @overload
-    def read(
-        self,
-        path: str,
-        format: Literal["bytes"],
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> bytearray:
-        """
-        Read file content as a `bytearray`.
-
-        :param path: Path to the file
-        :param user: Run the operation as this user
-        :param format: Format of the file content—`bytes`
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: File content as a `bytearray`
-        """
-        ...
-
-    @overload
-    def read(
-        self,
-        path: str,
-        format: Literal["stream"],
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> Iterator[bytes]:
-        """
-        Read file content as a `Iterator[bytes]`.
-
-        :param path: Path to the file
-        :param user: Run the operation as this user
-        :param format: Format of the file content—`stream`
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: File content as an `Iterator[bytes]`
-        """
-        ...
-
-    def read(
-        self,
-        path: str,
-        format: Literal["text", "bytes", "stream"] = "text",
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ):
-        # Use the /download/ endpoint from sandboxagent.go
-        download_url = f"/download/{path.lstrip('/')}"
-        
-        r = self._envd_api.get(
-            download_url,
-            timeout=self._connection_config.get_request_timeout(request_timeout),
-        )
-
-        err = handle_envd_api_exception(r)
-        if err:
-            raise err
-
-        if format == "text":
-            return r.text
-        elif format == "bytes":
-            return bytearray(r.content)
-        elif format == "stream":
-            return r.iter_bytes()
-
-    @overload
-    def write(
-        self,
-        path: str,
-        data: Union[str, bytes, IO],
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> WriteInfo:
-        """
-        Write content to a file on the path.
-
-        Writing to a file that doesn't exist creates the file.
-
-        Writing to a file that already exists overwrites the file.
-
-        Writing to a file at path that doesn't exist creates the necessary directories.
-
-        :param path: Path to the file
-        :param data: Data to write to the file, can be a `str`, `bytes`, or `IO`.
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: Information about the written file
-        """
-
-    @overload
-    def write(
-        self,
-        files: List[WriteEntry],
-        user: Optional[Username] = "user",
-        request_timeout: Optional[float] = None,
-    ) -> List[WriteInfo]:
-        """
-        Writes a list of files to the filesystem.
-        When writing to a file that doesn't exist, the file will get created.
-        When writing to a file that already exists, the file will get overwritten.
-        When writing to a file that's in a directory that doesn't exist, you'll get an error.
-
-        :param files: list of files to write
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request
-        :return: Information about the written files
-        """
-
-    def write(
-        self,
-        path_or_files: Union[str, List[WriteEntry]],
-        data_or_user: Union[str, bytes, IO, Username] = "user",
-        user_or_request_timeout: Optional[Union[float, Username]] = None,
-        request_timeout_or_none: Optional[float] = None,
-    ) -> Union[WriteInfo, List[WriteInfo]]:
-        path, write_files, user, request_timeout = None, [], "user", None
-        if isinstance(path_or_files, str):
-            if isinstance(data_or_user, list):
-                raise Exception(
-                    "Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files."
-                )
-            path, write_files, user, request_timeout = (
-                path_or_files,
-                [{"path": path_or_files, "data": data_or_user}],
-                user_or_request_timeout or "user",
-                request_timeout_or_none,
-            )
-        else:
-            if path_or_files is None:
-                raise Exception("Path or files are required")
-            path, write_files, user, request_timeout = (
-                None,
-                path_or_files,
-                data_or_user,
-                user_or_request_timeout,
-            )
-
-        # Allow passing empty list of files
-        if len(write_files) == 0:
-            return []
-
-        # Use the /upload endpoint from sandboxagent.go
-        # This endpoint expects multipart/form-data with 'file' field and 'path' form field
-        results = []
-        for file in write_files:
-            file_path, file_data = file["path"], file["data"]
-            
-            # Prepare file data
-            if isinstance(file_data, str):
-                file_content = file_data.encode('utf-8')
-            elif isinstance(file_data, bytes):
-                file_content = file_data
-            elif isinstance(file_data, IOBase):
-                file_content = file_data.read()
-                if isinstance(file_content, str):
-                    file_content = file_content.encode('utf-8')
-            else:
-                raise ValueError(f"Unsupported data type for file {file_path}")
-
-            # Prepare multipart form data
-            files = [("file", (file_path, file_content))]
-            data = {"path": file_path}
-
-            r = self._envd_api.post(
-                "/upload",
-                files=files,
-                data=data,
-                timeout=self._connection_config.get_request_timeout(request_timeout),
-            )
-
-            err = handle_envd_api_exception(r)
-            if err:
-                raise err
-            
-            # For now, create a mock WriteInfo since sandboxagent.go returns plain text
-            # In a real implementation, you might want to enhance the server to return JSON
-            results.append(WriteInfo(
-                path=file_path,
-                name=file_path.split('/')[-1] if '/' in file_path else file_path,
-                type=FileType.FILE,
-            ))
-
-        # Return appropriate response based on input format
-        if len(results) == 1 and path:
-            return results[0]
-        else:
-            return results
-
-    def list(
-        self,
-        path: str,
-        depth: Optional[int] = 1,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> List[EntryInfo]:
-        """
-        List entries in a directory.
-
-        :param path: Path to the directory
-        :param depth: Depth of the directory to list
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: List of entries in the directory
-        """
-        if depth is not None and depth < 1:
-            raise InvalidArgumentException("depth should be at least 1")
-
-        try:
-            res = self._rpc.list_dir(
-                api_pb2.ListDirRequest(path=path, depth=depth),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-
-            entries: List[EntryInfo] = []
-            for entry in res.entries:
-                event_type = map_file_type(entry.type)
-
-                if event_type:
-                    entries.append(
-                        EntryInfo(
-                            name=entry.name,
-                            type=event_type,
-                            path=entry.path,
-                            size=entry.size,
-                            mode=entry.mode,
-                            permissions=entry.permissions,
-                            owner=entry.owner,
-                            group=entry.group,
-                            modified_time=entry.modified_time.ToDatetime(),
-                            # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
-                            symlink_target=(
-                                entry.symlink_target
-                                if entry.HasField("symlink_target")
-                                else None
-                            ),
-                        )
-                    )
-
-            return entries
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-    def exists(
-        self,
-        path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> bool:
-        """
-        Check if a file or a directory exists.
-
-        :param path: Path to a file or a directory
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: `True` if the file or directory exists, `False` otherwise
-        """
-        try:
-            self._rpc.stat(
-                api_pb2.StatRequest(path=path),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-            return True
-
-        except Exception as e:
-            if "no such file or directory" in str(e):
-                return False
-            raise handle_rpc_exception(e)
-
-    def get_info(
-        self,
-        path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> EntryInfo:
-        """
-        Get information about a file or directory.
-
-        :param path: Path to a file or a directory
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: Information about the file or directory like name, type, and path
-        """
-        try:
-            r = self._rpc.stat(
-                api_pb2.StatRequest(path=path),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-
-            return EntryInfo(
-                name=r.entry.name,
-                type=map_file_type(r.entry.type),
-                path=r.entry.path,
-                size=r.entry.size,
-                mode=r.entry.mode,
-                permissions=r.entry.permissions,
-                owner=r.entry.owner,
-                group=r.entry.group,
-                modified_time=r.entry.modified_time.ToDatetime(),
-                # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
-                symlink_target=(
-                    r.entry.symlink_target
-                    if r.entry.HasField("symlink_target")
-                    else None
-                ),
-            )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-    def remove(
-        self,
-        path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> None:
-        """
-        Remove a file or a directory.
-
-        :param path: Path to a file or a directory
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-        """
-        try:
-            self._rpc.remove(
-                api_pb2.RemoveRequest(path=path),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-    def rename(
-        self,
-        old_path: str,
-        new_path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> EntryInfo:
-        """
-        Rename a file or directory.
-
-        :param old_path: Path to the file or directory to rename
-        :param new_path: New path to the file or directory
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: Information about the renamed file or directory
-        """
-        try:
-            r = self._rpc.move(
-                api_pb2.MoveRequest(
-                    source=old_path,
-                    destination=new_path,
-                ),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-
-            return EntryInfo(
-                name=r.entry.name,
-                type=map_file_type(r.entry.type),
-                path=r.entry.path,
-                size=r.entry.size,
-                mode=r.entry.mode,
-                permissions=r.entry.permissions,
-                owner=r.entry.owner,
-                group=r.entry.group,
-                modified_time=r.entry.modified_time.ToDatetime(),
-                # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
-                symlink_target=(
-                    r.entry.symlink_target
-                    if r.entry.HasField("symlink_target")
-                    else None
-                ),
-            )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-    def make_dir(
-        self,
-        path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-    ) -> bool:
-        """
-        Create a new directory and all directories along the way if needed on the specified path.
-
-        :param path: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-
-        :return: `True` if the directory was created, `False` if the directory already exists
-        """
-        try:
-            self._rpc.make_dir(
-                api_pb2.MakeDirRequest(path=path),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-
-            return True
-        except Exception as e:
-            if "directory already exists" in str(e):
-                return False
-            raise handle_rpc_exception(e)
-
-    def watch_dir(
-        self,
-        path: str,
-        user: Username = "user",
-        request_timeout: Optional[float] = None,
-        recursive: bool = False,
-    ) -> WatchHandle:
-        """
-        Watch directory for filesystem events.
-
-        :param path: Path to a directory to watch
-        :param user: Run the operation as this user
-        :param request_timeout: Timeout for the request in **seconds**
-        :param recursive: Watch directory recursively
-
-        :return: `WatchHandle` object for stopping watching directory
-        """
-        if (
-            recursive
-            and self._envd_version is not None
-            and Version(self._envd_version) < ENVD_VERSION_RECURSIVE_WATCH
-        ):
-            raise TemplateException(
-                "You need to update the template to use recursive watching. "
-                "You can do this by running `e2b template build` in the directory with the template."
-            )
-
-        try:
-            r = self._rpc.create_watcher(
-                api_pb2.CreateWatcherRequest(path=path, recursive=recursive),
-                self._headers,
-                timeout_seconds=self._connection_config.get_request_timeout(
-                    request_timeout
-                ),
-            )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-        return WatchHandle(self._rpc, r.watcher_id)
+from io import IOBase
+from typing import IO, Iterator, List, Literal, Optional, Union, overload
+
+import httpcore
+import httpx
+import urllib3
+from packaging.version import Version
+
+from ... import csx_connect
+from ...connection_config import (
+    KEEPALIVE_PING_HEADER,
+    KEEPALIVE_PING_INTERVAL_SEC,
+    ConnectionConfig,
+    Username,
+)
+from ...exceptions import InvalidArgumentException, TemplateException
+from ...generated import api_pb2, api_pb2_connect
+from ...generated.api import (
+    ENVD_API_DOWNLOAD_FILES_ROUTE,
+    ENVD_API_UPLOAD_FILES_ROUTE,
+    handle_envd_api_exception,
+)
+from ...generated.rpc import authentication_header, handle_rpc_exception
+from ...generated.versions import ENVD_VERSION_RECURSIVE_WATCH
+from ...sandbox.filesystem.filesystem import (
+    EntryInfo,
+    FileType,
+    WriteEntry,
+    WriteInfo,
+    map_file_type,
+)
+from ...sandbox_sync.filesystem.watch_handle import WatchHandle
+
+
+class Filesystem:
+    """
+    Module for interacting with the filesystem in the sandbox.
+    """
+
+    def __init__(
+        self,
+        envd_api_url: str,
+        envd_version: Optional[str],
+        connection_config: ConnectionConfig,
+        pool: urllib3.PoolManager,
+        envd_api: httpx.Client,
+    ) -> None:
+        self._envd_api_url = envd_api_url
+        self._envd_version = envd_version
+        self._connection_config = connection_config
+        self._pool = pool
+        self._envd_api = envd_api
+
+        self._rpc = api_pb2_connect.FilesystemClient(
+            envd_api_url,
+            http_client=pool
+        )
+        self._headers = self._connection_config.headers
+
+    @overload
+    def read(
+        self,
+        path: str,
+        format: Literal["text"] = "text",
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> str:
+        """
+        Read file content as a `str`.
+
+        :param path: Path to the file
+        :param user: Run the operation as this user
+        :param format: Format of the file content—`text` by default
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: File content as a `str`
+        """
+        ...
+
+    @overload
+    def read(
+        self,
+        path: str,
+        format: Literal["bytes"],
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> bytearray:
+        """
+        Read file content as a `bytearray`.
+
+        :param path: Path to the file
+        :param user: Run the operation as this user
+        :param format: Format of the file content—`bytes`
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: File content as a `bytearray`
+        """
+        ...
+
+    @overload
+    def read(
+        self,
+        path: str,
+        format: Literal["stream"],
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> Iterator[bytes]:
+        """
+        Read file content as a `Iterator[bytes]`.
+
+        :param path: Path to the file
+        :param user: Run the operation as this user
+        :param format: Format of the file content—`stream`
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: File content as an `Iterator[bytes]`
+        """
+        ...
+
+    def read(
+        self,
+        path: str,
+        format: Literal["text", "bytes", "stream"] = "text",
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ):
+        # Use the /download/ endpoint from sandboxagent.go
+        download_url = f"/download/{path.lstrip('/')}"
+        
+        r = self._envd_api.get(
+            download_url,
+            timeout=self._connection_config.get_request_timeout(request_timeout),
+        )
+
+        err = handle_envd_api_exception(r)
+        if err:
+            raise err
+
+        if format == "text":
+            return r.text
+        elif format == "bytes":
+            return bytearray(r.content)
+        elif format == "stream":
+            return r.iter_bytes()
+
+    @overload
+    def write(
+        self,
+        path: str,
+        data: Union[str, bytes, IO],
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> WriteInfo:
+        """
+        Write content to a file on the path.
+
+        Writing to a file that doesn't exist creates the file.
+
+        Writing to a file that already exists overwrites the file.
+
+        Writing to a file at path that doesn't exist creates the necessary directories.
+
+        :param path: Path to the file
+        :param data: Data to write to the file, can be a `str`, `bytes`, or `IO`.
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: Information about the written file
+        """
+
+    @overload
+    def write(
+        self,
+        files: List[WriteEntry],
+        user: Optional[Username] = "user",
+        request_timeout: Optional[float] = None,
+    ) -> List[WriteInfo]:
+        """
+        Writes a list of files to the filesystem.
+        When writing to a file that doesn't exist, the file will get created.
+        When writing to a file that already exists, the file will get overwritten.
+        When writing to a file that's in a directory that doesn't exist, you'll get an error.
+
+        :param files: list of files to write
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request
+        :return: Information about the written files
+        """
+
+    def write(
+        self,
+        path_or_files: Union[str, List[WriteEntry]],
+        data_or_user: Union[str, bytes, IO, Username] = "user",
+        user_or_request_timeout: Optional[Union[float, Username]] = None,
+        request_timeout_or_none: Optional[float] = None,
+    ) -> Union[WriteInfo, List[WriteInfo]]:
+        path, write_files, user, request_timeout = None, [], "user", None
+        if isinstance(path_or_files, str):
+            if isinstance(data_or_user, list):
+                raise Exception(
+                    "Cannot specify both path and array of files. You have to specify either path and data for a single file or an array for multiple files."
+                )
+            path, write_files, user, request_timeout = (
+                path_or_files,
+                [{"path": path_or_files, "data": data_or_user}],
+                user_or_request_timeout or "user",
+                request_timeout_or_none,
+            )
+        else:
+            if path_or_files is None:
+                raise Exception("Path or files are required")
+            path, write_files, user, request_timeout = (
+                None,
+                path_or_files,
+                data_or_user,
+                user_or_request_timeout,
+            )
+
+        # Allow passing empty list of files
+        if len(write_files) == 0:
+            return []
+
+        # Use the /upload endpoint from sandboxagent.go
+        # This endpoint expects multipart/form-data with 'file' field and 'path' form field
+        results = []
+        for file in write_files:
+            file_path, file_data = file["path"], file["data"]
+            
+            # Prepare file data
+            if isinstance(file_data, str):
+                file_content = file_data.encode('utf-8')
+            elif isinstance(file_data, bytes):
+                file_content = file_data
+            elif isinstance(file_data, IOBase):
+                file_content = file_data.read()
+                if isinstance(file_content, str):
+                    file_content = file_content.encode('utf-8')
+            else:
+                raise ValueError(f"Unsupported data type for file {file_path}")
+
+            # Prepare multipart form data
+            files = [("file", (file_path, file_content))]
+            data = {"path": file_path}
+
+            r = self._envd_api.post(
+                "/upload",
+                files=files,
+                data=data,
+                timeout=self._connection_config.get_request_timeout(request_timeout),
+            )
+
+            err = handle_envd_api_exception(r)
+            if err:
+                raise err
+            
+            # For now, create a mock WriteInfo since sandboxagent.go returns plain text
+            # In a real implementation, you might want to enhance the server to return JSON
+            results.append(WriteInfo(
+                path=file_path,
+                name=file_path.split('/')[-1] if '/' in file_path else file_path,
+                type=FileType.FILE,
+            ))
+
+        # Return appropriate response based on input format
+        if len(results) == 1 and path:
+            return results[0]
+        else:
+            return results
+
+    def list(
+        self,
+        path: str,
+        depth: Optional[int] = 1,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> List[EntryInfo]:
+        """
+        List entries in a directory.
+
+        :param path: Path to the directory
+        :param depth: Depth of the directory to list
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: List of entries in the directory
+        """
+        if depth is not None and depth < 1:
+            raise InvalidArgumentException("depth should be at least 1")
+
+        try:
+            res = self._rpc.list_dir(
+                api_pb2.ListDirRequest(path=path, depth=depth),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+
+            entries: List[EntryInfo] = []
+            for entry in res.entries:
+                event_type = map_file_type(entry.type)
+
+                if event_type:
+                    entries.append(
+                        EntryInfo(
+                            name=entry.name,
+                            type=event_type,
+                            path=entry.path,
+                            size=entry.size,
+                            mode=entry.mode,
+                            permissions=entry.permissions,
+                            owner=entry.owner,
+                            group=entry.group,
+                            modified_time=entry.modified_time.ToDatetime(),
+                            # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
+                            symlink_target=(
+                                entry.symlink_target
+                                if entry.HasField("symlink_target")
+                                else None
+                            ),
+                        )
+                    )
+
+            return entries
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+    def exists(
+        self,
+        path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> bool:
+        """
+        Check if a file or a directory exists.
+
+        :param path: Path to a file or a directory
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `True` if the file or directory exists, `False` otherwise
+        """
+        try:
+            self._rpc.stat(
+                api_pb2.StatRequest(path=path),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+            return True
+
+        except Exception as e:
+            if "no such file or directory" in str(e):
+                return False
+            raise handle_rpc_exception(e)
+
+    def get_info(
+        self,
+        path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> EntryInfo:
+        """
+        Get information about a file or directory.
+
+        :param path: Path to a file or a directory
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: Information about the file or directory like name, type, and path
+        """
+        try:
+            r = self._rpc.stat(
+                api_pb2.StatRequest(path=path),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+
+            return EntryInfo(
+                name=r.entry.name,
+                type=map_file_type(r.entry.type),
+                path=r.entry.path,
+                size=r.entry.size,
+                mode=r.entry.mode,
+                permissions=r.entry.permissions,
+                owner=r.entry.owner,
+                group=r.entry.group,
+                modified_time=r.entry.modified_time.ToDatetime(),
+                # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
+                symlink_target=(
+                    r.entry.symlink_target
+                    if r.entry.HasField("symlink_target")
+                    else None
+                ),
+            )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+    def remove(
+        self,
+        path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> None:
+        """
+        Remove a file or a directory.
+
+        :param path: Path to a file or a directory
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+        """
+        try:
+            self._rpc.remove(
+                api_pb2.RemoveRequest(path=path),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+    def rename(
+        self,
+        old_path: str,
+        new_path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> EntryInfo:
+        """
+        Rename a file or directory.
+
+        :param old_path: Path to the file or directory to rename
+        :param new_path: New path to the file or directory
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: Information about the renamed file or directory
+        """
+        try:
+            r = self._rpc.move(
+                api_pb2.MoveRequest(
+                    source=old_path,
+                    destination=new_path,
+                ),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+
+            return EntryInfo(
+                name=r.entry.name,
+                type=map_file_type(r.entry.type),
+                path=r.entry.path,
+                size=r.entry.size,
+                mode=r.entry.mode,
+                permissions=r.entry.permissions,
+                owner=r.entry.owner,
+                group=r.entry.group,
+                modified_time=r.entry.modified_time.ToDatetime(),
+                # Optional, we can't directly access symlink_target otherwise if will be "" instead of None
+                symlink_target=(
+                    r.entry.symlink_target
+                    if r.entry.HasField("symlink_target")
+                    else None
+                ),
+            )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+    def make_dir(
+        self,
+        path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+    ) -> bool:
+        """
+        Create a new directory and all directories along the way if needed on the specified path.
+
+        :param path: Path to a new directory. For example '/dirA/dirB' when creating 'dirB'.
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+
+        :return: `True` if the directory was created, `False` if the directory already exists
+        """
+        try:
+            self._rpc.make_dir(
+                api_pb2.MakeDirRequest(path=path),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+
+            return True
+        except Exception as e:
+            if "directory already exists" in str(e):
+                return False
+            raise handle_rpc_exception(e)
+
+    def watch_dir(
+        self,
+        path: str,
+        user: Username = "user",
+        request_timeout: Optional[float] = None,
+        recursive: bool = False,
+    ) -> WatchHandle:
+        """
+        Watch directory for filesystem events.
+
+        :param path: Path to a directory to watch
+        :param user: Run the operation as this user
+        :param request_timeout: Timeout for the request in **seconds**
+        :param recursive: Watch directory recursively
+
+        :return: `WatchHandle` object for stopping watching directory
+        """
+        if (
+            recursive
+            and self._envd_version is not None
+            and Version(self._envd_version) < ENVD_VERSION_RECURSIVE_WATCH
+        ):
+            raise TemplateException(
+                "You need to update the template to use recursive watching. "
+                "You can do this by running `scalebox template build` in the directory with the template."
+            )
+
+        try:
+            r = self._rpc.create_watcher(
+                api_pb2.CreateWatcherRequest(path=path, recursive=recursive),
+                self._headers,
+                timeout_seconds=self._connection_config.get_request_timeout(
+                    request_timeout
+                ),
+            )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+        return WatchHandle(self._rpc, r.watcher_id)

scalebox/version.py

@@ -2,8 +2,8 @@
 Version information for ScaleBox Python SDK
 """
 
-__version__ = "0.1.22"
-__version_info__ = (0, 1, 22)
+__version__ = "0.1.24"
+__version_info__ = (0, 1, 24)
 
 
 def get_version() -> str:

{scalebox_sdk-0.1.22.dist-info → scalebox_sdk-0.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scalebox-sdk
-Version: 0.1.22
+Version: 0.1.24
 Summary: ScaleBox Python SDK - A multi-language code execution sandbox with Python, R, Node.js, Deno/TypeScript, Java, and Bash support
 Author-email: ScaleBox Team <dev@scalebox.dev>
 Maintainer-email: ScaleBox Team <dev@scalebox.dev>

{scalebox_sdk-0.1.22.dist-info → scalebox_sdk-0.1.24.dist-info}/RECORD

@@ -1,9 +1,9 @@
-scalebox/__init__.py,sha256=hRyCCz7cISfsaC_i79eCYm8EDLVgKoH2jCK9bks99BQ,1812
+scalebox/__init__.py,sha256=mJ4xOcm_wLKtYS81Ir74xYu_wn40S_jwkdL94sULmm8,1812
 scalebox/cli.py,sha256=HWIyGuhbP1WZm839CwTysauL78xMBOoatFychxzloxQ,3904
 scalebox/connection_config.py,sha256=W2hMeXlxUHvR51guqOWEEDv35o4XP8SbLkDXqa20C0M,2655
 scalebox/exceptions.py,sha256=10R9VXfvgO4XJJnxyzyrzkxliyeEBX0ZC36izXa8R5k,2053
 scalebox/requirements.txt,sha256=LEYsk2VzoxKR-V44Y6qJuJ3vKdTYS79f1Gv1Ajleifo,567
-scalebox/version.py,sha256=xPJw3UIUzgAs8Pe9WBXxxPFm4uNWwrEx9LB-rgSV2Uc,323
+scalebox/version.py,sha256=zPiqwFEMt--CAZTeF-4OEP4BpRKQzKJ3uTPWkbziA9Y,323
 scalebox/api/__init__.py,sha256=_9nWyeNg4Y_Z30YpBNoDP6S92YdlO_5xBkrp-we0SIg,4167
 scalebox/api/metadata.py,sha256=lg5ekfnFZYZoCoJxIPo961HEGVg_rLLRJBbw4ZApM_Y,512
 scalebox/api/client/__init__.py,sha256=IVRaxvQcdPu1Xxc3t--g3ir3Wl5f3Y0zKMwy1nkKN80,155
@@ -34,7 +34,7 @@ scalebox/api/client/models/identifier_masking_details.py,sha256=97xSg4Nr3D5xbjGD
 scalebox/api/client/models/listed_sandbox.py,sha256=oQUitQWjCk1HOXX7K7YdaGWBLQnPu4GnMt2E9-rQOTw,4040
 scalebox/api/client/models/log_level.py,sha256=uv6u1nkqfzdxTjJAxLZdWuH5goVI_g-ULLhh6TU5dw8,189
 scalebox/api/client/models/new_access_token.py,sha256=sjlQ7dEj4ByCgwud750SbxwyjggAKB1s-o_N7dRCo7s,1480
-scalebox/api/client/models/new_sandbox.py,sha256=z_LaZ0RS6qI95IVGklKgQZ301zSah9HerzND78QAP80,3934
+scalebox/api/client/models/new_sandbox.py,sha256=-mnu5wZPkofTGqsbDmA1nWTFDw-fzPu2Mg_rVISxd70,3937
 scalebox/api/client/models/new_team_api_key.py,sha256=neYLvvvzyPcpXYV5gDHVkv_ovjKdIBKUTX04cD5QKGA,1473
 scalebox/api/client/models/node.py,sha256=nuEZij7z7iXzBQYTFwardHlSixWrepztFmMIIqd8Ek4,4653
 scalebox/api/client/models/node_detail.py,sha256=ywP1oDzyxi7hIJAMTvINQQ8CwMsd1PlH1R5bEw716Ig,4511
@@ -115,7 +115,7 @@ scalebox/sandbox_sync/commands/command.py,sha256=308RgsexBQaLVbUc2ui6oKOLh6xUFDM
 scalebox/sandbox_sync/commands/command_handle.py,sha256=XPN1SpW00NqHxTuyceh4MLik-YQPEKfu4FOtf8pIC7Y,4615
 scalebox/sandbox_sync/commands/pty.py,sha256=KQStIe-ts_sSWjE_zD01AMqMCGbq9wGeXzbN-i4js9Q,5629
 scalebox/sandbox_sync/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scalebox/sandbox_sync/filesystem/filesystem.py,sha256=ajZgv3VyBfFtO8o4BIx6w7z1vhFugnLXysRfLBsa_ms,18193
+scalebox/sandbox_sync/filesystem/filesystem.py,sha256=MqjXNWrUw2_JaFh2UrMkfZsHdKtyJwLU5dPux1EH8Zw,18741
 scalebox/sandbox_sync/filesystem/watch_handle.py,sha256=dC9p74AHMv-3mQ1tudmOPjrpjvcJ7wFmCduNdity6os,2027
 scalebox/test/CODE_INTERPRETER_TESTS_READY.md,sha256=gtS9jRp2VB44MVG-ztb1JgYiqWtea8Z-TMEK1mZzfgE,11365
 scalebox/test/README.md,sha256=1rpgOo8uv-zT6QNw05MCCl8XzplD6xvWl3gE7frn9xI,9129
@@ -148,9 +148,9 @@ scalebox/test/testsandbox_sync.py,sha256=v1dFAJWKbyLnjIiafTR9TafxJF1gaUk-W2mmQU4
 scalebox/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scalebox/utils/httpcoreclient.py,sha256=kjTndd-YECPe3n_G1HfGgitzRwntC21tqtIqZ62V6Lg,9868
 scalebox/utils/httpxclient.py,sha256=oLpCP2RChvnspS6Unl6ngmpY72yPokTfSqMm9m-7k38,13442
-scalebox_sdk-0.1.22.dist-info/licenses/LICENSE,sha256=9zP32kHlBovkfji1R6ptx3H7WjJJvnf4UuwTpfogmsY,1069
-scalebox_sdk-0.1.22.dist-info/METADATA,sha256=6nAZZ7ScXZah72V6FlXGwm8N0QRFRlR2otIxxu7mDhA,12736
-scalebox_sdk-0.1.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-scalebox_sdk-0.1.22.dist-info/entry_points.txt,sha256=g7C1Trcg8EyvAGMnHpJ3alqtZzQuMypYUQVFK13kOFM,47
-scalebox_sdk-0.1.22.dist-info/top_level.txt,sha256=CDjlibkbOG-MT-s1TRxs4Xe_iN1m11ii48spB6DOMj4,9
-scalebox_sdk-0.1.22.dist-info/RECORD,,
+scalebox_sdk-0.1.24.dist-info/licenses/LICENSE,sha256=9zP32kHlBovkfji1R6ptx3H7WjJJvnf4UuwTpfogmsY,1069
+scalebox_sdk-0.1.24.dist-info/METADATA,sha256=2w0Hw5R8QRgwCrs7lVqkP8JO2oFjMZthXkOeyIJ10YY,12736
+scalebox_sdk-0.1.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+scalebox_sdk-0.1.24.dist-info/entry_points.txt,sha256=g7C1Trcg8EyvAGMnHpJ3alqtZzQuMypYUQVFK13kOFM,47
+scalebox_sdk-0.1.24.dist-info/top_level.txt,sha256=CDjlibkbOG-MT-s1TRxs4Xe_iN1m11ii48spB6DOMj4,9
+scalebox_sdk-0.1.24.dist-info/RECORD,,