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

scalebox/sandbox_sync/filesystem/filesystem.py

@@ -148,7 +148,7 @@ class Filesystem:
         self,
         path: str,
         data: Union[str, bytes, IO],
-        user: Username = "user",
+        user: Username = "root",
         request_timeout: Optional[float] = None,
     ) -> WriteInfo:
         """
@@ -172,7 +172,7 @@ class Filesystem:
     def write(
         self,
         files: List[WriteEntry],
-        user: Optional[Username] = "user",
+        user: Optional[Username] = "root",
         request_timeout: Optional[float] = None,
     ) -> List[WriteInfo]:
         """
@@ -190,7 +190,7 @@ class Filesystem:
     def write(
         self,
         path_or_files: Union[str, List[WriteEntry]],
-        data_or_user: Union[str, bytes, IO, Username] = "user",
+        data_or_user: Union[str, bytes, IO, Username] = "root",
         user_or_request_timeout: Optional[Union[float, Username]] = None,
         request_timeout_or_none: Optional[float] = None,
     ) -> Union[WriteInfo, List[WriteInfo]]:

scalebox/sandbox_sync/filesystem/watch_handle.py

@@ -1,66 +1,66 @@
-from typing import List
-
-from ...exceptions import SandboxException
-from ...generated import api_pb2_connect
-from ...generated.api_pb2 import GetWatcherEventsRequest, RemoveWatcherRequest
-from ...generated.rpc import handle_rpc_exception
-from ...sandbox.filesystem.watch_handle import FilesystemEvent, map_event_type
-
-
-class WatchHandle:
-    """
-    Handle for watching filesystem events.
-    It is used to get the latest events that have occurred in the watched directory.
-
-    Use `.stop()` to stop watching the directory.
-    """
-
-    def __init__(
-        self,
-        rpc: api_pb2_connect.FilesystemClient,
-        watcher_id: str,
-    ):
-        self._rpc = rpc
-        self._watcher_id = watcher_id
-        self._closed = False
-
-    def stop(self):
-        """
-        Stop watching the directory.
-        After you stop the watcher you won't be able to get the events anymore.
-        """
-        try:
-            self._rpc.remove_watcher(RemoveWatcherRequest(watcher_id=self._watcher_id))
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-        self._closed = True
-
-    def get_new_events(self) -> List[FilesystemEvent]:
-        """
-        Get the latest events that have occurred in the watched directory since the last call, or from the beginning of the watching, up until now.
-
-        :return: List of filesystem events
-        """
-        if self._closed:
-            raise SandboxException("The watcher is already stopped")
-
-        try:
-            r = self._rpc.get_watcher_events(
-                GetWatcherEventsRequest(watcher_id=self._watcher_id)
-            )
-        except Exception as e:
-            raise handle_rpc_exception(e)
-
-        events = []
-        for event in r.events:
-            event_type = map_event_type(event.type)
-            if event_type:
-                events.append(
-                    FilesystemEvent(
-                        name=event.name,
-                        type=event_type,
-                    )
-                )
-
-        return events
+from typing import List
+
+from ...exceptions import SandboxException
+from ...generated import api_pb2_connect
+from ...generated.api_pb2 import GetWatcherEventsRequest, RemoveWatcherRequest
+from ...generated.rpc import handle_rpc_exception
+from ...sandbox.filesystem.watch_handle import FilesystemEvent, map_event_type
+
+
+class WatchHandle:
+    """
+    Handle for watching filesystem events.
+    It is used to get the latest events that have occurred in the watched directory.
+
+    Use `.stop()` to stop watching the directory.
+    """
+
+    def __init__(
+        self,
+        rpc: api_pb2_connect.FilesystemClient,
+        watcher_id: str,
+    ):
+        self._rpc = rpc
+        self._watcher_id = watcher_id
+        self._closed = False
+
+    def stop(self):
+        """
+        Stop watching the directory.
+        After you stop the watcher you won't be able to get the events anymore.
+        """
+        try:
+            self._rpc.remove_watcher(RemoveWatcherRequest(watcher_id=self._watcher_id))
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+        self._closed = True
+
+    def get_new_events(self) -> List[FilesystemEvent]:
+        """
+        Get the latest events that have occurred in the watched directory since the last call, or from the beginning of the watching, up until now.
+
+        :return: List of filesystem events
+        """
+        if self._closed:
+            raise SandboxException("The watcher is already stopped")
+
+        try:
+            r = self._rpc.get_watcher_events(
+                GetWatcherEventsRequest(watcher_id=self._watcher_id)
+            )
+        except Exception as e:
+            raise handle_rpc_exception(e)
+
+        events = []
+        for event in r.events:
+            event_type = map_event_type(event.type)
+            if event_type:
+                events.append(
+                    FilesystemEvent(
+                        name=event.name,
+                        type=event_type,
+                    )
+                )
+
+        return events

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
@@ -407,16 +343,18 @@ class Sandbox(SandboxSetup, SandboxApi):
             headers=connection_headers,
             proxy=proxy,
         )
-        print("connection_config" + str(connection_config.__dict__))
+        # print("connection_config" + str(connection_config.__dict__))
         sanbox= cls(
             sandbox_id=sandbox_id,
             sandbox_domain=sandbox_domain,
             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
+        timeout = 10.0
         interval = 0.3
         elapsed = 0.0
         while elapsed <= timeout:
@@ -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:
@@ -454,7 +392,7 @@ class Sandbox(SandboxSetup, SandboxApi):
                 ENVD_API_HEALTH_ROUTE,
                 timeout=self.connection_config.get_request_timeout(request_timeout),
             )
-            print(r)
+            # print(r)
             if r.status_code == 502:
                 return False
 
@@ -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,
+        )