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

blaxel/core/client/models/acl.py

@@ -1,133 +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="ACL")
-
-
-@_attrs_define
-class ACL:
-    """ACL
-
-    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
-        id (Union[Unset, str]): ACL id
-        resource_id (Union[Unset, str]): Resource ID
-        resource_type (Union[Unset, str]): Resource type
-        role (Union[Unset, str]): Role
-        subject_id (Union[Unset, str]): Subject ID
-        subject_type (Union[Unset, str]): Subject type
-        workspace (Union[Unset, str]): Workspace name
-    """
-
-    created_at: Union[Unset, str] = UNSET
-    updated_at: Union[Unset, str] = UNSET
-    id: Union[Unset, str] = UNSET
-    resource_id: Union[Unset, str] = UNSET
-    resource_type: Union[Unset, str] = UNSET
-    role: Union[Unset, str] = UNSET
-    subject_id: Union[Unset, str] = UNSET
-    subject_type: Union[Unset, str] = UNSET
-    workspace: 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
-
-        id = self.id
-
-        resource_id = self.resource_id
-
-        resource_type = self.resource_type
-
-        role = self.role
-
-        subject_id = self.subject_id
-
-        subject_type = self.subject_type
-
-        workspace = self.workspace
-
-        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 id is not UNSET:
-            field_dict["id"] = id
-        if resource_id is not UNSET:
-            field_dict["resource_id"] = resource_id
-        if resource_type is not UNSET:
-            field_dict["resource_type"] = resource_type
-        if role is not UNSET:
-            field_dict["role"] = role
-        if subject_id is not UNSET:
-            field_dict["subject_id"] = subject_id
-        if subject_type is not UNSET:
-            field_dict["subject_type"] = subject_type
-        if workspace is not UNSET:
-            field_dict["workspace"] = workspace
-
-        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()
-        created_at = d.pop("createdAt", d.pop("created_at", UNSET))
-
-        updated_at = d.pop("updatedAt", d.pop("updated_at", UNSET))
-
-        id = d.pop("id", UNSET)
-
-        resource_id = d.pop("resource_id", UNSET)
-
-        resource_type = d.pop("resource_type", UNSET)
-
-        role = d.pop("role", UNSET)
-
-        subject_id = d.pop("subject_id", UNSET)
-
-        subject_type = d.pop("subject_type", UNSET)
-
-        workspace = d.pop("workspace", UNSET)
-
-        acl = cls(
-            created_at=created_at,
-            updated_at=updated_at,
-            id=id,
-            resource_id=resource_id,
-            resource_type=resource_type,
-            role=role,
-            subject_id=subject_id,
-            subject_type=subject_type,
-            workspace=workspace,
-        )
-
-        acl.additional_properties = d
-        return acl
-
-    @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/billable_time_metric.py

@@ -1,89 +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.jobs_chart_value import JobsChartValue
-
-
-T = TypeVar("T", bound="BillableTimeMetric")
-
-
-@_attrs_define
-class BillableTimeMetric:
-    """Billable time metric
-
-    Attributes:
-        billable_time (Union[Unset, list['JobsChartValue']]): Billable time
-        total_allocation (Union[Unset, float]): Total memory allocation in GB-seconds
-    """
-
-    billable_time: Union[Unset, list["JobsChartValue"]] = UNSET
-    total_allocation: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        billable_time: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.billable_time, Unset):
-            billable_time = []
-            for billable_time_item_data in self.billable_time:
-                if type(billable_time_item_data) is dict:
-                    billable_time_item = billable_time_item_data
-                else:
-                    billable_time_item = billable_time_item_data.to_dict()
-                billable_time.append(billable_time_item)
-
-        total_allocation = self.total_allocation
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if billable_time is not UNSET:
-            field_dict["billableTime"] = billable_time
-        if total_allocation is not UNSET:
-            field_dict["totalAllocation"] = total_allocation
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.jobs_chart_value import JobsChartValue
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        billable_time = []
-        _billable_time = d.pop("billableTime", d.pop("billable_time", UNSET))
-        for billable_time_item_data in _billable_time or []:
-            billable_time_item = JobsChartValue.from_dict(billable_time_item_data)
-
-            billable_time.append(billable_time_item)
-
-        total_allocation = d.pop("totalAllocation", d.pop("total_allocation", UNSET))
-
-        billable_time_metric = cls(
-            billable_time=billable_time,
-            total_allocation=total_allocation,
-        )
-
-        billable_time_metric.additional_properties = d
-        return billable_time_metric
-
-    @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/core_spec.py

