waldur-api-client 7.7.6__py3-none-any.whl → 7.7.7__py3-none-any.whl

waldur_api_client/models/order_details.py

@@ -31,7 +31,6 @@ class OrderDetails:
         offering_image (Union[Unset, str]):
         offering_thumbnail (Union[Unset, str]):
         offering_type (Union[Unset, str]):
-        offering_terms_of_service (Union[Unset, str]):
         offering_shared (Union[Unset, bool]): Accessible to all customers.
         offering_billable (Union[Unset, bool]): Purchase and usage is invoiced.
         offering_plugin_options (Union[Unset, Any]): Public data used by specific plugin, such as storage mode for
@@ -106,7 +105,6 @@ class OrderDetails:
     offering_image: Union[Unset, str] = UNSET
     offering_thumbnail: Union[Unset, str] = UNSET
     offering_type: Union[Unset, str] = UNSET
-    offering_terms_of_service: Union[Unset, str] = UNSET
     offering_shared: Union[Unset, bool] = UNSET
     offering_billable: Union[Unset, bool] = UNSET
     offering_plugin_options: Union[Unset, Any] = UNSET
@@ -187,8 +185,6 @@ class OrderDetails:
 
         offering_type = self.offering_type
 
-        offering_terms_of_service = self.offering_terms_of_service
-
         offering_shared = self.offering_shared
 
         offering_billable = self.offering_billable
@@ -468,8 +464,6 @@ class OrderDetails:
             field_dict["offering_thumbnail"] = offering_thumbnail
         if offering_type is not UNSET:
             field_dict["offering_type"] = offering_type
-        if offering_terms_of_service is not UNSET:
-            field_dict["offering_terms_of_service"] = offering_terms_of_service
         if offering_shared is not UNSET:
             field_dict["offering_shared"] = offering_shared
         if offering_billable is not UNSET:
@@ -616,8 +610,6 @@ class OrderDetails:
 
         offering_type = d.pop("offering_type", UNSET)
 
-        offering_terms_of_service = d.pop("offering_terms_of_service", UNSET)
-
         offering_shared = d.pop("offering_shared", UNSET)
 
         offering_billable = d.pop("offering_billable", UNSET)
@@ -1061,7 +1053,6 @@ class OrderDetails:
             offering_image=offering_image,
             offering_thumbnail=offering_thumbnail,
             offering_type=offering_type,
-            offering_terms_of_service=offering_terms_of_service,
             offering_shared=offering_shared,
             offering_billable=offering_billable,
             offering_plugin_options=offering_plugin_options,

waldur_api_client/models/patched_offering_terms_of_service_request.py

