waldur-api-client 7.6.7__py3-none-any.whl → 7.6.9__py3-none-any.whl

waldur_api_client/models/patched_maintenance_announcement_offering_request.py

@@ -0,0 +1,94 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.impact_level_enum import ImpactLevelEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedMaintenanceAnnouncementOfferingRequest")
+
+
+@_attrs_define
+class PatchedMaintenanceAnnouncementOfferingRequest:
+    """
+    Attributes:
+        maintenance (Union[Unset, str]):
+        offering (Union[Unset, str]):
+        impact_level (Union[Unset, ImpactLevelEnum]):
+        impact_description (Union[Unset, str]): Specific description of how this offering will be affected
+    """
+
+    maintenance: Union[Unset, str] = UNSET
+    offering: Union[Unset, str] = UNSET
+    impact_level: Union[Unset, ImpactLevelEnum] = UNSET
+    impact_description: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        maintenance = self.maintenance
+
+        offering = self.offering
+
+        impact_level: Union[Unset, int] = UNSET
+        if not isinstance(self.impact_level, Unset):
+            impact_level = self.impact_level.value
+
+        impact_description = self.impact_description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if maintenance is not UNSET:
+            field_dict["maintenance"] = maintenance
+        if offering is not UNSET:
+            field_dict["offering"] = offering
+        if impact_level is not UNSET:
+            field_dict["impact_level"] = impact_level
+        if impact_description is not UNSET:
+            field_dict["impact_description"] = impact_description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        maintenance = d.pop("maintenance", UNSET)
+
+        offering = d.pop("offering", UNSET)
+
+        _impact_level = d.pop("impact_level", UNSET)
+        impact_level: Union[Unset, ImpactLevelEnum]
+        if isinstance(_impact_level, Unset):
+            impact_level = UNSET
+        else:
+            impact_level = ImpactLevelEnum(_impact_level)
+
+        impact_description = d.pop("impact_description", UNSET)
+
+        patched_maintenance_announcement_offering_request = cls(
+            maintenance=maintenance,
+            offering=offering,
+            impact_level=impact_level,
+            impact_description=impact_description,
+        )
+
+        patched_maintenance_announcement_offering_request.additional_properties = d
+        return patched_maintenance_announcement_offering_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

waldur_api_client/models/patched_maintenance_announcement_offering_template_request.py

@@ -0,0 +1,94 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.impact_level_enum import ImpactLevelEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedMaintenanceAnnouncementOfferingTemplateRequest")
+
+
+@_attrs_define
+class PatchedMaintenanceAnnouncementOfferingTemplateRequest:
+    """
+    Attributes:
+        maintenance_template (Union[Unset, str]):
+        offering (Union[Unset, str]):
+        impact_level (Union[Unset, ImpactLevelEnum]):
+        impact_description (Union[Unset, str]): Specific description of how this offering will be affected
+    """
+
+    maintenance_template: Union[Unset, str] = UNSET
+    offering: Union[Unset, str] = UNSET
+    impact_level: Union[Unset, ImpactLevelEnum] = UNSET
+    impact_description: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        maintenance_template = self.maintenance_template
+
+        offering = self.offering
+
+        impact_level: Union[Unset, int] = UNSET
+        if not isinstance(self.impact_level, Unset):
+            impact_level = self.impact_level.value
+
+        impact_description = self.impact_description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if maintenance_template is not UNSET:
+            field_dict["maintenance_template"] = maintenance_template
+        if offering is not UNSET:
+            field_dict["offering"] = offering
+        if impact_level is not UNSET:
+            field_dict["impact_level"] = impact_level
+        if impact_description is not UNSET:
+            field_dict["impact_description"] = impact_description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        maintenance_template = d.pop("maintenance_template", UNSET)
+
+        offering = d.pop("offering", UNSET)
+
+        _impact_level = d.pop("impact_level", UNSET)
+        impact_level: Union[Unset, ImpactLevelEnum]
+        if isinstance(_impact_level, Unset):
+            impact_level = UNSET
+        else:
+            impact_level = ImpactLevelEnum(_impact_level)
+
+        impact_description = d.pop("impact_description", UNSET)
+
+        patched_maintenance_announcement_offering_template_request = cls(
+            maintenance_template=maintenance_template,
+            offering=offering,
+            impact_level=impact_level,
+            impact_description=impact_description,
+        )
+
+        patched_maintenance_announcement_offering_template_request.additional_properties = d
+        return patched_maintenance_announcement_offering_template_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

waldur_api_client/models/patched_maintenance_announcement_request.py

@@ -0,0 +1,128 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..models.maintenance_type_enum import MaintenanceTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedMaintenanceAnnouncementRequest")
+
+
+@_attrs_define
+class PatchedMaintenanceAnnouncementRequest:
+    """
+    Attributes:
+        name (Union[Unset, str]):
+        message (Union[Unset, str]):
+        maintenance_type (Union[Unset, MaintenanceTypeEnum]):
+        scheduled_start (Union[Unset, datetime.datetime]): When the maintenance is scheduled to begin
+        scheduled_end (Union[Unset, datetime.datetime]): When the maintenance is scheduled to complete
+        service_provider (Union[Unset, str]): Service provider announcing the maintenance
+    """
+
+    name: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+    maintenance_type: Union[Unset, MaintenanceTypeEnum] = UNSET
+    scheduled_start: Union[Unset, datetime.datetime] = UNSET
+    scheduled_end: Union[Unset, datetime.datetime] = UNSET
+    service_provider: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        message = self.message
+
+        maintenance_type: Union[Unset, int] = UNSET
+        if not isinstance(self.maintenance_type, Unset):
+            maintenance_type = self.maintenance_type.value
+
+        scheduled_start: Union[Unset, str] = UNSET
+        if not isinstance(self.scheduled_start, Unset):
+            scheduled_start = self.scheduled_start.isoformat()
+
+        scheduled_end: Union[Unset, str] = UNSET
+        if not isinstance(self.scheduled_end, Unset):
+            scheduled_end = self.scheduled_end.isoformat()
+
+        service_provider = self.service_provider
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if message is not UNSET:
+            field_dict["message"] = message
+        if maintenance_type is not UNSET:
+            field_dict["maintenance_type"] = maintenance_type
+        if scheduled_start is not UNSET:
+            field_dict["scheduled_start"] = scheduled_start
+        if scheduled_end is not UNSET:
+            field_dict["scheduled_end"] = scheduled_end
+        if service_provider is not UNSET:
+            field_dict["service_provider"] = service_provider
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        _maintenance_type = d.pop("maintenance_type", UNSET)
+        maintenance_type: Union[Unset, MaintenanceTypeEnum]
+        if isinstance(_maintenance_type, Unset):
+            maintenance_type = UNSET
+        else:
+            maintenance_type = MaintenanceTypeEnum(_maintenance_type)
+
+        _scheduled_start = d.pop("scheduled_start", UNSET)
+        scheduled_start: Union[Unset, datetime.datetime]
+        if isinstance(_scheduled_start, Unset):
+            scheduled_start = UNSET
+        else:
+            scheduled_start = isoparse(_scheduled_start)
+
+        _scheduled_end = d.pop("scheduled_end", UNSET)
+        scheduled_end: Union[Unset, datetime.datetime]
+        if isinstance(_scheduled_end, Unset):
+            scheduled_end = UNSET
+        else:
+            scheduled_end = isoparse(_scheduled_end)
+
+        service_provider = d.pop("service_provider", UNSET)
+
+        patched_maintenance_announcement_request = cls(
+            name=name,
+            message=message,
+            maintenance_type=maintenance_type,
+            scheduled_start=scheduled_start,
+            scheduled_end=scheduled_end,
+            service_provider=service_provider,
+        )
+
+        patched_maintenance_announcement_request.additional_properties = d
+        return patched_maintenance_announcement_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

waldur_api_client/models/patched_maintenance_announcement_template_request.py

@@ -0,0 +1,94 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.maintenance_type_enum import MaintenanceTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedMaintenanceAnnouncementTemplateRequest")
+
+
+@_attrs_define
+class PatchedMaintenanceAnnouncementTemplateRequest:
+    """
+    Attributes:
+        name (Union[Unset, str]):
+        message (Union[Unset, str]):
+        maintenance_type (Union[Unset, MaintenanceTypeEnum]):
+        service_provider (Union[Unset, str]): Service provider announcing the maintenance
+    """
+
+    name: Union[Unset, str] = UNSET
+    message: Union[Unset, str] = UNSET
+    maintenance_type: Union[Unset, MaintenanceTypeEnum] = UNSET
+    service_provider: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        message = self.message
+
+        maintenance_type: Union[Unset, int] = UNSET
+        if not isinstance(self.maintenance_type, Unset):
+            maintenance_type = self.maintenance_type.value
+
+        service_provider = self.service_provider
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if message is not UNSET:
+            field_dict["message"] = message
+        if maintenance_type is not UNSET:
+            field_dict["maintenance_type"] = maintenance_type
+        if service_provider is not UNSET:
+            field_dict["service_provider"] = service_provider
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        _maintenance_type = d.pop("maintenance_type", UNSET)
+        maintenance_type: Union[Unset, MaintenanceTypeEnum]
+        if isinstance(_maintenance_type, Unset):
+            maintenance_type = UNSET
+        else:
+            maintenance_type = MaintenanceTypeEnum(_maintenance_type)
+
+        service_provider = d.pop("service_provider", UNSET)
+
+        patched_maintenance_announcement_template_request = cls(
+            name=name,
+            message=message,
+            maintenance_type=maintenance_type,
+            service_provider=service_provider,
+        )
+
+        patched_maintenance_announcement_template_request.additional_properties = d
+        return patched_maintenance_announcement_template_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

waldur_api_client/models/update_offering_component_request.py

