blaxel 0.2.1rc71__tar.gz → 0.2.1rc73__tar.gz

{blaxel-0.2.1rc71 → blaxel-0.2.1rc73}/PKG-INFO

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

{blaxel-0.2.1rc71 → blaxel-0.2.1rc73}/pyproject.toml

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

{blaxel-0.2.1rc71 → blaxel-0.2.1rc73}/src/blaxel/core/sandbox/process.py

@@ -10,6 +10,21 @@ from .client.models.process_request import ProcessRequest
 from .types import SandboxConfiguration
 
 
+class ProcessResponseWithLogs(ProcessResponse):
+    """Extended ProcessResponse that adds a logs property."""
+
+    logs: Optional[str] = None
+
+    @classmethod
+    def from_process_response(cls, process_response: ProcessResponse, logs: Optional[str] = None):
+        """Create ProcessResponseWithLogs from an existing ProcessResponse."""
+        # Create a new instance from the dict representation
+        instance = cls.from_dict(process_response.to_dict())
+        # Add the logs
+        instance.logs = logs
+        return instance
+
+
 class SandboxProcess(SandboxAction):
     def __init__(self, sandbox_config: SandboxConfiguration):
         super().__init__(sandbox_config)
@@ -75,16 +90,56 @@ class SandboxProcess(SandboxAction):
 
         return {"close": close}
 
-    async def exec(self, process: Union[ProcessRequest, Dict[str, Any]]) -> ProcessResponse:
+    async def exec(
+        self,
+        process: Union[ProcessRequest, Dict[str, Any]],
+        on_log: Optional[Callable[[str], None]] = None,
+    ) -> ProcessResponseWithLogs:
         if isinstance(process, dict):
             process = ProcessRequest.from_dict(process)
 
         async with self.get_client() as client_instance:
             response = await client_instance.post("/process", json=process.to_dict())
