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

blaxel/core/sandbox/default/filesystem.py

@@ -47,11 +47,11 @@ class SandboxFileSystem(SandboxAction):
         path = self.format_path(path)
 
         # Calculate content size in bytes
-        content_size = len(content.encode('utf-8'))
+        content_size = len(content.encode("utf-8"))
 
         # Use multipart upload for large files
         if content_size > MULTIPART_THRESHOLD:
-            content_bytes = content.encode('utf-8')
+            content_bytes = content.encode("utf-8")
             return await self._upload_with_multipart(path, content_bytes, "0644")
 
         # Use regular upload for small files
@@ -66,7 +66,9 @@ class SandboxFileSystem(SandboxAction):
         finally:
             await response.aclose()
 
-    async def write_binary(self, path: str, content: Union[bytes, bytearray, str]) -> SuccessResponse:
+    async def write_binary(
+        self, path: str, content: Union[bytes, bytearray, str]
+    ) -> SuccessResponse:
         """Write binary content to a file.
 
         Args:
@@ -96,7 +98,11 @@ class SandboxFileSystem(SandboxAction):
 
         # Prepare multipart form data
         files = {
-            "file": ("binary-file.bin", binary_file, "application/octet-stream"),
+            "file": (
+                "binary-file.bin",
+                binary_file,
+                "application/octet-stream",
+            ),
         }
         data = {"permissions": "0644", "path": path}
 
@@ -109,7 +115,7 @@ class SandboxFileSystem(SandboxAction):
         try:
             content_bytes = await response.aread()
             if not response.is_success:
-                error_text = content_bytes.decode('utf-8', errors='ignore')
+                error_text = content_bytes.decode("utf-8", errors="ignore")
                 raise Exception(f"Failed to write binary: {response.status_code} {error_text}")
             return SuccessResponse.from_dict(json.loads(content_bytes))
         finally:
@@ -246,18 +252,18 @@ class SandboxFileSystem(SandboxAction):
             FindResponse with matching files/directories
         """
         path = self.format_path(path)
-        
+
         params = {}
         if type is not None:
-            params['type'] = type
+            params["type"] = type
         if patterns is not None and len(patterns) > 0:
-            params['patterns'] = ','.join(patterns)
+            params["patterns"] = ",".join(patterns)
         if max_results is not None:
-            params['maxResults'] = max_results
+            params["maxResults"] = max_results
         if exclude_dirs is not None and len(exclude_dirs) > 0:
-            params['excludeDirs'] = ','.join(exclude_dirs)
+            params["excludeDirs"] = ",".join(exclude_dirs)
         if exclude_hidden is not None:
-            params['excludeHidden'] = exclude_hidden
+            params["excludeHidden"] = exclude_hidden
 
         url = f"{self.url}/filesystem-find/{path}"
         headers = {**settings.headers, **self.sandbox_config.headers}
@@ -267,8 +273,9 @@ class SandboxFileSystem(SandboxAction):
         try:
             data = json.loads(await response.aread())
             self.handle_response_error(response)
-                
+
             from ..client.models.find_response import FindResponse
+
             return FindResponse.from_dict(data)
         finally:
             await response.aclose()
@@ -298,18 +305,18 @@ class SandboxFileSystem(SandboxAction):
             ContentSearchResponse with matching lines
         """
         path = self.format_path(path)
-        
-        params = {'query': query}
+
+        params = {"query": query}
         if case_sensitive is not None:
-            params['caseSensitive'] = case_sensitive
+            params["caseSensitive"] = case_sensitive
         if context_lines is not None:
-            params['contextLines'] = context_lines
+            params["contextLines"] = context_lines
         if max_results is not None:
-            params['maxResults'] = max_results
+            params["maxResults"] = max_results
         if file_pattern is not None:
-            params['filePattern'] = file_pattern
+            params["filePattern"] = file_pattern
         if exclude_dirs is not None and len(exclude_dirs) > 0:
-            params['excludeDirs'] = ','.join(exclude_dirs)
+            params["excludeDirs"] = ",".join(exclude_dirs)
 
         url = f"{self.url}/filesystem-content-search/{path}"
         headers = {**settings.headers, **self.sandbox_config.headers}
@@ -319,58 +326,15 @@ class SandboxFileSystem(SandboxAction):
         try:
             data = json.loads(await response.aread())
             self.handle_response_error(response)
-                
-            from ..client.models.content_search_response import ContentSearchResponse
+
+            from ..client.models.content_search_response import (
+                ContentSearchResponse,
+            )
+
             return ContentSearchResponse.from_dict(data)
         finally:
             await response.aclose()
 
-    async def find(
-        self,
-        path: str,
-        type: str | None = None,
-        patterns: List[str] | None = None,
-        max_results: int | None = None,
-        exclude_dirs: List[str] | None = None,
-        exclude_hidden: bool | None = None,
-    ):
-        """Find files and directories.
-
-        Args:
-            path: Path to search in
-            type: Type of search ('file' or 'directory')
-            patterns: File patterns to include (e.g., ['*.py', '*.json'])
-            max_results: Maximum number of results to return
-            exclude_dirs: Directory names to skip
-            exclude_hidden: Exclude hidden files and directories
-
-        Returns:
-            FindResponse with matching files/directories
-        """
-        path = self.format_path(path)
-        
-        params = {}
-        if type is not None:
-            params['type'] = type
-        if patterns is not None and len(patterns) > 0:
-            params['patterns'] = ','.join(patterns)
-        if max_results is not None:
-            params['maxResults'] = max_results
-        if exclude_dirs is not None and len(exclude_dirs) > 0:
-            params['excludeDirs'] = ','.join(exclude_dirs)
-        if exclude_hidden is not None:
-            params['excludeHidden'] = exclude_hidden
-
-        url = f"{self.url}/filesystem-find/{path}"
-        headers = {**settings.headers, **self.sandbox_config.headers}
-
-        async with self.get_client() as client_instance:
-            response = await client_instance.get(url, params=params, headers=headers)
-            self.handle_response_error(response)
-            
-            from ..client.models.find_response import FindResponse
-            return FindResponse.from_dict(response.json())
-
     async def cp(self, source: str, destination: str, max_wait: int = 180000) -> CopyResponse:
         """Copy files or directories using the cp command.
 
@@ -383,9 +347,7 @@ class SandboxFileSystem(SandboxAction):
             raise Exception("Process instance not available. Cannot execute cp command.")
 
         # Execute cp -r command
-        process = await self.process.exec({
-            "command": f"cp -r {source} {destination}"
-        })
+        process = await self.process.exec({"command": f"cp -r {source} {destination}"})
 
         # Wait for process to complete
         process = await self.process.wait(process.pid, max_wait=max_wait, interval=100)
@@ -395,11 +357,7 @@ class SandboxFileSystem(SandboxAction):
             logs = process.logs if hasattr(process, "logs") else "Unknown error"
             raise Exception(f"Could not copy {source} to {destination} cause: {logs}")
 
-        return CopyResponse(
-            message="Files copied",
-            source=source,
-            destination=destination
-        )
+        return CopyResponse(message="Files copied", source=source, destination=destination)
 
     def watch(
         self,
@@ -496,7 +454,9 @@ class SandboxFileSystem(SandboxAction):
         return path
 
     # Multipart upload helper methods
-    async def _initiate_multipart_upload(self, path: str, permissions: str = "0644") -> Dict[str, Any]:
+    async def _initiate_multipart_upload(
+        self, path: str, permissions: str = "0644"
+    ) -> Dict[str, Any]:
         """Initiate a multipart upload session."""
         path = self.format_path(path)
         url = f"{self.url}/filesystem-multipart/initiate/{path}"
@@ -512,9 +472,7 @@ class SandboxFileSystem(SandboxAction):
         finally:
             await response.aclose()
 
-    async def _upload_part(
-        self, upload_id: str, part_number: int, data: bytes
-    ) -> Dict[str, Any]:
+    async def _upload_part(self, upload_id: str, part_number: int, data: bytes) -> Dict[str, Any]:
         """Upload a single part of a multipart upload."""
         url = f"{self.url}/filesystem-multipart/{upload_id}/part"
         headers = {**settings.headers, **self.sandbox_config.headers}
@@ -524,9 +482,7 @@ class SandboxFileSystem(SandboxAction):
         files = {"file": ("part", io.BytesIO(data), "application/octet-stream")}
 
         client = self.get_client()
-        response = await client.put(
-            url, files=files, params=params, headers=headers
-        )
+        response = await client.put(url, files=files, params=params, headers=headers)
         try:
             data = json.loads(await response.aread())
             self.handle_response_error(response)

blaxel/core/sandbox/default/interpreter.py

@@ -17,7 +17,9 @@ 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:
@@ -148,11 +150,15 @@ 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")
@@ -200,7 +206,10 @@ 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",
@@ -243,7 +252,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))
@@ -271,10 +280,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")
@@ -287,10 +296,8 @@ 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,11 +15,15 @@ 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

@@ -15,7 +15,9 @@ 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:
@@ -111,7 +113,9 @@ 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:
@@ -175,7 +179,8 @@ 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
@@ -187,11 +192,6 @@ class SandboxProcess(SandboxAction):
             if "on_log" in process:
                 on_log = process["on_log"]
                 del process["on_log"]
-            if "wait_for_completion" in process:
-                process["waitForCompletion"] = process["wait_for_completion"]
-            if "wait_for_ports" in process:
-                process["waitForPorts"] = process["wait_for_ports"]
-                del process["wait_for_ports"]
             process = ProcessRequest.from_dict(process)
 
         # Store original wait_for_completion setting
@@ -200,13 +200,14 @@ 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:
@@ -227,7 +228,8 @@ 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
@@ -255,6 +257,7 @@ class SandboxProcess(SandboxAction):
 
     async def get(self, identifier: str) -> ProcessResponse:
         import json
+
         client = self.get_client()
         response = await client.get(f"/process/{identifier}")
         try:
@@ -266,6 +269,7 @@ class SandboxProcess(SandboxAction):
 
     async def list(self) -> list[ProcessResponse]:
         import json
+
         client = self.get_client()
         response = await client.get("/process")
         try:
@@ -277,6 +281,7 @@ class SandboxProcess(SandboxAction):
 
     async def stop(self, identifier: str) -> SuccessResponse:
         import json
+
         client = self.get_client()
         response = await client.delete(f"/process/{identifier}")
         try:
@@ -288,6 +293,7 @@ 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:
@@ -298,9 +304,12 @@ 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,26 +105,32 @@ 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__)
                 )
             )
         ):
+            config: SandboxCreateConfiguration
             if sandbox is None:
-                sandbox = SandboxCreateConfiguration()
+                config = SandboxCreateConfiguration()
             elif isinstance(sandbox, dict) and not isinstance(sandbox, Sandbox):
-                sandbox = SandboxCreateConfiguration.from_dict(sandbox)
+                config = SandboxCreateConfiguration.from_dict(sandbox)
+            elif isinstance(sandbox, SandboxCreateConfiguration):
+                config = sandbox
+            else:
+                raise ValueError(f"Unexpected sandbox type: {type(sandbox)}")
 
             # Set defaults if not provided
-            name = sandbox.name or default_name
-            image = sandbox.image or default_image
-            memory = sandbox.memory or default_memory
-            ports = sandbox._normalize_ports() or UNSET
-            envs = sandbox._normalize_envs() or UNSET
-            volumes = sandbox._normalize_volumes() or UNSET
-            ttl = sandbox.ttl
-            expires = sandbox.expires
-            region = sandbox.region
-            lifecycle = sandbox.lifecycle
+            name = config.name or default_name
+            image = config.image or default_image
+            memory = config.memory or default_memory
+            ports = config._normalize_ports() or UNSET
+            envs = config._normalize_envs() or UNSET
+            volumes = config._normalize_volumes() or UNSET
+            ttl = config.ttl
+            expires = config.expires
+            region = config.region
+            lifecycle = config.lifecycle
             # snapshot_enabled = sandbox.snapshot_enabled
 
             # Create full Sandbox object
@@ -132,7 +138,11 @@ 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,5 +15,3 @@ __all__ = [
     "SyncSandboxCodegen",
     "SyncCodeInterpreter",
 ]
-
-

blaxel/core/sandbox/sync/action.py

@@ -51,7 +51,8 @@ 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,
@@ -61,5 +62,3 @@ 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,9 +20,7 @@ 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,
@@ -66,5 +64,3 @@ class SyncSandboxCodegen(SyncSandboxAction):
             if isinstance(response, ErrorResponse):
                 raise Exception(f"Reranking failed: {response}")
             return response
-
-

blaxel/core/sandbox/sync/filesystem.py

@@ -61,7 +61,11 @@ 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}"
@@ -195,7 +199,10 @@ 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("/"):
@@ -244,7 +251,9 @@ 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}
@@ -261,7 +270,9 @@ 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:
@@ -274,8 +285,10 @@ 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
@@ -298,5 +311,3 @@ 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,7 +15,9 @@ 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":
@@ -221,7 +223,10 @@ 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",
@@ -238,7 +243,9 @@ 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:
@@ -270,7 +277,6 @@ class SyncCodeInterpreter(SyncSandboxInstance):
         if cwd:
             data["cwd"] = cwd
 
-
         with self.process.get_client() as client:
             response = client.post(
                 "/port/8888/contexts",
@@ -283,5 +289,3 @@ class SyncCodeInterpreter(SyncSandboxInstance):
                 raise RuntimeError(details)
             data = response.json()
             return SyncCodeInterpreter.Context.from_json(data)
-
-

blaxel/core/sandbox/sync/network.py

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