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

scalebox/sandbox_async/filesystem/watch_handle.py

@@ -1,61 +1,61 @@
-import asyncio
-import inspect
-from typing import Any, AsyncGenerator, Optional
-
-from ...generated.api_pb2 import WatchDirResponse
-from ...generated.rpc import handle_rpc_exception
-from ...sandbox.filesystem.watch_handle import FilesystemEvent, map_event_type
-from ...sandbox_async.utils import OutputHandler
-
-
-class AsyncWatchHandle:
-    """
-    Handle for watching a directory in the sandbox filesystem.
-
-    Use `.stop()` to stop watching the directory.
-    """
-
-    def __init__(
-        self,
-        events: AsyncGenerator[WatchDirResponse, Any],
-        on_event: OutputHandler[FilesystemEvent],
-        on_exit: Optional[OutputHandler[Exception]] = None,
-    ):
-        self._events = events
-        self._on_event = on_event
-        self._on_exit = on_exit
-
-        self._wait = asyncio.create_task(self._handle_events())
-
-    async def stop(self):
-        """
-        Stop watching the directory.
-        """
-        self._wait.cancel()
-        # BUG: In Python 3.8 closing async generator can throw RuntimeError.
-        # await self._events.aclose()
-
-    async def _iterate_events(self):
-        try:
-            async for event in self._events:
-                if event.HasField("filesystem"):
-                    event_type = map_event_type(event.filesystem.type)
-                    if event_type:
-                        yield FilesystemEvent(
-                            name=event.filesystem.name,
-                            type=event_type,
-                        )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-    async def _handle_events(self):
-        try:
-            async for event in self._iterate_events():
-                cb = self._on_event(event)
-                if inspect.isawaitable(cb):
-                    await cb
-        except Exception as e:
-            if self._on_exit:
-                cb = self._on_exit(e)
-                if inspect.isawaitable(cb):
-                    await cb
+import asyncio
+import inspect
+from typing import Any, AsyncGenerator, Optional
+
+from ...generated.api_pb2 import WatchDirResponse
+from ...generated.rpc import handle_rpc_exception
+from ...sandbox.filesystem.watch_handle import FilesystemEvent, map_event_type
+from ...sandbox_async.utils import OutputHandler
+
+
+class AsyncWatchHandle:
+    """
+    Handle for watching a directory in the sandbox filesystem.
+
+    Use `.stop()` to stop watching the directory.
+    """
+
+    def __init__(
+        self,
+        events: AsyncGenerator[WatchDirResponse, Any],
+        on_event: OutputHandler[FilesystemEvent],
+        on_exit: Optional[OutputHandler[Exception]] = None,
+    ):
+        self._events = events
+        self._on_event = on_event
+        self._on_exit = on_exit
+
+        self._wait = asyncio.create_task(self._handle_events())
+
+    async def stop(self):
+        """
+        Stop watching the directory.
+        """
+        self._wait.cancel()
+        # BUG: In Python 3.8 closing async generator can throw RuntimeError.
+        # await self._events.aclose()
+
+    async def _iterate_events(self):
+        try:
+            async for event in self._events:
+                if event.HasField("filesystem"):
+                    event_type = map_event_type(event.filesystem.type)
+                    if event_type:
+                        yield FilesystemEvent(
+                            name=event.filesystem.name,
+                            type=event_type,
+                        )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+    async def _handle_events(self):
+        try:
+            async for event in self._iterate_events():
+                cb = self._on_event(event)
+                if inspect.isawaitable(cb):
+                    await cb
+        except Exception as e:
+            if self._on_exit:
+                cb = self._on_exit(e)
+                if inspect.isawaitable(cb):
+                    await cb

scalebox/sandbox_async/main.py

@@ -6,10 +6,10 @@ from typing import Dict, List, Optional, TypedDict, overload
 import aiohttp
 import httpx
 from aiohttp import TCPConnector
-from typing_extensions import Unpack
+from typing_extensions import Unpack, Self
 
 from ..api.client.types import Unset
-from ..connection_config import ConnectionConfig, ProxyTypes
+from ..connection_config import ConnectionConfig, ProxyTypes, ApiParams
 from ..exceptions import SandboxException, request_timeout_error
 from ..generated.api import ENVD_API_HEALTH_ROUTE, ahandle_envd_api_exception
 from ..sandbox.main import SandboxSetup
@@ -41,6 +41,8 @@ class AsyncSandboxOpts(TypedDict):
     envd_version: Optional[str]
     envd_access_token: Optional[str]
     connection_config: ConnectionConfig
