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

waldur_api_client/models/service_provider_offering_user_compliance.py

@@ -0,0 +1,179 @@
+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 ..models.service_provider_offering_user_compliance_state_enum import ServiceProviderOfferingUserComplianceStateEnum
+
+T = TypeVar("T", bound="ServiceProviderOfferingUserCompliance")
+
+
+@_attrs_define
+class ServiceProviderOfferingUserCompliance:
+    """
+    Attributes:
+        uuid (UUID):
+        user_full_name (str):
+        user_email (str):
+        offering_name (str):
+        checklist_name (Union[None, str]):
+        username (Union[None, str]):
+        state (ServiceProviderOfferingUserComplianceStateEnum):
+        completion_percentage (Union[None, int]):
+        compliance_status (str):
+        last_updated (Union[None, datetime.datetime]):
+        created (datetime.datetime):
+    """
+
+    uuid: UUID
+    user_full_name: str
+    user_email: str
+    offering_name: str
+    checklist_name: Union[None, str]
+    username: Union[None, str]
+    state: ServiceProviderOfferingUserComplianceStateEnum
+    completion_percentage: Union[None, int]
+    compliance_status: str
+    last_updated: Union[None, datetime.datetime]
+    created: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        user_full_name = self.user_full_name
+
+        user_email = self.user_email
+
+        offering_name = self.offering_name
+
+        checklist_name: Union[None, str]
+        checklist_name = self.checklist_name
+
+        username: Union[None, str]
+        username = self.username
+
+        state = self.state.value
+
+        completion_percentage: Union[None, int]
+        completion_percentage = self.completion_percentage
+
+        compliance_status = self.compliance_status
+
+        last_updated: Union[None, str]
+        if isinstance(self.last_updated, datetime.datetime):
+            last_updated = self.last_updated.isoformat()
+        else:
+            last_updated = self.last_updated
+
+        created = self.created.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "user_full_name": user_full_name,
+                "user_email": user_email,
+                "offering_name": offering_name,
+                "checklist_name": checklist_name,
+                "username": username,
+                "state": state,
+                "completion_percentage": completion_percentage,
+                "compliance_status": compliance_status,
+                "last_updated": last_updated,
+                "created": created,
+            }
+        )
+
+        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"))
+
+        user_full_name = d.pop("user_full_name")
+
+        user_email = d.pop("user_email")
+
+        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"))
+
+        def _parse_username(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        username = _parse_username(d.pop("username"))
+
+        state = ServiceProviderOfferingUserComplianceStateEnum(d.pop("state"))
+
+        def _parse_completion_percentage(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        completion_percentage = _parse_completion_percentage(d.pop("completion_percentage"))
+
+        compliance_status = d.pop("compliance_status")
+
+        def _parse_last_updated(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_updated_type_0 = isoparse(data)
+
+                return last_updated_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        last_updated = _parse_last_updated(d.pop("last_updated"))
+
+        created = isoparse(d.pop("created"))
+
+        service_provider_offering_user_compliance = cls(
+            uuid=uuid,
+            user_full_name=user_full_name,
+            user_email=user_email,
+            offering_name=offering_name,
+            checklist_name=checklist_name,
+            username=username,
+            state=state,
+            completion_percentage=completion_percentage,
+            compliance_status=compliance_status,
+            last_updated=last_updated,
+            created=created,
+        )
+
+        service_provider_offering_user_compliance.additional_properties = d
+        return service_provider_offering_user_compliance
+
+    @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/service_provider_offering_user_compliance_state_enum.py

@@ -0,0 +1,17 @@
+from enum import IntEnum
+
+
+class ServiceProviderOfferingUserComplianceStateEnum(IntEnum):
+    VALUE_1 = 1
+    VALUE_2 = 2
+    VALUE_3 = 3
+    VALUE_4 = 4
+    VALUE_5 = 5
+    VALUE_6 = 6
+    VALUE_7 = 7
+    VALUE_8 = 8
+    VALUE_9 = 9
+    VALUE_10 = 10
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/slurm_invoices_slurm_package_create_order_attributes.py

@@ -0,0 +1,75 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SlurmInvoicesSlurmPackageCreateOrderAttributes")
+
+
+@_attrs_define
+class SlurmInvoicesSlurmPackageCreateOrderAttributes:
+    """This mixin allows to specify list of fields to be rendered by serializer.
+    It expects that request is available in serializer's context.
+
+    It is disabled for nested serializers (where parent is another serializer)
+    but remains active for list views (where parent is a ListSerializer).
+
+        Attributes:
+            name (str):
+            description (Union[Unset, str]):
+    """
+
+    name: str
+    description: Union[Unset, str] = 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
+
+        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
+
+        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)
+
+        slurm_invoices_slurm_package_create_order_attributes = cls(
+            name=name,
+            description=description,
+        )
+
+        slurm_invoices_slurm_package_create_order_attributes.additional_properties = d
+        return slurm_invoices_slurm_package_create_order_attributes
+
+    @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/sync_status_enum.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SyncStatusEnum(str, Enum):
+    IN_SYNC = "in_sync"
+    OUT_OF_SYNC = "out_of_sync"
+    SYNC_FAILED = "sync_failed"
+
+    def __str__(self) -> str:
+        return str(self.value)

waldur_api_client/models/user_offering_consent.py

@@ -0,0 +1,202 @@
+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="UserOfferingConsent")
+
+
+@_attrs_define
+class UserOfferingConsent:
+    """
+    Attributes:
+        uuid (UUID):
+        user_uuid (UUID):
+        offering_uuid (UUID):
+        agreement_date (datetime.datetime):
+        revocation_date (Union[None, datetime.datetime]):
+        created (datetime.datetime):
+        user_username (str): Required. 128 characters or fewer. Lowercase letters, numbers and @/./+/-/_ characters
+        user_full_name (str):
+        user_email (str):
+        offering_name (str):
+        offering_slug (str):
+        offering_url (str):
+        modified (datetime.datetime):
+        has_consent (bool):
+        requires_reconsent (bool):
+        version (Union[Unset, str]):
+    """
+
+    uuid: UUID
+    user_uuid: UUID
+    offering_uuid: UUID
+    agreement_date: datetime.datetime
+    revocation_date: Union[None, datetime.datetime]
+    created: datetime.datetime
+    user_username: str
+    user_full_name: str
+    user_email: str
+    offering_name: str
+    offering_slug: str
+    offering_url: str
+    modified: datetime.datetime
+    has_consent: bool
+    requires_reconsent: bool
+    version: 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)
+
+        user_uuid = str(self.user_uuid)
+
+        offering_uuid = str(self.offering_uuid)
+
+        agreement_date = self.agreement_date.isoformat()
+
+        revocation_date: Union[None, str]
+        if isinstance(self.revocation_date, datetime.datetime):
+            revocation_date = self.revocation_date.isoformat()
+        else:
+            revocation_date = self.revocation_date
+
+        created = self.created.isoformat()
+
+        user_username = self.user_username
+
+        user_full_name = self.user_full_name
+
+        user_email = self.user_email
+
+        offering_name = self.offering_name
+
+        offering_slug = self.offering_slug
+
+        offering_url = self.offering_url
+
+        modified = self.modified.isoformat()
+
+        has_consent = self.has_consent
+
+        requires_reconsent = self.requires_reconsent
+
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "user_uuid": user_uuid,
+                "offering_uuid": offering_uuid,
+                "agreement_date": agreement_date,
+                "revocation_date": revocation_date,
+                "created": created,
+                "user_username": user_username,
+                "user_full_name": user_full_name,
+                "user_email": user_email,
+                "offering_name": offering_name,
+                "offering_slug": offering_slug,
+                "offering_url": offering_url,
+                "modified": modified,
+                "has_consent": has_consent,
+                "requires_reconsent": requires_reconsent,
+            }
+        )
+        if version is not UNSET:
+            field_dict["version"] = version
+
+        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"))
+
+        user_uuid = UUID(d.pop("user_uuid"))
+
+        offering_uuid = UUID(d.pop("offering_uuid"))
+
+        agreement_date = isoparse(d.pop("agreement_date"))
+
+        def _parse_revocation_date(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                revocation_date_type_0 = isoparse(data)
+
+                return revocation_date_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        revocation_date = _parse_revocation_date(d.pop("revocation_date"))
+
+        created = isoparse(d.pop("created"))
+
+        user_username = d.pop("user_username")
+
+        user_full_name = d.pop("user_full_name")
+
+        user_email = d.pop("user_email")
+
+        offering_name = d.pop("offering_name")
+
+        offering_slug = d.pop("offering_slug")
+
+        offering_url = d.pop("offering_url")
+
+        modified = isoparse(d.pop("modified"))
+
+        has_consent = d.pop("has_consent")
+
+        requires_reconsent = d.pop("requires_reconsent")
+
+        version = d.pop("version", UNSET)
+
+        user_offering_consent = cls(
+            uuid=uuid,
+            user_uuid=user_uuid,
+            offering_uuid=offering_uuid,
+            agreement_date=agreement_date,
+            revocation_date=revocation_date,
+            created=created,
+            user_username=user_username,
+            user_full_name=user_full_name,
+            user_email=user_email,
+            offering_name=offering_name,
+            offering_slug=offering_slug,
+            offering_url=offering_url,
+            modified=modified,
+            has_consent=has_consent,
+            requires_reconsent=requires_reconsent,
+            version=version,
+        )
+
+        user_offering_consent.additional_properties = d
+        return user_offering_consent
+
+    @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/user_offering_consent_create.py

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

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

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UserOfferingConsentRequest")
+
+
+@_attrs_define
+class UserOfferingConsentRequest:
+    """
+    Attributes:
+        version (Union[Unset, str]):
+    """
+
+    version: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        version = self.version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if version is not UNSET:
+            field_dict["version"] = version
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        version = d.pop("version", UNSET)
+
+        user_offering_consent_request = cls(
+            version=version,
+        )
+
+        user_offering_consent_request.additional_properties = d
+        return user_offering_consent_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