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

waldur_api_client/models/{question_options.py → call_compliance_review_request.py}

@@ -7,60 +7,52 @@ from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="QuestionOptions")
+T = TypeVar("T", bound="CallComplianceReviewRequest")
 
 
 @_attrs_define
-class QuestionOptions:
+class CallComplianceReviewRequest:
     """
     Attributes:
-        uuid (UUID):
-        label (str):
-        order (Union[Unset, int]):
+        proposal_uuid (UUID):
+        review_notes (Union[Unset, str]):
     """
 
-    uuid: UUID
-    label: str
-    order: Union[Unset, int] = UNSET
+    proposal_uuid: UUID
+    review_notes: Union[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)
+        proposal_uuid = str(self.proposal_uuid)
 
-        label = self.label
-
-        order = self.order
+        review_notes = self.review_notes
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
-                "uuid": uuid,
-                "label": label,
+                "proposal_uuid": proposal_uuid,
             }
         )
-        if order is not UNSET:
-            field_dict["order"] = order
+        if review_notes is not UNSET:
+            field_dict["review_notes"] = review_notes
 
         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"))
-
-        label = d.pop("label")
+        proposal_uuid = UUID(d.pop("proposal_uuid"))
 
-        order = d.pop("order", UNSET)
+        review_notes = d.pop("review_notes", UNSET)
 
-        question_options = cls(
-            uuid=uuid,
-            label=label,
-            order=order,
+        call_compliance_review_request = cls(
+            proposal_uuid=proposal_uuid,
+            review_notes=review_notes,
         )
 
-        question_options.additional_properties = d
-        return question_options
+        call_compliance_review_request.additional_properties = d
+        return call_compliance_review_request
 
     @property
     def additional_keys(self) -> list[str]:

waldur_api_client/models/call_managing_organisations_count_o_item.py

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

waldur_api_client/models/checklist.py

@@ -5,6 +5,7 @@ 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="Checklist")
@@ -20,8 +21,9 @@ class Checklist:
         questions_count (int):
         category_name (str):
         category_uuid (UUID):
-        roles (list[str]):
         description (Union[Unset, str]):
+        checklist_type (Union[Unset, ChecklistTypeEnum]):
+        category (Union[None, UUID, Unset]): Category of the checklist
     """
 
     uuid: UUID
@@ -30,8 +32,9 @@ class Checklist:
     questions_count: int
     category_name: str
     category_uuid: UUID
-    roles: list[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]:
@@ -47,10 +50,20 @@ class Checklist:
 
         category_uuid = str(self.category_uuid)
 
-        roles = self.roles
-
         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(
@@ -61,11 +74,14 @@ class Checklist:
                 "questions_count": questions_count,
                 "category_name": category_name,
                 "category_uuid": category_uuid,
-                "roles": roles,
             }
         )
         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
 
@@ -84,10 +100,32 @@ class Checklist:
 
         category_uuid = UUID(d.pop("category_uuid"))
 
-        roles = cast(list[str], d.pop("roles"))
-
         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 = cls(
             uuid=uuid,
             url=url,
@@ -95,8 +133,9 @@ class Checklist:
             questions_count=questions_count,
             category_name=category_name,
             category_uuid=category_uuid,
-            roles=roles,
             description=description,
+            checklist_type=checklist_type,
+            category=category,
         )
 
         checklist.additional_properties = d

waldur_api_client/models/{create_checklist_request.py → checklist_category_request.py}

@@ -1,54 +1,55 @@
 from collections.abc import Mapping
+from io import BytesIO
 from typing import Any, TypeVar, Union, cast
 
 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
+from .. import types
+from ..types import UNSET, File, Unset
 
-T = TypeVar("T", bound="CreateChecklistRequest")
+T = TypeVar("T", bound="ChecklistCategoryRequest")
 
 
 @_attrs_define
-class CreateChecklistRequest:
+class ChecklistCategoryRequest:
     """
     Attributes:
         name (str):
-        checklist_type (ChecklistTypeEnum):
+        icon (Union[File, None, Unset]):
         description (Union[Unset, str]):
