blaxel 0.2.1rc76__tar.gz → 0.2.1rc78__tar.gz

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/PKG-INFO

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

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/pyproject.toml

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

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/src/blaxel/core/sandbox/__init__.py

@@ -8,6 +8,7 @@ from .sandbox import (
 from .types import (
     CopyResponse,
     SandboxConfiguration,
+    SandboxCreateConfiguration,
     SandboxFilesystemFile,
     SessionCreateOptions,
     SessionWithToken,
@@ -19,6 +20,7 @@ __all__ = [
     "SessionCreateOptions",
     "SessionWithToken",
     "SandboxConfiguration",
+    "SandboxCreateConfiguration",
     "WatchEvent",
     "SandboxFilesystemFile",
     "CopyResponse",

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/src/blaxel/core/sandbox/sandbox.py

@@ -15,7 +15,7 @@ from .network import SandboxNetwork
 from .preview import SandboxPreviews
 from .process import SandboxProcess
 from .session import SandboxSessions
-from .types import SandboxConfiguration, SessionWithToken
+from .types import SandboxConfiguration, SandboxCreateConfiguration, SessionWithToken
 
 logger = logging.getLogger(__name__)
 
@@ -69,22 +69,53 @@ class SandboxInstance:
 
     @classmethod
     async def create(
-        cls, sandbox: Union[Sandbox, Dict[str, Any], None] = None
+        cls, sandbox: Union[Sandbox, SandboxCreateConfiguration, Dict[str, Any], None] = None
     ) -> "SandboxInstance":
-        if sandbox is None:
-            sandbox = Sandbox()
-        if isinstance(sandbox, dict):
-            sandbox = Sandbox.from_dict(sandbox)
-        if not sandbox.metadata:
-            sandbox.metadata = Metadata(name=uuid.uuid4().hex)
-        if not sandbox.spec:
-            sandbox.spec = SandboxSpec(runtime=Runtime(image="blaxel/prod-base:latest"))
-        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"
+        # Generate default values
+        default_name = f"sandbox-{uuid.uuid4().hex[:8]}"
+        default_image = "blaxel/prod-base:latest"
+        default_memory = 4096
+
+        # Handle SandboxCreateConfiguration or simple dict with name/image/memory keys
+        if sandbox is None or isinstance(sandbox, (SandboxCreateConfiguration, dict)) and (
+            not isinstance(sandbox, Sandbox) and (
+                sandbox is None or
+                'name' in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__) or
+                'image' in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__) or
+                'memory' in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+            )
+        ):
+            if sandbox is None:
+                sandbox = SandboxCreateConfiguration()
+            elif isinstance(sandbox, dict) and not isinstance(sandbox, Sandbox):
+                sandbox = SandboxCreateConfiguration.from_dict(sandbox)
+
+            # Set defaults if not provided
+            name = sandbox.name or default_name
+            image = sandbox.image or default_image
+            memory = sandbox.memory or default_memory
+
+            # Create full Sandbox object
+            sandbox = Sandbox(
+                metadata=Metadata(name=name),
+                spec=SandboxSpec(runtime=Runtime(image=image, memory=memory, generation="mk3"))
+            )
+        else:
+            # Handle existing Sandbox object or dict conversion
+            if isinstance(sandbox, dict):
+                sandbox = Sandbox.from_dict(sandbox)
+
+            # Set defaults for missing fields
+            if not sandbox.metadata:
+                sandbox.metadata = Metadata(name=uuid.uuid4().hex.replace('-', ''))
+            if not sandbox.spec:
+                sandbox.spec = SandboxSpec(runtime=Runtime(image=default_image))
+            if not sandbox.spec.runtime:
+                sandbox.spec.runtime = Runtime(image=default_image, memory=default_memory)
+
+            sandbox.spec.runtime.image = sandbox.spec.runtime.image or default_image
+            sandbox.spec.runtime.memory = sandbox.spec.runtime.memory or default_memory
+            sandbox.spec.runtime.generation = sandbox.spec.runtime.generation or "mk3"
 
         response = await create_sandbox(
             client=client,
@@ -115,14 +146,30 @@ class SandboxInstance:
 
     @classmethod
     async def create_if_not_exists(
-        cls, sandbox: Union[Sandbox, Dict[str, Any]]
+        cls, sandbox: Union[Sandbox, SandboxCreateConfiguration, Dict[str, Any]]
     ) -> "SandboxInstance":
         """Create a sandbox if it doesn't exist, otherwise return existing."""
-        if isinstance(sandbox, dict):
-            sandbox = Sandbox.from_dict(sandbox)
-
         try:
-            sandbox_instance = await cls.get(sandbox.metadata.name)
+            # Extract name from different configuration types
+            if isinstance(sandbox, SandboxCreateConfiguration):
+                name = sandbox.name
+            elif isinstance(sandbox, dict):
+                if 'name' in sandbox:
+                    name = sandbox['name']
+                elif 'metadata' in sandbox and isinstance(sandbox['metadata'], dict):
+                    name = sandbox['metadata'].get('name')
+                else:
+                    # If no name provided, we can't check if it exists, so create new
+                    return await cls.create(sandbox)
+            elif isinstance(sandbox, Sandbox):
+                name = sandbox.metadata.name if sandbox.metadata else None
+            else:
+                name = None
+
+            if not name:
+                raise ValueError("Sandbox name is required")
+
+            sandbox_instance = await cls.get(name)
             return sandbox_instance
         except Exception as e:
             # Check if it's a 404 error (sandbox not found)

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/src/blaxel/core/sandbox/types.py

@@ -101,3 +101,24 @@ class CopyResponse:
         self.message = message
         self.source = source
         self.destination = destination
+
+
+class SandboxCreateConfiguration:
+    """Simplified configuration for creating sandboxes with default values."""
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        image: Optional[str] = None,
+        memory: Optional[int] = None,
+    ):
+        self.name = name
+        self.image = image
+        self.memory = memory
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
+        return cls(
+            name=data.get("name"),
+            image=data.get("image"),
+            memory=data.get("memory"),
+        )

{blaxel-0.2.1rc76 → blaxel-0.2.1rc78}/src/blaxel/googleadk/tools.py

@@ -69,4 +69,3 @@ async def bl_tools(tools_names: list[str], **kwargs: Any) -> list[BaseTool]:
     tools = bl_tools_core(tools_names, **kwargs)
     await tools.initialize()
     return [GoogleADKTool(tool) for tool in tools.get_tools()]
-    return [GoogleADKTool(tool) for tool in tools.get_tools()]

blaxel-0.2.1rc78/tests/integration/sandbox/create.py

@@ -0,0 +1,104 @@
+import asyncio
+import sys
+from blaxel.core.sandbox import SandboxInstance, SandboxCreateConfiguration
+
+
+async def main():
+    """Test various sandbox creation scenarios."""
+    try:
+        # Test 1: Create sandbox with no parameters (should use defaults)
+        print("Test 1: Create sandbox with default parameters...")
+        sandbox = await SandboxInstance.create()
+        await sandbox.wait()
+        print(f"✅ Created sandbox with default name: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted default sandbox")
+
+        # Test 2: Create sandbox with spec containing runtime image
+        print("\nTest 2: Create sandbox with spec runtime...")
+        sandbox = await SandboxInstance.create({
+            "spec": {
+                "runtime": {
+                    "image": "blaxel/prod-base:latest"
+                }
+            }
+        })
+        await sandbox.wait()
+        print(f"✅ Created sandbox with spec: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted spec sandbox")
+
+        # Test 3: Create sandbox with simplified name configuration
+        print("\nTest 3: Create sandbox with name configuration...")
+        sandbox = await SandboxInstance.create({"name": "sandbox-with-name"})
+        await sandbox.wait()
+        print(f"✅ Created sandbox with name: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel/'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted named sandbox")
+
+        # Test 4: Create sandbox using SandboxCreateConfiguration
+        print("\nTest 4: Create sandbox with SandboxCreateConfiguration...")
+        config = SandboxCreateConfiguration(name="sandbox-config-test")
+        sandbox = await SandboxInstance.create(config)
+        await sandbox.wait()
+        print(f"✅ Created sandbox with config: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel/'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted config sandbox")
+
+        # Test 5: Create sandbox if not exists with name
+        print("\nTest 5: Create sandbox if not exists with name...")
+        sandbox = await SandboxInstance.create_if_not_exists({"name": "sandbox-cine-name"})
+        await sandbox.wait()
+        print(f"✅ Created/found sandbox: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel/'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted create-if-not-exists sandbox")
+
+        # Test 6: Create sandbox if not exists with metadata structure
+        print("\nTest 6: Create sandbox if not exists with metadata...")
+        sandbox = await SandboxInstance.create_if_not_exists({
+            "metadata": {"name": "sandbox-cine-metadata"}
+        })
+        await sandbox.wait()
+        print(f"✅ Created/found sandbox with metadata: {sandbox.metadata.name}")
+        print(await sandbox.fs.ls('/blaxel/'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted metadata sandbox")
+
+        # Test 7: Create sandbox with custom image and memory
+        print("\nTest 7: Create sandbox with custom image and memory...")
+        custom_config = SandboxCreateConfiguration(
+            name="sandbox-custom",
+            image="blaxel/prod-base:latest",
+            memory=2048
+        )
+        sandbox = await SandboxInstance.create(custom_config)
+        await sandbox.wait()
+        print(f"✅ Created custom sandbox: {sandbox.metadata.name}")
+        print(f"   Image: {sandbox.spec.runtime.image}")
+        print(f"   Memory: {sandbox.spec.runtime.memory}")
+        print(await sandbox.fs.ls('/blaxel/'))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted custom sandbox")
+
+        print("\n🎉 All sandbox creation tests passed!")
+
+    except Exception as e:
+        print(f"❌ There was an error => {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+        print("✅ Tests completed successfully")
+        sys.exit(0)
+    except Exception as err:
+        print(f"❌ There was an error => {err}")
+        sys.exit(1)