+    object_storage: Optional[Dict[str, str]]
+    network_proxy: Optional[Dict[str, any]]
 
 
 class AsyncSandbox(SandboxSetup, SandboxApi):
@@ -101,6 +103,17 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
         """
         return self._sandbox_domain
 
+    @property
+    def object_storage(self) -> Optional[Dict[str, str]]:
+        """
+        Object storage configuration returned during sandbox creation (if any).
+        Only synchronous sandboxes currently expose this field.
+        """
+        return self._object_storage
+
+    def network_proxy(self) -> Optional[Dict[str, object]]:
+        return self._network_proxy
+
     @property
     def envd_api_url(self) -> str:
         return self._envd_api_url
@@ -126,7 +139,8 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
         super().__init__()
 
         self._connection_config = opts["connection_config"]
-
+        self._object_storage = opts["object_storage"]
+        self._network_proxy = opts["network_proxy"]
         self._sandbox_id = opts["sandbox_id"]
         self._sandbox_domain = opts["sandbox_domain"] or self.connection_config.domain
         debug=self._connection_config.debug
@@ -222,13 +236,16 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
         timeout: Optional[int] = None,
         metadata: Optional[Dict[str, str]] = None,
         envs: Optional[Dict[str, str]] = None,
+        object_storage: Optional[Dict[str, str]] = None,
         api_key: Optional[str] = None,
         domain: Optional[str] = None,
         debug: Optional[bool] = None,
+        sandbox_id: Optional[str] = None,
         request_timeout: Optional[float] = None,
         proxy: Optional[ProxyTypes] = None,
         secure: Optional[bool] = None,
         allow_internet_access: Optional[bool] = True,
+        net_proxy_country: Optional[str] = None,
     ):
         """
         Create a new sandbox.
@@ -251,11 +268,32 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
         """
 
         connection_headers = {"Authorization": "Bearer root", }
+        network_proxy = {}
         if debug:
             sandbox_id = "debug_sandbox_id"
             sandbox_domain = None
             envd_version = None
             envd_access_token = None
+        elif sandbox_id is not None:
+            response = await SandboxApi._cls_get_info(
+                sandbox_id,
+                api_key=api_key,
+                domain=domain,
+                debug=debug,
+                request_timeout=request_timeout,
+                proxy=proxy,
+            )
+
+            sandbox_domain = response.sandbox_domain
+            envd_version = response.envd_version
+            envd_access_token = response._envd_access_token
+            object_storage = response.object_storage
+            network_proxy = response.network_proxy
+
+            if response._envd_access_token is not None and not isinstance(
+                    response._envd_access_token, Unset
+            ):
+                connection_headers["X-Access-Token"] = response._envd_access_token
         else:
             response = await SandboxApi._create_sandbox(
                 template=template or cls.default_template,
@@ -269,12 +307,16 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
                 secure=secure,
                 proxy=proxy,
                 allow_internet_access=allow_internet_access,
+                object_storage=object_storage,
+                net_proxy_country=net_proxy_country,
             )
 
             sandbox_id = response.sandbox_id
             sandbox_domain = response.sandbox_domain
             envd_version = response.envd_version
             envd_access_token = response.envd_access_token
+            object_storage = response.object_storage
+            network_proxy = response.network_proxy
 
         if envd_access_token is not None and not isinstance(
             envd_access_token, Unset
@@ -297,9 +339,11 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
             envd_version=envd_version,
             envd_access_token=envd_access_token,
             connection_config=connection_config,
+            object_storage=object_storage,
+            network_proxy=network_proxy
         )
-        timeout = 5.0
-        interval = 0.1
+        timeout = 10.0
+        interval = 0.3
         elapsed = 0.0
 
         while elapsed <= timeout:
@@ -312,69 +356,158 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
             time.sleep(interval)
             elapsed += interval
         else:
-            print("connect "+sandbox_domain+ENVD_API_HEALTH_ROUTE +" timeout 5s")
+            print("connect "+sandbox_domain+ENVD_API_HEALTH_ROUTE +" timeout 10s")
         return sanbox
 
+    @overload
+    async def connect(
+            self,
+            timeout: Optional[int] = None,
+            **opts: Unpack[ApiParams],
+    ) -> Self:
+        """
+        Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.
+        Sandbox must be either running or be paused.
+
+        With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
+
+        :param timeout: Timeout for the sandbox in **seconds**
+            For running sandboxes, the timeout will update only if the new timeout is longer than the existing one.
+        :return: A running sandbox instance
+
+        @example
+        ```python
+        sandbox = await AsyncSandbox.create()
+        await sandbox.beta_pause()
+
+        # Another code block
+        same_sandbox = await sandbox.connect()
+        ```
+        """
+        ...
+
+    @overload
     @classmethod
     async def connect(
-        cls,
-        sandbox_id: str,
-        api_key: Optional[str] = None,
-        domain: Optional[str] = None,
-        debug: Optional[bool] = None,
-        proxy: Optional[ProxyTypes] = None,
-    ):
+            cls,
+            sandbox_id: str,
+            timeout: Optional[int] = None,
+            **opts: Unpack[ApiParams],
+    ) -> Self:
         """