@@ -1,194 +0,0 @@
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
-
-from attrs import define as _attrs_define
-from attrs import field as _attrs_field
-
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.core_spec_configurations import CoreSpecConfigurations
-    from ..models.flavor import Flavor
-    from ..models.revision_configuration import RevisionConfiguration
-    from ..models.runtime import Runtime
-
-
-T = TypeVar("T", bound="CoreSpec")
-
-
-@_attrs_define
-class CoreSpec:
-    """Core specification
-
-    Attributes:
-        configurations (Union[Unset, CoreSpecConfigurations]): Optional configurations for the object
-        enabled (Union[Unset, bool]): Enable or disable the resource
-        flavors (Union[Unset, list['Flavor']]): Types of hardware available for deployments
-        integration_connections (Union[Unset, list[str]]):
-        policies (Union[Unset, list[str]]):
-        revision (Union[Unset, RevisionConfiguration]): Revision configuration
-        runtime (Union[Unset, Runtime]): Set of configurations for a deployment
-        sandbox (Union[Unset, bool]): Sandbox mode
-    """
-
-    configurations: Union[Unset, "CoreSpecConfigurations"] = UNSET
-    enabled: Union[Unset, bool] = UNSET
-    flavors: Union[Unset, list["Flavor"]] = UNSET
-    integration_connections: Union[Unset, list[str]] = UNSET
-    policies: Union[Unset, list[str]] = UNSET
-    revision: Union[Unset, "RevisionConfiguration"] = UNSET
-    runtime: Union[Unset, "Runtime"] = UNSET
-    sandbox: Union[Unset, bool] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        configurations: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.configurations
-            and not isinstance(self.configurations, Unset)
-            and not isinstance(self.configurations, dict)
-        ):
-            configurations = self.configurations.to_dict()
-        elif self.configurations and isinstance(self.configurations, dict):
-            configurations = self.configurations
-
-        enabled = self.enabled
-
-        flavors: Union[Unset, list[dict[str, Any]]] = UNSET
-        if not isinstance(self.flavors, Unset):
-            flavors = []
-            for componentsschemas_flavors_item_data in self.flavors:
-                if type(componentsschemas_flavors_item_data) is dict:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data
-                else:
-                    componentsschemas_flavors_item = componentsschemas_flavors_item_data.to_dict()
-                flavors.append(componentsschemas_flavors_item)
-
-        integration_connections: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.integration_connections, Unset):
-            integration_connections = self.integration_connections
-
-        policies: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.policies, Unset):
-            policies = self.policies
-
-        revision: Union[Unset, dict[str, Any]] = UNSET
-        if (
-            self.revision
-            and not isinstance(self.revision, Unset)
-            and not isinstance(self.revision, dict)
-        ):
-            revision = self.revision.to_dict()
-        elif self.revision and isinstance(self.revision, dict):
-            revision = self.revision
-
-        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
-
-        sandbox = self.sandbox
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if configurations is not UNSET:
-            field_dict["configurations"] = configurations
-        if enabled is not UNSET:
-            field_dict["enabled"] = enabled
-        if flavors is not UNSET:
-            field_dict["flavors"] = flavors
-        if integration_connections is not UNSET:
-            field_dict["integrationConnections"] = integration_connections
-        if policies is not UNSET:
-            field_dict["policies"] = policies
-        if revision is not UNSET:
-            field_dict["revision"] = revision
-        if runtime is not UNSET:
-            field_dict["runtime"] = runtime
-        if sandbox is not UNSET:
-            field_dict["sandbox"] = sandbox
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.core_spec_configurations import CoreSpecConfigurations
-        from ..models.flavor import Flavor
-        from ..models.revision_configuration import RevisionConfiguration
-        from ..models.runtime import Runtime
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        _configurations = d.pop("configurations", UNSET)
-        configurations: Union[Unset, CoreSpecConfigurations]
-        if isinstance(_configurations, Unset):
-            configurations = UNSET
-        else:
-            configurations = CoreSpecConfigurations.from_dict(_configurations)
-
-        enabled = d.pop("enabled", UNSET)
-
-        flavors = []
-        _flavors = d.pop("flavors", UNSET)
-        for componentsschemas_flavors_item_data in _flavors or []:
-            componentsschemas_flavors_item = Flavor.from_dict(componentsschemas_flavors_item_data)
-
-            flavors.append(componentsschemas_flavors_item)
-
-        integration_connections = cast(
-            list[str], d.pop("integrationConnections", d.pop("integration_connections", UNSET))
-        )
-
-        policies = cast(list[str], d.pop("policies", UNSET))
-
-        _revision = d.pop("revision", UNSET)
-        revision: Union[Unset, RevisionConfiguration]
-        if isinstance(_revision, Unset):
-            revision = UNSET
-        else:
-            revision = RevisionConfiguration.from_dict(_revision)
-
-        _runtime = d.pop("runtime", UNSET)
-        runtime: Union[Unset, Runtime]
-        if isinstance(_runtime, Unset):
-            runtime = UNSET
-        else:
-            runtime = Runtime.from_dict(_runtime)
-
-        sandbox = d.pop("sandbox", UNSET)
-
-        core_spec = cls(
-            configurations=configurations,
-            enabled=enabled,
-            flavors=flavors,
-            integration_connections=integration_connections,
-            policies=policies,
-            revision=revision,
-            runtime=runtime,
-            sandbox=sandbox,
-        )
-
-        core_spec.additional_properties = d
-        return core_spec
-
-    @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/core_spec_configurations.py

@@ -1,77 +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.spec_configuration import SpecConfiguration
-
-
-T = TypeVar("T", bound="CoreSpecConfigurations")
-
-
-@_attrs_define
-class CoreSpecConfigurations:
-    """Optional configurations for the object
-
-    Attributes:
-        key (Union[Unset, SpecConfiguration]): Configuration, this is a key value storage. In your object you can
-            retrieve the value with config[key]
-    """
-
-    key: Union[Unset, "SpecConfiguration"] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        key: Union[Unset, dict[str, Any]] = UNSET
-        if self.key and not isinstance(self.key, Unset) and not isinstance(self.key, dict):
-            key = self.key.to_dict()
-        elif self.key and isinstance(self.key, dict):
-            key = self.key
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if key is not UNSET:
-            field_dict["key"] = key
-
-        return field_dict
-
-    @classmethod
-    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T | None:
-        from ..models.spec_configuration import SpecConfiguration
-
-        if not src_dict:
-            return None
-        d = src_dict.copy()
-        _key = d.pop("key", UNSET)
-        key: Union[Unset, SpecConfiguration]
-        if isinstance(_key, Unset):
-            key = UNSET
-        else:
-            key = SpecConfiguration.from_dict(_key)
-
-        core_spec_configurations = cls(
-            key=key,
-        )
-
-        core_spec_configurations.additional_properties = d
-        return core_spec_configurations
-
-    @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/histogram_bucket.py

@@ -1,79 +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="HistogramBucket")
-
-
-@_attrs_define
-class HistogramBucket:
-    """Histogram bucket
-
-    Attributes:
-        count (Union[Unset, int]): Count
-        end (Union[Unset, float]): End
-        start (Union[Unset, float]): Start
-    """
-
-    count: Union[Unset, int] = UNSET
-    end: Union[Unset, float] = UNSET
-    start: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        count = self.count
-
-        end = self.end
-
-        start = self.start
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if count is not UNSET:
-            field_dict["count"] = count
-        if end is not UNSET:
-            field_dict["end"] = end
-        if start is not UNSET:
-            field_dict["start"] = start
-
-        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()
-        count = d.pop("count", UNSET)
-
-        end = d.pop("end", UNSET)
-
-        start = d.pop("start", UNSET)
-
-        histogram_bucket = cls(
-            count=count,
-            end=end,
-            start=start,
-        )
-
-        histogram_bucket.additional_properties = d
-        return histogram_bucket
-
-    @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/histogram_stats.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="HistogramStats")
-
-
-@_attrs_define
-class HistogramStats:
-    """Histogram stats
-
-    Attributes:
-        average (Union[Unset, float]): Average request duration
-        p50 (Union[Unset, float]): P50 request duration
-        p90 (Union[Unset, float]): P90 request duration
-        p99 (Union[Unset, float]): P99 request duration
-    """
-
-    average: Union[Unset, float] = UNSET
-    p50: Union[Unset, float] = UNSET
-    p90: Union[Unset, float] = UNSET
-    p99: Union[Unset, float] = UNSET
-    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        average = self.average
-
-        p50 = self.p50
-
-        p90 = self.p90
-
-        p99 = self.p99
-
-        field_dict: dict[str, Any] = {}
-        field_dict.update(self.additional_properties)
-        field_dict.update({})
-        if average is not UNSET:
-            field_dict["average"] = average
-        if p50 is not UNSET:
-            field_dict["p50"] = p50
-        if p90 is not UNSET:
-            field_dict["p90"] = p90
-        if p99 is not UNSET:
-            field_dict["p99"] = p99
-
-        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()
-        average = d.pop("average", UNSET)
-
-        p50 = d.pop("p50", UNSET)
-
-        p90 = d.pop("p90", UNSET)
-
-        p99 = d.pop("p99", UNSET)
-
-        histogram_stats = cls(
-            average=average,
-            p50=p50,
-            p90=p90,
-            p99=p99,
-        )
-
-        histogram_stats.additional_properties = d
-        return histogram_stats
-
-    @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