@@ -0,0 +1,96 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedOfferingTermsOfServiceRequest")
+
+
+@_attrs_define
+class PatchedOfferingTermsOfServiceRequest:
+    """
+    Attributes:
+        terms_of_service (Union[Unset, str]):
+        terms_of_service_link (Union[Unset, str]):
+        version (Union[Unset, str]):
+        is_active (Union[Unset, bool]):
+        requires_reconsent (Union[Unset, bool]): If True, user will be asked to re-consent to the terms of service when
+            the terms of service are updated.
+    """
+
+    terms_of_service: Union[Unset, str] = UNSET
+    terms_of_service_link: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    is_active: Union[Unset, bool] = UNSET
+    requires_reconsent: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        terms_of_service = self.terms_of_service
+
+        terms_of_service_link = self.terms_of_service_link
+
+        version = self.version
+
+        is_active = self.is_active
+
+        requires_reconsent = self.requires_reconsent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if terms_of_service is not UNSET:
+            field_dict["terms_of_service"] = terms_of_service
+        if terms_of_service_link is not UNSET:
+            field_dict["terms_of_service_link"] = terms_of_service_link
+        if version is not UNSET:
+            field_dict["version"] = version
+        if is_active is not UNSET:
+            field_dict["is_active"] = is_active
+        if requires_reconsent is not UNSET:
+            field_dict["requires_reconsent"] = requires_reconsent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        terms_of_service = d.pop("terms_of_service", UNSET)
+
+        terms_of_service_link = d.pop("terms_of_service_link", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        is_active = d.pop("is_active", UNSET)
+
+        requires_reconsent = d.pop("requires_reconsent", UNSET)
+
+        patched_offering_terms_of_service_request = cls(
+            terms_of_service=terms_of_service,
+            terms_of_service_link=terms_of_service_link,
+            version=version,
+            is_active=is_active,
+            requires_reconsent=requires_reconsent,
+        )
+
+        patched_offering_terms_of_service_request.additional_properties = d
+        return patched_offering_terms_of_service_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_user_offering_consent_request.py

@@ -0,0 +1,59 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatchedUserOfferingConsentRequest")
+
+
+@_attrs_define
+class PatchedUserOfferingConsentRequest:
+    """
+    Attributes:
+        version (Union[Unset, str]):
+    """
+
+    version: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if version is not UNSET:
+            field_dict["version"] = version
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        version = d.pop("version", UNSET)
+
+        patched_user_offering_consent_request = cls(
+            version=version,
+        )
+
+        patched_user_offering_consent_request.additional_properties = d
+        return patched_user_offering_consent_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/permission_project.py

@@ -0,0 +1,147 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PermissionProject")
+
+
+@_attrs_define
+class PermissionProject:
+    """
+    Attributes:
+        url (Union[Unset, str]):
+        uuid (Union[Unset, UUID]):
+        name (Union[Unset, str]):
+        image (Union[None, Unset, str]):
+        resource_count (Union[Unset, int]):
+        end_date (Union[None, Unset, datetime.date]): The date is inclusive. Once reached, all project resource will be
+            scheduled for termination.
+    """
+
+    url: Union[Unset, str] = UNSET
+    uuid: Union[Unset, UUID] = UNSET
+    name: Union[Unset, str] = UNSET
+    image: Union[None, Unset, str] = UNSET
+    resource_count: Union[Unset, int] = UNSET
+    end_date: Union[None, Unset, datetime.date] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.uuid, Unset):
+            uuid = str(self.uuid)
+
+        name = self.name
+
+        image: Union[None, Unset, str]
+        if isinstance(self.image, Unset):
+            image = UNSET
+        else:
+            image = self.image
+
+        resource_count = self.resource_count
+
+        end_date: Union[None, Unset, str]
+        if isinstance(self.end_date, Unset):
+            end_date = UNSET
+        elif isinstance(self.end_date, datetime.date):
+            end_date = self.end_date.isoformat()
+        else:
+            end_date = self.end_date
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if url is not UNSET:
+            field_dict["url"] = url
+        if uuid is not UNSET:
+            field_dict["uuid"] = uuid
+        if name is not UNSET:
+            field_dict["name"] = name
+        if image is not UNSET:
+            field_dict["image"] = image
+        if resource_count is not UNSET:
+            field_dict["resource_count"] = resource_count
+        if end_date is not UNSET:
+            field_dict["end_date"] = end_date
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url", UNSET)
+
+        _uuid = d.pop("uuid", UNSET)
+        uuid: Union[Unset, UUID]
+        if isinstance(_uuid, Unset):
+            uuid = UNSET
+        else:
+            uuid = UUID(_uuid)
+
+        name = d.pop("name", UNSET)
+
+        def _parse_image(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)
+
+        image = _parse_image(d.pop("image", UNSET))
+
+        resource_count = d.pop("resource_count", UNSET)
+
+        def _parse_end_date(data: object) -> Union[None, Unset, datetime.date]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                end_date_type_0 = isoparse(data).date()
+
+                return end_date_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.date], data)
+
+        end_date = _parse_end_date(d.pop("end_date", UNSET))
+
+        permission_project = cls(
+            url=url,
+            uuid=uuid,
+            name=name,
+            image=image,
+            resource_count=resource_count,
+            end_date=end_date,
+        )
+
+        permission_project.additional_properties = d
+        return permission_project
+
+    @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/project_answer.py

@@ -0,0 +1,122 @@
+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
+
+T = TypeVar("T", bound="ProjectAnswer")
+
+
+@_attrs_define
+class ProjectAnswer:
+    """
+    Attributes:
+        project_uuid (UUID):
+        project_name (str):
+        completion_uuid (Union[None, str]): Get completion UUID.
+        completion_percentage (float): Get completion percentage.
+        is_completed (bool): Get completion status.
+        requires_review (bool): Get review requirement status.
+        answers_count (int): Get count of answers.
+        unanswered_required_count (int): Get count of unanswered required questions.
+    """
+
+    project_uuid: UUID
+    project_name: str
+    completion_uuid: Union[None, str]
+    completion_percentage: float
+    is_completed: bool
+    requires_review: bool
+    answers_count: int
+    unanswered_required_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_uuid = str(self.project_uuid)
+
+        project_name = self.project_name
+
+        completion_uuid: Union[None, str]
+        completion_uuid = self.completion_uuid
+
+        completion_percentage = self.completion_percentage
+
+        is_completed = self.is_completed
+
+        requires_review = self.requires_review
+
+        answers_count = self.answers_count
+
+        unanswered_required_count = self.unanswered_required_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_uuid": project_uuid,
+                "project_name": project_name,
+                "completion_uuid": completion_uuid,
+                "completion_percentage": completion_percentage,
+                "is_completed": is_completed,
+                "requires_review": requires_review,
+                "answers_count": answers_count,
+                "unanswered_required_count": unanswered_required_count,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        project_uuid = UUID(d.pop("project_uuid"))
+
+        project_name = d.pop("project_name")
+
+        def _parse_completion_uuid(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        completion_uuid = _parse_completion_uuid(d.pop("completion_uuid"))
+
+        completion_percentage = d.pop("completion_percentage")
+
+        is_completed = d.pop("is_completed")
+
+        requires_review = d.pop("requires_review")
+
+        answers_count = d.pop("answers_count")
+
+        unanswered_required_count = d.pop("unanswered_required_count")
+
+        project_answer = cls(
+            project_uuid=project_uuid,
+            project_name=project_name,
+            completion_uuid=completion_uuid,
+            completion_percentage=completion_percentage,
+            is_completed=is_completed,
+            requires_review=requires_review,
+            answers_count=answers_count,
+            unanswered_required_count=unanswered_required_count,
+        )
+
+        project_answer.additional_properties = d
+        return project_answer
+
+    @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/project_detail.py

@@ -0,0 +1,133 @@
+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
+
+T = TypeVar("T", bound="ProjectDetail")
+
+
+@_attrs_define
+class ProjectDetail:
+    """
+    Attributes:
+        project_uuid (UUID):
+        project_name (str):
+        completion_uuid (Union[None, UUID]):
+        completion_percentage (float):
+        is_completed (bool):
+        requires_review (bool):
+        answers (list[Any]):
+        unanswered_required_questions (list[Any]):
+    """
+
+    project_uuid: UUID
+    project_name: str
+    completion_uuid: Union[None, UUID]
+    completion_percentage: float
+    is_completed: bool
+    requires_review: bool
+    answers: list[Any]
+    unanswered_required_questions: list[Any]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_uuid = str(self.project_uuid)
+
+        project_name = self.project_name
+
+        completion_uuid: Union[None, str]
+        if isinstance(self.completion_uuid, UUID):
+            completion_uuid = str(self.completion_uuid)
+        else:
+            completion_uuid = self.completion_uuid
+
+        completion_percentage = self.completion_percentage
+
+        is_completed = self.is_completed
+
+        requires_review = self.requires_review
+
+        answers = self.answers
+
+        unanswered_required_questions = self.unanswered_required_questions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_uuid": project_uuid,
+                "project_name": project_name,
+                "completion_uuid": completion_uuid,
+                "completion_percentage": completion_percentage,
+                "is_completed": is_completed,
+                "requires_review": requires_review,
+                "answers": answers,
+                "unanswered_required_questions": unanswered_required_questions,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        project_uuid = UUID(d.pop("project_uuid"))
+
+        project_name = d.pop("project_name")
+
+        def _parse_completion_uuid(data: object) -> Union[None, UUID]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                completion_uuid_type_0 = UUID(data)
+
+                return completion_uuid_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, UUID], data)
+
+        completion_uuid = _parse_completion_uuid(d.pop("completion_uuid"))
+
+        completion_percentage = d.pop("completion_percentage")
+
+        is_completed = d.pop("is_completed")
+
+        requires_review = d.pop("requires_review")
+
+        answers = cast(list[Any], d.pop("answers"))
+
+        unanswered_required_questions = cast(list[Any], d.pop("unanswered_required_questions"))
+
+        project_detail = cls(
+            project_uuid=project_uuid,
+            project_name=project_name,
+            completion_uuid=completion_uuid,
+            completion_percentage=completion_percentage,
+            is_completed=is_completed,
+            requires_review=requires_review,
+            answers=answers,
+            unanswered_required_questions=unanswered_required_questions,
+        )
+
+        project_detail.additional_properties = d
+        return project_detail
+
+    @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