-        Connect to an existing sandbox.
+        Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.
+        Sandbox must be either running or be paused.
+
         With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
 
         :param sandbox_id: Sandbox ID
-        :param api_key: SBX API Key to use for authentication, defaults to `SBX_API_KEY` environment variable
-        :param proxy: Proxy to use for the request and for the **requests made to the returned sandbox**
-
-        :return: sandbox instance for the existing sandbox
+        :param timeout: Timeout for the sandbox in **seconds**
+            For running sandboxes, the timeout will update only if the new timeout is longer than the existing one.
+        :return: A running sandbox instance
 
         @example
         ```python
         sandbox = await AsyncSandbox.create()
-        sandbox_id = sandbox.sandbox_id
+        await AsyncSandbox.beta_pause(sandbox.sandbox_id)
 
         # Another code block
-        same_sandbox = await AsyncSandbox.connect(sandbox_id)
+        same_sandbox = await AsyncSandbox.connect(sandbox.sandbox_id))
+        ```
         """
+        ...
 
-        connection_headers = {"Authorization": "Bearer root"}
+    @class_method_variant("_cls_connect")
+    async def connect(
+            self,
+            timeout: Optional[int] = None,
+            **opts: Unpack[ApiParams],
+    ) -> Self:
+        """
+        Connect to a sandbox. If the sandbox is paused, it will be automatically resumed.
+        Sandbox must be either running or be paused.
 
-        response = await SandboxApi._cls_get_info(
-            sandbox_id,
-            api_key=api_key,
-            domain=domain,
-            debug=debug,
-            proxy=proxy,
-        )
+        With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
 
-        if response._envd_access_token is not None and not isinstance(
-            response._envd_access_token, Unset
-        ):
-            connection_headers["X-Access-Token"] = response._envd_access_token
-        print("connection_headers:"+str(connection_headers))
+        :param timeout: Timeout for the sandbox in **seconds**
+            For running sandboxes, the timeout will update only if the new timeout is longer than the existing one.
+        :return: A running sandbox instance
 
-        connection_config = ConnectionConfig(
-            api_key=api_key,
-            domain=domain,
-            debug=debug,
-            headers=connection_headers,
-            proxy=proxy,
-        )
+        @example
+        ```python
+        sandbox = await AsyncSandbox.create()
+        await sandbox.beta_pause()
 
-        return cls(
-            sandbox_id=sandbox_id,
-            sandbox_domain=response.sandbox_domain,
-            connection_config=connection_config,
-            envd_version=response.envd_version,
-            envd_access_token=response._envd_access_token,
+        # Another code block
+        same_sandbox = await sandbox.connect()
+        ```
+        """
+        await SandboxApi._cls_connect(
+            sandbox_id=self.sandbox_id,
+            timeout=timeout,
+            **opts,
         )
 
+        return self
+    # @classmethod
+    # async def connect(
+    #     cls,
+    #     sandbox_id: str,
+    #     api_key: Optional[str] = None,
+    #     domain: Optional[str] = None,
+    #     debug: Optional[bool] = None,
+    #     proxy: Optional[ProxyTypes] = None,
+    # ):
+    #     """
+    #     Connect to an existing sandbox.
+    #     With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
+    #
+    #     :param sandbox_id: Sandbox ID
+    #     :param api_key: SBX API Key to use for authentication, defaults to `SBX_API_KEY` environment variable
+    #     :param proxy: Proxy to use for the request and for the **requests made to the returned sandbox**
+    #
+    #     :return: sandbox instance for the existing sandbox
+    #
+    #     @example
+    #     ```python
+    #     sandbox = await AsyncSandbox.create()
+    #     sandbox_id = sandbox.sandbox_id
+    #
+    #     # Another code block
+    #     same_sandbox = await AsyncSandbox.connect(sandbox_id)
+    #     """
+    #
+    #     connection_headers = {"Authorization": "Bearer root"}
+    #
+    #     response = await SandboxApi._cls_get_info(
+    #         sandbox_id,
+    #         api_key=api_key,
+    #         domain=domain,
+    #         debug=debug,
+    #         proxy=proxy,
+    #     )
+    #
+    #     if response._envd_access_token is not None and not isinstance(
+    #         response._envd_access_token, Unset
+    #     ):
+    #         connection_headers["X-Access-Token"] = response._envd_access_token
+    #     print("connection_headers:"+str(connection_headers))
+    #
+    #     connection_config = ConnectionConfig(
+    #         api_key=api_key,
+    #         domain=domain,
+    #         debug=debug,
+    #         headers=connection_headers,
+    #         proxy=proxy,
+    #     )
+    #
+    #     return cls(
+    #         sandbox_id=sandbox_id,
+    #         sandbox_domain=response.sandbox_domain,
+    #         connection_config=connection_config,
+    #         envd_version=response.envd_version,
+    #         envd_access_token=response._envd_access_token,
+    #     )
+
     async def __aenter__(self):
         if self._session.closed:
             connector = TCPConnector(
@@ -645,3 +778,52 @@ class AsyncSandbox(SandboxSetup, SandboxApi):
             end=end,
             **config_dict,
         )
