mithril-client 0.1.0a1__cp314-cp314-macosx_11_0_arm64.whl

mithril/api/bindings/models/get_reservations_response.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, 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.reservation_model import ReservationModel
+
+
+T = TypeVar("T", bound="GetReservationsResponse")
+
+
+@_attrs_define
+class GetReservationsResponse:
+    """Attributes:
+    data (list[ReservationModel]):
+    next_cursor (None | str | Unset):
+    """
+
+    data: list[ReservationModel]
+    next_cursor: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        next_cursor: None | str | Unset
+        if isinstance(self.next_cursor, Unset):
+            next_cursor = UNSET
+        else:
+            next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+            }
+        )
+        if next_cursor is not UNSET:
+            field_dict["next_cursor"] = next_cursor
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.reservation_model import ReservationModel
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = ReservationModel.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        def _parse_next_cursor(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor", UNSET))
+
+        get_reservations_response = cls(
+            data=data,
+            next_cursor=next_cursor,
+        )
+
+        get_reservations_response.additional_properties = d
+        return get_reservations_response
+
+    @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

mithril/api/bindings/models/get_reservations_v2_reservation_get_sort_by.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetReservationsV2ReservationGetSortBy(str, Enum):
+    CREATED_AT = "created_at"
+    STATUS = "status"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_reservations_v2_reservation_get_status.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetReservationsV2ReservationGetStatus(str, Enum):
+    ACTIVE = "Active"
+    CANCELED = "Canceled"
+    ENDED = "Ended"
+    PAUSED = "Paused"
+    PENDING = "Pending"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/historical_price_point_model.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="HistoricalPricePointModel")
+
+
+@_attrs_define
+class HistoricalPricePointModel:
+    """A single historical price point for an instance type in a region.
+
+    Attributes:
+        spot_instance_price (str): Spot price per hour in dollars
+        reserved_instance_price (str): Reserved price per hour in dollars
+        timestamp (str): Timestamp when this price was recorded
+        instance_type (str): Instance type FID
+        region (str): Region name
+    """
+
+    spot_instance_price: str
+    reserved_instance_price: str
+    timestamp: str
+    instance_type: str
+    region: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        spot_instance_price = self.spot_instance_price
+
+        reserved_instance_price = self.reserved_instance_price
+
+        timestamp = self.timestamp
+
+        instance_type = self.instance_type
+
+        region = self.region
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "spot_instance_price": spot_instance_price,
+                "reserved_instance_price": reserved_instance_price,
+                "timestamp": timestamp,
+                "instance_type": instance_type,
+                "region": region,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        spot_instance_price = d.pop("spot_instance_price")
+
+        reserved_instance_price = d.pop("reserved_instance_price")
+
+        timestamp = d.pop("timestamp")
+
+        instance_type = d.pop("instance_type")
+
+        region = d.pop("region")
+
+        historical_price_point_model = cls(
+            spot_instance_price=spot_instance_price,
+            reserved_instance_price=reserved_instance_price,
+            timestamp=timestamp,
+            instance_type=instance_type,
+            region=region,
+        )
+
+        historical_price_point_model.additional_properties = d
+        return historical_price_point_model
+
+    @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

mithril/api/bindings/models/historical_prices_response_model.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.historical_price_point_model import HistoricalPricePointModel
+
+
+T = TypeVar("T", bound="HistoricalPricesResponseModel")
+
+
+@_attrs_define
+class HistoricalPricesResponseModel:
+    """Response model for historical pricing data.
+
+    Attributes:
+        prices (list[HistoricalPricePointModel]): List of historical price points
+    """
+
+    prices: list[HistoricalPricePointModel]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prices = []
+        for prices_item_data in self.prices:
+            prices_item = prices_item_data.to_dict()
+            prices.append(prices_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prices": prices,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.historical_price_point_model import HistoricalPricePointModel
+
+        d = dict(src_dict)
+        prices = []
+        _prices = d.pop("prices")
+        for prices_item_data in _prices:
+            prices_item = HistoricalPricePointModel.from_dict(prices_item_data)
+
+            prices.append(prices_item)
+
+        historical_prices_response_model = cls(
+            prices=prices,
+        )
+
+        historical_prices_response_model.additional_properties = d
+        return historical_prices_response_model
+
+    @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

mithril/api/bindings/models/http_validation_error.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error import ValidationError
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """Attributes:
+    detail (list[ValidationError] | Unset):
+    """
+
+    detail: list[ValidationError] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.validation_error import ValidationError
+
+        d = dict(src_dict)
+        _detail = d.pop("detail", UNSET)
+        detail: list[ValidationError] | Unset = UNSET
+        if _detail is not UNSET:
+            detail = []
+            for detail_item_data in _detail:
+                detail_item = ValidationError.from_dict(detail_item_data)
+
+                detail.append(detail_item)
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @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

mithril/api/bindings/models/image_version_model.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ImageVersionModel")
+
+
+@_attrs_define
+class ImageVersionModel:
+    """Attributes:
+    image_version_fid (str):
+    image_version_name (str):
+    os (str):
+    kernel (str):
+    stable (bool):
+    supported_regions (list[str]):
+    deactivated_at (None | str | Unset):
+    nvidia_driver (None | str | Unset):
+    cuda (None | str | Unset):
+    cuda_toolkit (None | str | Unset):
+    nvidia_container_toolkit (None | str | Unset):
+    packages (None | str | Unset):
+    """
+
+    image_version_fid: str
+    image_version_name: str
+    os: str
+    kernel: str
+    stable: bool
+    supported_regions: list[str]
+    deactivated_at: None | str | Unset = UNSET
+    nvidia_driver: None | str | Unset = UNSET
+    cuda: None | str | Unset = UNSET
+    cuda_toolkit: None | str | Unset = UNSET
+    nvidia_container_toolkit: None | str | Unset = UNSET
+    packages: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        image_version_fid = self.image_version_fid
+
+        image_version_name = self.image_version_name
+
+        os = self.os
+
+        kernel = self.kernel
+
+        stable = self.stable
+
+        supported_regions = self.supported_regions
+
+        deactivated_at: None | str | Unset
+        if isinstance(self.deactivated_at, Unset):
+            deactivated_at = UNSET
+        else:
+            deactivated_at = self.deactivated_at
+
+        nvidia_driver: None | str | Unset
+        if isinstance(self.nvidia_driver, Unset):
+            nvidia_driver = UNSET
+        else:
+            nvidia_driver = self.nvidia_driver
+
+        cuda: None | str | Unset
+        if isinstance(self.cuda, Unset):
+            cuda = UNSET
+        else:
+            cuda = self.cuda
+
+        cuda_toolkit: None | str | Unset
+        if isinstance(self.cuda_toolkit, Unset):
+            cuda_toolkit = UNSET
+        else:
+            cuda_toolkit = self.cuda_toolkit
+
+        nvidia_container_toolkit: None | str | Unset
+        if isinstance(self.nvidia_container_toolkit, Unset):
+            nvidia_container_toolkit = UNSET
+        else:
+            nvidia_container_toolkit = self.nvidia_container_toolkit
+
+        packages: None | str | Unset
+        if isinstance(self.packages, Unset):
+            packages = UNSET
+        else:
+            packages = self.packages
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "image_version_fid": image_version_fid,
+                "image_version_name": image_version_name,
+                "os": os,
+                "kernel": kernel,
+                "stable": stable,
+                "supported_regions": supported_regions,
+            }
+        )
+        if deactivated_at is not UNSET:
+            field_dict["deactivated_at"] = deactivated_at
+        if nvidia_driver is not UNSET:
+            field_dict["nvidia_driver"] = nvidia_driver
+        if cuda is not UNSET:
+            field_dict["cuda"] = cuda
+        if cuda_toolkit is not UNSET:
+            field_dict["cuda_toolkit"] = cuda_toolkit
+        if nvidia_container_toolkit is not UNSET:
+            field_dict["nvidia_container_toolkit"] = nvidia_container_toolkit
+        if packages is not UNSET:
+            field_dict["packages"] = packages
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        image_version_fid = d.pop("image_version_fid")
+
+        image_version_name = d.pop("image_version_name")
+
+        os = d.pop("os")
+
+        kernel = d.pop("kernel")
+
+        stable = d.pop("stable")
+
+        supported_regions = cast(list[str], d.pop("supported_regions"))
+
+        def _parse_deactivated_at(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        deactivated_at = _parse_deactivated_at(d.pop("deactivated_at", UNSET))
+
+        def _parse_nvidia_driver(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        nvidia_driver = _parse_nvidia_driver(d.pop("nvidia_driver", UNSET))
+
+        def _parse_cuda(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        cuda = _parse_cuda(d.pop("cuda", UNSET))
+
+        def _parse_cuda_toolkit(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        cuda_toolkit = _parse_cuda_toolkit(d.pop("cuda_toolkit", UNSET))
+
+        def _parse_nvidia_container_toolkit(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        nvidia_container_toolkit = _parse_nvidia_container_toolkit(
+            d.pop("nvidia_container_toolkit", UNSET)
+        )
+
+        def _parse_packages(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        packages = _parse_packages(d.pop("packages", UNSET))
+
+        image_version_model = cls(
+            image_version_fid=image_version_fid,
+            image_version_name=image_version_name,
+            os=os,
+            kernel=kernel,
+            stable=stable,
+            supported_regions=supported_regions,
+            deactivated_at=deactivated_at,
+            nvidia_driver=nvidia_driver,
+            cuda=cuda,
+            cuda_toolkit=cuda_toolkit,
+            nvidia_container_toolkit=nvidia_container_toolkit,
+            packages=packages,
+        )
+
+        image_version_model.additional_properties = d
+        return image_version_model
+
+    @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