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

waldur_api_client/models/project.py

@@ -8,6 +8,7 @@ from attrs import field as _attrs_field
 from dateutil.parser import isoparse
 
 from ..models.blank_enum import BlankEnum
+from ..models.kind_enum import KindEnum
 from ..models.oecd_fos_2007_code_enum import OecdFos2007CodeEnum
 from ..types import UNSET, Unset
 
@@ -49,6 +50,7 @@ class Project:
         image (Union[None, Unset, str]):
         resources_count (Union[Unset, int]):
         max_service_accounts (Union[None, Unset, int]): Maximum number of service accounts allowed
+        kind (Union[Unset, KindEnum]):
         project_credit (Union[None, Unset, float]):
         marketplace_resource_count (Union[Unset, ProjectMarketplaceResourceCount]):
         billing_price_estimate (Union[Unset, NestedPriceEstimate]):
@@ -79,6 +81,7 @@ class Project:
     image: Union[None, Unset, str] = UNSET
     resources_count: Union[Unset, int] = UNSET
     max_service_accounts: Union[None, Unset, int] = UNSET
+    kind: Union[Unset, KindEnum] = UNSET
     project_credit: Union[None, Unset, float] = UNSET
     marketplace_resource_count: Union[Unset, "ProjectMarketplaceResourceCount"] = UNSET
     billing_price_estimate: Union[Unset, "NestedPriceEstimate"] = UNSET
@@ -187,6 +190,10 @@ class Project:
         else:
             max_service_accounts = self.max_service_accounts
 
+        kind: Union[Unset, str] = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
         project_credit: Union[None, Unset, float]
         if isinstance(self.project_credit, Unset):
             project_credit = UNSET
@@ -254,6 +261,8 @@ class Project:
             field_dict["resources_count"] = resources_count
         if max_service_accounts is not UNSET:
             field_dict["max_service_accounts"] = max_service_accounts
+        if kind is not UNSET:
+            field_dict["kind"] = kind
         if project_credit is not UNSET:
             field_dict["project_credit"] = project_credit
         if marketplace_resource_count is not UNSET:
@@ -437,6 +446,13 @@ class Project:
 
         max_service_accounts = _parse_max_service_accounts(d.pop("max_service_accounts", UNSET))
 
+        _kind = d.pop("kind", UNSET)
+        kind: Union[Unset, KindEnum]
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = KindEnum(_kind)
+
         def _parse_project_credit(data: object) -> Union[None, Unset, float]:
             if data is None:
                 return data
@@ -486,6 +502,7 @@ class Project:
             image=image,
             resources_count=resources_count,
             max_service_accounts=max_service_accounts,
+            kind=kind,
             project_credit=project_credit,
             marketplace_resource_count=marketplace_resource_count,
             billing_price_estimate=billing_price_estimate,

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

waldur_api_client/models/project_details_response.py

@@ -0,0 +1,115 @@
+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_info import ChecklistInfo
+    from ..models.project_detail import ProjectDetail
+
+
+T = TypeVar("T", bound="ProjectDetailsResponse")
+
+
+@_attrs_define
+class ProjectDetailsResponse:
+    """
+    Attributes:
+        checklist (ChecklistInfo):
+        total_projects (int):
+        projects_with_completions (int):
+        fully_completed_projects (int):
+        projects_requiring_review (int):
+        project_details (list['ProjectDetail']):
+    """
+
+    checklist: "ChecklistInfo"
+    total_projects: int
+    projects_with_completions: int
+    fully_completed_projects: int
+    projects_requiring_review: int
+    project_details: list["ProjectDetail"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        checklist = self.checklist.to_dict()
+
+        total_projects = self.total_projects
+
+        projects_with_completions = self.projects_with_completions
+
+        fully_completed_projects = self.fully_completed_projects
+
+        projects_requiring_review = self.projects_requiring_review
+
+        project_details = []
+        for project_details_item_data in self.project_details:
+            project_details_item = project_details_item_data.to_dict()
+            project_details.append(project_details_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "checklist": checklist,
+                "total_projects": total_projects,
+                "projects_with_completions": projects_with_completions,
+                "fully_completed_projects": fully_completed_projects,
+                "projects_requiring_review": projects_requiring_review,
+                "project_details": project_details,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.checklist_info import ChecklistInfo
+        from ..models.project_detail import ProjectDetail
+
+        d = dict(src_dict)
+        checklist = ChecklistInfo.from_dict(d.pop("checklist"))
+
+        total_projects = d.pop("total_projects")
+
+        projects_with_completions = d.pop("projects_with_completions")
+
+        fully_completed_projects = d.pop("fully_completed_projects")
+
+        projects_requiring_review = d.pop("projects_requiring_review")
+
+        project_details = []
+        _project_details = d.pop("project_details")
+        for project_details_item_data in _project_details:
+            project_details_item = ProjectDetail.from_dict(project_details_item_data)
+
+            project_details.append(project_details_item)
+
+        project_details_response = cls(
+            checklist=checklist,
+            total_projects=total_projects,
+            projects_with_completions=projects_with_completions,
+            fully_completed_projects=fully_completed_projects,
+            projects_requiring_review=projects_requiring_review,
+            project_details=project_details,
+        )
+
+        project_details_response.additional_properties = d
+        return project_details_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/project_permission_review.py

@@ -0,0 +1,166 @@
+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
+
+T = TypeVar("T", bound="ProjectPermissionReview")
+
+
+@_attrs_define
+class ProjectPermissionReview:
+    """
+    Attributes:
+        url (str):
+        uuid (UUID):
+        reviewer_full_name (Union[None, str]):
+        reviewer_uuid (Union[None, UUID]):
+        is_pending (bool):
+        created (datetime.datetime):
+        closed (Union[None, datetime.datetime]):
+        project_uuid (UUID):
+        project_name (str):
+    """
+
+    url: str
+    uuid: UUID
+    reviewer_full_name: Union[None, str]
+    reviewer_uuid: Union[None, UUID]
+    is_pending: bool
+    created: datetime.datetime
+    closed: Union[None, datetime.datetime]
+    project_uuid: UUID
+    project_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        uuid = str(self.uuid)
+
+        reviewer_full_name: Union[None, str]
+        reviewer_full_name = self.reviewer_full_name
+
+        reviewer_uuid: Union[None, str]
+        if isinstance(self.reviewer_uuid, UUID):
+            reviewer_uuid = str(self.reviewer_uuid)
+        else:
+            reviewer_uuid = self.reviewer_uuid
+
+        is_pending = self.is_pending
+
+        created = self.created.isoformat()
+
+        closed: Union[None, str]
+        if isinstance(self.closed, datetime.datetime):
+            closed = self.closed.isoformat()
+        else:
+            closed = self.closed
+
+        project_uuid = str(self.project_uuid)
+
+        project_name = self.project_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+                "uuid": uuid,
+                "reviewer_full_name": reviewer_full_name,
+                "reviewer_uuid": reviewer_uuid,
+                "is_pending": is_pending,
+                "created": created,
+                "closed": closed,
+                "project_uuid": project_uuid,
+                "project_name": project_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        uuid = UUID(d.pop("uuid"))
+
+        def _parse_reviewer_full_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        reviewer_full_name = _parse_reviewer_full_name(d.pop("reviewer_full_name"))
+
+        def _parse_reviewer_uuid(data: object) -> Union[None, UUID]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                reviewer_uuid_type_0 = UUID(data)
+
+                return reviewer_uuid_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, UUID], data)
+
+        reviewer_uuid = _parse_reviewer_uuid(d.pop("reviewer_uuid"))
+
+        is_pending = d.pop("is_pending")
+
+        created = isoparse(d.pop("created"))
+
+        def _parse_closed(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                closed_type_0 = isoparse(data)
+
+                return closed_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        closed = _parse_closed(d.pop("closed"))
+
+        project_uuid = UUID(d.pop("project_uuid"))
+
+        project_name = d.pop("project_name")
+
+        project_permission_review = cls(
+            url=url,
+            uuid=uuid,
+            reviewer_full_name=reviewer_full_name,
+            reviewer_uuid=reviewer_uuid,
+            is_pending=is_pending,
+            created=created,
+            closed=closed,
+            project_uuid=project_uuid,
+            project_name=project_name,
+        )
+
+        project_permission_review.additional_properties = d
+        return project_permission_review
+
+    @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_permissions_reviews_count_o_item.py

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

waldur_api_client/models/project_permissions_reviews_list_o_item.py

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

waldur_api_client/models/project_request.py

@@ -9,6 +9,7 @@ from dateutil.parser import isoparse
 
 from .. import types
 from ..models.blank_enum import BlankEnum
+from ..models.kind_enum import KindEnum
 from ..models.oecd_fos_2007_code_enum import OecdFos2007CodeEnum
 from ..types import UNSET, File, Unset
 
@@ -30,6 +31,7 @@ class ProjectRequest:
         oecd_fos_2007_code (Union[BlankEnum, None, OecdFos2007CodeEnum, Unset]):
         is_industry (Union[Unset, bool]):
         image (Union[File, None, Unset]):
+        kind (Union[Unset, KindEnum]):
     """
 
     name: str
@@ -42,6 +44,7 @@ class ProjectRequest:
     oecd_fos_2007_code: Union[BlankEnum, None, OecdFos2007CodeEnum, Unset] = UNSET
     is_industry: Union[Unset, bool] = UNSET
     image: Union[File, None, Unset] = UNSET
+    kind: Union[Unset, KindEnum] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -96,6 +99,10 @@ class ProjectRequest:
         else:
             image = self.image
 
+        kind: Union[Unset, str] = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -120,6 +127,8 @@ class ProjectRequest:
             field_dict["is_industry"] = is_industry
         if image is not UNSET:
             field_dict["image"] = image
+        if kind is not UNSET:
+            field_dict["kind"] = kind
 
         return field_dict
 
@@ -221,6 +230,13 @@ class ProjectRequest:
 
         image = _parse_image(d.pop("image", UNSET))
 
+        _kind = d.pop("kind", UNSET)
+        kind: Union[Unset, KindEnum]
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = KindEnum(_kind)
+
         project_request = cls(
             name=name,
             customer=customer,
@@ -232,6 +248,7 @@ class ProjectRequest:
             oecd_fos_2007_code=oecd_fos_2007_code,
             is_industry=is_industry,
             image=image,
+            kind=kind,
         )
 
         project_request.additional_properties = d