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

waldur_api_client/models/rancher_ingresses_count_state_item.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class RancherIngressesCountStateItem(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/rancher_namespaces_count_o_item.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class RancherNamespacesCountOItem(str, Enum):
+    CLUSTER_NAME = "cluster_name"
+    NAME = "name"
+    PROJECT_NAME = "project_name"
+    VALUE_0 = "-cluster_name"
+    VALUE_1 = "-name"
+    VALUE_2 = "-project_name"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/rancher_role_templates_count_o_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class RancherRoleTemplatesCountOItem(str, Enum):
+    NAME = "name"
+    SCOPE_TYPE = "scope_type"
+    VALUE_0 = "-name"
+    VALUE_1 = "-scope_type"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/rancher_services_count_state_item.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class RancherServicesCountStateItem(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/rancher_templates_count_o_item.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class RancherTemplatesCountOItem(str, Enum):
+    CATALOG_NAME = "catalog_name"
+    NAME = "name"
+    VALUE_0 = "-catalog_name"
+    VALUE_1 = "-name"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/rancher_workloads_count_o_item.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class RancherWorkloadsCountOItem(str, Enum):
+    CLUSTER_NAME = "cluster_name"
+    NAME = "name"
+    NAMESPACE_NAME = "namespace_name"
+    PROJECT_NAME = "project_name"
+    VALUE_0 = "-cluster_name"
+    VALUE_1 = "-name"
+    VALUE_2 = "-namespace_name"
+    VALUE_3 = "-project_name"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/remote_project_update_request.py

@@ -23,12 +23,12 @@ class RemoteProjectUpdateRequest:
         offering_name (str):
         offering_uuid (UUID):
         created (datetime.datetime):
-        reviewed_at (Union[None, datetime.datetime]):
+        reviewed_at (Union[None, datetime.datetime]): Timestamp when the review was completed
         reviewed_by_full_name (str):
         reviewed_by_uuid (UUID):
         old_oecd_fos_2007_label (str):
         new_oecd_fos_2007_label (str):
-        review_comment (Union[None, Unset, str]):
+        review_comment (Union[None, Unset, str]): Optional comment provided during review
         old_name (Union[Unset, str]):
         new_name (Union[Unset, str]):
         old_description (Union[Unset, str]):

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