@@ -0,0 +1,274 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.billing_type_enum import BillingTypeEnum
+from ..models.blank_enum import BlankEnum
+from ..models.limit_period_enum import LimitPeriodEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateOfferingComponentRequest")
+
+
+@_attrs_define
+class UpdateOfferingComponentRequest:
+    """
+    Attributes:
+        uuid (UUID):
+        billing_type (BillingTypeEnum):
+        type_ (str): Unique internal name of the measured unit, for example floating_ip.
+        name (str): Display name for the measured unit, for example, Floating IP.
+        description (Union[Unset, str]):
+        measured_unit (Union[Unset, str]): Unit of measurement, for example, GB.
+        unit_factor (Union[Unset, int]): The conversion factor from backend units to measured_unit
+        limit_period (Union[BlankEnum, LimitPeriodEnum, None, Unset]):
+        limit_amount (Union[None, Unset, int]):
+        article_code (Union[Unset, str]):
+        max_value (Union[None, Unset, int]):
+        min_value (Union[None, Unset, int]):
+        max_available_limit (Union[None, Unset, int]):
+        is_boolean (Union[Unset, bool]):
+        default_limit (Union[None, Unset, int]):
+    """
+
+    uuid: UUID
+    billing_type: BillingTypeEnum
+    type_: str
+    name: str
+    description: Union[Unset, str] = UNSET
+    measured_unit: Union[Unset, str] = UNSET
+    unit_factor: Union[Unset, int] = UNSET
+    limit_period: Union[BlankEnum, LimitPeriodEnum, None, Unset] = UNSET
+    limit_amount: Union[None, Unset, int] = UNSET
+    article_code: Union[Unset, str] = UNSET
+    max_value: Union[None, Unset, int] = UNSET
+    min_value: Union[None, Unset, int] = UNSET
+    max_available_limit: Union[None, Unset, int] = UNSET
+    is_boolean: Union[Unset, bool] = UNSET
+    default_limit: Union[None, Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        billing_type = self.billing_type.value
+
+        type_ = self.type_
+
+        name = self.name
+
+        description = self.description
+
+        measured_unit = self.measured_unit
+
+        unit_factor = self.unit_factor
+
+        limit_period: Union[None, Unset, str]
+        if isinstance(self.limit_period, Unset):
+            limit_period = UNSET
+        elif isinstance(self.limit_period, LimitPeriodEnum):
+            limit_period = self.limit_period.value
+        elif isinstance(self.limit_period, BlankEnum):
+            limit_period = self.limit_period.value
+        else:
+            limit_period = self.limit_period
+
+        limit_amount: Union[None, Unset, int]
+        if isinstance(self.limit_amount, Unset):
+            limit_amount = UNSET
+        else:
+            limit_amount = self.limit_amount
+
+        article_code = self.article_code
+
+        max_value: Union[None, Unset, int]
+        if isinstance(self.max_value, Unset):
+            max_value = UNSET
+        else:
+            max_value = self.max_value
+
+        min_value: Union[None, Unset, int]
+        if isinstance(self.min_value, Unset):
+            min_value = UNSET
+        else:
+            min_value = self.min_value
+
+        max_available_limit: Union[None, Unset, int]
+        if isinstance(self.max_available_limit, Unset):
+            max_available_limit = UNSET
+        else:
+            max_available_limit = self.max_available_limit
+
+        is_boolean = self.is_boolean
+
+        default_limit: Union[None, Unset, int]
+        if isinstance(self.default_limit, Unset):
+            default_limit = UNSET
+        else:
+            default_limit = self.default_limit
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "billing_type": billing_type,
+                "type": type_,
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if measured_unit is not UNSET:
+            field_dict["measured_unit"] = measured_unit
+        if unit_factor is not UNSET:
+            field_dict["unit_factor"] = unit_factor
+        if limit_period is not UNSET:
+            field_dict["limit_period"] = limit_period
+        if limit_amount is not UNSET:
+            field_dict["limit_amount"] = limit_amount
+        if article_code is not UNSET:
+            field_dict["article_code"] = article_code
+        if max_value is not UNSET:
+            field_dict["max_value"] = max_value
+        if min_value is not UNSET:
+            field_dict["min_value"] = min_value
+        if max_available_limit is not UNSET:
+            field_dict["max_available_limit"] = max_available_limit
+        if is_boolean is not UNSET:
+            field_dict["is_boolean"] = is_boolean
+        if default_limit is not UNSET:
+            field_dict["default_limit"] = default_limit
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        uuid = UUID(d.pop("uuid"))
+
+        billing_type = BillingTypeEnum(d.pop("billing_type"))
+
+        type_ = d.pop("type")
+
+        name = d.pop("name")
+
+        description = d.pop("description", UNSET)
+
+        measured_unit = d.pop("measured_unit", UNSET)
+
+        unit_factor = d.pop("unit_factor", UNSET)
+
+        def _parse_limit_period(data: object) -> Union[BlankEnum, LimitPeriodEnum, None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                limit_period_type_0 = LimitPeriodEnum(data)
+
+                return limit_period_type_0
+            except:  # noqa: E722
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                limit_period_type_1 = BlankEnum(data)
+
+                return limit_period_type_1
+            except:  # noqa: E722
+                pass
+            return cast(Union[BlankEnum, LimitPeriodEnum, None, Unset], data)
+
+        limit_period = _parse_limit_period(d.pop("limit_period", UNSET))
+
+        def _parse_limit_amount(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        limit_amount = _parse_limit_amount(d.pop("limit_amount", UNSET))
+
+        article_code = d.pop("article_code", UNSET)
+
+        def _parse_max_value(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        max_value = _parse_max_value(d.pop("max_value", UNSET))
+
+        def _parse_min_value(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        min_value = _parse_min_value(d.pop("min_value", UNSET))
+
+        def _parse_max_available_limit(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        max_available_limit = _parse_max_available_limit(d.pop("max_available_limit", UNSET))
+
+        is_boolean = d.pop("is_boolean", UNSET)
+
+        def _parse_default_limit(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        default_limit = _parse_default_limit(d.pop("default_limit", UNSET))
+
+        update_offering_component_request = cls(
+            uuid=uuid,
+            billing_type=billing_type,
+            type_=type_,
+            name=name,
+            description=description,
+            measured_unit=measured_unit,
+            unit_factor=unit_factor,
+            limit_period=limit_period,
+            limit_amount=limit_amount,
+            article_code=article_code,
+            max_value=max_value,
+            min_value=min_value,
+            max_available_limit=max_available_limit,
+            is_boolean=is_boolean,
+            default_limit=default_limit,
+        )
+
+        update_offering_component_request.additional_properties = d
+        return update_offering_component_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