blaxel 0.2.7rc84__tar.gz → 0.2.7rc85__tar.gz

{blaxel-0.2.7rc84 → blaxel-0.2.7rc85}/PKG-INFO

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

{blaxel-0.2.7rc84 → blaxel-0.2.7rc85}/pyproject.toml

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

{blaxel-0.2.7rc84 → blaxel-0.2.7rc85}/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.7rc84 → blaxel-0.2.7rc85}/src/blaxel/core/sandbox/process.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Callable, Dict, Literal, Optional, Union
+from typing import Callable, Dict, Literal, Optional, Union
 
 import httpx
 
@@ -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):
@@ -76,25 +76,14 @@ class SandboxProcess(SandboxAction):
         return {"close": close}
 
     async def exec(
-        self, process: Union[ProcessRequest, ProcessRequestWithLog, Dict[str, Any]]
-    ) -> ProcessResponse:
-        on_log = None
-        if isinstance(process, ProcessRequestWithLog):
+        self, process: Union[ProcessRequest, ProcessRequestWithLog]
+    ) -> Union[ProcessResponse, ProcessResponseWithLog]:
+        """Execute a process in the sandbox."""
+        on_log: Optional[Callable[[str], None]] = None
+        if isinstance(process, ProcessRequestWithLog) and process.on_log:
             on_log = process.on_log
-            process = process.to_dict()
-
-        if isinstance(process, dict):
-            if "on_log" in process:
-                on_log = process["on_log"]
-                del process["on_log"]
-            process = ProcessRequest.from_dict(process)
-
-        # Store original wait_for_completion setting
-        should_wait_for_completion = process.wait_for_completion
 
-        # 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
+        should_wait_for_completion = getattr(process, "wait_for_completion", True)
 
         async with self.get_client() as client_instance:
             response = await client_instance.post("/process", json=process.to_dict())
@@ -118,7 +107,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 +115,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.7rc84 → blaxel-0.2.7rc85}/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.7rc84 → blaxel-0.2.7rc85}/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: