blaxel 0.2.33__tar.gz → 0.2.34__tar.gz

{blaxel-0.2.33 → blaxel-0.2.34}/PKG-INFO

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

{blaxel-0.2.33 → blaxel-0.2.34}/pyproject.toml

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

{blaxel-0.2.33 → blaxel-0.2.34}/src/blaxel/__init__.py

@@ -4,8 +4,8 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-__version__ = "0.2.33"
-__commit__ = "3472a6744215e59d421423f105edb2ec34edebe8"
+__version__ = "0.2.34"
+__commit__ = "84fc1c14e48dec727c7de1966c51022e09f7c80f"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

{blaxel-0.2.33 → blaxel-0.2.34}/src/blaxel/core/__init__.py

@@ -30,7 +30,7 @@ from .sandbox import (
 )
 from .sandbox.types import Sandbox
 from .tools import BlTools, bl_tools, convert_mcp_tool_to_blaxel_tool
-from .volume import VolumeCreateConfiguration, VolumeInstance
+from .volume import SyncVolumeInstance, VolumeCreateConfiguration, VolumeInstance
 
 __all__ = [
     "BlAgent",
@@ -65,6 +65,7 @@ __all__ = [
     "convert_mcp_tool_to_blaxel_tool",
     "websocket_client",
     "VolumeInstance",
+    "SyncVolumeInstance",
     "VolumeCreateConfiguration",
     "verify_webhook_signature",
     "verify_webhook_from_request",

{blaxel-0.2.33 → blaxel-0.2.34}/src/blaxel/core/sandbox/default/sandbox.py

@@ -1,6 +1,6 @@
 import logging
 import uuid
-from typing import Any, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union
 
 from ...client.api.compute.create_sandbox import asyncio as create_sandbox
 from ...client.api.compute.delete_sandbox import asyncio as delete_sandbox
@@ -26,6 +26,24 @@ from .session import SandboxSessions
 logger = logging.getLogger(__name__)
 
 
+class _AsyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SandboxInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            async def instance_delete() -> Sandbox:
+                return await self._delete_func(instance.metadata.name)
+
+            return instance_delete
+
+
 class SandboxInstance:
     def __init__(
         self,
@@ -107,6 +125,7 @@ class SandboxInstance:
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "snapshot_enabled"
                     in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "labels" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -135,7 +154,7 @@ class SandboxInstance:
 
             # Create full Sandbox object
             sandbox = Sandbox(
-                metadata=Metadata(name=name),
+                metadata=Metadata(name=name, labels=config.labels),
                 spec=SandboxSpec(
                     runtime=Runtime(
                         image=image,
@@ -202,14 +221,6 @@ class SandboxInstance:
         response = await list_sandboxes()
         return [cls(sandbox) for sandbox in response]
 
-    @classmethod
-    async def delete(cls, sandbox_name: str) -> Sandbox:
-        response = await delete_sandbox(
-            sandbox_name,
-            client=client,
-        )
-        return response
-
     @classmethod
     async def update_metadata(
         cls, sandbox_name: str, metadata: SandboxUpdateMetadata
@@ -319,3 +330,16 @@ class SandboxInstance:
             headers={"X-Blaxel-Preview-Token": session.token},
             params={"bl_preview_token": session.token},
         )
+
+
+async def _delete_sandbox_by_name(sandbox_name: str) -> Sandbox:
+    """Delete a sandbox by name."""
+    response = await delete_sandbox(
+        sandbox_name,
+        client=client,
+    )
+    return response
+
+
+# Assign the delete descriptor to support both class-level and instance-level calls
+SandboxInstance.delete = _AsyncDeleteDescriptor(_delete_sandbox_by_name)

{blaxel-0.2.33 → blaxel-0.2.34}/src/blaxel/core/sandbox/sync/sandbox.py

@@ -1,6 +1,6 @@
 import logging
 import uuid
-from typing import Any, Dict, List, Union
+from typing import Any, Callable, Dict, List, Union
 
 from ...client.api.compute.create_sandbox import sync as create_sandbox
 from ...client.api.compute.delete_sandbox import sync as delete_sandbox
@@ -26,6 +26,24 @@ from .session import SyncSandboxSessions
 logger = logging.getLogger(__name__)
 
 
+class _SyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SyncSandboxInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            def instance_delete() -> Sandbox:
+                return self._delete_func(instance.metadata.name)
+
+            return instance_delete
+
+
 class SyncSandboxInstance:
     def __init__(
         self,
@@ -102,6 +120,7 @@ class SyncSandboxInstance:
                     or "lifecycle" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                     or "snapshot_enabled"
                     in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
+                    or "labels" in (sandbox if isinstance(sandbox, dict) else sandbox.__dict__)
                 )
             )
         ):
@@ -125,7 +144,7 @@ class SyncSandboxInstance:
             region = config.region
             lifecycle = config.lifecycle
             sandbox = Sandbox(
-                metadata=Metadata(name=name),
+                metadata=Metadata(name=name, labels=config.labels),
                 spec=SandboxSpec(
                     runtime=Runtime(
                         image=image,
@@ -184,14 +203,6 @@ class SyncSandboxInstance:
         response = list_sandboxes(client=client)
         return [cls(sandbox) for sandbox in response]
 
-    @classmethod
-    def delete(cls, sandbox_name: str) -> Sandbox:
-        response = delete_sandbox(
-            sandbox_name,
-            client=client,
-        )
-        return response
-
     @classmethod
     def update_metadata(
         cls, sandbox_name: str, metadata: SandboxUpdateMetadata
@@ -261,3 +272,16 @@ class SyncSandboxInstance:
             headers={"X-Blaxel-Preview-Token": session.token},
             params={"bl_preview_token": session.token},
         )
+
+
+def _delete_sandbox_by_name(sandbox_name: str) -> Sandbox:
+    """Delete a sandbox by name."""
+    response = delete_sandbox(
+        sandbox_name,
+        client=client,
+    )
+    return response
+
+
+# Assign the delete descriptor to support both class-level and instance-level calls
+SyncSandboxInstance.delete = _SyncDeleteDescriptor(_delete_sandbox_by_name)

{blaxel-0.2.33 → blaxel-0.2.34}/src/blaxel/core/sandbox/types.py

@@ -155,6 +155,7 @@ class SandboxCreateConfiguration:
         region: str | None = None,
         lifecycle: Union[SandboxLifecycle, Dict[str, Any]] | None = None,
         snapshot_enabled: bool | None = None,
+        labels: Dict[str, str] | None = None,
     ):
         self.name = name
         self.image = image
@@ -167,6 +168,7 @@ class SandboxCreateConfiguration:
         self.region = region
         self.lifecycle = lifecycle
         self.snapshot_enabled = snapshot_enabled
+        self.labels = labels
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "SandboxCreateConfiguration":
@@ -190,6 +192,7 @@ class SandboxCreateConfiguration:
             region=data.get("region"),
             lifecycle=lifecycle,
             snapshot_enabled=data.get("snapshot_enabled"),
+            labels=data.get("labels"),
         )
 
     def _normalize_ports(self) -> List[Port] | None:

blaxel-0.2.34/src/blaxel/core/volume/__init__.py

@@ -0,0 +1,5 @@
+"""Volume module for persistent storage management."""
+
+from .volume import SyncVolumeInstance, VolumeCreateConfiguration, VolumeInstance
+
+__all__ = ["VolumeInstance", "SyncVolumeInstance", "VolumeCreateConfiguration"]

blaxel-0.2.34/src/blaxel/core/volume/volume.py

@@ -0,0 +1,367 @@
+import uuid
+from typing import Callable, Dict, List, Union
+
+from ..client.api.volumes.create_volume import asyncio as create_volume
+from ..client.api.volumes.create_volume import sync as create_volume_sync
+from ..client.api.volumes.delete_volume import asyncio as delete_volume
+from ..client.api.volumes.delete_volume import sync as delete_volume_sync
+from ..client.api.volumes.get_volume import asyncio as get_volume
+from ..client.api.volumes.get_volume import sync as get_volume_sync
+from ..client.api.volumes.list_volumes import asyncio as list_volumes
+from ..client.api.volumes.list_volumes import sync as list_volumes_sync
+from ..client.client import client
+from ..client.models import Metadata, Volume, VolumeSpec
+from ..client.types import UNSET
+
+
+class _AsyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: VolumeInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            async def instance_delete() -> Volume:
+                return await self._delete_func(instance.metadata.name or "")
+
+            return instance_delete
+
+
+class _SyncDeleteDescriptor:
+    """Descriptor that provides both class-level and instance-level delete functionality (sync)."""
+
+    def __init__(self, delete_func: Callable):
+        self._delete_func = delete_func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            # Called on the class: SyncVolumeInstance.delete("name")
+            return self._delete_func
+        else:
+            # Called on an instance: instance.delete()
+            def instance_delete() -> Volume:
+                return self._delete_func(instance.metadata.name or "")
+
+            return instance_delete
+
+
+class VolumeCreateConfiguration:
+    """Simplified configuration for creating volumes with default values."""
+
+    def __init__(
+        self,
+        name: str | None = None,
+        display_name: str | None = None,
+        labels: Dict[str, str] | None = None,
+        size: int | None = None,  # Size in MB
+        region: str | None = None,  # AWS region
+        template: str | None = None,  # Template
+    ):
+        self.name = name
+        self.display_name = display_name
+        self.labels = labels
+        self.size = size
+        self.region = region
+        self.template = template
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, any]) -> "VolumeCreateConfiguration":
+        return cls(
+            name=data.get("name"),
+            display_name=data.get("display_name"),
+            labels=data.get("labels"),
+            size=data.get("size"),
+            region=data.get("region"),
+            template=data.get("template"),
+        )
+
+
+class VolumeInstance:
+    def __init__(self, volume: Volume):
+        self.volume = volume
+
+    @property
+    def metadata(self):
+        return self.volume.metadata
+
+    @property
+    def spec(self):
+        return self.volume.spec
+
+    @property
+    def status(self):
+        return self.volume.status
+
+    @property
+    def name(self):
+        return self.volume.metadata.name if self.volume.metadata else None
+
+    @property
+    def display_name(self):
+        return self.volume.metadata.display_name if self.volume.metadata else None
+
+    @property
+    def size(self):
+        return self.volume.spec.size if self.volume.spec else None
+
+    @property
+    def region(self):
+        return self.volume.spec.region if self.volume.spec else None
+
+    @property
+    def template(self):
+        return self.volume.spec.template if self.volume.spec else None
+
+    @classmethod
+    async def create(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "VolumeInstance":
+        # Generate default values
+        default_name = f"volume-{uuid.uuid4().hex[:8]}"
+        default_size = 1024  # 1GB in MB
+
+        # Handle different configuration types
+        if isinstance(config, Volume):
+            volume = config
+        elif isinstance(config, VolumeCreateConfiguration):
+            volume = Volume(
+                metadata=Metadata(
+                    name=config.name or default_name,
+                    display_name=config.display_name or config.name or default_name,
+                    labels=config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=config.size or default_size,
+                    region=config.region or UNSET,
+                    template=config.template or UNSET,
+                ),
+            )
+        elif isinstance(config, dict):
+            volume_config = VolumeCreateConfiguration.from_dict(config)
+            volume = Volume(
+                metadata=Metadata(
+                    name=volume_config.name or default_name,
+                    display_name=volume_config.display_name or volume_config.name or default_name,
+                    labels=volume_config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=volume_config.size or default_size,
+                    region=volume_config.region or UNSET,
+                    template=volume_config.template or UNSET,
+                ),
+            )
+        else:
+            raise ValueError(
+                f"Invalid config type: {type(config)}. Expected VolumeCreateConfiguration, Volume, or dict."
+            )
+
+        # Ensure required fields have defaults
+        if not volume.metadata:
+            volume.metadata = Metadata(name=default_name)
+        if not volume.metadata.name:
+            volume.metadata.name = default_name
+        if not volume.spec:
+            volume.spec = VolumeSpec(size=default_size)
+        if not volume.spec.size:
+            volume.spec.size = default_size
+
+        response = await create_volume(client=client, body=volume)
+        return cls(response)
+
+    @classmethod
+    async def get(cls, volume_name: str) -> "VolumeInstance":
+        response = await get_volume(volume_name=volume_name, client=client)
+        return cls(response)
+
+    @classmethod
+    async def list(cls) -> list["VolumeInstance"]:
+        response = await list_volumes(client=client)
+        return [cls(volume) for volume in response or []]
+
+    @classmethod
+    async def create_if_not_exists(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "VolumeInstance":
+        """Create a volume if it doesn't exist, otherwise return existing."""
+        try:
+            return await cls.create(config)
+        except Exception as e:
+            # Check if it's a 409 conflict error (volume already exists)
+            if (hasattr(e, "status_code") and e.status_code == 409) or (
+                hasattr(e, "code") and e.code in [409, "VOLUME_ALREADY_EXISTS"]
+            ):
+                # Extract name from different configuration types
+                if isinstance(config, VolumeCreateConfiguration):
+                    name = config.name
+                elif isinstance(config, dict):
+                    name = config.get("name")
+                elif isinstance(config, Volume):
+                    name = config.metadata.name if config.metadata else None
+                else:
+                    name = None
+
+                if not name:
+                    raise ValueError("Volume name is required")
+
+                volume_instance = await cls.get(name)
+                return volume_instance
+            raise e
+
+
+class SyncVolumeInstance:
+    """Synchronous volume instance for managing persistent storage."""
+
+    def __init__(self, volume: Volume):
+        self.volume = volume
+
+    @property
+    def metadata(self):
+        return self.volume.metadata
+
+    @property
+    def spec(self):
+        return self.volume.spec
+
+    @property
+    def status(self):
+        return self.volume.status
+
+    @property
+    def name(self):
+        return self.volume.metadata.name if self.volume.metadata else None
+
+    @property
+    def display_name(self):
+        return self.volume.metadata.display_name if self.volume.metadata else None
+
+    @property
+    def size(self):
+        return self.volume.spec.size if self.volume.spec else None
+
+    @property
+    def region(self):
+        return self.volume.spec.region if self.volume.spec else None
+
+    @property
+    def template(self):
+        return self.volume.spec.template if self.volume.spec else None
+
+    @classmethod
+    def create(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "SyncVolumeInstance":
+        """Create a new volume synchronously."""
+        # Generate default values
+        default_name = f"volume-{uuid.uuid4().hex[:8]}"
+        default_size = 1024  # 1GB in MB
+
+        # Handle different configuration types
+        if isinstance(config, Volume):
+            volume = config
+        elif isinstance(config, VolumeCreateConfiguration):
+            volume = Volume(
+                metadata=Metadata(
+                    name=config.name or default_name,
+                    display_name=config.display_name or config.name or default_name,
+                    labels=config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=config.size or default_size,
+                    region=config.region or UNSET,
+                    template=config.template or UNSET,
+                ),
+            )
+        elif isinstance(config, dict):
+            volume_config = VolumeCreateConfiguration.from_dict(config)
+            volume = Volume(
+                metadata=Metadata(
+                    name=volume_config.name or default_name,
+                    display_name=volume_config.display_name or volume_config.name or default_name,
+                    labels=volume_config.labels,
+                ),
+                spec=VolumeSpec(
+                    size=volume_config.size or default_size,
+                    region=volume_config.region or UNSET,
+                    template=volume_config.template or UNSET,
+                ),
+            )
+        else:
+            raise ValueError(
+                f"Invalid config type: {type(config)}. Expected VolumeCreateConfiguration, Volume, or dict."
+            )
+
+        # Ensure required fields have defaults
+        if not volume.metadata:
+            volume.metadata = Metadata(name=default_name)
+        if not volume.metadata.name:
+            volume.metadata.name = default_name
+        if not volume.spec:
+            volume.spec = VolumeSpec(size=default_size)
+        if not volume.spec.size:
+            volume.spec.size = default_size
+
+        response = create_volume_sync(client=client, body=volume)
+        return cls(response)
+
+    @classmethod
+    def get(cls, volume_name: str) -> "SyncVolumeInstance":
+        """Get a volume by name synchronously."""
+        response = get_volume_sync(volume_name=volume_name, client=client)
+        return cls(response)
+
+    @classmethod
+    def list(cls) -> List["SyncVolumeInstance"]:
+        """List all volumes synchronously."""
+        response = list_volumes_sync(client=client)
+        return [cls(volume) for volume in response or []]
+
+    @classmethod
+    def create_if_not_exists(
+        cls, config: Union[VolumeCreateConfiguration, Volume, Dict[str, any]]
+    ) -> "SyncVolumeInstance":
+        """Create a volume if it doesn't exist, otherwise return existing."""
+        try:
+            return cls.create(config)
+        except Exception as e:
+            # Check if it's a 409 conflict error (volume already exists)
+            if (hasattr(e, "status_code") and e.status_code == 409) or (
+                hasattr(e, "code") and e.code in [409, "VOLUME_ALREADY_EXISTS"]
+            ):
+                # Extract name from different configuration types
+                if isinstance(config, VolumeCreateConfiguration):
+                    name = config.name
+                elif isinstance(config, dict):
+                    name = config.get("name")
+                elif isinstance(config, Volume):
+                    name = config.metadata.name if config.metadata else None
+                else:
+                    name = None
+
+                if not name:
+                    raise ValueError("Volume name is required")
+
+                volume_instance = cls.get(name)
+                return volume_instance
+            raise e
+
+
+async def _delete_volume_by_name(volume_name: str) -> Volume:
+    """Delete a volume by name (async)."""
+    response = await delete_volume(volume_name=volume_name, client=client)
+    return response
+
+
+def _delete_volume_by_name_sync(volume_name: str) -> Volume:
+    """Delete a volume by name (sync)."""
+    response = delete_volume_sync(volume_name=volume_name, client=client)
+    return response
+
+
+# Assign the delete descriptors to support both class-level and instance-level calls
+VolumeInstance.delete = _AsyncDeleteDescriptor(_delete_volume_by_name)
+SyncVolumeInstance.delete = _SyncDeleteDescriptor(_delete_volume_by_name_sync)

{blaxel-0.2.33 → blaxel-0.2.34}/tests/integration/sandbox/small.py

@@ -3,6 +3,7 @@ import time
 from logging import getLogger
 
 from utils import create_or_get_sandbox
+from blaxel.core import SandboxInstance
 
 logger = getLogger(__name__)
 
@@ -24,6 +25,11 @@ async def main():
     )
     print(result)
 
+    await sandbox.delete()
+
+    sandbox = await SandboxInstance.create()
+
+    await SandboxInstance.delete(sandbox.metadata.name)
 
 if __name__ == "__main__":
     asyncio.run(main())

blaxel-0.2.33/src/blaxel/core/volume/__init__.py

@@ -1,5 +0,0 @@
-"""Volume module for persistent storage management."""
-
-from .volume import VolumeCreateConfiguration, VolumeInstance
-
-__all__ = ["VolumeInstance", "VolumeCreateConfiguration"]