mithril-client 0.1.0a1__cp314-cp314-macosx_10_12_x86_64.whl

mithril/api/bindings/client.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import ssl
+from typing import Any
+
+import httpx
+from attrs import define, evolve, field
+
+
+@define
+class Client:
+    """A class for keeping track of data related to the API
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: str | bool | ssl.SSLContext = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: httpx.Client | None = field(default=None, init=False)
+    _async_client: httpx.AsyncClient | None = field(default=None, init=False)
+
+    def with_headers(self, headers: dict[str, str]) -> Client:
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> Client:
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> Client:
+        """Get a new client matching this one with a new timeout configuration"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> Client:
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> Client:
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> Client:
+        """Manually set the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> Client:
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: object, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)
+
+
+@define
+class AuthenticatedClient:
+    """A Client which has been authenticated for use on secured endpoints
+
+    The following are accepted as keyword arguments and will be used to construct httpx Clients internally:
+
+        ``base_url``: The base URL for the API, all requests are made to a relative path to this URL
+
+        ``cookies``: A dictionary of cookies to be sent with every request
+
+        ``headers``: A dictionary of headers to be sent with every request
+
+        ``timeout``: The maximum amount of a time a request can take. API functions will raise
+        httpx.TimeoutException if this is exceeded.
+
+        ``verify_ssl``: Whether or not to verify the SSL certificate of the API server. This should be True in production,
+        but can be set to False for testing purposes.
+
+        ``follow_redirects``: Whether or not to follow redirects. Default value is False.
+
+        ``httpx_args``: A dictionary of additional arguments to be passed to the ``httpx.Client`` and ``httpx.AsyncClient`` constructor.
+
+
+    Attributes:
+        raise_on_unexpected_status: Whether or not to raise an errors.UnexpectedStatus if the API returns a
+            status code that was not documented in the source OpenAPI document. Can also be provided as a keyword
+            argument to the constructor.
+        token: The token to use for authentication
+        prefix: The prefix to use for the Authorization header
+        auth_header_name: The name of the Authorization header
+    """
+
+    raise_on_unexpected_status: bool = field(default=False, kw_only=True)
+    _base_url: str = field(alias="base_url")
+    _cookies: dict[str, str] = field(factory=dict, kw_only=True, alias="cookies")
+    _headers: dict[str, str] = field(factory=dict, kw_only=True, alias="headers")
+    _timeout: httpx.Timeout | None = field(default=None, kw_only=True, alias="timeout")
+    _verify_ssl: str | bool | ssl.SSLContext = field(
+        default=True, kw_only=True, alias="verify_ssl"
+    )
+    _follow_redirects: bool = field(
+        default=False, kw_only=True, alias="follow_redirects"
+    )
+    _httpx_args: dict[str, Any] = field(factory=dict, kw_only=True, alias="httpx_args")
+    _client: httpx.Client | None = field(default=None, init=False)
+    _async_client: httpx.AsyncClient | None = field(default=None, init=False)
+
+    token: str
+    prefix: str = "Bearer"
+    auth_header_name: str = "Authorization"
+
+    def with_headers(self, headers: dict[str, str]) -> AuthenticatedClient:
+        """Get a new client matching this one with additional headers"""
+        if self._client is not None:
+            self._client.headers.update(headers)
+        if self._async_client is not None:
+            self._async_client.headers.update(headers)
+        return evolve(self, headers={**self._headers, **headers})
+
+    def with_cookies(self, cookies: dict[str, str]) -> AuthenticatedClient:
+        """Get a new client matching this one with additional cookies"""
+        if self._client is not None:
+            self._client.cookies.update(cookies)
+        if self._async_client is not None:
+            self._async_client.cookies.update(cookies)
+        return evolve(self, cookies={**self._cookies, **cookies})
+
+    def with_timeout(self, timeout: httpx.Timeout) -> AuthenticatedClient:
+        """Get a new client matching this one with a new timeout configuration"""
+        if self._client is not None:
+            self._client.timeout = timeout
+        if self._async_client is not None:
+            self._async_client.timeout = timeout
+        return evolve(self, timeout=timeout)
+
+    def set_httpx_client(self, client: httpx.Client) -> AuthenticatedClient:
+        """Manually set the underlying httpx.Client
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._client = client
+        return self
+
+    def get_httpx_client(self) -> httpx.Client:
+        """Get the underlying httpx.Client, constructing a new one if not previously set"""
+        if self._client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._client
+
+    def __enter__(self) -> AuthenticatedClient:
+        """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
+        self.get_httpx_client().__enter__()
+        return self
+
+    def __exit__(self, *args: object, **kwargs: Any) -> None:
+        """Exit a context manager for internal httpx.Client (see httpx docs)"""
+        self.get_httpx_client().__exit__(*args, **kwargs)
+
+    def set_async_httpx_client(
+        self, async_client: httpx.AsyncClient
+    ) -> AuthenticatedClient:
+        """Manually set the underlying httpx.AsyncClient
+
+        **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
+        """
+        self._async_client = async_client
+        return self
+
+    def get_async_httpx_client(self) -> httpx.AsyncClient:
+        """Get the underlying httpx.AsyncClient, constructing a new one if not previously set"""
+        if self._async_client is None:
+            self._headers[self.auth_header_name] = (
+                f"{self.prefix} {self.token}" if self.prefix else self.token
+            )
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                cookies=self._cookies,
+                headers=self._headers,
+                timeout=self._timeout,
+                verify=self._verify_ssl,
+                follow_redirects=self._follow_redirects,
+                **self._httpx_args,
+            )
+        return self._async_client
+
+    async def __aenter__(self) -> AuthenticatedClient:
+        """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
+        await self.get_async_httpx_client().__aenter__()
+        return self
+
+    async def __aexit__(self, *args: object, **kwargs: Any) -> None:
+        """Exit a context manager for underlying httpx.AsyncClient (see httpx docs)"""
+        await self.get_async_httpx_client().__aexit__(*args, **kwargs)

mithril/api/bindings/errors.py

@@ -0,0 +1,18 @@
+"""Contains shared errors types that can be raised from API functions"""
+
+from __future__ import annotations
+
+
+class UnexpectedStatus(Exception):
+    """Raised by api functions when the response status an undocumented status and Client.raise_on_unexpected_status is True"""
+
+    def __init__(self, status_code: int, content: bytes):
+        self.status_code = status_code
+        self.content = content
+
+        super().__init__(
+            f"Unexpected status code: {status_code}\n\nResponse content:\n{content.decode(errors='ignore')}"
+        )
+
+
+__all__ = ["UnexpectedStatus"]

mithril/api/bindings/models/__init__.py

@@ -0,0 +1,169 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from __future__ import annotations
+
+from .api_key_model import ApiKeyModel
+from .auction_model import AuctionModel
+from .availability_slot_model import AvailabilitySlotModel
+from .bid_history_event_model import BidHistoryEventModel
+from .bid_history_event_model_event_type import BidHistoryEventModelEventType
+from .bid_history_response import BidHistoryResponse
+from .bid_model import BidModel
+from .bid_model_status import BidModelStatus
+from .bid_status_response import BidStatusResponse
+from .bid_status_response_status import BidStatusResponseStatus
+from .check_availability_response import CheckAvailabilityResponse
+from .create_api_key_request import CreateApiKeyRequest
+from .create_api_key_response import CreateApiKeyResponse
+from .create_bid_request import CreateBidRequest
+from .create_kubernetes_cluster_request import CreateKubernetesClusterRequest
+from .create_kubernetes_cluster_request_k8s_version import (
+    CreateKubernetesClusterRequestK8SVersion,
+)
+from .create_lifecycle_script_request import CreateLifecycleScriptRequest
+from .create_reservation_request import CreateReservationRequest
+from .create_ssh_key_request import CreateSshKeyRequest
+from .create_volume_request import CreateVolumeRequest
+from .create_volume_request_disk_interface import CreateVolumeRequestDiskInterface
+from .created_ssh_key_model import CreatedSshKeyModel
+from .current_prices_response import CurrentPricesResponse
+from .extend_reservation_request import ExtendReservationRequest
+from .extension_availability_response import ExtensionAvailabilityResponse
+from .get_availability_v2_reservation_availability_get_mode import (
+    GetAvailabilityV2ReservationAvailabilityGetMode,
+)
+from .get_bids_response import GetBidsResponse
+from .get_bids_v2_spot_bids_get_sort_by import GetBidsV2SpotBidsGetSortBy
+from .get_bids_v2_spot_bids_get_status import GetBidsV2SpotBidsGetStatus
+from .get_instances_response import GetInstancesResponse
+from .get_instances_v2_instances_get_order_type_in_type_0_item import (
+    GetInstancesV2InstancesGetOrderTypeInType0Item,
+)
+from .get_instances_v2_instances_get_sort_by import GetInstancesV2InstancesGetSortBy
+from .get_instances_v2_instances_get_status_in_type_0_item import (
+    GetInstancesV2InstancesGetStatusInType0Item,
+)
+from .get_latest_end_time_response import GetLatestEndTimeResponse
+from .get_reservations_response import GetReservationsResponse
+from .get_reservations_v2_reservation_get_sort_by import (
+    GetReservationsV2ReservationGetSortBy,
+)
+from .get_reservations_v2_reservation_get_status import (
+    GetReservationsV2ReservationGetStatus,
+)
+from .historical_price_point_model import HistoricalPricePointModel
+from .historical_prices_response_model import HistoricalPricesResponseModel
+from .http_validation_error import HTTPValidationError
+from .image_version_model import ImageVersionModel
+from .instance_model import InstanceModel
+from .instance_model_status import InstanceModelStatus
+from .instance_status_response import InstanceStatusResponse
+from .instance_status_response_status import InstanceStatusResponseStatus
+from .instance_type_model import InstanceTypeModel
+from .kubernetes_cluster_model import KubernetesClusterModel
+from .kubernetes_cluster_model_status import KubernetesClusterModelStatus
+from .launch_specification_model import LaunchSpecificationModel
+from .lifecycle_script_model import LifecycleScriptModel
+from .lifecycle_script_scope import LifecycleScriptScope
+from .list_lifecycle_scripts_response import ListLifecycleScriptsResponse
+from .list_lifecycle_scripts_v2_lifecycle_scripts_get_sort_by import (
+    ListLifecycleScriptsV2LifecycleScriptsGetSortBy,
+)
+from .me_response import MeResponse
+from .new_ssh_key_model import NewSshKeyModel
+from .persistent_disk_change import PersistentDiskChange
+from .project_model import ProjectModel
+from .public_lifecycle_script_scope import PublicLifecycleScriptScope
+from .quota_model import QuotaModel
+from .reservation_model import ReservationModel
+from .reservation_model_status import ReservationModelStatus
+from .size import Size
+from .size_unit import SizeUnit
+from .sort_direction import SortDirection
+from .teammate_response import TeammateResponse
+from .update_bid_request import UpdateBidRequest
+from .update_lifecycle_script_request import UpdateLifecycleScriptRequest
+from .update_reservation_request import UpdateReservationRequest
+from .update_ssh_key_request import UpdateSshKeyRequest
+from .update_volume_request import UpdateVolumeRequest
+from .validation_error import ValidationError
+from .volume_model import VolumeModel
+from .volume_model_attachments import VolumeModelAttachments
+from .volume_model_interface import VolumeModelInterface
+
+__all__ = (
+    "ApiKeyModel",
+    "AuctionModel",
+    "AvailabilitySlotModel",
+    "BidHistoryEventModel",
+    "BidHistoryEventModelEventType",
+    "BidHistoryResponse",
+    "BidModel",
+    "BidModelStatus",
+    "BidStatusResponse",
+    "BidStatusResponseStatus",
+    "CheckAvailabilityResponse",
+    "CreateApiKeyRequest",
+    "CreateApiKeyResponse",
+    "CreateBidRequest",
+    "CreateKubernetesClusterRequest",
+    "CreateKubernetesClusterRequestK8SVersion",
+    "CreateLifecycleScriptRequest",
+    "CreateReservationRequest",
+    "CreateSshKeyRequest",
+    "CreateVolumeRequest",
+    "CreateVolumeRequestDiskInterface",
+    "CreatedSshKeyModel",
+    "CurrentPricesResponse",
+    "ExtendReservationRequest",
+    "ExtensionAvailabilityResponse",
+    "GetAvailabilityV2ReservationAvailabilityGetMode",
+    "GetBidsResponse",
+    "GetBidsV2SpotBidsGetSortBy",
+    "GetBidsV2SpotBidsGetStatus",
+    "GetInstancesResponse",
+    "GetInstancesV2InstancesGetOrderTypeInType0Item",
+    "GetInstancesV2InstancesGetSortBy",
+    "GetInstancesV2InstancesGetStatusInType0Item",
+    "GetLatestEndTimeResponse",
+    "GetReservationsResponse",
+    "GetReservationsV2ReservationGetSortBy",
+    "GetReservationsV2ReservationGetStatus",
+    "HTTPValidationError",
+    "HistoricalPricePointModel",
+    "HistoricalPricesResponseModel",
+    "ImageVersionModel",
+    "InstanceModel",
+    "InstanceModelStatus",
+    "InstanceStatusResponse",
+    "InstanceStatusResponseStatus",
+    "InstanceTypeModel",
+    "KubernetesClusterModel",
+    "KubernetesClusterModelStatus",
+    "LaunchSpecificationModel",
+    "LifecycleScriptModel",
+    "LifecycleScriptScope",
+    "ListLifecycleScriptsResponse",
+    "ListLifecycleScriptsV2LifecycleScriptsGetSortBy",
+    "MeResponse",
+    "NewSshKeyModel",
+    "PersistentDiskChange",
+    "ProjectModel",
+    "PublicLifecycleScriptScope",
+    "QuotaModel",
+    "ReservationModel",
+    "ReservationModelStatus",
+    "Size",
+    "SizeUnit",
+    "SortDirection",
+    "TeammateResponse",
+    "UpdateBidRequest",
+    "UpdateLifecycleScriptRequest",
+    "UpdateReservationRequest",
+    "UpdateSshKeyRequest",
+    "UpdateVolumeRequest",
+    "ValidationError",
+    "VolumeModel",
+    "VolumeModelAttachments",
+    "VolumeModelInterface",
+)

