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

waldur_api_client/models/robot_account_details.py

@@ -24,58 +24,58 @@ T = TypeVar("T", bound="RobotAccountDetails")
 class RobotAccountDetails:
     """
     Attributes:
-        url (str):
-        uuid (UUID):
-        created (datetime.datetime):
-        modified (datetime.datetime):
-        resource (str):
-        type_ (str): Type of the robot account.
-        users (list['BasicUser']):
-        backend_id (str):
-        fingerprints (list['Fingerprint']):
-        responsible_user (Union['BasicUser', None]):
-        user_keys (list['SshKey']):
-        resource_name (str):
-        resource_uuid (UUID):
-        project_name (str):
-        project_uuid (UUID):
-        customer_uuid (UUID):
-        customer_name (str):
-        offering_customer_uuid (UUID):
-        offering_plugin_options (MergedPluginOptions):
+        url (Union[Unset, str]):
+        uuid (Union[Unset, UUID]):
+        created (Union[Unset, datetime.datetime]):
+        modified (Union[Unset, datetime.datetime]):
         username (Union[Unset, str]):
         description (Union[Unset, str]):
         error_message (Union[Unset, str]):
         error_traceback (Union[Unset, str]):
+        resource (Union[Unset, str]):
+        type_ (Union[Unset, str]): Type of the robot account.
+        users (Union[Unset, list['BasicUser']]):
         keys (Union[Unset, Any]):
+        backend_id (Union[Unset, str]):
+        fingerprints (Union[Unset, list['Fingerprint']]):
+        responsible_user (Union['BasicUser', None, Unset]):
         state (Union[Unset, RobotAccountStates]):
+        user_keys (Union[Unset, list['SshKey']]):
+        resource_name (Union[Unset, str]):
+        resource_uuid (Union[Unset, UUID]):
+        project_name (Union[Unset, str]):
+        project_uuid (Union[Unset, UUID]):
+        customer_uuid (Union[Unset, UUID]):
+        customer_name (Union[Unset, str]):
+        offering_customer_uuid (Union[Unset, UUID]):
+        offering_plugin_options (Union[Unset, MergedPluginOptions]):
     """
 
-    url: str
-    uuid: UUID
-    created: datetime.datetime
-    modified: datetime.datetime
-    resource: str
-    type_: str
-    users: list["BasicUser"]
-    backend_id: str
-    fingerprints: list["Fingerprint"]
-    responsible_user: Union["BasicUser", None]
-    user_keys: list["SshKey"]
-    resource_name: str
-    resource_uuid: UUID
-    project_name: str
-    project_uuid: UUID
-    customer_uuid: UUID
-    customer_name: str
-    offering_customer_uuid: UUID
-    offering_plugin_options: "MergedPluginOptions"
+    url: Union[Unset, str] = UNSET
+    uuid: Union[Unset, UUID] = UNSET
+    created: Union[Unset, datetime.datetime] = UNSET
+    modified: Union[Unset, datetime.datetime] = UNSET
     username: Union[Unset, str] = UNSET
     description: Union[Unset, str] = UNSET
     error_message: Union[Unset, str] = UNSET
     error_traceback: Union[Unset, str] = UNSET
+    resource: Union[Unset, str] = UNSET
+    type_: Union[Unset, str] = UNSET
+    users: Union[Unset, list["BasicUser"]] = UNSET
     keys: Union[Unset, Any] = UNSET
+    backend_id: Union[Unset, str] = UNSET
+    fingerprints: Union[Unset, list["Fingerprint"]] = UNSET
+    responsible_user: Union["BasicUser", None, Unset] = UNSET
     state: Union[Unset, RobotAccountStates] = UNSET
+    user_keys: Union[Unset, list["SshKey"]] = UNSET
+    resource_name: Union[Unset, str] = UNSET
+    resource_uuid: Union[Unset, UUID] = UNSET
+    project_name: Union[Unset, str] = UNSET
+    project_uuid: Union[Unset, UUID] = UNSET
+    customer_uuid: Union[Unset, UUID] = UNSET
+    customer_name: Union[Unset, str] = UNSET
+    offering_customer_uuid: Union[Unset, UUID] = UNSET
+    offering_plugin_options: Union[Unset, "MergedPluginOptions"] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -83,94 +83,104 @@ class RobotAccountDetails:
 
         url = self.url
 
-        uuid = str(self.uuid)
+        uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.uuid, Unset):
+            uuid = str(self.uuid)
 