-        roles (Union[Unset, list[str]]):
     """
 
     name: str
-    checklist_type: ChecklistTypeEnum
+    icon: Union[File, None, Unset] = UNSET
     description: Union[Unset, str] = UNSET
-    roles: Union[Unset, list[str]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         name = self.name
 
-        checklist_type = self.checklist_type.value
+        icon: Union[None, Unset, types.FileTypes]
+        if isinstance(self.icon, Unset):
+            icon = UNSET
+        elif isinstance(self.icon, File):
+            icon = self.icon.to_tuple()
 
-        description = self.description
+        else:
+            icon = self.icon
 
-        roles: Union[Unset, list[str]] = UNSET
-        if not isinstance(self.roles, Unset):
-            roles = self.roles
+        description = self.description
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
                 "name": name,
-                "checklist_type": checklist_type,
             }
         )
+        if icon is not UNSET:
+            field_dict["icon"] = icon
         if description is not UNSET:
             field_dict["description"] = description
-        if roles is not UNSET:
-            field_dict["roles"] = roles
 
         return field_dict
 
@@ -57,21 +58,33 @@ class CreateChecklistRequest:
         d = dict(src_dict)
         name = d.pop("name")
 
-        checklist_type = ChecklistTypeEnum(d.pop("checklist_type"))
+        def _parse_icon(data: object) -> Union[File, None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, bytes):
+                    raise TypeError()
+                icon_type_0 = File(payload=BytesIO(data))
 
-        description = d.pop("description", UNSET)
+                return icon_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[File, None, Unset], data)
 
-        roles = cast(list[str], d.pop("roles", UNSET))
+        icon = _parse_icon(d.pop("icon", UNSET))
+
+        description = d.pop("description", UNSET)
 
-        create_checklist_request = cls(
+        checklist_category_request = cls(
             name=name,
-            checklist_type=checklist_type,
+            icon=icon,
             description=description,
-            roles=roles,
         )
 
-        create_checklist_request.additional_properties = d
-        return create_checklist_request
+        checklist_category_request.additional_properties = d
+        return checklist_category_request
 
     @property
     def additional_keys(self) -> list[str]:

waldur_api_client/models/checklist_completion.py

@@ -0,0 +1,118 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+T = TypeVar("T", bound="ChecklistCompletion")
+
+
+@_attrs_define
+class ChecklistCompletion:
+    """
+    Attributes:
+        uuid (UUID):
+        is_completed (bool): Whether all required questions have been answered
+        completion_percentage (float):
+        unanswered_required_questions (list[Any]):
+        checklist_name (str):
+        checklist_description (str):
+        created (datetime.datetime):
+        modified (datetime.datetime):
+    """
+
+    uuid: UUID
+    is_completed: bool
+    completion_percentage: float
+    unanswered_required_questions: list[Any]
+    checklist_name: str
+    checklist_description: str
+    created: datetime.datetime
+    modified: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        is_completed = self.is_completed
+
+        completion_percentage = self.completion_percentage
+
+        unanswered_required_questions = self.unanswered_required_questions
+
+        checklist_name = self.checklist_name
+
+        checklist_description = self.checklist_description
+
+        created = self.created.isoformat()
+
+        modified = self.modified.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "is_completed": is_completed,
+                "completion_percentage": completion_percentage,
+                "unanswered_required_questions": unanswered_required_questions,
+                "checklist_name": checklist_name,
+                "checklist_description": checklist_description,
+                "created": created,
+                "modified": modified,
+            }
+        )
+
+        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"))
+
+        is_completed = d.pop("is_completed")
+
+        completion_percentage = d.pop("completion_percentage")
+
+        unanswered_required_questions = cast(list[Any], d.pop("unanswered_required_questions"))
+
+        checklist_name = d.pop("checklist_name")
+
+        checklist_description = d.pop("checklist_description")
+
+        created = isoparse(d.pop("created"))
+
+        modified = isoparse(d.pop("modified"))
+
+        checklist_completion = cls(
+            uuid=uuid,
+            is_completed=is_completed,
+            completion_percentage=completion_percentage,
+            unanswered_required_questions=unanswered_required_questions,
+            checklist_name=checklist_name,
+            checklist_description=checklist_description,
+            created=created,
+            modified=modified,
+        )
+
+        checklist_completion.additional_properties = d
+        return checklist_completion
+
+    @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_completion_reviewer.py

@@ -0,0 +1,203 @@
+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="ChecklistCompletionReviewer")
+
+
+@_attrs_define
+class ChecklistCompletionReviewer:
+    """
+    Attributes:
+        uuid (UUID):
+        is_completed (bool): Whether all required questions have been answered
+        completion_percentage (float):
+        unanswered_required_questions (list[Any]):
+        checklist_name (str):
+        checklist_description (str):
+        created (datetime.datetime):
+        modified (datetime.datetime):
+        requires_review (bool): Whether any answers triggered review requirements
+        reviewed_by_name (str):
+        review_trigger_summary (list[Any]):
+        reviewed_by (Union[None, Unset, int]): User who reviewed the checklist completion
+        reviewed_at (Union[None, Unset, datetime.datetime]):
+        review_notes (Union[Unset, str]): Notes from the reviewer
+    """
+
+    uuid: UUID
+    is_completed: bool
+    completion_percentage: float
+    unanswered_required_questions: list[Any]
+    checklist_name: str
+    checklist_description: str
+    created: datetime.datetime
+    modified: datetime.datetime
+    requires_review: bool
+    reviewed_by_name: str
+    review_trigger_summary: list[Any]
+    reviewed_by: Union[None, Unset, int] = UNSET
+    reviewed_at: Union[None, Unset, datetime.datetime] = UNSET
+    review_notes: Union[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)
+
+        is_completed = self.is_completed
+
+        completion_percentage = self.completion_percentage
+
+        unanswered_required_questions = self.unanswered_required_questions
+
+        checklist_name = self.checklist_name
+
+        checklist_description = self.checklist_description
+
+        created = self.created.isoformat()
+
+        modified = self.modified.isoformat()
+
+        requires_review = self.requires_review
+
+        reviewed_by_name = self.reviewed_by_name
+
+        review_trigger_summary = self.review_trigger_summary
+
+        reviewed_by: Union[None, Unset, int]
+        if isinstance(self.reviewed_by, Unset):
+            reviewed_by = UNSET
+        else:
+            reviewed_by = self.reviewed_by
+
+        reviewed_at: Union[None, Unset, str]
+        if isinstance(self.reviewed_at, Unset):
+            reviewed_at = UNSET
+        elif isinstance(self.reviewed_at, datetime.datetime):
+            reviewed_at = self.reviewed_at.isoformat()
+        else:
+            reviewed_at = self.reviewed_at
+
+        review_notes = self.review_notes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "is_completed": is_completed,
+                "completion_percentage": completion_percentage,
+                "unanswered_required_questions": unanswered_required_questions,
+                "checklist_name": checklist_name,
+                "checklist_description": checklist_description,
+                "created": created,
+                "modified": modified,
+                "requires_review": requires_review,
+                "reviewed_by_name": reviewed_by_name,
+                "review_trigger_summary": review_trigger_summary,
+            }
+        )
+        if reviewed_by is not UNSET:
+            field_dict["reviewed_by"] = reviewed_by
+        if reviewed_at is not UNSET:
+            field_dict["reviewed_at"] = reviewed_at
+        if review_notes is not UNSET:
+            field_dict["review_notes"] = review_notes
+
+        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"))
+
+        is_completed = d.pop("is_completed")
+
+        completion_percentage = d.pop("completion_percentage")
+
+        unanswered_required_questions = cast(list[Any], d.pop("unanswered_required_questions"))
+
+        checklist_name = d.pop("checklist_name")
+
+        checklist_description = d.pop("checklist_description")
+
+        created = isoparse(d.pop("created"))
+
+        modified = isoparse(d.pop("modified"))
+
+        requires_review = d.pop("requires_review")
+
+        reviewed_by_name = d.pop("reviewed_by_name")
+
+        review_trigger_summary = cast(list[Any], d.pop("review_trigger_summary"))
+
+        def _parse_reviewed_by(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)
+
+        reviewed_by = _parse_reviewed_by(d.pop("reviewed_by", UNSET))
+
+        def _parse_reviewed_at(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                reviewed_at_type_0 = isoparse(data)
+
+                return reviewed_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        reviewed_at = _parse_reviewed_at(d.pop("reviewed_at", UNSET))
+
+        review_notes = d.pop("review_notes", UNSET)
+
+        checklist_completion_reviewer = cls(
+            uuid=uuid,
+            is_completed=is_completed,
+            completion_percentage=completion_percentage,
+            unanswered_required_questions=unanswered_required_questions,
+            checklist_name=checklist_name,
+            checklist_description=checklist_description,
+            created=created,
+            modified=modified,
+            requires_review=requires_review,
+            reviewed_by_name=reviewed_by_name,
+            review_trigger_summary=review_trigger_summary,
+            reviewed_by=reviewed_by,
+            reviewed_at=reviewed_at,
+            review_notes=review_notes,
+        )
+
+        checklist_completion_reviewer.additional_properties = d
+        return checklist_completion_reviewer
+
+    @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/{operator_enum.py → checklist_operators.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class OperatorEnum(str, Enum):
+class ChecklistOperators(str, Enum):
     CONTAINS = "contains"
     EQUALS = "equals"
     IN = "in"