blaxel 0.2.26rc119__py3-none-any.whl → 0.2.27__py3-none-any.whl

blaxel/core/sandbox/client/models/__init__.py

@@ -2,8 +2,6 @@
 
 from .apply_edit_request import ApplyEditRequest
 from .apply_edit_response import ApplyEditResponse
-from .content_search_match import ContentSearchMatch
-from .content_search_response import ContentSearchResponse
 from .delete_network_process_pid_monitor_response_200 import (
     DeleteNetworkProcessPidMonitorResponse200,
 )
@@ -15,10 +13,6 @@ from .file_with_content import FileWithContent
 from .filesystem_multipart_upload import FilesystemMultipartUpload
 from .filesystem_multipart_upload_parts import FilesystemMultipartUploadParts
 from .filesystem_uploaded_part import FilesystemUploadedPart
-from .find_match import FindMatch
-from .find_response import FindResponse
-from .fuzzy_search_match import FuzzySearchMatch
-from .fuzzy_search_response import FuzzySearchResponse
 from .get_network_process_pid_ports_response_200 import GetNetworkProcessPidPortsResponse200
 from .multipart_complete_request import MultipartCompleteRequest
 from .multipart_initiate_request import MultipartInitiateRequest
@@ -39,15 +33,11 @@ from .ranked_file import RankedFile
 from .reranking_response import RerankingResponse
 from .subdirectory import Subdirectory
 from .success_response import SuccessResponse