-        created = self.created.isoformat()
+        created: Union[Unset, str] = UNSET
+        if not isinstance(self.created, Unset):
+            created = self.created.isoformat()
 
-        modified = self.modified.isoformat()
+        modified: Union[Unset, str] = UNSET
+        if not isinstance(self.modified, Unset):
+            modified = self.modified.isoformat()
+
+        username = self.username
+
+        description = self.description
+
+        error_message = self.error_message
+
+        error_traceback = self.error_traceback
 
         resource = self.resource
 
         type_ = self.type_
 
-        users = []
-        for users_item_data in self.users:
-            users_item = users_item_data.to_dict()
-            users.append(users_item)
+        users: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.users, Unset):
+            users = []
+            for users_item_data in self.users:
+                users_item = users_item_data.to_dict()
+                users.append(users_item)
 
-        backend_id = self.backend_id
+        keys = self.keys
 
-        fingerprints = []
-        for fingerprints_item_data in self.fingerprints:
-            fingerprints_item = fingerprints_item_data.to_dict()
-            fingerprints.append(fingerprints_item)
+        backend_id = self.backend_id
 
-        responsible_user: Union[None, dict[str, Any]]
-        if isinstance(self.responsible_user, BasicUser):
+        fingerprints: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.fingerprints, Unset):
+            fingerprints = []
+            for fingerprints_item_data in self.fingerprints:
+                fingerprints_item = fingerprints_item_data.to_dict()
+                fingerprints.append(fingerprints_item)
+
+        responsible_user: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.responsible_user, Unset):
+            responsible_user = UNSET
+        elif isinstance(self.responsible_user, BasicUser):
             responsible_user = self.responsible_user.to_dict()
         else:
             responsible_user = self.responsible_user
 
-        user_keys = []
-        for user_keys_item_data in self.user_keys:
-            user_keys_item = user_keys_item_data.to_dict()
-            user_keys.append(user_keys_item)
+        state: Union[Unset, int] = UNSET
+        if not isinstance(self.state, Unset):
+            state = self.state.value
+
+        user_keys: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.user_keys, Unset):
+            user_keys = []
+            for user_keys_item_data in self.user_keys:
+                user_keys_item = user_keys_item_data.to_dict()
+                user_keys.append(user_keys_item)
 
         resource_name = self.resource_name
 
-        resource_uuid = str(self.resource_uuid)
+        resource_uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.resource_uuid, Unset):
+            resource_uuid = str(self.resource_uuid)
 
         project_name = self.project_name
 
-        project_uuid = str(self.project_uuid)
+        project_uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.project_uuid, Unset):
+            project_uuid = str(self.project_uuid)
 
-        customer_uuid = str(self.customer_uuid)
+        customer_uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.customer_uuid, Unset):
+            customer_uuid = str(self.customer_uuid)
 
         customer_name = self.customer_name
 
-        offering_customer_uuid = str(self.offering_customer_uuid)
+        offering_customer_uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.offering_customer_uuid, Unset):
+            offering_customer_uuid = str(self.offering_customer_uuid)
 
-        offering_plugin_options = self.offering_plugin_options.to_dict()
-
-        username = self.username
-
-        description = self.description
-
-        error_message = self.error_message
-
-        error_traceback = self.error_traceback
-
-        keys = self.keys
-
-        state: Union[Unset, int] = UNSET
-        if not isinstance(self.state, Unset):
-            state = self.state.value
+        offering_plugin_options: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.offering_plugin_options, Unset):
+            offering_plugin_options = self.offering_plugin_options.to_dict()
 
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update(
-            {
-                "url": url,
-                "uuid": uuid,
-                "created": created,
-                "modified": modified,
-                "resource": resource,
-                "type": type_,
-                "users": users,
-                "backend_id": backend_id,
-                "fingerprints": fingerprints,
-                "responsible_user": responsible_user,
-                "user_keys": user_keys,
-                "resource_name": resource_name,
-                "resource_uuid": resource_uuid,
-                "project_name": project_name,
-                "project_uuid": project_uuid,
-                "customer_uuid": customer_uuid,
-                "customer_name": customer_name,
-                "offering_customer_uuid": offering_customer_uuid,
-                "offering_plugin_options": offering_plugin_options,
-            }
-        )
+        field_dict.update({})
+        if url is not UNSET:
+            field_dict["url"] = url
+        if uuid is not UNSET:
+            field_dict["uuid"] = uuid
+        if created is not UNSET:
+            field_dict["created"] = created
+        if modified is not UNSET:
+            field_dict["modified"] = modified
         if username is not UNSET:
             field_dict["username"] = username
         if description is not UNSET:
@@ -179,10 +189,40 @@ class RobotAccountDetails:
             field_dict["error_message"] = error_message
         if error_traceback is not UNSET:
             field_dict["error_traceback"] = error_traceback
+        if resource is not UNSET:
+            field_dict["resource"] = resource
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if users is not UNSET:
+            field_dict["users"] = users
         if keys is not UNSET:
             field_dict["keys"] = keys
+        if backend_id is not UNSET:
+            field_dict["backend_id"] = backend_id
+        if fingerprints is not UNSET:
+            field_dict["fingerprints"] = fingerprints
+        if responsible_user is not UNSET:
+            field_dict["responsible_user"] = responsible_user
         if state is not UNSET:
             field_dict["state"] = state
+        if user_keys is not UNSET:
+            field_dict["user_keys"] = user_keys
+        if resource_name is not UNSET:
+            field_dict["resource_name"] = resource_name
+        if resource_uuid is not UNSET:
+            field_dict["resource_uuid"] = resource_uuid
+        if project_name is not UNSET:
+            field_dict["project_name"] = project_name
+        if project_uuid is not UNSET:
+            field_dict["project_uuid"] = project_uuid
+        if customer_uuid is not UNSET:
+            field_dict["customer_uuid"] = customer_uuid
+        if customer_name is not UNSET:
+            field_dict["customer_name"] = customer_name
+        if offering_customer_uuid is not UNSET:
+            field_dict["offering_customer_uuid"] = offering_customer_uuid
+        if offering_plugin_options is not UNSET:
+            field_dict["offering_plugin_options"] = offering_plugin_options
 
         return field_dict
 
@@ -194,37 +234,64 @@ class RobotAccountDetails:
         from ..models.ssh_key import SshKey
 
         d = dict(src_dict)
-        url = d.pop("url")
+        url = d.pop("url", UNSET)
 
-        uuid = UUID(d.pop("uuid"))
+        _uuid = d.pop("uuid", UNSET)
+        uuid: Union[Unset, UUID]
+        if isinstance(_uuid, Unset):
+            uuid = UNSET
+        else:
+            uuid = UUID(_uuid)
 
-        created = isoparse(d.pop("created"))
+        _created = d.pop("created", UNSET)
+        created: Union[Unset, datetime.datetime]
+        if isinstance(_created, Unset):
+            created = UNSET
+        else:
+            created = isoparse(_created)
 
-        modified = isoparse(d.pop("modified"))
+        _modified = d.pop("modified", UNSET)
+        modified: Union[Unset, datetime.datetime]
+        if isinstance(_modified, Unset):
+            modified = UNSET
+        else:
+            modified = isoparse(_modified)
 
-        resource = d.pop("resource")
+        username = d.pop("username", UNSET)
 
-        type_ = d.pop("type")
+        description = d.pop("description", UNSET)
+
+        error_message = d.pop("error_message", UNSET)
+
+        error_traceback = d.pop("error_traceback", UNSET)
+
+        resource = d.pop("resource", UNSET)
+
+        type_ = d.pop("type", UNSET)
 
         users = []
-        _users = d.pop("users")
-        for users_item_data in _users:
+        _users = d.pop("users", UNSET)
+        for users_item_data in _users or []:
             users_item = BasicUser.from_dict(users_item_data)
 
             users.append(users_item)
 
-        backend_id = d.pop("backend_id")
+        keys = d.pop("keys", UNSET)
+
+        backend_id = d.pop("backend_id", UNSET)
 
         fingerprints = []
-        _fingerprints = d.pop("fingerprints")
-        for fingerprints_item_data in _fingerprints:
+        _fingerprints = d.pop("fingerprints", UNSET)
+        for fingerprints_item_data in _fingerprints or []:
             fingerprints_item = Fingerprint.from_dict(fingerprints_item_data)
 
             fingerprints.append(fingerprints_item)
 
-        def _parse_responsible_user(data: object) -> Union["BasicUser", None]:
+        def _parse_responsible_user(data: object) -> Union["BasicUser", None, Unset]:
             if data is None:
                 return data
+            if isinstance(data, Unset):
+                return data
             try:
                 if not isinstance(data, dict):
                     raise TypeError()
@@ -233,61 +300,82 @@ class RobotAccountDetails:
                 return responsible_user_type_1
             except:  # noqa: E722
                 pass
-            return cast(Union["BasicUser", None], data)
+            return cast(Union["BasicUser", None, Unset], data)
+
+        responsible_user = _parse_responsible_user(d.pop("responsible_user", UNSET))
 
-        responsible_user = _parse_responsible_user(d.pop("responsible_user"))
+        _state = d.pop("state", UNSET)
+        state: Union[Unset, RobotAccountStates]
+        if isinstance(_state, Unset):
+            state = UNSET
+        else:
+            state = RobotAccountStates(_state)
 
         user_keys = []
-        _user_keys = d.pop("user_keys")
-        for user_keys_item_data in _user_keys:
+        _user_keys = d.pop("user_keys", UNSET)
+        for user_keys_item_data in _user_keys or []:
             user_keys_item = SshKey.from_dict(user_keys_item_data)
 
             user_keys.append(user_keys_item)
 
-        resource_name = d.pop("resource_name")
-
-        resource_uuid = UUID(d.pop("resource_uuid"))
-
-        project_name = d.pop("project_name")
-
-        project_uuid = UUID(d.pop("project_uuid"))
-
-        customer_uuid = UUID(d.pop("customer_uuid"))
-
-        customer_name = d.pop("customer_name")
+        resource_name = d.pop("resource_name", UNSET)
 
-        offering_customer_uuid = UUID(d.pop("offering_customer_uuid"))
-
-        offering_plugin_options = MergedPluginOptions.from_dict(d.pop("offering_plugin_options"))
+        _resource_uuid = d.pop("resource_uuid", UNSET)
+        resource_uuid: Union[Unset, UUID]
+        if isinstance(_resource_uuid, Unset):
+            resource_uuid = UNSET
+        else:
+            resource_uuid = UUID(_resource_uuid)
 
-        username = d.pop("username", UNSET)
+        project_name = d.pop("project_name", UNSET)
 
-        description = d.pop("description", UNSET)
+        _project_uuid = d.pop("project_uuid", UNSET)
+        project_uuid: Union[Unset, UUID]
+        if isinstance(_project_uuid, Unset):
+            project_uuid = UNSET
+        else:
+            project_uuid = UUID(_project_uuid)
 
-        error_message = d.pop("error_message", UNSET)
+        _customer_uuid = d.pop("customer_uuid", UNSET)
+        customer_uuid: Union[Unset, UUID]
+        if isinstance(_customer_uuid, Unset):
+            customer_uuid = UNSET
+        else:
+            customer_uuid = UUID(_customer_uuid)
 
-        error_traceback = d.pop("error_traceback", UNSET)
+        customer_name = d.pop("customer_name", UNSET)
 
-        keys = d.pop("keys", UNSET)
+        _offering_customer_uuid = d.pop("offering_customer_uuid", UNSET)
+        offering_customer_uuid: Union[Unset, UUID]
+        if isinstance(_offering_customer_uuid, Unset):
+            offering_customer_uuid = UNSET
+        else:
+            offering_customer_uuid = UUID(_offering_customer_uuid)
 
-        _state = d.pop("state", UNSET)
-        state: Union[Unset, RobotAccountStates]
-        if isinstance(_state, Unset):
-            state = UNSET
+        _offering_plugin_options = d.pop("offering_plugin_options", UNSET)
+        offering_plugin_options: Union[Unset, MergedPluginOptions]
+        if isinstance(_offering_plugin_options, Unset):
+            offering_plugin_options = UNSET
         else:
-            state = RobotAccountStates(_state)
+            offering_plugin_options = MergedPluginOptions.from_dict(_offering_plugin_options)
 
         robot_account_details = cls(
             url=url,
             uuid=uuid,
             created=created,
             modified=modified,
+            username=username,
+            description=description,
+            error_message=error_message,
+            error_traceback=error_traceback,
             resource=resource,
             type_=type_,
             users=users,
+            keys=keys,
             backend_id=backend_id,
             fingerprints=fingerprints,
             responsible_user=responsible_user,
+            state=state,
             user_keys=user_keys,
             resource_name=resource_name,
             resource_uuid=resource_uuid,
@@ -297,12 +385,6 @@ class RobotAccountDetails:
             customer_name=customer_name,
             offering_customer_uuid=offering_customer_uuid,
             offering_plugin_options=offering_plugin_options,
-            username=username,
-            description=description,
-            error_message=error_message,
-            error_traceback=error_traceback,
-            keys=keys,
-            state=state,
         )
 
         robot_account_details.additional_properties = d

waldur_api_client/models/service_provider.py

@@ -24,6 +24,7 @@ class ServiceProvider:
         uuid (Union[Unset, UUID]):
         created (Union[Unset, datetime.datetime]):
         description (Union[Unset, str]):
+        enable_notifications (Union[Unset, bool]):
         customer (Union[Unset, str]):
         customer_name (Union[Unset, str]):
         customer_uuid (Union[Unset, UUID]):
@@ -41,6 +42,7 @@ class ServiceProvider:
     uuid: Union[Unset, UUID] = UNSET
     created: Union[Unset, datetime.datetime] = UNSET
     description: Union[Unset, str] = UNSET
+    enable_notifications: Union[Unset, bool] = UNSET
     customer: Union[Unset, str] = UNSET
     customer_name: Union[Unset, str] = UNSET
     customer_uuid: Union[Unset, UUID] = UNSET
@@ -67,6 +69,8 @@ class ServiceProvider:
 
         description = self.description
 
+        enable_notifications = self.enable_notifications
+
         customer = self.customer
 
         customer_name = self.customer_name
@@ -111,6 +115,8 @@ class ServiceProvider:
             field_dict["created"] = created
         if description is not UNSET:
             field_dict["description"] = description
+        if enable_notifications is not UNSET:
+            field_dict["enable_notifications"] = enable_notifications
         if customer is not UNSET:
             field_dict["customer"] = customer
         if customer_name is not UNSET:
@@ -159,6 +165,8 @@ class ServiceProvider:
 
         description = d.pop("description", UNSET)
 
+        enable_notifications = d.pop("enable_notifications", UNSET)
+
         customer = d.pop("customer", UNSET)
 
         customer_name = d.pop("customer_name", UNSET)
@@ -203,6 +211,7 @@ class ServiceProvider:
             uuid=uuid,
             created=created,
             description=description,
+            enable_notifications=enable_notifications,
             customer=customer,
             customer_name=customer_name,
             customer_uuid=customer_uuid,

waldur_api_client/models/service_provider_compliance_overview.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="ServiceProviderComplianceOverview")
+
+
+@_attrs_define
+class ServiceProviderComplianceOverview:
+    """
+    Attributes:
+        offering_uuid (UUID):
+        offering_name (str):
+        checklist_name (Union[None, str]):
+        total_users (int):
+        users_with_completions (int):
+        completed_users (int):
+        pending_users (int):
+        compliance_rate (float):
+    """
+
+    offering_uuid: UUID
+    offering_name: str
+    checklist_name: Union[None, str]
+    total_users: int
+    users_with_completions: int
+    completed_users: int
+    pending_users: int
+    compliance_rate: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        offering_uuid = str(self.offering_uuid)
+
+        offering_name = self.offering_name
+
+        checklist_name: Union[None, str]
+        checklist_name = self.checklist_name
+
+        total_users = self.total_users
+
+        users_with_completions = self.users_with_completions
+
+        completed_users = self.completed_users
+
+        pending_users = self.pending_users
+
+        compliance_rate = self.compliance_rate
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "offering_uuid": offering_uuid,
+                "offering_name": offering_name,
+                "checklist_name": checklist_name,
+                "total_users": total_users,
+                "users_with_completions": users_with_completions,
+                "completed_users": completed_users,
+                "pending_users": pending_users,
+                "compliance_rate": compliance_rate,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        offering_uuid = UUID(d.pop("offering_uuid"))
+
+        offering_name = d.pop("offering_name")
+
+        def _parse_checklist_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        checklist_name = _parse_checklist_name(d.pop("checklist_name"))
+
+        total_users = d.pop("total_users")
+
+        users_with_completions = d.pop("users_with_completions")
+
+        completed_users = d.pop("completed_users")
+
+        pending_users = d.pop("pending_users")
+
+        compliance_rate = d.pop("compliance_rate")
+
+        service_provider_compliance_overview = cls(
+            offering_uuid=offering_uuid,
+            offering_name=offering_name,
+            checklist_name=checklist_name,
+            total_users=total_users,
+            users_with_completions=users_with_completions,
+            completed_users=completed_users,
+            pending_users=pending_users,
+            compliance_rate=compliance_rate,
+        )
+
+        service_provider_compliance_overview.additional_properties = d
+        return service_provider_compliance_overview
+
+    @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