scalebox-sdk 0.1.25__py3-none-any.whl → 1.0.2__py3-none-any.whl

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

scalebox/sandbox_sync/main.py

@@ -8,10 +8,11 @@ import httpx
 import urllib3
 from httpx import Timeout
 from packaging.version import Version
+from typing_extensions import Self, Unpack
 from urllib3 import Retry
 
 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, handle_envd_api_exception
 from ..sandbox.main import SandboxSetup
@@ -101,6 +102,17 @@ class Sandbox(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, any]]:
+        return self._network_proxy
+
     @property
     def envd_api_url(self) -> str:
         return self._envd_api_url
@@ -153,104 +165,19 @@ class Sandbox(SandboxSetup, SandboxApi):
         """
         super().__init__()
         self._connection_config = opts["connection_config"]
-
+        self._object_storage = opts["object_storage"]
         self._sandbox_id = opts["sandbox_id"]
+        self._network_proxy = opts["network_proxy"]
         self._sandbox_domain = opts["sandbox_domain"] or self.connection_config.domain
         debug = self._connection_config.debug
-        # connection_headers = {"Authorization": "Bearer root", }
-
-        # if debug:
-        #     self._sandbox_id = "debug_sandbox_id"
-        #     self._sandbox_domain = None
-        #     self._envd_version = None
-        #     self._envd_access_token = None
-        # elif sandbox_id is not None:
-        #     response = SandboxApi._cls_get_info(
-        #         sandbox_id,
-        #         api_key=api_key,
-        #         domain=domain,
-        #         debug=debug,
-        #         request_timeout=request_timeout,
-        #         proxy=proxy,
-        #     )
-        #
-        #     self._sandbox_id = sandbox_id
-        #     self._sandbox_domain = response.sandbox_domain
-        #     self._envd_version = response.envd_version
-        #     self._envd_access_token = response._envd_access_token
-        #
-        #     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:
-        #     template = template or self.default_template
-        #     timeout = timeout or self.default_sandbox_timeout
-        #     response = SandboxApi._create_sandbox(
-        #         template=template,
-        #         api_key=api_key,
-        #         timeout=timeout,
-        #         metadata=metadata,
-        #         env_vars=envs,
-        #         domain=domain,
-        #         debug=debug,
-        #         request_timeout=request_timeout,
-        #         secure=secure or False,
-        #         proxy=proxy,
-        #         allow_internet_access=allow_internet_access,
-        #     )
-        #
-        #     self._sandbox_id = response.sandbox_id
-        #     self._sandbox_domain = response.sandbox_domain
-        #     self._envd_version = response.envd_version
-        #
-        #     if response.envd_access_token is not None and not isinstance(
-        #         response.envd_access_token, Unset
-        #     ):
-        #         self._envd_access_token = response.envd_access_token
-        #         connection_headers["X-Access-Token"] = response.envd_access_token
-        #     else:
-        #         self._envd_access_token = None
-        # self._transport = TransportWithLogger(limits=self._limits, proxy=proxy)
-        # self._connection_config = ConnectionConfig(
-        #     api_key=api_key,
-        #     domain=domain,
-        #     debug=debug,
-        #     request_timeout=request_timeout,
-        #     headers=connection_headers,
-        #     proxy=proxy,
-        # )
+        self.__envd_access_token=opts["envd_access_token"]
 
         self._sandbox_domain = self._sandbox_domain or self._connection_config.domain
-        # self._envd_api_url = f"{'http' if self.connection_config.debug else 'https'}://{self.get_host(self.envd_port)}"
         if debug:
             self._envd_api_url = f"http://{self.get_host(8888)}"
-        # elif self._sandbox_id is not None:
-        #     response = SandboxApi._cls_get_info(
-        #         self._sandbox_id,
-        #         api_key=self._api_key(),
-        #         domain=self._sandbox_domain,
-        #         debug=debug,
-        #         request_timeout=self.request_timeout,
-        #         proxy=self.proxy,
-        #     )
-        #
-        #     self._sandbox_id = self._sandbox_id
-        #     self._sandbox_domain = response.sandbox_domain
-        #     self._envd_version = response.envd_version
-        #     self._envd_access_token = response._envd_access_token
-        #
-        #     if response._envd_access_token is not None and not isinstance(
-        #         response._envd_access_token, Unset
-        #     ):
-        #         self._connection_config["X-Access-Token"] = response._envd_access_token
-        #     self._envd_api_url = f"http://{self.get_host(self.envd_port)}"
         else:
             self._envd_api_url = f"https://{self.get_host(self.envd_port)}"
         self._transport = TransportWithLogger(limits=self._limits, proxy=self._connection_config.proxy)
-        # self._envd_api_url = f"http://localhost:8088"
-        # self._envd_api_url = f"http://{self.get_host(self.envd_port)}"
-        # self._envd_api_url = f"http://localhost:31000"
         self._envd_api = httpx.Client(
             base_url=self._envd_api_url,
             transport=self._transport,
@@ -317,6 +244,7 @@ class Sandbox(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,
@@ -325,6 +253,7 @@ class Sandbox(SandboxSetup, SandboxApi):
             proxy: Optional[ProxyTypes] = None,
             secure: Optional[bool] = None,
             allow_internet_access: Optional[bool] = True,
+            net_proxy_country: Optional[str] = None
     ):
         """
         Create a new sandbox.