-            self.handle_response_error(
-                response, response.json() if response.content else None, None
-            )
-            return ProcessResponse.from_dict(response.json())
+
+            # 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, None, None)
+                    raise
+
+            self.handle_response_error(response, response_data, None)
+            result = ProcessResponse.from_dict(response_data)
+
+            # Setup log streaming if on_log is provided
+            stream_control = None
+            if on_log is not None:
+                stream_control = self.stream_logs(result.pid, {"on_log": on_log})
+
+            # Wait for completion if requested
+            logs = None
+            if process.wait_for_completion:
+                try:
+                    # Wait for process to complete
+                    result = await self.wait(result.pid)
+
+                    # Get the logs
+                    logs = await self.logs(result.pid, "all")
+                except Exception as e:
+                    # If waiting fails, still try to return what we have
+                    if stream_control:
+                        stream_control["close"]()
+                    raise e
+
+            # Close stream if it was opened and we're done
+            if stream_control and process.wait_for_completion:
+                stream_control["close"]()
+
+            # Return wrapped response with logs
+            return ProcessResponseWithLogs.from_process_response(result, logs)
 
     async def wait(
         self, identifier: str, max_wait: int = 60000, interval: int = 1000

{blaxel-0.2.1rc71 → blaxel-0.2.1rc73}/src/blaxel/core/sandbox/sandbox.py

@@ -82,6 +82,8 @@ class SandboxInstance:
         if not sandbox.spec.runtime:
             sandbox.spec.runtime = Runtime(image="blaxel/prod-base:latest")
 
+        sandbox.spec.runtime.image = sandbox.spec.runtime.image or "blaxel/prod-base:latest"
+        sandbox.spec.runtime.memory = sandbox.spec.runtime.memory or 4096
         sandbox.spec.runtime.generation = sandbox.spec.runtime.generation or "mk3"
 
         response = await create_sandbox(

blaxel-0.2.1rc73/tests/integration/sandbox/process.py

@@ -0,0 +1,215 @@
+import asyncio
+from logging import getLogger
+
+from utils import create_or_get_sandbox
+
+from blaxel.core.sandbox import SandboxInstance
+from blaxel.core.sandbox.client.models.process_request import ProcessRequest
+
+logger = getLogger(__name__)
+
+SANDBOX_NAME = "sandbox-test-python-process-features"
+
+
+async def test_wait_for_completion_with_logs(sandbox: SandboxInstance):
+    """Test exec with wait_for_completion parameter that retrieves logs."""
+    print("🔧 Testing wait_for_completion with logs...")
+
+    # Create a process that outputs some logs
+    process_request = ProcessRequest(
+        name="wait-completion-test",
+        command='sh -c "echo Starting process; echo This is stdout; echo This is stderr >&2; sleep 2; echo Process completed"',
+        wait_for_completion=True,
+    )
+
+    # Execute with wait_for_completion=True
+    response = await sandbox.process.exec(process_request)
+
+    # Check that we got the response
+    assert response is not None
+    assert response.name == "wait-completion-test"
+    assert response.status is not None  # Should have a status
+
+    # Check that logs were added to the response
+    assert hasattr(response, "logs")
+    assert response.logs is not None
+    logs = response.logs
+    assert isinstance(logs, str)
+    assert len(logs) > 0
+
+    # Verify log content
+    assert "Starting process" in logs
+    assert "This is stdout" in logs
+    assert "This is stderr" in logs
+    assert "Process completed" in logs
+
+    print(f"✅ Process completed with status: {response.status}")
+    print(f"✅ Retrieved logs (length: {len(logs)} chars)")
+    print(f"   First 100 chars: {logs[:100]}...")
+
+
+async def test_on_log_callback(sandbox: SandboxInstance):
+    """Test exec with on_log callback parameter."""
+    print("🔧 Testing on_log callback...")
+
+    # Create a list to collect log messages
+    log_messages = []
+
+    def log_collector(message: str):
+        log_messages.append(message)
+        print(f"   📝 Log received: {message!r}")  # Show repr to see exact content
+
+    # Create a process that outputs logs over time
+    process_request = ProcessRequest(
+        command='sh -c "echo First message; sleep 1; echo Second message; sleep 1; echo Third message"'
+    )
+
+    # Execute with on_log callback (name will be auto-generated)
+    response = await sandbox.process.exec(process_request, on_log=log_collector)
+
+    # Check that a name was generated
+    assert response.name is not None
+    assert response.name.startswith("proc-")
+    print(f"✅ Auto-generated process name: {response.name}")
+
+    # Wait for the process to complete and logs to be collected
+    await sandbox.process.wait(response.name)
+
+    # Give a bit more time for final logs to arrive
+    await asyncio.sleep(2)
+
+    # Check that we received log messages
+    assert len(log_messages) > 0
+    print(f"✅ Received {len(log_messages)} log messages")
+
+    # Join all messages to check content
+    all_logs = " ".join(log_messages)
+
+    # Verify we got expected messages
+    assert "First message" in all_logs
+    assert "Second message" in all_logs
+    assert "Third message" in all_logs
+
+    print("✅ Log callback test completed successfully")
+
+
+async def test_combined_features(sandbox: SandboxInstance):
+    """Test using both wait_for_completion and on_log together."""
+    print("🔧 Testing combined wait_for_completion and on_log...")
+
+    # Create a list to collect real-time logs
+    realtime_logs = []
+
+    def realtime_collector(message: str):
+        realtime_logs.append(message)
+
+    # Create a process with a specific name
+    process_request = ProcessRequest(
+        name="combined-test",
+        command='sh -c "echo Starting combined test; sleep 1; echo Middle of test; sleep 1; echo Test completed"',
+        wait_for_completion=True,
+    )
+
+    # Execute with both features
+    response = await sandbox.process.exec(process_request, on_log=realtime_collector)
+
+    # Check the response
+    assert response.name == "combined-test"
+    assert response.status is not None
+
+    # Check that we got logs in the response
+    assert hasattr(response, "logs")
+    final_logs = response.logs
+
+    # Check that we got real-time logs
+    assert len(realtime_logs) > 0
+
+    print(f"✅ Process completed with status: {response.status}")
+    print(f"✅ Real-time logs collected: {len(realtime_logs)} messages")
+    print(f"✅ Final logs in response: {len(final_logs)} chars")
+
+    # Verify content
+    assert "Starting combined test" in final_logs
+    assert "Test completed" in final_logs
+
+    # Real-time logs should also contain the messages
+    all_realtime = " ".join(realtime_logs)
+    assert "Starting combined test" in all_realtime
+    assert "Middle of test" in all_realtime
+    assert "Test completed" in all_realtime
+
+
+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...")
+
+    log_count = 0
+
+    def count_logs(message: str):
+        nonlocal log_count
+        log_count += 1
+
+    # Process without name
+    process_dict = {"command": "echo 'Testing auto name generation'"}
+
+    # Execute with on_log (should auto-generate name)
+    response = await sandbox.process.exec(process_dict, on_log=count_logs)
+
+    # Check that name was generated
+    assert response.name is not None
+    assert response.name.startswith("proc-")
+    assert len(response.name) > len("proc-")  # Should have UUID suffix
+
+    print(f"✅ Auto-generated name: {response.name}")
+
+    # Wait a bit for logs
+    await asyncio.sleep(2)
+
+    # Should have received at least one log
+    assert log_count > 0
+    print(f"✅ Received {log_count} log messages")
+
+
+async def main():
+    """Main test function for new process features."""
+    print("🚀 Starting sandbox process feature tests...")
+
+    try:
+        # Create or get sandbox
+        sandbox = await create_or_get_sandbox(SANDBOX_NAME)
+        print(f"✅ Sandbox ready: {sandbox.metadata.name}")
+
+        # Wait for sandbox to be deployed
+        await sandbox.wait()
+        print("✅ Sandbox deployed successfully")
+        await sandbox.fs.ls("/blaxel")
+        # Run tests
+        await test_wait_for_completion_with_logs(sandbox)
+        print()
+
+        await test_on_log_callback(sandbox)
+        print()
+
+        await test_combined_features(sandbox)
+        print()
+
+        await test_on_log_without_name(sandbox)
+        print()
+
+        print("🎉 All process feature tests completed successfully!")
+
+    except Exception as e:
+        print(f"❌ Process feature test failed with error: {e}")
+        logger.exception("Process feature test error")
+        raise
+    finally:
+        print("🧹 Cleaning up...")
+        try:
+            await SandboxInstance.delete(SANDBOX_NAME)
+            print("✅ Sandbox deleted")
+        except Exception as e:
+            print(f"⚠️ Failed to delete sandbox: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())