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

blaxel/core/sandbox/default/process.py

@@ -200,37 +200,40 @@ 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()
+        async with self.get_client() as client_instance:
+            response = await client_instance.post("/process", json=process.to_dict())
+            # Parse JSON response only once, with better error handling
+            response_data = None
+            if response.content:
+                try:
+                    response_data = response.json()
+                except Exception:
+                    # If JSON parsing fails, check the response first
+                    self.handle_response_error(response)
+                    raise
+
             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:
-            await response.aclose()
 
-        # Handle wait_for_completion with parallel log streaming
-        if should_wait_for_completion and on_log is not None:
-            stream_control = self._stream_logs(result.pid, {"on_log": on_log})
-            try:
-                # Wait for process completion
-                result = await self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
-            finally:
-                # Clean up log streaming
-                if stream_control:
-                    stream_control["close"]()
-        else:
-            # For non-blocking execution, set up log streaming immediately if requested
-            if on_log is not None:
+            # Handle wait_for_completion with parallel log streaming
+            if should_wait_for_completion and 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
-                )
-
-        return result
+                try:
+                    # Wait for process completion
+                    result = await self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
+                finally:
+                    # Clean up log streaming
+                    if stream_control:
+                        stream_control["close"]()
+            else:
+                # For non-blocking execution, set up log streaming immediately if requested
+                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
+                    )
+
+            return result
 
     async def wait(
         self, identifier: str, max_wait: int = 60000, interval: int = 1000
@@ -254,58 +257,37 @@ class SandboxProcess(SandboxAction):
         return data
 
     async def get(self, identifier: str) -> ProcessResponse:
-        import json
-        client = self.get_client()
-        response = await client.get(f"/process/{identifier}")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.get(f"/process/{identifier}")
             self.handle_response_error(response)
-            return ProcessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return ProcessResponse.from_dict(response.json())
 
     async def list(self) -> list[ProcessResponse]:
-        import json
-        client = self.get_client()
-        response = await client.get("/process")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.get("/process")
             self.handle_response_error(response)
-            return [ProcessResponse.from_dict(item) for item in data]
-        finally:
-            await response.aclose()
+            return [ProcessResponse.from_dict(item) for item in response.json()]
 
     async def stop(self, identifier: str) -> SuccessResponse:
-        import json
-        client = self.get_client()
-        response = await client.delete(f"/process/{identifier}")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.delete(f"/process/{identifier}")
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def kill(self, identifier: str) -> SuccessResponse:
-        import json
-        client = self.get_client()
-        response = await client.delete(f"/process/{identifier}/kill")
-        try:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.delete(f"/process/{identifier}/kill")
             self.handle_response_error(response)
-            return SuccessResponse.from_dict(data)
-        finally:
-            await response.aclose()
+            return SuccessResponse.from_dict(response.json())
 
     async def logs(
         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:
-            data = json.loads(await response.aread())
+        async with self.get_client() as client_instance:
+            response = await client_instance.get(f"/process/{identifier}/logs")
             self.handle_response_error(response)
+
+            data = response.json()
             if log_type == "all":
                 return data.get("logs", "")
             elif log_type == "stdout":
@@ -314,5 +296,3 @@ class SandboxProcess(SandboxAction):
                 return data.get("stderr", "")
 
             raise Exception("Unsupported log type")
-        finally:
-            await response.aclose()

blaxel/core/sandbox/sync/filesystem.py

@@ -1,5 +1,6 @@
 import io
 import json
+import logging
 import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Union
@@ -16,6 +17,8 @@ from ..types import (
 )
 from .action import SyncSandboxAction
 
+logger = logging.getLogger(__name__)
+
 # Multipart upload constants
 MULTIPART_THRESHOLD = 5 * 1024 * 1024  # 5MB
 CHUNK_SIZE = 5 * 1024 * 1024  # 5MB per part
@@ -256,7 +259,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
         with self.get_client() as client_instance:
             response = client_instance.delete(url, headers=headers)
             if not response.is_success:
-                print(f"Warning: Failed to abort multipart upload: {response.status_code}")
+                logger.warning(f"Failed to abort multipart upload: {response.status_code}")
 
     def _upload_with_multipart(self, path: str, data: bytes, permissions: str = "0644") -> SuccessResponse:
         init_response = self._initiate_multipart_upload(path, permissions)
@@ -293,7 +296,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             try:
                 self._abort_multipart_upload(upload_id)
             except Exception as abort_error:
-                print(f"Failed to abort multipart upload: {abort_error}")
+                logger.warning(f"Failed to abort multipart upload: {abort_error}")
             raise error
 
 

blaxel/googleadk/model.py

@@ -55,7 +55,6 @@ class AuthenticatedLiteLLMClient(LiteLLMClient):
 
 
 async def get_google_adk_model(url: str, type: str, model: str, **kwargs):
-    print("HEER TWO")
     llm_client = AuthenticatedLiteLLMClient()
     if type == "mistral":
         return LiteLlm(

blaxel/livekit/model.py

@@ -22,7 +22,6 @@ class DynamicHeadersHTTPClient(httpx.AsyncClient):
         auth_headers = settings.auth.get_headers()
         for key, value in auth_headers.items():
             request.headers[key] = value
-        print(request.__dict__)
         return await super().send(request, *args, **kwargs)
 
 

{blaxel-0.2.26rc119.dist-info → blaxel-0.2.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.26rc119
+Version: 0.2.28
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -10,7 +10,7 @@ Author-email: cploujoux <cploujoux@blaxel.ai>
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: attrs>=21.3.0
-Requires-Dist: httpx[http2]>=0.27.0
+Requires-Dist: httpx>=0.27.0
 Requires-Dist: mcp>=1.9.4
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pyjwt>=2.0.0