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

scalebox/sandbox/signature.py

@@ -1,40 +1,40 @@
-import base64
-import hashlib
-import time
-from typing import Literal, Optional, TypedDict
-
-Operation = Literal["read", "write"]
-
-
-class Signature(TypedDict):
-    signature: str
-    expiration: Optional[int]  # Unix timestamp or None
-
-
-def get_signature(
-    path: str,
-    operation: Operation,
-    user: str,
-    envd_access_token: Optional[str],
-    expiration_in_seconds: Optional[int] = None,
-) -> Signature:
-    """
-    Generate a v1 signature for sandbox file URLs.
-    """
-    if not envd_access_token:
-        raise ValueError("Access token is not set and signature cannot be generated!")
-
-    expiration = (
-        int(time.time()) + expiration_in_seconds if expiration_in_seconds else None
-    )
-
-    raw = (
-        f"{path}:{operation}:{user}:{envd_access_token}"
-        if expiration is None
-        else f"{path}:{operation}:{user}:{envd_access_token}:{expiration}"
-    )
-
-    digest = hashlib.sha256(raw.encode("utf-8")).digest()
-    encoded = base64.b64encode(digest).rstrip(b"=").decode("ascii")
-
-    return {"signature": f"v1_{encoded}", "expiration": expiration}
+import base64
+import hashlib
+import time
+from typing import Literal, Optional, TypedDict
+
+Operation = Literal["read", "write"]
+
+
+class Signature(TypedDict):
+    signature: str
+    expiration: Optional[int]  # Unix timestamp or None
+
+
+def get_signature(
+    path: str,
+    operation: Operation,
+    user: str,
+    envd_access_token: Optional[str],
+    expiration_in_seconds: Optional[int] = None,
+) -> Signature:
+    """
+    Generate a v1 signature for sandbox file URLs.
+    """
+    if not envd_access_token:
+        raise ValueError("Access token is not set and signature cannot be generated!")
+
+    expiration = (
+        int(time.time()) + expiration_in_seconds if expiration_in_seconds else None
+    )
+
+    raw = (
+        f"{path}:{operation}:{user}:{envd_access_token}"
+        if expiration is None
+        else f"{path}:{operation}:{user}:{envd_access_token}:{expiration}"
+    )
+    print(raw)
+    digest = hashlib.sha256(raw.encode("utf-8")).digest()
+    encoded = base64.b64encode(digest).rstrip(b"=").decode("ascii")
+
+    return {"signature": f"v1_{encoded}", "expiration": expiration}

scalebox/sandbox/utils.py

@@ -1,34 +1,34 @@
-import functools
-from typing import Any, Optional, Type, TypeVar, cast
-
-T = TypeVar("T")
-
-
-class class_method_variant(object):
-    def __init__(self, class_method_name):
-        self.class_method_name = class_method_name
-
-    method: Any
-
-    def __call__(self, method: T) -> T:
-        self.method = method
-        return cast(T, self)
-
-    def __get__(self, obj, objtype: Optional[Type[Any]] = None):
-        @functools.wraps(self.method)
-        def _wrapper(*args, **kwargs):
-            if obj is not None:
-                # Method was called as an instance method, e.g.
-                # instance.method(...)
-                return self.method(obj, *args, **kwargs)
-            elif len(args) > 0 and objtype is not None and isinstance(args[0], objtype):
-                # Method was called as a class method with the instance as the
-                # first argument, e.g. Class.method(instance, ...) which in
-                # Python is the same thing as calling an instance method
-                return self.method(args[0], *args[1:], **kwargs)
-            else:
-                # Method was called as a class method, e.g. Class.method(...)
-                class_method = getattr(objtype, self.class_method_name)
-                return class_method(*args, **kwargs)
-
-        return _wrapper
+import functools
+from typing import Any, Optional, Type, TypeVar, cast
+
+T = TypeVar("T")
+
+
+class class_method_variant(object):
+    def __init__(self, class_method_name):
+        self.class_method_name = class_method_name
+
+    method: Any
+
+    def __call__(self, method: T) -> T:
+        self.method = method
+        return cast(T, self)
+
+    def __get__(self, obj, objtype: Optional[Type[Any]] = None):
+        @functools.wraps(self.method)
+        def _wrapper(*args, **kwargs):
+            if obj is not None:
+                # Method was called as an instance method, e.g.
+                # instance.method(...)
+                return self.method(obj, *args, **kwargs)
+            elif len(args) > 0 and objtype is not None and isinstance(args[0], objtype):
+                # Method was called as a class method with the instance as the
+                # first argument, e.g. Class.method(instance, ...) which in
+                # Python is the same thing as calling an instance method
+                return self.method(args[0], *args[1:], **kwargs)
+            else:
+                # Method was called as a class method, e.g. Class.method(...)
+                class_method = getattr(objtype, self.class_method_name)
+                return class_method(*args, **kwargs)
+
+        return _wrapper

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,6 +339,8 @@ 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 = 10.0
         interval = 0.3
@@ -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,
+        )