blaxel 0.2.8__tar.gz → 0.2.9__tar.gz

{blaxel-0.2.8 → blaxel-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.8
+Version: 0.2.9
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai

{blaxel-0.2.8 → blaxel-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.2.8"
+version = "0.2.9"
 description = "Blaxel - AI development platform SDK"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]

{blaxel-0.2.8 → blaxel-0.2.9}/src/blaxel/core/sandbox/__init__.py

@@ -8,6 +8,7 @@ from .sandbox import (
 from .types import (
     CopyResponse,
     ProcessRequestWithLog,
+    ProcessResponseWithLog,
     SandboxConfiguration,
     SandboxCreateConfiguration,
     SandboxFilesystemFile,
@@ -30,4 +31,5 @@ __all__ = [
     "SandboxPreviews",
     "SandboxProcess",
     "ProcessRequestWithLog",
+    "ProcessResponseWithLog",
 ]

{blaxel-0.2.8 → blaxel-0.2.9}/src/blaxel/core/sandbox/process.py

@@ -7,7 +7,7 @@ from ..common.settings import settings
 from .action import SandboxAction
 from .client.models import ProcessResponse, SuccessResponse
 from .client.models.process_request import ProcessRequest
-from .types import ProcessRequestWithLog, SandboxConfiguration
+from .types import ProcessRequestWithLog, ProcessResponseWithLog, SandboxConfiguration
 
 
 class SandboxProcess(SandboxAction):
@@ -77,7 +77,8 @@ class SandboxProcess(SandboxAction):
 
     async def exec(
         self, process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]]
-    ) -> ProcessResponse:
+    ) -> Union[ProcessResponse, ProcessResponseWithLog]:
+        """Execute a process in the sandbox."""
         on_log = None
         if isinstance(process, ProcessRequestWithLog):
             on_log = process.on_log
@@ -95,7 +96,6 @@ 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
-
         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
@@ -118,7 +118,7 @@ class SandboxProcess(SandboxAction):
                     stream_control = self.stream_logs(result.pid, {"on_log": on_log})
                 try:
                     # Wait for process completion
-                    result = await self.wait(result.pid, interval=50)
+                    result = await self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
                 finally:
                     # Clean up log streaming
                     if stream_control:
@@ -126,8 +126,11 @@ class SandboxProcess(SandboxAction):
             else:
                 # For non-blocking execution, set up log streaming immediately if requested
                 if on_log is not None:
-                    stream = self.stream_logs(result.pid, {"on_log": on_log})
-                    result.additional_properties["close"] = stream["close"]
+                    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(

{blaxel-0.2.8 → blaxel-0.2.9}/src/blaxel/core/sandbox/sandbox.py

@@ -47,7 +47,7 @@ class SandboxInstance:
     def spec(self):
         return self.sandbox.spec
 
-    async def wait(self, max_wait: int = 60000, interval: int = 1000) -> None:
+    async def wait(self, max_wait: int = 60000, interval: int = 1000) -> "SandboxInstance":
         start_time = time.time() * 1000  # Convert to milliseconds
         while self.sandbox.status != "DEPLOYED":
             await asyncio.sleep(interval / 1000)  # Convert to seconds
@@ -68,6 +68,17 @@ class SandboxInstance:
             if (time.time() * 1000) - start_time > max_wait:
                 raise Exception("Sandbox did not deploy in time")
 
+        if self.sandbox.status == "DEPLOYED":
+            try:
+                # This is a hack for sometime receiving a 502,
+                # need to remove this once we have a better way to handle this
+                await self.fs.ls("/")
+            except:
+                # pass
+                pass
+
+        return self
+
     @classmethod
     async def create(
         cls, sandbox: Union[Sandbox, SandboxCreateConfiguration, Dict[str, Any], None] = None
@@ -109,7 +120,9 @@ class SandboxInstance:
             sandbox = Sandbox(
                 metadata=Metadata(name=name),
                 spec=SandboxSpec(
-                    runtime=Runtime(image=image, memory=memory, ports=ports, envs=envs, generation="mk3")
+                    runtime=Runtime(
+                        image=image, memory=memory, ports=ports, envs=envs, generation="mk3"
+                    )
                 ),
             )
         else:

{blaxel-0.2.8 → blaxel-0.2.9}/src/blaxel/core/sandbox/types.py

@@ -6,6 +6,7 @@ from attrs import define as _attrs_define
 from ..client.models import Port, Sandbox
 from ..client.types import UNSET
 from .client.models.process_request import ProcessRequest
+from .client.models.process_response import ProcessResponse
 
 
 class SessionCreateOptions:
@@ -182,3 +183,26 @@ class SandboxCreateConfiguration:
 @_attrs_define
 class ProcessRequestWithLog(ProcessRequest):
     on_log: Callable[[str], None] = None
+
+
+class ProcessResponseWithLog:
+    """A process response with additional close functionality for stream management."""
+
+    def __init__(self, process_response: ProcessResponse, close_func: Callable[[], None]):
+        self._process_response = process_response
+        self._close_func = close_func
+
+    def close(self) -> None:
+        """Close the log stream without terminating the process."""
+        self._close_func()
+
+    def __getattr__(self, name: str) -> Any:
+        """Delegate attribute access to the underlying ProcessResponse."""
+        return getattr(self._process_response, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Handle setting attributes, preserving special attributes."""
+        if name.startswith("_") or name == "close":
+            super().__setattr__(name, value)
+        else:
+            setattr(self._process_response, name, value)

blaxel-0.2.9/tests/integration/sandbox/execfirst.py

@@ -0,0 +1,43 @@
+import asyncio
+import sys
+
+from utils import create_or_get_sandbox
+
+from blaxel.core.sandbox import SandboxInstance
+
+
+async def main():
+    """Test that validates the exec fix by creating multiple sandboxes and executing commands immediately."""
+    sandbox_created = []
+    try:
+        i = 0
+        while i < 10:
+            sandbox_name = f"next-js-{i}"
+            sandbox = await create_or_get_sandbox(sandbox_name=sandbox_name)
+
+            process = await sandbox.process.exec(
+                {
+                    "command": "echo 'Hello, world!'",
+                    "workingDir": "/blaxel",
+                    "waitForCompletion": True,
+                }
+            )
+
+            print(process.logs)
+            sandbox_created.append(sandbox_name)
+            i += 1
+
+    except Exception as e:
+        print(f"There was an error => {e}")
+    finally:
+        for sandbox_name in sandbox_created:
+            await SandboxInstance.delete(sandbox_name)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+        sys.exit(0)
+    except Exception as err:
+        print(f"There was an error => {err}")
+        sys.exit(1)

{blaxel-0.2.8 → blaxel-0.2.9}/tests/integration/sandbox/process.py

@@ -1,9 +1,14 @@
 import asyncio
+import time
 from logging import getLogger
 
 from utils import create_or_get_sandbox
 
-from blaxel.core.sandbox import ProcessRequestWithLog, SandboxInstance
+from blaxel.core.sandbox import (
+    ProcessRequestWithLog,
+    ProcessResponseWithLog,
+    SandboxInstance,
+)
 from blaxel.core.sandbox.client.models.process_request import ProcessRequest
 
 logger = getLogger(__name__)
@@ -142,34 +147,107 @@ async def test_combined_features(sandbox: SandboxInstance):
 
 
 async def test_on_log_without_name(sandbox: SandboxInstance):
-    """Test that on_log works when no name is provided (auto-generates name)."""
-    print("🔧 Testing on_log with auto-generated name...")
+    """Test on_log callback without specifying name (should generate one)."""
+    print("🔧 Testing on_log callback without name...")
 
-    log_count = 0
+    # Track logs
+    log_messages = []
 
-    def count_logs(message: str):
-        nonlocal log_count
-        log_count += 1
+    def log_collector(message: str):
+        log_messages.append(message)
+        print(f"   📝 Log received: {repr(message)}")
 
-    # Process without name
-    process_dict = {"command": "echo 'Testing auto name generation'", "on_log": count_logs}
+    # Create a process without specifying a name
+    process_request = ProcessRequestWithLog(
+        command='sh -c "echo Hello from unnamed process; echo Second message; sleep 1; echo Final message"',
+        wait_for_completion=True,
+        on_log=log_collector,
+    )
 
-    # Execute with on_log (should auto-generate name)
-    response = await sandbox.process.exec(process_dict)
+    # Execute
+    response = await sandbox.process.exec(process_request)
 
-    # Check that name was generated
+    # Check that a name was generated
     assert response.name is not None
-    assert response.name.startswith("proc-")
-    assert len(response.name) > len("proc-")  # Should have UUID suffix
+    assert len(response.name) > 0
 
-    print(f"✅ Auto-generated name: {response.name}")
+    # Check that we received logs
+    assert len(log_messages) > 0
+    all_logs = " ".join(log_messages)
+    assert "Hello from unnamed process" in all_logs
+    assert "Second message" in all_logs
+    assert "Final message" in all_logs
+
+    print(f"✅ Process completed with generated name: {response.name}")
+    print(f"✅ Received {len(log_messages)} log messages")
 
-    # Wait a bit for logs
+
+async def test_stream_close(sandbox: SandboxInstance):
+    """Test stream close functionality."""
+    print("🔧 Testing stream close functionality...")
+
+    # Track logs and when they stop
+    log_messages = []
+    last_log_time = time.time()
+    is_receiving_logs = True
+
+    def log_collector(message: str):
+        nonlocal last_log_time, is_receiving_logs
+        log_messages.append(message)
+        last_log_time = time.time()
+        is_receiving_logs = True
+        print(f"   📝 Log received at {time.time()}: {repr(message)}")
+
+    # Create a long-running process that outputs logs continuously
+    process_request = ProcessRequestWithLog(
+        name="stream-close-test",
+        command="sh -c 'for i in $(seq 1 5); do echo \"Hello from stdout $i\"; sleep 1; done'",
+        wait_for_completion=False,  # Important: don't wait for completion
+        on_log=log_collector,
+    )
+
+    # Execute and get response with close() method
+    response = await sandbox.process.exec(process_request)
+
+    # Check that we got a response with close method
+    assert isinstance(response, ProcessResponseWithLog), "Response should be ProcessResponseWithLog"
+    assert hasattr(response, "close"), "Response should have close() method"
+    assert callable(response.close), "close should be a function"
+
+    # Wait for a few logs to come in
     await asyncio.sleep(2)
 
-    # Should have received at least one log
-    assert log_count > 0
-    print(f"✅ Received {log_count} log messages")
+    # Should have received some logs by now
+    logs_before_close = len(log_messages)
+    assert logs_before_close > 0, "Should have received some logs before close"
+    print(f"✅ Received {logs_before_close} logs before closing")
+
+    # Close the stream
+    print("   🛑 Calling close() to stop the stream...")
+    response.close()
+
+    # Mark that we're no longer expecting logs
+    is_receiving_logs = False
+
+    # Wait a bit to ensure no more logs come in
+    logs_at_close = len(log_messages)
+    await asyncio.sleep(3)
+
+    # Check that no new logs were received after close
+    logs_after_close = len(log_messages)
+    assert logs_after_close == logs_at_close, (
+        f"No new logs should be received after close (before: {logs_at_close}, after: {logs_after_close})"
+    )
+
+    print(f"✅ Stream closed successfully. Total logs received: {len(log_messages)}")
+    print("✅ Process should still be running in background (not killed by close)")
+
+    # Verify the process is still running (close should only stop streaming, not kill the process)
+    try:
+        process_info = await sandbox.process.get(response.name)
+        print(f"✅ Process status after close: {process_info.status} -> {process_info.logs}")
+    except Exception as error:
+        print(f"⚠️ Could not check process status: {error}")
 
 
 async def main():
@@ -195,6 +273,9 @@ async def main():
         await test_on_log_without_name(sandbox)
         print()
 
+        await test_stream_close(sandbox)
+        print()
+
         print("🎉 All process feature tests completed successfully!")
 
     except Exception as e: