waldur-api-client 7.7.3__py3-none-any.whl → 7.7.5__py3-none-any.whl

waldur_api_client/models/checklist_request.py

@@ -0,0 +1,118 @@
+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.checklist_type_enum import ChecklistTypeEnum
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ChecklistRequest")
+
+
+@_attrs_define
+class ChecklistRequest:
+    """
+    Attributes:
+        name (str):
+        description (Union[Unset, str]):
+        checklist_type (Union[Unset, ChecklistTypeEnum]):
+        category (Union[None, UUID, Unset]): Category of the checklist
+    """
+
+    name: str
+    description: Union[Unset, str] = UNSET
+    checklist_type: Union[Unset, ChecklistTypeEnum] = UNSET
+    category: Union[None, UUID, Unset] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        checklist_type: Union[Unset, str] = UNSET
+        if not isinstance(self.checklist_type, Unset):
+            checklist_type = self.checklist_type.value
+
+        category: Union[None, Unset, str]
+        if isinstance(self.category, Unset):
+            category = UNSET
+        elif isinstance(self.category, UUID):
+            category = str(self.category)
+        else:
+            category = self.category
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if checklist_type is not UNSET:
+            field_dict["checklist_type"] = checklist_type
+        if category is not UNSET:
+            field_dict["category"] = category
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        description = d.pop("description", UNSET)
+
+        _checklist_type = d.pop("checklist_type", UNSET)
+        checklist_type: Union[Unset, ChecklistTypeEnum]
+        if isinstance(_checklist_type, Unset):
+            checklist_type = UNSET
+        else:
+            checklist_type = ChecklistTypeEnum(_checklist_type)
+
+        def _parse_category(data: object) -> Union[None, UUID, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                category_type_0 = UUID(data)
+
+                return category_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, UUID, Unset], data)
+
+        category = _parse_category(d.pop("category", UNSET))
+
+        checklist_request = cls(
+            name=name,
+            description=description,
+            checklist_type=checklist_type,
+            category=category,
+        )
+
+        checklist_request.additional_properties = d
+        return checklist_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/checklist_response.py

@@ -0,0 +1,93 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.checklist_completion import ChecklistCompletion
+    from ..models.checklist_response_checklist import ChecklistResponseChecklist
+    from ..models.question_with_answer import QuestionWithAnswer
+
+
+T = TypeVar("T", bound="ChecklistResponse")
+
+
+@_attrs_define
+class ChecklistResponse:
+    """
+    Attributes:
+        checklist (ChecklistResponseChecklist):
+        completion (ChecklistCompletion):
+        questions (list['QuestionWithAnswer']):
+    """
+
+    checklist: "ChecklistResponseChecklist"
+    completion: "ChecklistCompletion"
+    questions: list["QuestionWithAnswer"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        checklist = self.checklist.to_dict()
+
+        completion = self.completion.to_dict()
+
+        questions = []
+        for questions_item_data in self.questions:
+            questions_item = questions_item_data.to_dict()
+            questions.append(questions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "checklist": checklist,
+                "completion": completion,
+                "questions": questions,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.checklist_completion import ChecklistCompletion
+        from ..models.checklist_response_checklist import ChecklistResponseChecklist
+        from ..models.question_with_answer import QuestionWithAnswer
+
+        d = dict(src_dict)
+        checklist = ChecklistResponseChecklist.from_dict(d.pop("checklist"))
+
+        completion = ChecklistCompletion.from_dict(d.pop("completion"))
+
+        questions = []
+        _questions = d.pop("questions")
+        for questions_item_data in _questions:
+            questions_item = QuestionWithAnswer.from_dict(questions_item_data)
+
+            questions.append(questions_item)
+
+        checklist_response = cls(
+            checklist=checklist,
+            completion=completion,
+            questions=questions,
+        )
+
+        checklist_response.additional_properties = d
+        return checklist_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

waldur_api_client/models/{customer_checklist_stat.py → checklist_response_checklist.py}

@@ -4,59 +4,28 @@ from typing import Any, TypeVar
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="CustomerChecklistStat")
+T = TypeVar("T", bound="ChecklistResponseChecklist")
 
 
 @_attrs_define
-class CustomerChecklistStat:
-    """
-    Attributes:
-        name (str):
-        uuid (str):
-        score (float):
-    """
+class ChecklistResponseChecklist:
+    """ """
 
-    name: str
-    uuid: str
-    score: float
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        name = self.name
-
-        uuid = self.uuid
-
-        score = self.score
-
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "name": name,
-                "uuid": uuid,
-                "score": score,
-            }
-        )
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        name = d.pop("name")
-
-        uuid = d.pop("uuid")
-
-        score = d.pop("score")
-
-        customer_checklist_stat = cls(
-            name=name,
-            uuid=uuid,
-            score=score,
-        )
+        checklist_response_checklist = cls()
 
-        customer_checklist_stat.additional_properties = d
-        return customer_checklist_stat
+        checklist_response_checklist.additional_properties = d
+        return checklist_response_checklist
 
     @property
     def additional_keys(self) -> list[str]:

waldur_api_client/models/checklist_reviewer_response.py

@@ -0,0 +1,93 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.checklist_completion_reviewer import ChecklistCompletionReviewer
+    from ..models.checklist_reviewer_response_checklist import ChecklistReviewerResponseChecklist
+    from ..models.question_with_answer_reviewer import QuestionWithAnswerReviewer
+
+
+T = TypeVar("T", bound="ChecklistReviewerResponse")
+
+
+@_attrs_define
+class ChecklistReviewerResponse:
+    """
+    Attributes:
+        checklist (ChecklistReviewerResponseChecklist):
+        completion (ChecklistCompletionReviewer):
+        questions (list['QuestionWithAnswerReviewer']):
+    """
+
+    checklist: "ChecklistReviewerResponseChecklist"
+    completion: "ChecklistCompletionReviewer"
+    questions: list["QuestionWithAnswerReviewer"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        checklist = self.checklist.to_dict()
+
+        completion = self.completion.to_dict()
+
+        questions = []
+        for questions_item_data in self.questions:
+            questions_item = questions_item_data.to_dict()
+            questions.append(questions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "checklist": checklist,
+                "completion": completion,
+                "questions": questions,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.checklist_completion_reviewer import ChecklistCompletionReviewer
+        from ..models.checklist_reviewer_response_checklist import ChecklistReviewerResponseChecklist
+        from ..models.question_with_answer_reviewer import QuestionWithAnswerReviewer
+
+        d = dict(src_dict)
+        checklist = ChecklistReviewerResponseChecklist.from_dict(d.pop("checklist"))
+
+        completion = ChecklistCompletionReviewer.from_dict(d.pop("completion"))
+
+        questions = []
+        _questions = d.pop("questions")
+        for questions_item_data in _questions:
+            questions_item = QuestionWithAnswerReviewer.from_dict(questions_item_data)
+
+            questions.append(questions_item)
+
+        checklist_reviewer_response = cls(
+            checklist=checklist,
+            completion=completion,
+            questions=questions,
+        )
+
+        checklist_reviewer_response.additional_properties = d
+        return checklist_reviewer_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

waldur_api_client/models/checklist_reviewer_response_checklist.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ChecklistReviewerResponseChecklist")
+
+
+@_attrs_define
+class ChecklistReviewerResponseChecklist:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        checklist_reviewer_response_checklist = cls()
+
+        checklist_reviewer_response_checklist.additional_properties = d
+        return checklist_reviewer_response_checklist
+
+    @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/checklist_type_enum.py

@@ -4,6 +4,7 @@ from enum import Enum
 class ChecklistTypeEnum(str, Enum):
     OFFERING_COMPLIANCE = "offering_compliance"
     PROJECT_COMPLIANCE = "project_compliance"
+    PROJECT_METADATA = "project_metadata"
     PROPOSAL_COMPLIANCE = "proposal_compliance"
 
     def __str__(self) -> str:

waldur_api_client/models/customer_credits_count_o_item.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class CustomerCreditsCountOItem(str, Enum):
+    CUSTOMER_NAME = "customer_name"
+    END_DATE = "end_date"
+    EXPECTED_CONSUMPTION = "expected_consumption"
+    VALUE = "value"
+    VALUE_0 = "-customer_name"
+    VALUE_1 = "-end_date"
+    VALUE_2 = "-expected_consumption"
+    VALUE_3 = "-value"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/customer_permissions_reviews_count_o_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class CustomerPermissionsReviewsCountOItem(str, Enum):
+    CLOSED = "closed"
+    CREATED = "created"
+    VALUE_0 = "-closed"
+    VALUE_1 = "-created"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/digitalocean_droplets_count_state_item.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class DigitaloceanDropletsCountStateItem(str, Enum):
+    CREATING = "CREATING"
+    CREATION_SCHEDULED = "CREATION_SCHEDULED"
+    DELETING = "DELETING"
+    DELETION_SCHEDULED = "DELETION_SCHEDULED"
+    ERRED = "ERRED"
+    OK = "OK"
+    UPDATE_SCHEDULED = "UPDATE_SCHEDULED"
+    UPDATING = "UPDATING"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/digitalocean_images_count_o_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class DigitaloceanImagesCountOItem(str, Enum):
+    DISTRIBUTION = "distribution"
+    TYPE = "type"
+    VALUE_0 = "-distribution"
+    VALUE_1 = "-type"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/email_logs_count_o_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class EmailLogsCountOItem(str, Enum):
+    SENT_AT = "sent_at"
+    SUBJECT = "subject"
+    VALUE_0 = "-sent_at"
+    VALUE_1 = "-subject"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/event_subscriptions_count_o_item.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class EventSubscriptionsCountOItem(str, Enum):
+    CREATED = "created"
+    VALUE_0 = "-created"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/events_count_o_item.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class EventsCountOItem(str, Enum):
+    CREATED = "created"
+    VALUE_0 = "-created"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/{checklist_admin.py → external_link.py}

@@ -1,114 +1,120 @@
+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="ChecklistAdmin")
+T = TypeVar("T", bound="ExternalLink")
 
 
 @_attrs_define
-class ChecklistAdmin:
+class ExternalLink:
     """
     Attributes:
-        uuid (UUID):
         url (str):
+        uuid (UUID):
         name (str):
-        questions_count (int):
-        category_name (str):
-        category_uuid (UUID):
-        roles (list[str]):
-        checklist_type (str):
+        link (str):
+        created (datetime.datetime):
+        modified (datetime.datetime):
         description (Union[Unset, str]):
+        image (Union[None, Unset, str]):
     """
 
-    uuid: UUID
     url: str
+    uuid: UUID
     name: str
-    questions_count: int
-    category_name: str
-    category_uuid: UUID
-    roles: list[str]
-    checklist_type: str
+    link: str
+    created: datetime.datetime
+    modified: datetime.datetime
     description: Union[Unset, str] = UNSET
+    image: Union[None, Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        uuid = str(self.uuid)
-
         url = self.url
 
-        name = self.name
-
-        questions_count = self.questions_count
+        uuid = str(self.uuid)
 
-        category_name = self.category_name
+        name = self.name
 
-        category_uuid = str(self.category_uuid)
+        link = self.link
 
-        roles = self.roles
+        created = self.created.isoformat()
 
-        checklist_type = self.checklist_type
+        modified = self.modified.isoformat()
 
         description = self.description
 
+        image: Union[None, Unset, str]
+        if isinstance(self.image, Unset):
+            image = UNSET
+        else:
+            image = self.image
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
-                "uuid": uuid,
                 "url": url,
+                "uuid": uuid,
                 "name": name,
-                "questions_count": questions_count,
-                "category_name": category_name,
-                "category_uuid": category_uuid,
-                "roles": roles,
-                "checklist_type": checklist_type,
+                "link": link,
+                "created": created,
+                "modified": modified,
             }
         )
         if description is not UNSET:
             field_dict["description"] = description