-from .tree_request import TreeRequest
-from .tree_request_files import TreeRequestFiles
 from .welcome_response import WelcomeResponse
 
 __all__ = (
     "ApplyEditRequest",
     "ApplyEditResponse",
-    "ContentSearchMatch",
-    "ContentSearchResponse",
     "DeleteNetworkProcessPidMonitorResponse200",
     "Directory",
     "ErrorResponse",
@@ -57,10 +47,6 @@ __all__ = (
     "FilesystemMultipartUploadParts",
     "FilesystemUploadedPart",
     "FileWithContent",
-    "FindMatch",
-    "FindResponse",
-    "FuzzySearchMatch",
-    "FuzzySearchResponse",
     "GetNetworkProcessPidPortsResponse200",
     "MultipartCompleteRequest",
     "MultipartInitiateRequest",
@@ -81,7 +67,5 @@ __all__ = (
     "RerankingResponse",
     "Subdirectory",
     "SuccessResponse",
-    "TreeRequest",
-    "TreeRequestFiles",
     "WelcomeResponse",
 )

blaxel/core/sandbox/default/action.py

@@ -1,7 +1,5 @@
 
-import os
 import httpx
-from contextlib import asynccontextmanager
 
 from ...common.internal import get_forced_url, get_global_unique_hash
 from ...common.settings import settings
@@ -11,7 +9,6 @@ from ..types import ResponseError, SandboxConfiguration
 class SandboxAction:
     def __init__(self, sandbox_config: SandboxConfiguration):
         self.sandbox_config = sandbox_config
-        self._client: httpx.AsyncClient | None = None
 
     @property
     def name(self) -> str:
@@ -46,8 +43,8 @@ class SandboxAction:
             url = self.forced_url
             return url[:-1] if url.endswith("/") else url
         # Uncomment when mk3 is fully available
-        if settings.run_internal_hostname:
-            return self.internal_url
+        # if settings.run_internal_hostname:
+        #     return self.internal_url
         return self.external_url
 
     @property
@@ -57,29 +54,15 @@ class SandboxAction:
         return None
 
     def get_client(self) -> httpx.AsyncClient:
-        """Get persistent HTTP client for this sandbox instance."""
-        if self._client is None:
-            base_url = self.sandbox_config.force_url or self.url
-            
-            # Build headers
-            if self.sandbox_config.force_url:
-                headers = self.sandbox_config.headers.copy()
-            else:
-                headers = {**settings.headers, **self.sandbox_config.headers}
-            
-            # Add X-Blaxel-Workspace header if BL_WORKSPACE env var is present
-            bl_workspace = os.environ.get("BL_WORKSPACE")
-            if bl_workspace:
-                headers["X-Blaxel-Workspace"] = bl_workspace
-            
-            self._client = httpx.AsyncClient(
-                base_url=base_url,
-                headers=headers,
-                http2=False,
-                limits=httpx.Limits(max_connections=100, max_keepalive_connections=20),
-                timeout=httpx.Timeout(300.0, connect=10.0),
+        if self.sandbox_config.force_url:
+            return httpx.AsyncClient(
+                base_url=self.sandbox_config.force_url, headers=self.sandbox_config.headers
             )
-        return self._client
+        # Create a new client instance each time to avoid "Cannot open a client instance more than once" error
+        return httpx.AsyncClient(
+            base_url=self.url,
+            headers={**settings.headers, **self.sandbox_config.headers},
+        )
 
     def handle_response_error(self, response: httpx.Response):
         if not response.is_success:

blaxel/core/sandbox/default/filesystem.py

@@ -31,14 +31,10 @@ class SandboxFileSystem(SandboxAction):
         path = self.format_path(path)
         body = FileRequest(is_directory=True, permissions=permissions)
 
-        client = self.get_client()
-        response = await client.put(f"/filesystem/{path}", json=body.to_dict())
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.put(f"/filesystem/{path}", json=body.to_dict())
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def write(self, path: str, content: str) -> SuccessResponse:
         path = self.format_path(path)
@@ -54,14 +50,10 @@ class SandboxFileSystem(SandboxAction):
         # Use regular upload for small files
         body = FileRequest(content=content)
 
-        client = self.get_client()
-        response = await client.put(f"/filesystem/{path}", json=body.to_dict())
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.put(f"/filesystem/{path}", json=body.to_dict())
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def write_binary(self, path: str, content: Union[bytes, bytearray, str]) -> SuccessResponse:
         """Write binary content to a file.
@@ -101,16 +93,13 @@ class SandboxFileSystem(SandboxAction):
         url = f"{self.url}/filesystem/{path}"
         headers = {**settings.headers, **self.sandbox_config.headers}
 
-        client = self.get_client()
-        response = await client.put(url, files=files, data=data, headers=headers)
-        try:
-            content_bytes = await response.aread()
+        async with self.get_client() as client_instance:
+            response = await client_instance.put(url, files=files, data=data, headers=headers)
+
             if not response.is_success:
-                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:
-            await response.aclose()
+                raise Exception(f"Failed to write binary: {response.status_code} {response.text}")
+
+            return SuccessResponse.from_dict(response.json())
 
     async def write_tree(
         self,
@@ -126,32 +115,26 @@ class SandboxFileSystem(SandboxAction):
 
         path = destination_path or ""
 
-        client = self.get_client()
-        response = await client.put(
-            f"/filesystem/tree/{path}",
-            json={"files": files_dict},
-            headers={"Content-Type": "application/json"},
-        )
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.put(
+                f"/filesystem/tree/{path}",
+                json={"files": files_dict},
+                headers={"Content-Type": "application/json"},
+            )
             self.handle_response_error(response)
-            return Directory.from_dict(data)
-        finally:
-            await response.aclose()
+            return Directory.from_dict(response.json())
 
     async def read(self, path: str) -> str:
         path = self.format_path(path)
 
-        client = self.get_client()
-        response = await client.get(f"/filesystem/{path}")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.get(f"/filesystem/{path}")
             self.handle_response_error(response)
+
+            data = response.json()
             if "content" in data:
                 return data["content"]
             raise Exception("Unsupported file type")
-        finally:
-            await response.aclose()
 
     async def read_binary(self, path: str) -> bytes:
         """Read binary content from a file.
@@ -171,14 +154,10 @@ class SandboxFileSystem(SandboxAction):
             "Accept": "application/octet-stream",
         }
 
-        client = self.get_client()
-        response = await client.get(url, headers=headers)
-        try:
-            content = await response.aread()
+        async with self.get_client() as client_instance:
+            response = await client_instance.get(url, headers=headers)
             self.handle_response_error(response)
-            return content
-        finally:
-            await response.aclose()
+            return response.content
 
     async def download(self, src: str, destination_path: str, mode: int = 0o644) -> None:
         """Download a file from the sandbox to the local filesystem.
@@ -196,125 +175,23 @@ class SandboxFileSystem(SandboxAction):
     async def rm(self, path: str, recursive: bool = False) -> SuccessResponse:
         path = self.format_path(path)
 
-        client = self.get_client()
-        params = {"recursive": "true"} if recursive else {}
-        response = await client.delete(f"/filesystem/{path}", params=params)
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            params = {"recursive": "true"} if recursive else {}
+            response = await client_instance.delete(f"/filesystem/{path}", params=params)
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def ls(self, path: str) -> Directory:
         path = self.format_path(path)
 
-        client = self.get_client()
-        response = await client.get(f"/filesystem/{path}")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.get(f"/filesystem/{path}")
             self.handle_response_error(response)
+
+            data = response.json()
             if not ("files" in data or "subdirectories" in data):
                 raise Exception('{"error": "Directory not found"}')
             return Directory.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
-
-        client = self.get_client()
-        response = await client.get(f"/filesystem-find/{path}", params=params)
-        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()
-
-    async def grep(
-        self,
-        query: str,
-        path: str = "/",
-        case_sensitive: bool | None = None,
-        context_lines: int | None = None,
-        max_results: int | None = None,
-        file_pattern: str | None = None,
-        exclude_dirs: List[str] | None = None,
-    ):
-        """Search for text content inside files using ripgrep.
-
-        Args:
-            query: Text to search for
-            path: Directory path to search in
-            case_sensitive: Case sensitive search (default: false)
-            context_lines: Number of context lines to include (default: 0)
-            max_results: Maximum number of results to return (default: 100)
-            file_pattern: File pattern to include (e.g., '*.py')
-            exclude_dirs: Directory names to skip
-
-        Returns:
-            ContentSearchResponse with matching lines
-        """
-        path = self.format_path(path)
-        
-        params = {'query': query}
-        if case_sensitive is not None:
-            params['caseSensitive'] = case_sensitive
-        if context_lines is not None:
-            params['contextLines'] = context_lines
-        if max_results is not None:
-            params['maxResults'] = max_results
-        if file_pattern is not None:
-            params['filePattern'] = file_pattern
-        if exclude_dirs is not None and len(exclude_dirs) > 0:
-            params['excludeDirs'] = ','.join(exclude_dirs)
-
-        client = self.get_client()
-        response = await client.get(f"/filesystem-content-search/{path}", params=params)
-        try:
-            data = json.loads(await response.aread())
-            self.handle_response_error(response)
-                
-            from ..client.models.content_search_response import ContentSearchResponse
-            return ContentSearchResponse.from_dict(data)
-        finally:
-            await response.aclose()
 
     async def cp(self, source: str, destination: str, max_wait: int = 180000) -> CopyResponse:
         """Copy files or directories using the cp command.
@@ -448,14 +325,10 @@ class SandboxFileSystem(SandboxAction):
         headers = {**settings.headers, **self.sandbox_config.headers}
         body = {"permissions": permissions}
 
-        client = self.get_client()
-        response = await client.post(url, json=body, headers=headers)
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.post(url, json=body, headers=headers)
             self.handle_response_error(response)
-            return data
-        finally:
-            await response.aclose()
+            return response.json()
 
     async def _upload_part(
         self, upload_id: str, part_number: int, data: bytes
@@ -468,16 +341,12 @@ class SandboxFileSystem(SandboxAction):
         # Prepare multipart form data with the file chunk
         files = {"file": ("part", io.BytesIO(data), "application/octet-stream")}
 
-        client = self.get_client()
-        response = await client.put(
-            url, files=files, params=params, headers=headers
-        )
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.put(
+                url, files=files, params=params, headers=headers
+            )
             self.handle_response_error(response)
-            return data
-        finally:
-            await response.aclose()
+            return response.json()
 
     async def _complete_multipart_upload(
         self, upload_id: str, parts: List[Dict[str, Any]]
@@ -487,28 +356,21 @@ class SandboxFileSystem(SandboxAction):
         headers = {**settings.headers, **self.sandbox_config.headers}
         body = {"parts": parts}
 
-        client = self.get_client()
-        response = await client.post(url, json=body, headers=headers)
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.post(url, json=body, headers=headers)
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def _abort_multipart_upload(self, upload_id: str) -> None:
         """Abort a multipart upload and clean up all parts."""
         url = f"{self.url}/filesystem-multipart/{upload_id}/abort"
         headers = {**settings.headers, **self.sandbox_config.headers}
 
-        client = self.get_client()
-        response = await client.delete(url, headers=headers)
-        try:
+        async with self.get_client() as client_instance:
+            response = await client_instance.delete(url, headers=headers)
             # Don't raise error if abort fails - we want to throw the original error
             if not response.is_success:
                 print(f"Warning: Failed to abort multipart upload: {response.status_code}")
-        finally:
-            await response.aclose()
 
     async def _upload_with_multipart(
         self, path: str, data: bytes, permissions: str = "0644"

blaxel/core/sandbox/default/interpreter.py

@@ -198,55 +198,55 @@ class CodeInterpreter(SandboxInstance):
 
         execution = CodeInterpreter.Execution()
 
-        client = self.process.get_client()
-        timeout_cfg = httpx.Timeout(
-            connect=connect_timeout, read=read_timeout, write=write_timeout, pool=pool_timeout
-        )
-        async with client.stream(
-            "POST",
-            "/port/8888/execute",
-            json=body,
-            timeout=timeout_cfg,
-        ) as response:
-            if response.status_code >= 400:
-                try:
-                    body_text = await response.aread()
-                    body_text = body_text.decode(errors="ignore")
-                except Exception:
-                    body_text = "<unavailable>"
-                req = getattr(response, "request", None)
-                method = getattr(req, "method", "UNKNOWN") if req else "UNKNOWN"
-                url = str(getattr(req, "url", "UNKNOWN")) if req else "UNKNOWN"
-                reason = getattr(response, "reason_phrase", "")
-                details = (
-                    "Execution failed\n"
-                    f"- method: {method}\n- url: {url}\n- status: {response.status_code} {reason}\n"
-                    f"- response-headers: {dict(response.headers)}\n- body:\n{body_text}"
-                )
-                self.logger.debug(details)
-                raise RuntimeError(details)
-
-            async for line in response.aiter_lines():
-                if not line:
-                    continue
-                try:
-                    decoded = line
-                except Exception:
-                    decoded = str(line)
-                try:
-                    self._parse_output(
-                        execution,
-                        decoded,
-                        on_stdout=on_stdout,
-                        on_stderr=on_stderr,
-                        on_result=on_result,
-                        on_error=on_error,
+        async with self.process.get_client() as client:
+            timeout_cfg = httpx.Timeout(
+                connect=connect_timeout, read=read_timeout, write=write_timeout, pool=pool_timeout
+            )
+            async with client.stream(
+                "POST",
+                "/port/8888/execute",
+                json=body,
+                timeout=timeout_cfg,
+            ) as response:
+                if response.status_code >= 400:
+                    try:
+                        body_text = await response.aread()
+                        body_text = body_text.decode(errors="ignore")
+                    except Exception:
+                        body_text = "<unavailable>"
+                    req = getattr(response, "request", None)
+                    method = getattr(req, "method", "UNKNOWN") if req else "UNKNOWN"
+                    url = str(getattr(req, "url", "UNKNOWN")) if req else "UNKNOWN"
+                    reason = getattr(response, "reason_phrase", "")
+                    details = (
+                        "Execution failed\n"
+                        f"- method: {method}\n- url: {url}\n- status: {response.status_code} {reason}\n"
+                        f"- response-headers: {dict(response.headers)}\n- body:\n{body_text}"
                     )
-                except json.JSONDecodeError:
+                    self.logger.debug(details)
+                    raise RuntimeError(details)
+
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    try:
+                        decoded = line
+                    except Exception:
+                        decoded = str(line)
+                    try:
+                        self._parse_output(
+                            execution,
+                            decoded,
+                            on_stdout=on_stdout,
+                            on_stderr=on_stderr,
+                            on_result=on_result,
+                            on_error=on_error,
+                        )
+                    except json.JSONDecodeError:
                         # Fallback: treat as stdout text-only message
-                    execution.logs.stdout.append(decoded)
-                    if on_stdout:
-                        on_stdout(CodeInterpreter.OutputMessage(decoded, None, False))
+                        execution.logs.stdout.append(decoded)
+                        if on_stdout:
+                            on_stdout(CodeInterpreter.OutputMessage(decoded, None, False))
 
         return execution
 
@@ -262,19 +262,15 @@ class CodeInterpreter(SandboxInstance):
         if cwd:
             data["cwd"] = cwd
 
-        client = self.process.get_client()
-        response = await client.post(
-            "/port/8888/contexts",
-            json=data,
-            timeout=request_timeout or 10.0,
-        )
-        try:
-            # Always read response body first
-            body_bytes = await response.aread()
-            
+        async with self.process.get_client() as client:
+            response = await client.post(
+                "/port/8888/contexts",
+                json=data,
+                timeout=request_timeout or 10.0,
+            )
             if response.status_code >= 400:
                 try:
-                    body_text = body_bytes.decode('utf-8', errors='ignore')
+                    body_text = response.text
                 except Exception:
                     body_text = "<unavailable>"
                 method = getattr(response.request, "method", "UNKNOWN")
@@ -287,10 +283,7 @@ class CodeInterpreter(SandboxInstance):
                 )
                 self.logger.debug(details)
                 raise RuntimeError(details)
-            
-            data = json.loads(body_bytes)
+            data = response.json()
             return CodeInterpreter.Context.from_json(data)
-        finally:
-            await response.aclose()