blaxel 0.1.9rc35__py3-none-any.whl → 0.1.9rc37__py3-none-any.whl

blaxel/client/models/serverless_config.py

@@ -1,10 +1,14 @@
-from typing import Any, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
+if TYPE_CHECKING:
+    from ..models.serverless_config_configuration import ServerlessConfigConfiguration
+
+
 T = TypeVar("T", bound="ServerlessConfig")
 
 
@@ -13,18 +17,30 @@ class ServerlessConfig:
     """Configuration for a serverless deployment
 
     Attributes:
+        configuration (Union[Unset, ServerlessConfigConfiguration]): The configuration for the deployment
         max_scale (Union[Unset, int]): The minimum number of replicas for the deployment. Can be 0 or 1 (in which case
             the deployment is always running in at least one location).
         min_scale (Union[Unset, int]): The maximum number of replicas for the deployment.
         timeout (Union[Unset, int]): The timeout for the deployment in seconds
     """
 
+    configuration: Union[Unset, "ServerlessConfigConfiguration"] = UNSET
     max_scale: Union[Unset, int] = UNSET
     min_scale: Union[Unset, int] = UNSET
     timeout: Union[Unset, int] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        configuration: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.configuration
+            and not isinstance(self.configuration, Unset)
+            and not isinstance(self.configuration, dict)
+        ):
+            configuration = self.configuration.to_dict()
+        elif self.configuration and isinstance(self.configuration, dict):
+            configuration = self.configuration
+
         max_scale = self.max_scale
 
         min_scale = self.min_scale
@@ -34,6 +50,8 @@ class ServerlessConfig:
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
+        if configuration is not UNSET:
+            field_dict["configuration"] = configuration
         if max_scale is not UNSET:
             field_dict["maxScale"] = max_scale
         if min_scale is not UNSET:
@@ -45,9 +63,18 @@ class ServerlessConfig:
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.serverless_config_configuration import ServerlessConfigConfiguration
+
         if not src_dict:
             return None
         d = src_dict.copy()
+        _configuration = d.pop("configuration", UNSET)
+        configuration: Union[Unset, ServerlessConfigConfiguration]
+        if isinstance(_configuration, Unset):
+            configuration = UNSET
+        else:
+            configuration = ServerlessConfigConfiguration.from_dict(_configuration)
+
         max_scale = d.pop("maxScale", UNSET)
 
         min_scale = d.pop("minScale", UNSET)
@@ -55,6 +82,7 @@ class ServerlessConfig:
         timeout = d.pop("timeout", UNSET)
 
         serverless_config = cls(
+            configuration=configuration,
             max_scale=max_scale,
             min_scale=min_scale,
             timeout=timeout,

blaxel/client/models/serverless_config_configuration.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ServerlessConfigConfiguration")
+
+
+@_attrs_define
+class ServerlessConfigConfiguration:
+    """The configuration for the deployment"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        serverless_config_configuration = cls()
+
+        serverless_config_configuration.additional_properties = d
+        return serverless_config_configuration
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/client/models/start_sandbox.py

@@ -0,0 +1,94 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="StartSandbox")
+
+
+@_attrs_define
+class StartSandbox:
+    """Response when starting a Sandbox
+
+    Attributes:
+        message (Union[Unset, str]): Human readable message about the start operation
+        metadata (Union[Unset, Metadata]): Metadata
+        status (Union[Unset, str]): Status of the Sandbox start operation
+    """
+
+    message: Union[Unset, str] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+    status: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+            metadata = self.metadata.to_dict()
+        elif self.metadata and isinstance(self.metadata, dict):
+            metadata = self.metadata
+
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if message is not UNSET:
+            field_dict["message"] = message
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.metadata import Metadata
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        message = d.pop("message", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        status = d.pop("status", UNSET)
+
+        start_sandbox = cls(
+            message=message,
+            metadata=metadata,
+            status=status,
+        )
+
+        start_sandbox.additional_properties = d
+        return start_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/client/models/stop_sandbox.py

@@ -0,0 +1,94 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="StopSandbox")
+
+
+@_attrs_define
+class StopSandbox:
+    """Response when stopping a Sandbox
+
+    Attributes:
+        message (Union[Unset, str]): Human readable message about the stop operation
+        metadata (Union[Unset, Metadata]): Metadata
+        status (Union[Unset, str]): Status of the Sandbox stop operation
+    """
+
+    message: Union[Unset, str] = UNSET
+    metadata: Union[Unset, "Metadata"] = UNSET
+    status: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+            metadata = self.metadata.to_dict()
+        elif self.metadata and isinstance(self.metadata, dict):
+            metadata = self.metadata
+
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if message is not UNSET:
+            field_dict["message"] = message
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if status is not UNSET:
+            field_dict["status"] = status
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.metadata import Metadata
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        message = d.pop("message", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        status = d.pop("status", UNSET)
+
+        stop_sandbox = cls(
+            message=message,
+            metadata=metadata,
+            status=status,
+        )
+
+        stop_sandbox.additional_properties = d
+        return stop_sandbox
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/client/models/trigger.py

@@ -0,0 +1,98 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.trigger_configuration import TriggerConfiguration
+
+
+T = TypeVar("T", bound="Trigger")
+
+
+@_attrs_define
+class Trigger:
+    """Trigger configuration
+
+    Attributes:
+        configuration (Union[Unset, TriggerConfiguration]): The configuration of the trigger
+        id (Union[Unset, str]): The id of the trigger
+        type_ (Union[Unset, str]): The type of trigger, can be http or http-async
+    """
+
+    configuration: Union[Unset, "TriggerConfiguration"] = UNSET
+    id: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        configuration: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.configuration
+            and not isinstance(self.configuration, Unset)
+            and not isinstance(self.configuration, dict)
+        ):
+            configuration = self.configuration.to_dict()
+        elif self.configuration and isinstance(self.configuration, dict):
+            configuration = self.configuration
+
+        id = self.id
+
+        type_ = self.type_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if configuration is not UNSET:
+            field_dict["configuration"] = configuration
+        if id is not UNSET:
+            field_dict["id"] = id
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.trigger_configuration import TriggerConfiguration
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _configuration = d.pop("configuration", UNSET)
+        configuration: Union[Unset, TriggerConfiguration]
+        if isinstance(_configuration, Unset):
+            configuration = UNSET
+        else:
+            configuration = TriggerConfiguration.from_dict(_configuration)
+
+        id = d.pop("id", UNSET)
+
+        type_ = d.pop("type", UNSET)
+
+        trigger = cls(
+            configuration=configuration,
+            id=id,
+            type_=type_,
+        )
+
+        trigger.additional_properties = d
+        return trigger
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/client/models/trigger_configuration.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="TriggerConfiguration")
+
+
+@_attrs_define
+class TriggerConfiguration:
+    """The configuration of the trigger"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        trigger_configuration = cls()
+
+        trigger_configuration.additional_properties = d
+        return trigger_configuration
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/client/models/workspace.py

@@ -7,6 +7,7 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.workspace_labels import WorkspaceLabels
+    from ..models.workspace_runtime import WorkspaceRuntime
 
 
 T = TypeVar("T", bound="Workspace")
@@ -26,6 +27,7 @@ class Workspace:
         labels (Union[Unset, WorkspaceLabels]): Workspace labels
         name (Union[Unset, str]): Workspace name
         region (Union[Unset, str]): Workspace write region
+        runtime (Union[Unset, WorkspaceRuntime]): Workspace runtime
     """
 
     created_at: Union[Unset, str] = UNSET
@@ -37,6 +39,7 @@ class Workspace:
     labels: Union[Unset, "WorkspaceLabels"] = UNSET
     name: Union[Unset, str] = UNSET
     region: Union[Unset, str] = UNSET
+    runtime: Union[Unset, "WorkspaceRuntime"] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -62,6 +65,12 @@ class Workspace:
 
         region = self.region
 
+        runtime: Union[Unset, dict[str, Any]] = UNSET
+        if self.runtime and not isinstance(self.runtime, Unset) and not isinstance(self.runtime, dict):
+            runtime = self.runtime.to_dict()
+        elif self.runtime and isinstance(self.runtime, dict):
+            runtime = self.runtime
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -83,12 +92,15 @@ class Workspace:
             field_dict["name"] = name
         if region is not UNSET:
             field_dict["region"] = region
+        if runtime is not UNSET:
+            field_dict["runtime"] = runtime
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
         from ..models.workspace_labels import WorkspaceLabels
+        from ..models.workspace_runtime import WorkspaceRuntime
 
         if not src_dict:
             return None
@@ -116,6 +128,13 @@ class Workspace:
 
         region = d.pop("region", UNSET)
 
+        _runtime = d.pop("runtime", UNSET)
+        runtime: Union[Unset, WorkspaceRuntime]
+        if isinstance(_runtime, Unset):
+            runtime = UNSET
+        else:
+            runtime = WorkspaceRuntime.from_dict(_runtime)
+
         workspace = cls(
             created_at=created_at,
             updated_at=updated_at,
@@ -126,6 +145,7 @@ class Workspace:
             labels=labels,
             name=name,
             region=region,
+            runtime=runtime,
         )
 
         workspace.additional_properties = d

blaxel/client/models/workspace_runtime.py

@@ -0,0 +1,61 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="WorkspaceRuntime")
+
+
+@_attrs_define
+class WorkspaceRuntime:
+    """Workspace runtime
+
+    Attributes:
+        generation (Union[Unset, str]): Workspace generation
+    """
+
+    generation: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        generation = self.generation
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if generation is not UNSET:
+            field_dict["generation"] = generation
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        generation = d.pop("generation", UNSET)
+
+        workspace_runtime = cls(
+            generation=generation,
+        )
+
+        workspace_runtime.additional_properties = d
+        return workspace_runtime
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

blaxel/common/autoload.py

@@ -1,11 +1,7 @@
-
-import logging
-
 from ..client import client
 from ..instrumentation.manager import telemetry_manager
 from .settings import settings
 
-
 def autoload() -> None:
     client.with_base_url(settings.base_url)
     client.with_auth(settings.auth)

blaxel/common/internal.py

@@ -0,0 +1,75 @@
+import base64
+import hashlib
+import os
+import re
+from typing import Optional
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+def get_alphanumeric_limited_hash(input_str, max_size):
+    # Create SHA-256 hash of the input string
+    hash_obj = hashlib.sha256(input_str.encode('utf-8'))
+    
+    # Get the hash digest in base64 format
+    hash_base64 = base64.b64encode(hash_obj.digest()).decode('utf-8')
+    
+    # Remove non-alphanumeric characters and convert to lowercase
+    alphanumeric = re.sub(r'[^a-zA-Z0-9]', '', hash_base64).lower()
+    
+    # Skip the first character to match the Node.js crypto output
+    alphanumeric = alphanumeric[1:]
+    
+    # Limit to max_size characters
+    return alphanumeric[:max_size] if len(alphanumeric) > max_size else alphanumeric
+
+
+def get_global_unique_hash(workspace: str, type: str, name: str) -> str:
+    """
+    Generate a unique hash for a combination of workspace, type, and name.
+
+    Args:
+        workspace: The workspace identifier
+        type: The type identifier
+        name: The name identifier
+
+    Returns:
+        A unique alphanumeric hash string of maximum length 48
+    """
+    global_unique_name = f"{workspace}-{type}-{name}"
+    hash = get_alphanumeric_limited_hash(global_unique_name, 48)
+    return hash
+
+class Agent:
+    def __init__(self, agent_name: str, workspace: str, run_internal_protocol: str, run_internal_hostname: str):
+        self.agent_name = agent_name
+        self.workspace = workspace
+        self.run_internal_protocol = run_internal_protocol
+        self.run_internal_hostname = run_internal_hostname
+
+    @property
+    def internal_url(self) -> str:
+        """
+        Generate the internal URL for the agent using a unique hash.
+
+        Returns:
+            The internal URL as a string
+        """
+        hash_value = get_global_unique_hash(
+            self.workspace,
+            "agent",
+            self.agent_name
+        )
+        return f"{self.run_internal_protocol}://{hash_value}.{self.run_internal_hostname}"
+
+    @property
+    def forced_url(self) -> Optional[str]:
+        """
+        Check for a forced URL in environment variables.
+
+        Returns:
+            The forced URL if found in environment variables, None otherwise
+        """
+        env_var = self.agent_name.replace("-", "_").upper()
+        env_key = f"BL_AGENT_{env_var}_URL"
+        return os.environ.get(env_key)