mithril/api/bindings/models/api_key_model.py

@@ -0,0 +1,114 @@
+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="ApiKeyModel")
+
+
+@_attrs_define
+class ApiKeyModel:
+    """Attributes:
+    fid (str):
+    name (str):
+    created_at (str):
+    expires_at (str):
+    snippet (str):
+    deactivated_at (None | str | Unset):
+    """
+
+    fid: str
+    name: str
+    created_at: str
+    expires_at: str
+    snippet: str
+    deactivated_at: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        fid = self.fid
+
+        name = self.name
+
+        created_at = self.created_at
+
+        expires_at = self.expires_at
+
+        snippet = self.snippet
+
+        deactivated_at: None | str | Unset
+        if isinstance(self.deactivated_at, Unset):
+            deactivated_at = UNSET
+        else:
+            deactivated_at = self.deactivated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "fid": fid,
+                "name": name,
+                "created_at": created_at,
+                "expires_at": expires_at,
+                "snippet": snippet,
+            }
+        )
+        if deactivated_at is not UNSET:
+            field_dict["deactivated_at"] = deactivated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        fid = d.pop("fid")
+
+        name = d.pop("name")
+
+        created_at = d.pop("created_at")
+
+        expires_at = d.pop("expires_at")
+
+        snippet = d.pop("snippet")
+
+        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))
+
+        api_key_model = cls(
+            fid=fid,
+            name=name,
+            created_at=created_at,
+            expires_at=expires_at,
+            snippet=snippet,
+            deactivated_at=deactivated_at,
+        )
+
+        api_key_model.additional_properties = d
+        return api_key_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