blaxel 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

blaxel/core/client/models/sandbox_metrics.py

@@ -1,88 +0,0 @@
-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="SandboxMetrics")
-
-
-@_attrs_define
-class SandboxMetrics:
-    """Enhanced sandbox metrics with memory, value, and percent data
-
-    Attributes:
-        memory (Union[Unset, float]): Memory limit in bytes (from query A)
-        percent (Union[Unset, float]): Memory usage percentage (from formula F1)
-        timestamp (Union[Unset, str]): Metric timestamp
-        value (Union[Unset, float]): Memory usage in bytes (from query B)
-    """
-
-    memory: Union[Unset, float] = UNSET
-    percent: Union[Unset, float] = UNSET
-    timestamp: Union[Unset, str] = UNSET
-    value: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        memory = self.memory
-
-        percent = self.percent
-
-        timestamp = self.timestamp
-
-        value = self.value
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if memory is not UNSET:
-            field_dict["memory"] = memory
-        if percent is not UNSET:
-            field_dict["percent"] = percent
-        if timestamp is not UNSET:
-            field_dict["timestamp"] = timestamp
-        if value is not UNSET:
-            field_dict["value"] = value
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        memory = d.pop("memory", UNSET)
-
-        percent = d.pop("percent", UNSET)
-
-        timestamp = d.pop("timestamp", UNSET)
-
-        value = d.pop("value", UNSET)
-
-        sandbox_metrics = cls(
-            memory=memory,
-            percent=percent,
-            timestamp=timestamp,
-            value=value,
-        )
-
-        sandbox_metrics.additional_properties = d
-        return sandbox_metrics
-
-    @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/core/client/models/serverless_config.py

@@ -1,117 +0,0 @@
-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")
-
-
-@_attrs_define
-class ServerlessConfig:
-    """Configuration for a serverless deployment
-
-    Attributes:
-        configuration (Union[Unset, ServerlessConfigConfiguration]): The configuration for the deployment
-        max_retries (Union[Unset, int]): The maximum number of retries 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_retries: Union[Unset, int] = 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_retries = self.max_retries
-
-        max_scale = self.max_scale
-
-        min_scale = self.min_scale
-
-        timeout = self.timeout
-
-        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_retries is not UNSET:
-            field_dict["maxRetries"] = max_retries
-        if max_scale is not UNSET:
-            field_dict["maxScale"] = max_scale
-        if min_scale is not UNSET:
-            field_dict["minScale"] = min_scale
-        if timeout is not UNSET:
-            field_dict["timeout"] = timeout
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        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_retries = d.pop("maxRetries", d.pop("max_retries", UNSET))
-
-        max_scale = d.pop("maxScale", d.pop("max_scale", UNSET))
-
-        min_scale = d.pop("minScale", d.pop("min_scale", UNSET))
-
-        timeout = d.pop("timeout", UNSET)
-
-        serverless_config = cls(
-            configuration=configuration,
-            max_retries=max_retries,
-            max_scale=max_scale,
-            min_scale=min_scale,
-            timeout=timeout,
-        )
-
-        serverless_config.additional_properties = d
-        return serverless_config
-
-    @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/core/client/models/serverless_config_configuration.py

@@ -1,45 +0,0 @@
-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 | None:
-        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/core/client/models/start_sandbox.py

@@ -1,98 +0,0 @@
-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 | None:
-        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/core/client/models/stop_sandbox.py

@@ -1,98 +0,0 @@
-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 | None:
-        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/core/client/models/store_agent.py

@@ -1,181 +0,0 @@
-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.store_agent_labels import StoreAgentLabels
-    from ..models.store_configuration import StoreConfiguration
-
-
-T = TypeVar("T", bound="StoreAgent")
-
-
-@_attrs_define
-class StoreAgent:
-    """Store agent
-
-    Attributes:
-        created_at (Union[Unset, str]): The date and time when the resource was created
-        updated_at (Union[Unset, str]): The date and time when the resource was updated
-        created_by (Union[Unset, str]): The user or service account who created the resource
-        updated_by (Union[Unset, str]): The user or service account who updated the resource
-        configuration (Union[Unset, list['StoreConfiguration']]): Store agent configuration
-        description (Union[Unset, str]): Store agent description
-        display_name (Union[Unset, str]): Store agent display name
-        image (Union[Unset, str]): Store agent image
-        labels (Union[Unset, StoreAgentLabels]): Store agent labels
-        name (Union[Unset, str]): Store agent name
-        prompt (Union[Unset, str]): Store agent prompt, this is to define what the agent does
-    """
-
-    created_at: Union[Unset, str] = UNSET
-    updated_at: Union[Unset, str] = UNSET
-    created_by: Union[Unset, str] = UNSET
-    updated_by: Union[Unset, str] = UNSET
-    configuration: Union[Unset, list["StoreConfiguration"]] = UNSET
-    description: Union[Unset, str] = UNSET
-    display_name: Union[Unset, str] = UNSET
-    image: Union[Unset, str] = UNSET
-    labels: Union[Unset, "StoreAgentLabels"] = UNSET
-    name: Union[Unset, str] = UNSET
-    prompt: Union[Unset, str] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        created_at = self.created_at
-
-        updated_at = self.updated_at
-
-        created_by = self.created_by
-
-        updated_by = self.updated_by
-
-        configuration: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.configuration, Unset):
-            configuration = []
-            for configuration_item_data in self.configuration:
-                if type(configuration_item_data) is dict:
-                    configuration_item = configuration_item_data
-                else:
-                    configuration_item = configuration_item_data.to_dict()
-                configuration.append(configuration_item)
-
-        description = self.description
-
-        display_name = self.display_name
-
-        image = self.image
-
-        labels: Union[Unset, dict[str, Any]] = UNSET
-        if self.labels and not isinstance(self.labels, Unset) and not isinstance(self.labels, dict):
-            labels = self.labels.to_dict()
-        elif self.labels and isinstance(self.labels, dict):
-            labels = self.labels
-
-        name = self.name
-
-        prompt = self.prompt
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if created_at is not UNSET:
-            field_dict["createdAt"] = created_at
-        if updated_at is not UNSET:
-            field_dict["updatedAt"] = updated_at
-        if created_by is not UNSET:
-            field_dict["createdBy"] = created_by
-        if updated_by is not UNSET:
-            field_dict["updatedBy"] = updated_by
-        if configuration is not UNSET:
-            field_dict["configuration"] = configuration
-        if description is not UNSET:
-            field_dict["description"] = description
-        if display_name is not UNSET:
-            field_dict["displayName"] = display_name
-        if image is not UNSET:
-            field_dict["image"] = image
-        if labels is not UNSET:
-            field_dict["labels"] = labels
-        if name is not UNSET:
-            field_dict["name"] = name
-        if prompt is not UNSET:
-            field_dict["prompt"] = prompt
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.store_agent_labels import StoreAgentLabels
-        from ..models.store_configuration import StoreConfiguration
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        created_at = d.pop("createdAt", d.pop("created_at", UNSET))
-
-        updated_at = d.pop("updatedAt", d.pop("updated_at", UNSET))
-
-        created_by = d.pop("createdBy", d.pop("created_by", UNSET))
-
-        updated_by = d.pop("updatedBy", d.pop("updated_by", UNSET))
-
-        configuration = []
-        _configuration = d.pop("configuration", UNSET)
-        for configuration_item_data in _configuration or []:
-            configuration_item = StoreConfiguration.from_dict(configuration_item_data)
-
-            configuration.append(configuration_item)
-
-        description = d.pop("description", UNSET)
-
-        display_name = d.pop("displayName", d.pop("display_name", UNSET))
-
-        image = d.pop("image", UNSET)
-
-        _labels = d.pop("labels", UNSET)
-        labels: Union[Unset, StoreAgentLabels]
-        if isinstance(_labels, Unset):
-            labels = UNSET
-        else:
-            labels = StoreAgentLabels.from_dict(_labels)
-
-        name = d.pop("name", UNSET)
-
-        prompt = d.pop("prompt", UNSET)
-
-        store_agent = cls(
-            created_at=created_at,
-            updated_at=updated_at,
-            created_by=created_by,
-            updated_by=updated_by,
-            configuration=configuration,
-            description=description,
-            display_name=display_name,
-            image=image,
-            labels=labels,
-            name=name,
-            prompt=prompt,
-        )
-
-        store_agent.additional_properties = d
-        return store_agent
-
-    @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/core/client/models/store_agent_labels.py

@@ -1,45 +0,0 @@
-from typing import Any, TypeVar
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-T = TypeVar("T", bound="StoreAgentLabels")
-
-
-@_attrs_define
-class StoreAgentLabels:
-    """Store agent labels"""
-
-    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 | None:
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        store_agent_labels = cls()
-
-        store_agent_labels.additional_properties = d
-        return store_agent_labels
-
-    @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