+
+    @overload
+    async def beta_pause(
+            self,
+            **opts: Unpack[ApiParams],
+    ) -> None:
+        """
+        [BETA] This feature is in beta and may change in the future.
+
+        Pause the sandbox.
+
+        :return: Sandbox ID that can be used to resume the sandbox
+        """
+        ...
+
+    @overload
+    @staticmethod
+    async def beta_pause(
+            sandbox_id: str,
+            **opts: Unpack[ApiParams],
+    ) -> None:
+        """
+        [BETA] This feature is in beta and may change in the future.
+
+        Pause the sandbox specified by sandbox ID.
+
+        :param sandbox_id: Sandbox ID
+
+        :return: Sandbox ID that can be used to resume the sandbox
+        """
+        ...
+
+    @class_method_variant("_cls_pause")
+    async def beta_pause(
+            self,
+            **opts: Unpack[ApiParams],
+    ) -> None:
+        """
+        [BETA] This feature is in beta and may change in the future.
+
+        Pause the sandbox.
+
+        :return: Sandbox ID that can be used to resume the sandbox
+        """
+
+        await SandboxApi._cls_pause(
+            sandbox_id=self.sandbox_id,
+            **opts,
+        )

scalebox/sandbox_async/sandbox_api.py

@@ -1,9 +1,14 @@
 import datetime
 import urllib.parse
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Unpack, TYPE_CHECKING
 
 from packaging.version import Version
 
+if TYPE_CHECKING:
+    from . import AsyncSandbox
+
+from ..api.client.api.sandboxes import post_sandboxes_sandbox_id_pause, post_sandboxes_sandbox_id_connect
+from ..api.client.models.connect_sandbox import ConnectSandbox
 from ..api import AsyncApiClient, SandboxCreateResponse, handle_api_exception
 from ..api.client.api.sandboxes import (
     delete_sandboxes_sandbox_id,
@@ -14,8 +19,8 @@ from ..api.client.api.sandboxes import (
     post_sandboxes_sandbox_id_timeout,
 )
 from ..api.client.models import Error, NewSandbox, PostSandboxesSandboxIDTimeoutBody
-from ..connection_config import ConnectionConfig, ProxyTypes
-from ..exceptions import SandboxException, TemplateException
+from ..connection_config import ConnectionConfig, ProxyTypes, ApiParams
+from ..exceptions import SandboxException, TemplateException, NotFoundException
 from ..sandbox.sandbox_api import (
     ListedSandbox,
     SandboxApiBase,
@@ -97,6 +102,9 @@ class SandboxApi(SandboxApiBase):
                 memory_mb=sandbox.memory_mb,
                 started_at=sandbox.started_at,
                 end_at=sandbox.end_at,
+                object_storage=sandbox.object_storage,
+                uptime=sandbox.uptime,
+                timeout=sandbox.timeout,
             )
             for sandbox in res.parsed
         ]
@@ -160,6 +168,9 @@ class SandboxApi(SandboxApiBase):
                 end_at=res.parsed.end_at,
                 envd_version=res.parsed.envd_version,
                 _envd_access_token=res.parsed.envd_access_token,
+                object_storage=res.parsed.object_storage,
+                uptime=res.parsed.uptime,
+                timeout=res.parsed.timeout,
             )
 
     @classmethod
@@ -256,6 +267,8 @@ class SandboxApi(SandboxApiBase):
         headers: Optional[Dict[str, str]] = None,
         proxy: Optional[ProxyTypes] = None,
         allow_internet_access: Optional[bool] = True,
+        object_storage: Optional[Dict[str, str]] = None,
+        net_proxy_country:Optional[str] = None,
     ) -> SandboxCreateResponse:
         config = ConnectionConfig(
             api_key=api_key,
@@ -279,6 +292,8 @@ class SandboxApi(SandboxApiBase):
                     secure=secure or False,
                     allow_internet_access=allow_internet_access,
                     is_async=False,
+                    object_storage=object_storage,
+                    net_proxy_country=net_proxy_country,
                 ),
                 client=api_client,
             )
@@ -301,6 +316,8 @@ class SandboxApi(SandboxApiBase):
                 sandbox_domain=res.parsed.domain,
                 envd_version=res.parsed.envd_version,
                 envd_access_token=res.parsed.envd_access_token,
+                object_storage=res.parsed.object_storage,
+                network_proxy=res.parsed.network_proxy,
             )
 
     @classmethod
@@ -363,3 +380,107 @@ class SandboxApi(SandboxApiBase):
                 )
                 for metric in res.parsed
             ]
+
+    @classmethod
+    async def _cls_pause(
+            cls,
+            sandbox_id: str,
+            **opts: Unpack[ApiParams],
+    ) -> str:
+        config = ConnectionConfig(**opts)
+
+        async with AsyncApiClient(
+                config,
+                limits=SandboxApiBase._limits,
+        ) as api_client:
+            res = await post_sandboxes_sandbox_id_pause.asyncio_detailed(
+                sandbox_id,
+                client=api_client,
+            )
+
+            if res.status_code == 404:
+                raise NotFoundException(f"Sandbox {sandbox_id} not found")
+
+            if res.status_code == 409:
+                return sandbox_id
+
+            if res.status_code >= 300:
+                raise handle_api_exception(res)
+
+            # Check if res.parse is Error
+            if isinstance(res.parsed, Error):
+                raise SandboxException(f"{res.parsed.message}: Request failed")
+
+            return sandbox_id
+
+    @classmethod
+    async def _cls_connect(
+            cls,
+            sandbox_id: str,
+            timeout: Optional[int] = None,
+            **opts: Unpack[ApiParams],
+    ) -> "AsyncSandbox":
+        timeout = timeout or SandboxApiBase.default_sandbox_timeout
+
+        # Sandbox is not running, resume it
+        config = ConnectionConfig(**opts)
+
+        async with AsyncApiClient(
+                config,
+                limits=SandboxApiBase._limits,
+        ) as api_client:
+            res = await post_sandboxes_sandbox_id_connect.asyncio_detailed(
+                sandbox_id,
+                client=api_client,
+                body=ConnectSandbox(timeout=timeout),
+            )
+
+            if res.status_code == 404:
+                raise NotFoundException(f"Paused sandbox {sandbox_id} not found")
+
+            if res.status_code >= 300:
+                raise handle_api_exception(res)
+
+            # Check if res.parse is Error
+            if isinstance(res.parsed, Error):
+                raise SandboxException(f"{res.parsed.message}: Request failed")
+
+            # Extract information from API response and create a full AsyncSandbox instance
+            # Use delayed import to avoid circular dependency
+            from . import AsyncSandbox
+            
+            response = res.parsed
+            if response is None:
+                raise SandboxException("Connect response is None")
+
+            connection_headers = {"Authorization": "Bearer root"}
+            
+            # Extract fields from API response
+            sandbox_domain = response.domain if hasattr(response, 'domain') and response.domain is not None else None
+            envd_version = response.envd_version if hasattr(response, 'envd_version') else None
+            envd_access_token = None
+            if hasattr(response, 'envd_access_token'):
+                from ..api.client.types import Unset
+                if response.envd_access_token is not None and not isinstance(response.envd_access_token, Unset):
+                    envd_access_token = response.envd_access_token
+                    connection_headers["X-Access-Token"] = envd_access_token
+
+            connection_config = ConnectionConfig(
+                api_key=config.api_key,
+                domain=config.domain,
+                debug=config.debug,
+                request_timeout=config.request_timeout,
+                headers=connection_headers,
+                proxy=config.proxy,
+            )
+
+            # Create and return a full AsyncSandbox instance
+            sandbox = AsyncSandbox(
+                sandbox_id=sandbox_id,
+                sandbox_domain=sandbox_domain,
+                envd_version=envd_version,
+                envd_access_token=envd_access_token,
+                connection_config=connection_config,
+            )
+
+            return sandbox