blaxel 0.2.31__py3-none-any.whl → 0.2.31rc120__py3-none-any.whl

blaxel/core/sandbox/default/interpreter.py

@@ -17,9 +17,7 @@ class CodeInterpreter(SandboxInstance):
     DEFAULT_PORTS = [
         {"name": "jupyter", "target": 8888, "protocol": "HTTP"},
     ]
-    DEFAULT_LIFECYCLE = {
-        "expirationPolicies": [{"type": "ttl-idle", "value": "30m", "action": "delete"}]
-    }
+    DEFAULT_LIFECYCLE = {"expirationPolicies": [{"type": "ttl-idle", "value": "30m", "action": "delete"}]}
 
     @classmethod
     async def get(cls, sandbox_name: str) -> CodeInterpreter:
@@ -150,15 +148,11 @@ class CodeInterpreter(SandboxInstance):
         elif data_type == "stdout":
             execution.logs.stdout.append(data["text"])
             if on_stdout:
-                return on_stdout(
-                    CodeInterpreter.OutputMessage(data["text"], data.get("timestamp"), False)
-                )
+                return on_stdout(CodeInterpreter.OutputMessage(data["text"], data.get("timestamp"), False))
         elif data_type == "stderr":
             execution.logs.stderr.append(data["text"])
             if on_stderr:
-                return on_stderr(
-                    CodeInterpreter.OutputMessage(data["text"], data.get("timestamp"), True)
-                )
+                return on_stderr(CodeInterpreter.OutputMessage(data["text"], data.get("timestamp"), True))
         elif data_type == "error":
             execution.error = CodeInterpreter.ExecutionError(
                 data.get("name", ""), data.get("value"), data.get("traceback")
@@ -206,10 +200,7 @@ class CodeInterpreter(SandboxInstance):
 
         client = self.process.get_client()
         timeout_cfg = httpx.Timeout(
-            connect=connect_timeout,
-            read=read_timeout,
-            write=write_timeout,
-            pool=pool_timeout,
+            connect=connect_timeout, read=read_timeout, write=write_timeout, pool=pool_timeout
         )
         async with client.stream(
             "POST",
@@ -252,7 +243,7 @@ class CodeInterpreter(SandboxInstance):
                         on_error=on_error,
                     )
                 except json.JSONDecodeError:
-                    # Fallback: treat as stdout text-only message
+                        # Fallback: treat as stdout text-only message
                     execution.logs.stdout.append(decoded)
                     if on_stdout:
                         on_stdout(CodeInterpreter.OutputMessage(decoded, None, False))
@@ -280,10 +271,10 @@ class CodeInterpreter(SandboxInstance):
         try:
             # Always read response body first
             body_bytes = await response.aread()
-
+            
             if response.status_code >= 400:
                 try:
-                    body_text = body_bytes.decode("utf-8", errors="ignore")
+                    body_text = body_bytes.decode('utf-8', errors='ignore')
                 except Exception:
                     body_text = "<unavailable>"
                 method = getattr(response.request, "method", "UNKNOWN")
@@ -296,8 +287,10 @@ class CodeInterpreter(SandboxInstance):
                 )
                 self.logger.debug(details)
                 raise RuntimeError(details)
-
+            
             data = json.loads(body_bytes)
             return CodeInterpreter.Context.from_json(data)
         finally:
             await response.aclose()
+
+

blaxel/core/sandbox/default/preview.py

@@ -15,15 +15,11 @@ from ...client.api.compute.delete_sandbox_preview import (
 from ...client.api.compute.delete_sandbox_preview_token import (
     asyncio as delete_sandbox_preview_token,
 )
-from ...client.api.compute.get_sandbox_preview import (
-    asyncio as get_sandbox_preview,
-)
+from ...client.api.compute.get_sandbox_preview import asyncio as get_sandbox_preview
 from ...client.api.compute.list_sandbox_preview_tokens import (
     asyncio as list_sandbox_preview_tokens,
 )
-from ...client.api.compute.list_sandbox_previews import (
-    asyncio as list_sandbox_previews,
-)
+from ...client.api.compute.list_sandbox_previews import asyncio as list_sandbox_previews
 from ...client.client import client
 from ...client.models import (
     Preview,

blaxel/core/sandbox/default/process.py

@@ -6,11 +6,7 @@ import httpx
 from ...common.settings import settings
 from ..client.models import ProcessResponse, SuccessResponse
 from ..client.models.process_request import ProcessRequest
-from ..types import (
-    ProcessRequestWithLog,
-    ProcessResponseWithLog,
-    SandboxConfiguration,
-)
+from ..types import ProcessRequestWithLog, ProcessResponseWithLog, SandboxConfiguration
 from .action import SandboxAction
 
 
@@ -19,9 +15,7 @@ class SandboxProcess(SandboxAction):
         super().__init__(sandbox_config)
 
     def stream_logs(
-        self,
-        process_name: str,
-        options: Dict[str, Callable[[str], None]] | None = None,
+        self, process_name: str, options: Dict[str, Callable[[str], None]] | None = None
     ) -> Dict[str, Callable[[], None]]:
         """Stream logs from a process with automatic reconnection and deduplication."""
         if options is None:
@@ -117,9 +111,7 @@ class SandboxProcess(SandboxAction):
         return {"close": close}
 
     def _stream_logs(
-        self,
-        identifier: str,
-        options: Dict[str, Callable[[str], None]] | None = None,
+        self, identifier: str, options: Dict[str, Callable[[str], None]] | None = None
     ) -> Dict[str, Callable[[], None]]:
         """Private method to stream logs from a process with callbacks for different output types."""
         if options is None:
@@ -183,8 +175,7 @@ class SandboxProcess(SandboxAction):
         return {"close": close}
 
     async def exec(
-        self,
-        process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]],
+        self, process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]]
     ) -> Union[ProcessResponse, ProcessResponseWithLog]:
         """Execute a process in the sandbox."""
         on_log = None
@@ -209,14 +200,13 @@ class SandboxProcess(SandboxAction):
         # Always start process without wait_for_completion to avoid server-side blocking
         if should_wait_for_completion and on_log is not None:
             process.wait_for_completion = False
-
+        
         client = self.get_client()
         response = await client.post("/process", json=process.to_dict())
         try:
             content_bytes = await response.aread()
             self.handle_response_error(response)
             import json
-
             response_data = json.loads(content_bytes) if content_bytes else None
             result = ProcessResponse.from_dict(response_data)
         finally:
@@ -237,8 +227,7 @@ class SandboxProcess(SandboxAction):
             if on_log is not None:
                 stream_control = self._stream_logs(result.pid, {"on_log": on_log})
                 return ProcessResponseWithLog(
-                    result,
-                    lambda: stream_control["close"]() if stream_control else None,
+                    result, lambda: stream_control["close"]() if stream_control else None
                 )
 
         return result
@@ -266,7 +255,6 @@ class SandboxProcess(SandboxAction):
 
     async def get(self, identifier: str) -> ProcessResponse:
         import json
-
         client = self.get_client()
         response = await client.get(f"/process/{identifier}")
         try:
@@ -278,7 +266,6 @@ class SandboxProcess(SandboxAction):
 
     async def list(self) -> list[ProcessResponse]:
         import json
-
         client = self.get_client()
         response = await client.get("/process")
         try:
@@ -290,7 +277,6 @@ class SandboxProcess(SandboxAction):
 
     async def stop(self, identifier: str) -> SuccessResponse:
         import json
-
         client = self.get_client()
         response = await client.delete(f"/process/{identifier}")
         try:
@@ -302,7 +288,6 @@ class SandboxProcess(SandboxAction):
 
     async def kill(self, identifier: str) -> SuccessResponse:
         import json
-
         client = self.get_client()
         response = await client.delete(f"/process/{identifier}/kill")
         try:
@@ -313,12 +298,9 @@ class SandboxProcess(SandboxAction):
             await response.aclose()
 
     async def logs(
-        self,
-        identifier: str,
-        log_type: Literal["stdout", "stderr", "all"] = "all",
+        self, identifier: str, log_type: Literal["stdout", "stderr", "all"] = "all"
     ) -> str:
         import json
-
         client = self.get_client()
         response = await client.get(f"/process/{identifier}/logs")
         try:

blaxel/core/sandbox/default/sandbox.py

@@ -105,8 +105,7 @@ class SandboxInstance:
                     or "expires" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "region" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
-                    or "snapshot_enabled"
-                    in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "snapshot_enabled" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -133,11 +132,7 @@ class SandboxInstance:
                 metadata=Metadata(name=name),
                 spec=SandboxSpec(
                     runtime=Runtime(
-                        image=image,
-                        memory=memory,
-                        ports=ports,
-                        envs=envs,
-                        generation="mk3",
+                        image=image, memory=memory, ports=ports, envs=envs, generation="mk3"
                     ),
                     volumes=volumes,
                 ),

blaxel/core/sandbox/sync/__init__.py

@@ -15,3 +15,5 @@ __all__ = [
     "SyncSandboxCodegen",
     "SyncCodeInterpreter",
 ]
+
+

blaxel/core/sandbox/sync/action.py

@@ -51,8 +51,7 @@ class SyncSandboxAction:
     def get_client(self) -> httpx.Client:
         if self.sandbox_config.force_url:
             return httpx.Client(
-                base_url=self.sandbox_config.force_url,
-                headers=self.sandbox_config.headers,
+                base_url=self.sandbox_config.force_url, headers=self.sandbox_config.headers
             )
         return httpx.Client(
             base_url=self.url,
@@ -62,3 +61,5 @@ class SyncSandboxAction:
     def handle_response_error(self, response: httpx.Response):
         if not response.is_success:
             raise ResponseError(response)
+
+

blaxel/core/sandbox/sync/codegen.py

@@ -20,7 +20,9 @@ class SyncSandboxCodegen(SyncSandboxAction):
     def __init__(self, sandbox_config: SandboxConfiguration):
         super().__init__(sandbox_config)
 
-    def fastapply(self, path: str, code_edit: str, model: str | None = None) -> ApplyEditResponse:
+    def fastapply(
+        self, path: str, code_edit: str, model: str | None = None
+    ) -> ApplyEditResponse:
         body = ApplyEditRequest(code_edit=code_edit, model=model)
         client = Client(
             base_url=self.url,
@@ -64,3 +66,5 @@ class SyncSandboxCodegen(SyncSandboxAction):
             if isinstance(response, ErrorResponse):
                 raise Exception(f"Reranking failed: {response}")
             return response
+
+

blaxel/core/sandbox/sync/filesystem.py

@@ -61,11 +61,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             return self._upload_with_multipart(path, content, "0644")
         binary_file = io.BytesIO(content)
         files = {
-            "file": (
-                "binary-file.bin",
-                binary_file,
-                "application/octet-stream",
-            ),
+            "file": ("binary-file.bin", binary_file, "application/octet-stream"),
         }
         data = {"permissions": "0644", "path": path}
         url = f"{self.url}/filesystem/{path}"
@@ -199,10 +195,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
                                     name=file_event_data.get("name", ""),
                                     content=file_event_data.get("content"),
                                 )
-                                if options.get("with_content") and file_event.op in [
-                                    "CREATE",
-                                    "WRITE",
-                                ]:
+                                if options.get("with_content") and file_event.op in ["CREATE", "WRITE"]:
                                     try:
                                         file_path = file_event.path
                                         if file_path.endswith("/"):
@@ -251,9 +244,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             self.handle_response_error(response)
             return response.json()
 
-    def _complete_multipart_upload(
-        self, upload_id: str, parts: List[Dict[str, Any]]
-    ) -> SuccessResponse:
+    def _complete_multipart_upload(self, upload_id: str, parts: List[Dict[str, Any]]) -> SuccessResponse:
         url = f"{self.url}/filesystem-multipart/{upload_id}/complete"
         headers = {**settings.headers, **self.sandbox_config.headers}
         body = {"parts": parts}
@@ -270,9 +261,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             if not response.is_success:
                 logger.warning(f"Failed to abort multipart upload: {response.status_code}")
 
-    def _upload_with_multipart(
-        self, path: str, data: bytes, permissions: str = "0644"
-    ) -> SuccessResponse:
+    def _upload_with_multipart(self, path: str, data: bytes, permissions: str = "0644") -> SuccessResponse:
         init_response = self._initiate_multipart_upload(path, permissions)
         upload_id = init_response.get("uploadId")
         if not upload_id:
@@ -285,10 +274,8 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             for i in range(0, num_parts, MAX_PARALLEL_UPLOADS):
                 threads = []
                 results: Dict[int, Dict[str, Any]] = {}
-
                 def make_upload(part_number: int, chunk: bytes):
                     results[part_number] = self._upload_part(upload_id, part_number, chunk)
-
                 for j in range(MAX_PARALLEL_UPLOADS):
                     if i + j >= num_parts:
                         break
@@ -311,3 +298,5 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             except Exception as abort_error:
                 logger.warning(f"Failed to abort multipart upload: {abort_error}")
             raise error
+
+

blaxel/core/sandbox/sync/interpreter.py

@@ -15,9 +15,7 @@ class SyncCodeInterpreter(SyncSandboxInstance):
     DEFAULT_PORTS = [
         {"name": "jupyter", "target": 8888, "protocol": "HTTP"},
     ]
-    DEFAULT_LIFECYCLE = {
-        "expirationPolicies": [{"type": "ttl-idle", "value": "30m", "action": "delete"}]
-    }
+    DEFAULT_LIFECYCLE = {"expirationPolicies": [{ "type": "ttl-idle", "value": "30m", "action": "delete" }]}
 
     @classmethod
     def get(cls, sandbox_name: str) -> "SyncCodeInterpreter":
@@ -223,10 +221,7 @@ class SyncCodeInterpreter(SyncSandboxInstance):
         # Use the process client to inherit base_url and headers
         with self.process.get_client() as client:
             timeout_cfg = httpx.Timeout(
-                connect=connect_timeout,
-                read=read_timeout,
-                write=write_timeout,
-                pool=pool_timeout,
+                connect=connect_timeout, read=read_timeout, write=write_timeout, pool=pool_timeout
             )
             with client.stream(
                 "POST",
@@ -243,9 +238,7 @@ class SyncCodeInterpreter(SyncSandboxInstance):
                     if not line:
                         continue
                     try:
-                        decoded = (
-                            line.decode() if isinstance(line, bytes | bytearray) else str(line)
-                        )
+                        decoded = line.decode() if isinstance(line, bytes | bytearray) else str(line)
                     except Exception:
                         decoded = str(line)
                     try:
@@ -277,6 +270,7 @@ class SyncCodeInterpreter(SyncSandboxInstance):
         if cwd:
             data["cwd"] = cwd
 
+
         with self.process.get_client() as client:
             response = client.post(
                 "/port/8888/contexts",
@@ -289,3 +283,5 @@ class SyncCodeInterpreter(SyncSandboxInstance):
                 raise RuntimeError(details)
             data = response.json()
             return SyncCodeInterpreter.Context.from_json(data)
+
+

blaxel/core/sandbox/sync/network.py

@@ -7,3 +7,5 @@ class SyncSandboxNetwork(SyncSandboxAction):
         super().__init__(sandbox_config)
 
     # Placeholder for future sync network operations
+
+

blaxel/core/sandbox/sync/preview.py

@@ -3,27 +3,13 @@ from datetime import datetime
 from typing import Any, Dict, List, Union
 
 from ...client import errors
-from ...client.api.compute.create_sandbox_preview import (
-    sync as create_sandbox_preview,
-)
-from ...client.api.compute.create_sandbox_preview_token import (
-    sync as create_sandbox_preview_token,
-)
-from ...client.api.compute.delete_sandbox_preview import (
-    sync as delete_sandbox_preview,
-)
-from ...client.api.compute.delete_sandbox_preview_token import (
-    sync as delete_sandbox_preview_token,
-)
-from ...client.api.compute.get_sandbox_preview import (
-    sync as get_sandbox_preview,
-)
-from ...client.api.compute.list_sandbox_preview_tokens import (
-    sync as list_sandbox_preview_tokens,
-)
-from ...client.api.compute.list_sandbox_previews import (
-    sync as list_sandbox_previews,
-)
+from ...client.api.compute.create_sandbox_preview import sync as create_sandbox_preview
+from ...client.api.compute.create_sandbox_preview_token import sync as create_sandbox_preview_token
+from ...client.api.compute.delete_sandbox_preview import sync as delete_sandbox_preview
+from ...client.api.compute.delete_sandbox_preview_token import sync as delete_sandbox_preview_token
+from ...client.api.compute.get_sandbox_preview import sync as get_sandbox_preview
+from ...client.api.compute.list_sandbox_preview_tokens import sync as list_sandbox_preview_tokens
+from ...client.api.compute.list_sandbox_previews import sync as list_sandbox_previews
 from ...client.client import client
 from ...client.models import (
     Preview,
@@ -169,3 +155,5 @@ def to_utc_z(dt: datetime) -> str:
     elif "T" in iso_string and not iso_string.endswith("Z"):
         return iso_string + "Z"
     return iso_string
+
+

blaxel/core/sandbox/sync/process.py

@@ -7,11 +7,7 @@ import httpx
 from ...common.settings import settings
 from ..client.models import ProcessResponse, SuccessResponse
 from ..client.models.process_request import ProcessRequest
-from ..types import (
-    ProcessRequestWithLog,
-    ProcessResponseWithLog,
-    SandboxConfiguration,
-)
+from ..types import ProcessRequestWithLog, ProcessResponseWithLog, SandboxConfiguration
 from .action import SyncSandboxAction
 
 
@@ -20,9 +16,7 @@ class SyncSandboxProcess(SyncSandboxAction):
         super().__init__(sandbox_config)
 
     def stream_logs(
-        self,
-        process_name: str,
-        options: Dict[str, Callable[[str], None]] | None = None,
+        self, process_name: str, options: Dict[str, Callable[[str], None]] | None = None
     ) -> Dict[str, Callable[[], None]]:
         if options is None:
             options = {}
@@ -37,7 +31,6 @@ class SyncSandboxProcess(SyncSandboxAction):
         def start_stream():
             nonlocal current_close
             log_counter = [0]
-
             def make_dedup(cb_key: str):
                 def inner(content: str):
                     key = f"{log_counter[0]}:{content}"
@@ -46,9 +39,7 @@ class SyncSandboxProcess(SyncSandboxAction):
                         seen_logs.add(key)
                         if options.get(cb_key):
                             options[cb_key](content)
-
                 return inner
-
             wrapped_options: Dict[str, Callable[[str], None]] = {}
             if "on_log" in options:
                 wrapped_options["on_log"] = make_dedup("on_log")
@@ -59,11 +50,9 @@ class SyncSandboxProcess(SyncSandboxAction):
             if current_close["fn"]:
                 current_close["fn"]()
             current_close["fn"] = self._stream_logs(process_name, wrapped_options)["close"]
-
             def schedule():
                 if is_running.is_set():
                     start_stream()
-
             with timer_lock:
                 if reconnect_timer["t"]:
                     reconnect_timer["t"].cancel()
@@ -71,9 +60,7 @@ class SyncSandboxProcess(SyncSandboxAction):
                 reconnect_timer["t"] = t
                 t.daemon = True
                 t.start()
-
         start_stream()
-
         def close():
             is_running.clear()
             with timer_lock:
@@ -84,18 +71,14 @@ class SyncSandboxProcess(SyncSandboxAction):
                 current_close["fn"]()
                 current_close["fn"] = None
             seen_logs.clear()
-
         return {"close": close}
 
     def _stream_logs(
-        self,
-        identifier: str,
-        options: Dict[str, Callable[[str], None]] | None = None,
+        self, identifier: str, options: Dict[str, Callable[[str], None]] | None = None
     ) -> Dict[str, Callable[[], None]]:
         if options is None:
             options = {}
         closed = threading.Event()
-
         def run():
             url = f"{self.url}/process/{identifier}/logs/stream"
             headers = {**settings.headers, **self.sandbox_config.headers}
@@ -133,18 +116,14 @@ class SyncSandboxProcess(SyncSandboxAction):
                 # Ignore on close
                 if not closed.is_set():
                     raise e
-
         thread = threading.Thread(target=run, daemon=True)
         thread.start()
-
         def close():
             closed.set()
-
         return {"close": close}
 
     def exec(
-        self,
-        process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]],
+        self, process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]]
     ) -> Union[ProcessResponse, ProcessResponseWithLog]:
         on_log = None
         if isinstance(process, ProcessRequestWithLog):
@@ -185,8 +164,7 @@ class SyncSandboxProcess(SyncSandboxAction):
                 if on_log is not None:
                     stream_control = self._stream_logs(result.pid, {"on_log": on_log})
                     return ProcessResponseWithLog(
-                        result,
-                        lambda: stream_control["close"]() if stream_control else None,
+                        result, lambda: stream_control["close"]() if stream_control else None
                     )
             return result
 
@@ -229,11 +207,7 @@ class SyncSandboxProcess(SyncSandboxAction):
             self.handle_response_error(response)
             return SuccessResponse.from_dict(response.json())
 
-    def logs(
-        self,
-        identifier: str,
-        log_type: Literal["stdout", "stderr", "all"] = "all",
-    ) -> str:
+    def logs(self, identifier: str, log_type: Literal["stdout", "stderr", "all"] = "all") -> str:
         with self.get_client() as client_instance:
             response = client_instance.get(f"/process/{identifier}/logs")
             self.handle_response_error(response)
@@ -245,3 +219,5 @@ class SyncSandboxProcess(SyncSandboxAction):
             elif log_type == "stderr":
                 return data.get("stderr", "")
             raise Exception("Unsupported log type")
+
+

blaxel/core/sandbox/sync/sandbox.py

@@ -100,8 +100,7 @@ class SyncSandboxInstance:
                     or "expires" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "region" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
-                    or "snapshot_enabled"
-                    in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "snapshot_enabled" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -123,11 +122,7 @@ class SyncSandboxInstance:
                 metadata=Metadata(name=name),
                 spec=SandboxSpec(
                     runtime=Runtime(
-                        image=image,
-                        memory=memory,
-                        ports=ports,
-                        envs=envs,
-                        generation="mk3",
+                        image=image, memory=memory, ports=ports, envs=envs, generation="mk3"
                     ),
                     volumes=volumes,
                 ),
@@ -188,9 +183,7 @@ class SyncSandboxInstance:
         return response
 
     @classmethod
-    def update_metadata(
-        cls, sandbox_name: str, metadata: SandboxUpdateMetadata
-    ) -> "SyncSandboxInstance":
+    def update_metadata(cls, sandbox_name: str, metadata: SandboxUpdateMetadata) -> "SyncSandboxInstance":
         sandbox_instance = cls.get(sandbox_name)
         sandbox = sandbox_instance.sandbox
         updated_sandbox = Sandbox.from_dict(sandbox.to_dict())
@@ -243,9 +236,7 @@ class SyncSandboxInstance:
             raise e
 
     @classmethod
-    def from_session(
-        cls, session: Union[SessionWithToken, Dict[str, Any]]
-    ) -> "SyncSandboxInstance":
+    def from_session(cls, session: Union[SessionWithToken, Dict[str, Any]]) -> "SyncSandboxInstance":
         if isinstance(session, dict):
             session = SessionWithToken.from_dict(session)
         sandbox_name = session.name.split("-")[0] if "-" in session.name else session.name
@@ -256,3 +247,5 @@ class SyncSandboxInstance:
             headers={"X-Blaxel-Preview-Token": session.token},
             params={"bl_preview_token": session.token},
         )
+
+

blaxel/core/sandbox/sync/session.py

@@ -22,9 +22,7 @@ class SyncSandboxSessions:
     def sandbox_name(self) -> str:
         return self.sandbox_config.metadata.name if self.sandbox_config.metadata else ""
 
-    def create(
-        self, options: Union[SessionCreateOptions, Dict[str, Any]] | None = None
-    ) -> SessionWithToken:
+    def create(self, options: Union[SessionCreateOptions, Dict[str, Any]] | None = None) -> SessionWithToken:
         if options is None:
             options = SessionCreateOptions()
         elif isinstance(options, dict):
@@ -114,9 +112,9 @@ class SyncSandboxSessions:
         return delete_sandbox_preview.sync(self.sandbox_name, name, client=client)
 
     def get_token(self, preview_name: str):
-        tokens_response = list_sandbox_preview_tokens.sync(
-            self.sandbox_name, preview_name, client=client
-        )
+        tokens_response = list_sandbox_preview_tokens.sync(self.sandbox_name, preview_name, client=client)
         if not tokens_response:
             return None
         return tokens_response[0]
+
+

blaxel/core/sandbox/types.py

@@ -148,8 +148,7 @@ class SandboxCreateConfiguration:
         memory: int | None = None,
         ports: Union[List[Port], List[Dict[str, Any]]] | None = None,
         envs: List[Dict[str, str]] | None = None,
-        volumes: Union[List[VolumeBinding], List[VolumeAttachment], List[Dict[str, Any]]]
-        | None = None,
+        volumes: Union[List[VolumeBinding], List[VolumeAttachment], List[Dict[str, Any]]] | None = None,
         ttl: str | None = None,
         expires: datetime | None = None,
         region: str | None = None,