+        if image is not UNSET:
+            field_dict["image"] = image
 
         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"))
-
         url = d.pop("url")
 
+        uuid = UUID(d.pop("uuid"))
+
         name = d.pop("name")
 
-        questions_count = d.pop("questions_count")
+        link = d.pop("link")
 
-        category_name = d.pop("category_name")
+        created = isoparse(d.pop("created"))
 
-        category_uuid = UUID(d.pop("category_uuid"))
+        modified = isoparse(d.pop("modified"))
 
-        roles = cast(list[str], d.pop("roles"))
+        description = d.pop("description", UNSET)
 
-        checklist_type = d.pop("checklist_type")
+        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)
 
-        description = d.pop("description", UNSET)
+        image = _parse_image(d.pop("image", UNSET))
 
-        checklist_admin = cls(
-            uuid=uuid,
+        external_link = cls(
             url=url,
+            uuid=uuid,
             name=name,
-            questions_count=questions_count,
-            category_name=category_name,
-            category_uuid=category_uuid,
-            roles=roles,
-            checklist_type=checklist_type,
+            link=link,
+            created=created,
+            modified=modified,
             description=description,
+            image=image,
         )
 
-        checklist_admin.additional_properties = d
-        return checklist_admin
+        external_link.additional_properties = d
+        return external_link
 
     @property
     def additional_keys(self) -> list[str]: