mithril-client 0.1.0a1__cp314-cp314-macosx_11_0_arm64.whl

mithril/api/bindings/models/current_prices_response.py

@@ -0,0 +1,202 @@
+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="CurrentPricesResponse")
+
+
+@_attrs_define
+class CurrentPricesResponse:
+    """Attributes:
+    spot_price_cents (int | None | Unset):
+    reserved_price_cents (int | None | Unset):
+    minimum_price_cents (int | None | Unset):
+    lowest_allocated_bid_cents (int | None | Unset):
+    dynamic_win_price_cents (int | None | Unset):
+    available_capacity (int | None | Unset):
+    total_capacity (int | None | Unset):
+    """
+
+    spot_price_cents: int | None | Unset = UNSET
+    reserved_price_cents: int | None | Unset = UNSET
+    minimum_price_cents: int | None | Unset = UNSET
+    lowest_allocated_bid_cents: int | None | Unset = UNSET
+    dynamic_win_price_cents: int | None | Unset = UNSET
+    available_capacity: int | None | Unset = UNSET
+    total_capacity: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        spot_price_cents: int | None | Unset
+        if isinstance(self.spot_price_cents, Unset):
+            spot_price_cents = UNSET
+        else:
+            spot_price_cents = self.spot_price_cents
+
+        reserved_price_cents: int | None | Unset
+        if isinstance(self.reserved_price_cents, Unset):
+            reserved_price_cents = UNSET
+        else:
+            reserved_price_cents = self.reserved_price_cents
+
+        minimum_price_cents: int | None | Unset
+        if isinstance(self.minimum_price_cents, Unset):
+            minimum_price_cents = UNSET
+        else:
+            minimum_price_cents = self.minimum_price_cents
+
+        lowest_allocated_bid_cents: int | None | Unset
+        if isinstance(self.lowest_allocated_bid_cents, Unset):
+            lowest_allocated_bid_cents = UNSET
+        else:
+            lowest_allocated_bid_cents = self.lowest_allocated_bid_cents
+
+        dynamic_win_price_cents: int | None | Unset
+        if isinstance(self.dynamic_win_price_cents, Unset):
+            dynamic_win_price_cents = UNSET
+        else:
+            dynamic_win_price_cents = self.dynamic_win_price_cents
+
+        available_capacity: int | None | Unset
+        if isinstance(self.available_capacity, Unset):
+            available_capacity = UNSET
+        else:
+            available_capacity = self.available_capacity
+
+        total_capacity: int | None | Unset
+        if isinstance(self.total_capacity, Unset):
+            total_capacity = UNSET
+        else:
+            total_capacity = self.total_capacity
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if spot_price_cents is not UNSET:
+            field_dict["spot_price_cents"] = spot_price_cents
+        if reserved_price_cents is not UNSET:
+            field_dict["reserved_price_cents"] = reserved_price_cents
+        if minimum_price_cents is not UNSET:
+            field_dict["minimum_price_cents"] = minimum_price_cents
+        if lowest_allocated_bid_cents is not UNSET:
+            field_dict["lowest_allocated_bid_cents"] = lowest_allocated_bid_cents
+        if dynamic_win_price_cents is not UNSET:
+            field_dict["dynamic_win_price_cents"] = dynamic_win_price_cents
+        if available_capacity is not UNSET:
+            field_dict["available_capacity"] = available_capacity
+        if total_capacity is not UNSET:
+            field_dict["total_capacity"] = total_capacity
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+
+        def _parse_spot_price_cents(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        spot_price_cents = _parse_spot_price_cents(d.pop("spot_price_cents", UNSET))
+
+        def _parse_reserved_price_cents(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        reserved_price_cents = _parse_reserved_price_cents(
+            d.pop("reserved_price_cents", UNSET)
+        )
+
+        def _parse_minimum_price_cents(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        minimum_price_cents = _parse_minimum_price_cents(
+            d.pop("minimum_price_cents", UNSET)
+        )
+
+        def _parse_lowest_allocated_bid_cents(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        lowest_allocated_bid_cents = _parse_lowest_allocated_bid_cents(
+            d.pop("lowest_allocated_bid_cents", UNSET)
+        )
+
+        def _parse_dynamic_win_price_cents(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        dynamic_win_price_cents = _parse_dynamic_win_price_cents(
+            d.pop("dynamic_win_price_cents", UNSET)
+        )
+
+        def _parse_available_capacity(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        available_capacity = _parse_available_capacity(
+            d.pop("available_capacity", UNSET)
+        )
+
+        def _parse_total_capacity(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        total_capacity = _parse_total_capacity(d.pop("total_capacity", UNSET))
+
+        current_prices_response = cls(
+            spot_price_cents=spot_price_cents,
+            reserved_price_cents=reserved_price_cents,
+            minimum_price_cents=minimum_price_cents,
+            lowest_allocated_bid_cents=lowest_allocated_bid_cents,
+            dynamic_win_price_cents=dynamic_win_price_cents,
+            available_capacity=available_capacity,
+            total_capacity=total_capacity,
+        )
+
+        current_prices_response.additional_properties = d
+        return current_prices_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/extend_reservation_request.py

@@ -0,0 +1,60 @@
+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="ExtendReservationRequest")
+
+
+@_attrs_define
+class ExtendReservationRequest:
+    """Attributes:
+    end_time (str):
+    """
+
+    end_time: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        end_time = self.end_time
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "end_time": end_time,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        end_time = d.pop("end_time")
+
+        extend_reservation_request = cls(
+            end_time=end_time,
+        )
+
+        extend_reservation_request.additional_properties = d
+        return extend_reservation_request
+
+    @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/extension_availability_response.py

@@ -0,0 +1,68 @@
+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="ExtensionAvailabilityResponse")
+
+
+@_attrs_define
+class ExtensionAvailabilityResponse:
+    """Attributes:
+    latest_extension_time (str):
+    available (bool):
+    """
+
+    latest_extension_time: str
+    available: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        latest_extension_time = self.latest_extension_time
+
+        available = self.available
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "latest_extension_time": latest_extension_time,
+                "available": available,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        latest_extension_time = d.pop("latest_extension_time")
+
+        available = d.pop("available")
+
+        extension_availability_response = cls(
+            latest_extension_time=latest_extension_time,
+            available=available,
+        )
+
+        extension_availability_response.additional_properties = d
+        return extension_availability_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_availability_v2_reservation_availability_get_mode.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetAvailabilityV2ReservationAvailabilityGetMode(str, Enum):
+    CHECK = "check"
+    LATEST_END_TIME = "latest_end_time"
+    SLOTS = "slots"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_bids_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.bid_model import BidModel
+
+
+T = TypeVar("T", bound="GetBidsResponse")
+
+
+@_attrs_define
+class GetBidsResponse:
+    """Attributes:
+    data (list[BidModel]):
+    next_cursor (None | str | Unset):
+    """
+
+    data: list[BidModel]
+    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.bid_model import BidModel
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = BidModel.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_bids_response = cls(
+            data=data,
+            next_cursor=next_cursor,
+        )
+
+        get_bids_response.additional_properties = d
+        return get_bids_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_bids_v2_spot_bids_get_sort_by.py

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

mithril/api/bindings/models/get_bids_v2_spot_bids_get_status.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetBidsV2SpotBidsGetStatus(str, Enum):
+    ALLOCATED = "Allocated"
+    OPEN = "Open"
+    PAUSED = "Paused"
+    PREEMPTING = "Preempting"
+    TERMINATED = "Terminated"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_instances_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.instance_model import InstanceModel
+
+
+T = TypeVar("T", bound="GetInstancesResponse")
+
+
+@_attrs_define
+class GetInstancesResponse:
+    """Attributes:
+    data (list[InstanceModel]):
+    next_cursor (None | str | Unset):
+    """
+
+    data: list[InstanceModel]
+    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.instance_model import InstanceModel
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InstanceModel.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_instances_response = cls(
+            data=data,
+            next_cursor=next_cursor,
+        )
+
+        get_instances_response.additional_properties = d
+        return get_instances_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_instances_v2_instances_get_order_type_in_type_0_item.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetInstancesV2InstancesGetOrderTypeInType0Item(str, Enum):
+    BID = "Bid"
+    RESERVATION = "Reservation"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_instances_v2_instances_get_sort_by.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetInstancesV2InstancesGetSortBy(str, Enum):
+    CREATED_AT = "created_at"
+    INSTANCE_STATUS = "instance_status"
+    INSTANCE_TYPE_FID = "instance_type_fid"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_instances_v2_instances_get_status_in_type_0_item.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class GetInstancesV2InstancesGetStatusInType0Item(str, Enum):
+    STATUS_CONFIRMED = "STATUS_CONFIRMED"
+    STATUS_ERROR = "STATUS_ERROR"
+    STATUS_INITIALIZING = "STATUS_INITIALIZING"
+    STATUS_NEW = "STATUS_NEW"
+    STATUS_PAUSED = "STATUS_PAUSED"
+    STATUS_PREEMPTED = "STATUS_PREEMPTED"
+    STATUS_PREEMPTING = "STATUS_PREEMPTING"
+    STATUS_RELOCATING = "STATUS_RELOCATING"
+    STATUS_REPLACED = "STATUS_REPLACED"
+    STATUS_RUNNING = "STATUS_RUNNING"
+    STATUS_SCHEDULED = "STATUS_SCHEDULED"
+    STATUS_STARTING = "STATUS_STARTING"
+    STATUS_STOPPED = "STATUS_STOPPED"
+    STATUS_STOPPING = "STATUS_STOPPING"
+    STATUS_TERMINATED = "STATUS_TERMINATED"
+
+    def __str__(self) -> str:
+        return str(self.value)

mithril/api/bindings/models/get_latest_end_time_response.py

@@ -0,0 +1,68 @@
+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="GetLatestEndTimeResponse")
+
+
+@_attrs_define
+class GetLatestEndTimeResponse:
+    """Attributes:
+    latest_end_time (str):
+    available (bool):
+    """
+
+    latest_end_time: str
+    available: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        latest_end_time = self.latest_end_time
+
+        available = self.available
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "latest_end_time": latest_end_time,
+                "available": available,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        latest_end_time = d.pop("latest_end_time")
+
+        available = d.pop("available")
+
+        get_latest_end_time_response = cls(
+            latest_end_time=latest_end_time,
+            available=available,
+        )
+
+        get_latest_end_time_response.additional_properties = d
+        return get_latest_end_time_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