waldur-api-client 7.6.8__py3-none-any.whl → 7.7.0__py3-none-any.whl

waldur_api_client/models/rule_request.py

@@ -1,11 +1,16 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union, cast
+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.rule_request_plan_attributes import RuleRequestPlanAttributes
+    from ..models.rule_request_plan_limits import RuleRequestPlanLimits
+
+
 T = TypeVar("T", bound="RuleRequest")
 
 
@@ -13,19 +18,31 @@ T = TypeVar("T", bound="RuleRequest")
 class RuleRequest:
     """
     Attributes:
+        name (str):
         customer (str):
         user_affiliations (Union[Unset, list[str]]):
         user_email_patterns (Union[Unset, list[str]]):
         project_role (Union[None, Unset, str]):
+        project_role_name (Union[None, Unset, str]):
+        plan (Union[None, Unset, str]):
+        plan_attributes (Union[Unset, RuleRequestPlanAttributes]):
+        plan_limits (Union[Unset, RuleRequestPlanLimits]):
     """
 
+    name: str
     customer: str
     user_affiliations: Union[Unset, list[str]] = UNSET
     user_email_patterns: Union[Unset, list[str]] = UNSET
     project_role: Union[None, Unset, str] = UNSET
+    project_role_name: Union[None, Unset, str] = UNSET
+    plan: Union[None, Unset, str] = UNSET
+    plan_attributes: Union[Unset, "RuleRequestPlanAttributes"] = UNSET
+    plan_limits: Union[Unset, "RuleRequestPlanLimits"] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
         customer = self.customer
 
         user_affiliations: Union[Unset, list[str]] = UNSET
@@ -42,10 +59,31 @@ class RuleRequest:
         else:
             project_role = self.project_role
 
+        project_role_name: Union[None, Unset, str]
+        if isinstance(self.project_role_name, Unset):
+            project_role_name = UNSET
+        else:
+            project_role_name = self.project_role_name
+
+        plan: Union[None, Unset, str]
+        if isinstance(self.plan, Unset):
+            plan = UNSET
+        else:
+            plan = self.plan
+
+        plan_attributes: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.plan_attributes, Unset):
+            plan_attributes = self.plan_attributes.to_dict()
+
+        plan_limits: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.plan_limits, Unset):
+            plan_limits = self.plan_limits.to_dict()
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
+                "name": name,
                 "customer": customer,
             }
         )
@@ -55,12 +93,25 @@ class RuleRequest:
             field_dict["user_email_patterns"] = user_email_patterns
         if project_role is not UNSET:
             field_dict["project_role"] = project_role
+        if project_role_name is not UNSET:
+            field_dict["project_role_name"] = project_role_name
+        if plan is not UNSET:
+            field_dict["plan"] = plan
+        if plan_attributes is not UNSET:
+            field_dict["plan_attributes"] = plan_attributes
+        if plan_limits is not UNSET:
+            field_dict["plan_limits"] = plan_limits
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.rule_request_plan_attributes import RuleRequestPlanAttributes
+        from ..models.rule_request_plan_limits import RuleRequestPlanLimits
+
         d = dict(src_dict)
+        name = d.pop("name")
+
         customer = d.pop("customer")
 
         user_affiliations = cast(list[str], d.pop("user_affiliations", UNSET))
@@ -76,11 +127,48 @@ class RuleRequest:
 
         project_role = _parse_project_role(d.pop("project_role", UNSET))
 
+        def _parse_project_role_name(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        project_role_name = _parse_project_role_name(d.pop("project_role_name", UNSET))
+
+        def _parse_plan(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        plan = _parse_plan(d.pop("plan", UNSET))
+
+        _plan_attributes = d.pop("plan_attributes", UNSET)
+        plan_attributes: Union[Unset, RuleRequestPlanAttributes]
+        if isinstance(_plan_attributes, Unset):
+            plan_attributes = UNSET
+        else:
+            plan_attributes = RuleRequestPlanAttributes.from_dict(_plan_attributes)
+
+        _plan_limits = d.pop("plan_limits", UNSET)
+        plan_limits: Union[Unset, RuleRequestPlanLimits]
+        if isinstance(_plan_limits, Unset):
+            plan_limits = UNSET
+        else:
+            plan_limits = RuleRequestPlanLimits.from_dict(_plan_limits)
+
         rule_request = cls(
+            name=name,
             customer=customer,
             user_affiliations=user_affiliations,
             user_email_patterns=user_email_patterns,
             project_role=project_role,
+            project_role_name=project_role_name,
+            plan=plan,
+            plan_attributes=plan_attributes,
+            plan_limits=plan_limits,
         )
 
         rule_request.additional_properties = d

waldur_api_client/models/{rule_plans_request_attributes.py → rule_request_plan_attributes.py}

@@ -4,11 +4,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="RulePlansRequestAttributes")
+T = TypeVar("T", bound="RuleRequestPlanAttributes")
 
 
 @_attrs_define
-class RulePlansRequestAttributes:
+class RuleRequestPlanAttributes:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class RulePlansRequestAttributes:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        rule_plans_request_attributes = cls()
+        rule_request_plan_attributes = cls()
 
-        rule_plans_request_attributes.additional_properties = d
-        return rule_plans_request_attributes
+        rule_request_plan_attributes.additional_properties = d
+        return rule_request_plan_attributes
 
     @property
     def additional_keys(self) -> list[str]:

waldur_api_client/models/{rule_plans_request_limits.py → rule_request_plan_limits.py}

@@ -4,11 +4,11 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="RulePlansRequestLimits")
+T = TypeVar("T", bound="RuleRequestPlanLimits")
 
 
 @_attrs_define
-class RulePlansRequestLimits:
+class RuleRequestPlanLimits:
     """ """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -22,10 +22,10 @@ class RulePlansRequestLimits:
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        rule_plans_request_limits = cls()
+        rule_request_plan_limits = cls()
 
-        rule_plans_request_limits.additional_properties = d
-        return rule_plans_request_limits
+        rule_request_plan_limits.additional_properties = d
+        return rule_request_plan_limits
 
     @property
     def additional_keys(self) -> list[str]:

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

{waldur_api_client-7.6.8.dist-info → waldur_api_client-7.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: waldur-api-client
-Version: 7.6.8
+Version: 7.7.0
 Summary: A client library for accessing Waldur API
 License: MIT
 Author: OpenNode Team