@@ -350,6 +279,7 @@ class Sandbox(SandboxSetup, SandboxApi):
                 "Cannot set metadata or timeout when connecting to an existing sandbox. "
                 "Use Sandbox.connect method instead.",
             )
+        network_proxy = {}
         connection_headers = {"Authorization": "Bearer root", }
         if debug:
             sandbox_id = "debug_sandbox_id"
@@ -369,6 +299,8 @@ class Sandbox(SandboxSetup, SandboxApi):
             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
@@ -387,12 +319,16 @@ class Sandbox(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
@@ -414,6 +350,8 @@ class Sandbox(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 = 10.0
@@ -429,7 +367,7 @@ class Sandbox(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
 
     def is_running(self, request_timeout: Optional[float] = None) -> bool:
@@ -468,64 +406,155 @@ class Sandbox(SandboxSetup, SandboxApi):
 
         return True
 
+    @overload
+    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 = Sandbox.create()
+        sandbox.beta_pause()
+
+        # Another code block
+        same_sandbox = sandbox.connect()
+
+        :return: A running sandbox instance
+        """
+        ...
+
+    @overload
     @classmethod
     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:
         """
-        Connects 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: Scalebox 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 = Sandbox()
-        sandbox_id = sandbox.sandbox_id
+        sandbox = Sandbox.create()
+        Sandbox.beta_pause(sandbox.sandbox_id)
 
         # Another code block
-        same_sandbox = Sandbox.connect(sandbox_id)
+        same_sandbox = Sandbox.connect(sandbox.sandbox_id)
         ```
         """
-        connection_headers = {"Authorization": "Bearer root"}
+        ...
 
-        response = SandboxApi._cls_get_info(
-            sandbox_id,
-            api_key=api_key,
-            domain=domain,
-            debug=debug,
-            proxy=proxy,
-        )
+    @class_method_variant("_cls_connect")
+    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.
 
-        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
-        connection_config = ConnectionConfig(
-            api_key=api_key,
-            domain=domain,
-            debug=debug,
-            headers=connection_headers,
-            proxy=proxy,
-        )
+        With sandbox ID you can connect to the same sandbox from different places or environments (serverless functions, etc).
 
-        return cls(
-            sandbox_id=sandbox_id,
-            sandbox_domain=response.sandbox_domain,
-            envd_version=response.envd_version,
-            envd_access_token=response._envd_access_token,
-            connection_config=connection_config,
+        :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 = Sandbox.create()
+        sandbox.beta_pause()
+
+        # Another code block
+        same_sandbox = sandbox.connect()
+        ```
+        """
+        SandboxApi._cls_connect(
+            sandbox_id=self.sandbox_id,
+            timeout=timeout,
+            **opts,
         )
 
+        return self
+
+    # @classmethod
+    # def connect(
+    #     cls,
+    #     sandbox_id: str,
+    #     api_key: Optional[str] = None,
+    #     domain: Optional[str] = None,
+    #     debug: Optional[bool] = None,
+    #     proxy: Optional[ProxyTypes] = None,
+    # ):
+    #     """
+    #     Connects 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: Scalebox 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 = Sandbox()
+    #     sandbox_id = sandbox.sandbox_id
+    #
+    #     # Another code block
+    #     same_sandbox = Sandbox.connect(sandbox_id)
+    #     ```
+    #     """
+    #     connection_headers = {"Authorization": "Bearer root"}
+    #
+    #     response = 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
+    #     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,
+    #         envd_version=response.envd_version,
+    #         envd_access_token=response._envd_access_token,
+    #         connection_config=connection_config,
+    #     )
+
     def __enter__(self):
         return self
 
@@ -787,3 +816,49 @@ class Sandbox(SandboxSetup, SandboxApi):
             end=end,
             **config_dict,
         )
+
+    @overload
+    def beta_pause(
+            self,
+            **opts: Unpack[ApiParams],
+    ) -> None:
+        """
+        [BETA] This feature is in beta and may change in the future.
+
+        Pause the sandbox.
+        """
+        ...
+
+    @overload
+    @classmethod
+    def beta_pause(
+            cls,
+            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
+        """
+        ...
+
+    @class_method_variant("_cls_pause")
+    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
+        """
+
+        SandboxApi._cls_pause(
+            sandbox_id=self.sandbox_id,
+            **opts,
+        )