blaxel 0.2.1rc78__tar.gz → 0.2.2rc79__tar.gz

{blaxel-0.2.1rc78 → blaxel-0.2.2rc79}/PKG-INFO

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

{blaxel-0.2.1rc78 → blaxel-0.2.2rc79}/pyproject.toml

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

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

@@ -10,6 +10,7 @@ from ..client.api.compute.get_sandbox import asyncio as get_sandbox
 from ..client.api.compute.list_sandboxes import asyncio as list_sandboxes
 from ..client.client import client
 from ..client.models import Metadata, Runtime, Sandbox, SandboxSpec
+from ..client.types import UNSET
 from .filesystem import SandboxFileSystem
 from .network import SandboxNetwork
 from .preview import SandboxPreviews
@@ -76,13 +77,19 @@ class SandboxInstance:
         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__)
+        # Handle SandboxCreateConfiguration or simple dict with name/image/memory/ports 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__)
+                    or "ports" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                )
             )
         ):
             if sandbox is None:
@@ -94,11 +101,14 @@ class SandboxInstance:
             name = sandbox.name or default_name
             image = sandbox.image or default_image
             memory = sandbox.memory or default_memory
+            ports = sandbox._normalize_ports() or UNSET
 
             # Create full Sandbox object
             sandbox = Sandbox(
                 metadata=Metadata(name=name),
-                spec=SandboxSpec(runtime=Runtime(image=image, memory=memory, generation="mk3"))
+                spec=SandboxSpec(
+                    runtime=Runtime(image=image, memory=memory, ports=ports, generation="mk3")
+                ),
             )
         else:
             # Handle existing Sandbox object or dict conversion
@@ -107,7 +117,7 @@ class SandboxInstance:
 
             # Set defaults for missing fields
             if not sandbox.metadata:
-                sandbox.metadata = Metadata(name=uuid.uuid4().hex.replace('-', ''))
+                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:
@@ -154,10 +164,10 @@ class SandboxInstance:
             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')
+                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)

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

@@ -1,7 +1,8 @@
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Union
 
-from ..client.models import Sandbox
+from ..client.models import Port, Sandbox
+from ..client.types import UNSET
 
 
 class SessionCreateOptions:
@@ -105,15 +106,18 @@ class CopyResponse:
 
 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,
+        ports: Optional[Union[List[Port], List[Dict[str, Any]]]] = None,
     ):
         self.name = name
         self.image = image
         self.memory = memory
+        self.ports = ports
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
@@ -121,4 +125,28 @@ class SandboxCreateConfiguration:
             name=data.get("name"),
             image=data.get("image"),
             memory=data.get("memory"),
+            ports=data.get("ports"),
         )
+
+    def _normalize_ports(self) -> Optional[List[Port]]:
+        """Convert ports to Port objects with default protocol HTTP if not specified."""
+        if not self.ports:
+            return None
+
+        port_objects = []
+        for port in self.ports:
+            if isinstance(port, Port):
+                # If it's already a Port object, ensure protocol defaults to HTTP
+                if port.protocol is UNSET or not port.protocol:
+                    port.protocol = "HTTP"
+                port_objects.append(port)
+            elif isinstance(port, dict):
+                # Convert dict to Port object with HTTP as default protocol
+                port_dict = port.copy()
+                if "protocol" not in port_dict or not port_dict["protocol"]:
+                    port_dict["protocol"] = "HTTP"
+                port_objects.append(Port.from_dict(port_dict))
+            else:
+                raise ValueError(f"Invalid port type: {type(port)}. Expected Port object or dict.")
+
+        return port_objects

{blaxel-0.2.1rc78 → blaxel-0.2.2rc79}/tests/integration/sandbox/create.py

@@ -1,6 +1,7 @@
 import asyncio
 import sys
-from blaxel.core.sandbox import SandboxInstance, SandboxCreateConfiguration
+
+from blaxel.core.sandbox import SandboxCreateConfiguration, SandboxInstance
 
 
 async def main():
@@ -11,22 +12,18 @@ async def main():
         sandbox = await SandboxInstance.create()
         await sandbox.wait()
         print(f"✅ Created sandbox with default name: {sandbox.metadata.name}")
-        print(await sandbox.fs.ls('/blaxel'))
+        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"
-                }
-            }
-        })
+        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'))
+        print(await sandbox.fs.ls("/blaxel"))
         await SandboxInstance.delete(sandbox.metadata.name)
         print("✅ Deleted spec sandbox")
 
@@ -35,7 +32,7 @@ async def main():
         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/'))
+        print(await sandbox.fs.ls("/blaxel/"))
         await SandboxInstance.delete(sandbox.metadata.name)
         print("✅ Deleted named sandbox")
 
@@ -45,7 +42,7 @@ async def main():
         sandbox = await SandboxInstance.create(config)
         await sandbox.wait()
         print(f"✅ Created sandbox with config: {sandbox.metadata.name}")
-        print(await sandbox.fs.ls('/blaxel/'))
+        print(await sandbox.fs.ls("/blaxel/"))
         await SandboxInstance.delete(sandbox.metadata.name)
         print("✅ Deleted config sandbox")
 
@@ -54,18 +51,18 @@ async def main():
         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/'))
+        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"}
-        })
+        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/'))
+        print(await sandbox.fs.ls("/blaxel/"))
         await SandboxInstance.delete(sandbox.metadata.name)
         print("✅ Deleted metadata sandbox")
 
@@ -74,22 +71,48 @@ async def main():
         custom_config = SandboxCreateConfiguration(
             name="sandbox-custom",
             image="blaxel/prod-base:latest",
-            memory=2048
+            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/'))
+        print(await sandbox.fs.ls("/blaxel/"))
         await SandboxInstance.delete(sandbox.metadata.name)
         print("✅ Deleted custom sandbox")
 
+        # Test 8: Create sandbox with ports
+        print("\nTest 8: Create sandbox with ports...")
+        ports_config = SandboxCreateConfiguration(
+            name="sandbox-with-ports",
+            image="blaxel/prod-base:latest",
+            memory=2048,
+            ports=[
+                {"name": "web", "target": 3000},  # Will default to HTTP
+                {"name": "api", "target": 8080, "protocol": "TCP"},
+            ],
+        )
+        sandbox = await SandboxInstance.create(ports_config)
+        await sandbox.wait()
+        print(f"✅ Created sandbox with ports: {sandbox.metadata.name}")
+        print(f"   Image: {sandbox.spec.runtime.image}")
+        print(f"   Memory: {sandbox.spec.runtime.memory}")
+        sandbox = await SandboxInstance.get(sandbox.metadata.name)
+        if sandbox.spec.runtime.ports:
+            print(f"   Ports: {len(sandbox.spec.runtime.ports)} configured")
+            for port in sandbox.spec.runtime.ports:
+                print(f"     - {port.name}: {port.target} ({port.protocol})")
+        print(await sandbox.fs.ls("/blaxel/"))
+        await SandboxInstance.delete(sandbox.metadata.name)
+        print("✅ Deleted ports 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)
 
@@ -101,4 +124,4 @@ if __name__ == "__main__":
         sys.exit(0)
     except Exception as err:
         print(f"❌ There was an error => {err}")
-        sys.exit(1)
+        sys.exit(1)