waldur-api-client 7.8.3__py3-none-any.whl → 7.8.5__py3-none-any.whl

waldur_api_client/models/nested_round.py

@@ -10,7 +10,7 @@ from dateutil.parser import isoparse
 from ..models.allocation_time_enum import AllocationTimeEnum
 from ..models.deciding_entity_enum import DecidingEntityEnum
 from ..models.review_strategy_enum import ReviewStrategyEnum
-from ..models.status_enum import StatusEnum
+from ..models.round_status import RoundStatus
 from ..types import UNSET, Unset
 
 T = TypeVar("T", bound="NestedRound")
@@ -25,7 +25,7 @@ class NestedRound:
         name (Union[Unset, str]):
         start_time (Union[Unset, datetime.datetime]):
         cutoff_time (Union[Unset, datetime.datetime]):
-        status (Union[Unset, StatusEnum]):
+        status (Union[Unset, RoundStatus]):
         review_strategy (Union[Unset, ReviewStrategyEnum]):
         deciding_entity (Union[Unset, DecidingEntityEnum]):
         allocation_time (Union[Unset, AllocationTimeEnum]):
@@ -40,7 +40,7 @@ class NestedRound:
     name: Union[Unset, str] = UNSET
     start_time: Union[Unset, datetime.datetime] = UNSET
     cutoff_time: Union[Unset, datetime.datetime] = UNSET
-    status: Union[Unset, StatusEnum] = UNSET
+    status: Union[Unset, RoundStatus] = UNSET
     review_strategy: Union[Unset, ReviewStrategyEnum] = UNSET
     deciding_entity: Union[Unset, DecidingEntityEnum] = UNSET
     allocation_time: Union[Unset, AllocationTimeEnum] = UNSET
@@ -170,11 +170,11 @@ class NestedRound:
             cutoff_time = isoparse(_cutoff_time)
 
         _status = d.pop("status", UNSET)
-        status: Union[Unset, StatusEnum]
+        status: Union[Unset, RoundStatus]
         if isinstance(_status, Unset):
             status = UNSET
         else:
-            status = StatusEnum(_status)
+            status = RoundStatus(_status)
 
         _review_strategy = d.pop("review_strategy", UNSET)
         review_strategy: Union[Unset, ReviewStrategyEnum]

waldur_api_client/models/nested_software_catalog.py

@@ -0,0 +1,134 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.nested_software_catalog_catalog import NestedSoftwareCatalogCatalog
+    from ..models.nested_software_catalog_partition import NestedSoftwareCatalogPartition
+
+
+T = TypeVar("T", bound="NestedSoftwareCatalog")
+
+
+@_attrs_define
+class NestedSoftwareCatalog:
+    """
+    Attributes:
+        uuid (Union[Unset, UUID]):
+        catalog (Union[Unset, NestedSoftwareCatalogCatalog]):
+        enabled_cpu_family (Union[Unset, Any]): List of enabled CPU families: ['x86_64', 'aarch64']
+        enabled_cpu_microarchitectures (Union[Unset, Any]): List of enabled CPU microarchitectures: ['generic', 'zen3']
+        package_count (Union[Unset, int]):
+        partition (Union[Unset, NestedSoftwareCatalogPartition]):
+    """
+
+    uuid: Union[Unset, UUID] = UNSET
+    catalog: Union[Unset, "NestedSoftwareCatalogCatalog"] = UNSET
+    enabled_cpu_family: Union[Unset, Any] = UNSET
+    enabled_cpu_microarchitectures: Union[Unset, Any] = UNSET
+    package_count: Union[Unset, int] = UNSET
+    partition: Union[Unset, "NestedSoftwareCatalogPartition"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid: Union[Unset, str] = UNSET
+        if not isinstance(self.uuid, Unset):
+            uuid = str(self.uuid)
+
+        catalog: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.catalog, Unset):
+            catalog = self.catalog.to_dict()
+
+        enabled_cpu_family = self.enabled_cpu_family
+
+        enabled_cpu_microarchitectures = self.enabled_cpu_microarchitectures
+
+        package_count = self.package_count
+
+        partition: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.partition, Unset):
+            partition = self.partition.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if uuid is not UNSET:
+            field_dict["uuid"] = uuid
+        if catalog is not UNSET:
+            field_dict["catalog"] = catalog
+        if enabled_cpu_family is not UNSET:
+            field_dict["enabled_cpu_family"] = enabled_cpu_family
+        if enabled_cpu_microarchitectures is not UNSET:
+            field_dict["enabled_cpu_microarchitectures"] = enabled_cpu_microarchitectures
+        if package_count is not UNSET:
+            field_dict["package_count"] = package_count
+        if partition is not UNSET:
+            field_dict["partition"] = partition
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.nested_software_catalog_catalog import NestedSoftwareCatalogCatalog
+        from ..models.nested_software_catalog_partition import NestedSoftwareCatalogPartition
+
+        d = dict(src_dict)
+        _uuid = d.pop("uuid", UNSET)
+        uuid: Union[Unset, UUID]
+        if isinstance(_uuid, Unset):
+            uuid = UNSET
+        else:
+            uuid = UUID(_uuid)
+
+        _catalog = d.pop("catalog", UNSET)
+        catalog: Union[Unset, NestedSoftwareCatalogCatalog]
+        if isinstance(_catalog, Unset):
+            catalog = UNSET
+        else:
+            catalog = NestedSoftwareCatalogCatalog.from_dict(_catalog)
+
+        enabled_cpu_family = d.pop("enabled_cpu_family", UNSET)
+
+        enabled_cpu_microarchitectures = d.pop("enabled_cpu_microarchitectures", UNSET)
+
+        package_count = d.pop("package_count", UNSET)
+
+        _partition = d.pop("partition", UNSET)
+        partition: Union[Unset, NestedSoftwareCatalogPartition]
+        if isinstance(_partition, Unset):
+            partition = UNSET
+        else:
+            partition = NestedSoftwareCatalogPartition.from_dict(_partition)
+
+        nested_software_catalog = cls(
+            uuid=uuid,
+            catalog=catalog,
+            enabled_cpu_family=enabled_cpu_family,
+            enabled_cpu_microarchitectures=enabled_cpu_microarchitectures,
+            package_count=package_count,
+            partition=partition,
+        )
+
+        nested_software_catalog.additional_properties = d
+        return nested_software_catalog
+
+    @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/nested_software_catalog_catalog.py

@@ -0,0 +1,86 @@
+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="NestedSoftwareCatalogCatalog")
+
+
+@_attrs_define
+class NestedSoftwareCatalogCatalog:
+    """
+    Attributes:
+        uuid (Union[Unset, str]):
+        name (Union[Unset, str]):
+        version (Union[Unset, str]):
+        description (Union[Unset, str]):
+    """
+
+    uuid: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    description: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = self.uuid
+
+        name = self.name
+
+        version = self.version
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if uuid is not UNSET:
+            field_dict["uuid"] = uuid
+        if name is not UNSET:
+            field_dict["name"] = name
+        if version is not UNSET:
+            field_dict["version"] = version
+        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)
+        uuid = d.pop("uuid", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        description = d.pop("description", UNSET)
+
+        nested_software_catalog_catalog = cls(
+            uuid=uuid,
+            name=name,
+            version=version,
+            description=description,
+        )
+
+        nested_software_catalog_catalog.additional_properties = d
+        return nested_software_catalog_catalog
+
+    @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/nested_software_catalog_partition.py

@@ -0,0 +1,86 @@
+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="NestedSoftwareCatalogPartition")
+
+
+@_attrs_define
+class NestedSoftwareCatalogPartition:
+    """
+    Attributes:
+        uuid (Union[Unset, str]):
+        partition_name (Union[Unset, str]):
+        priority_tier (Union[Unset, int]):
+        qos (Union[Unset, str]):
+    """
+
+    uuid: Union[Unset, str] = UNSET
+    partition_name: Union[Unset, str] = UNSET
+    priority_tier: Union[Unset, int] = UNSET
+    qos: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = self.uuid
+
+        partition_name = self.partition_name
+
+        priority_tier = self.priority_tier
+
+        qos = self.qos
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if uuid is not UNSET:
+            field_dict["uuid"] = uuid
+        if partition_name is not UNSET:
+            field_dict["partition_name"] = partition_name
+        if priority_tier is not UNSET:
+            field_dict["priority_tier"] = priority_tier
+        if qos is not UNSET:
+            field_dict["qos"] = qos
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        uuid = d.pop("uuid", UNSET)
+
+        partition_name = d.pop("partition_name", UNSET)
+
+        priority_tier = d.pop("priority_tier", UNSET)
+
+        qos = d.pop("qos", UNSET)
+
+        nested_software_catalog_partition = cls(
+            uuid=uuid,
+            partition_name=partition_name,
+            priority_tier=priority_tier,
+            qos=qos,
+        )
+
+        nested_software_catalog_partition.additional_properties = d
+        return nested_software_catalog_partition
+
+    @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/nested_software_catalog_request.py

@@ -0,0 +1,68 @@
+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="NestedSoftwareCatalogRequest")
+
+
+@_attrs_define
+class NestedSoftwareCatalogRequest:
+    """
+    Attributes:
+        enabled_cpu_family (Union[Unset, Any]): List of enabled CPU families: ['x86_64', 'aarch64']
+        enabled_cpu_microarchitectures (Union[Unset, Any]): List of enabled CPU microarchitectures: ['generic', 'zen3']
+    """
+
+    enabled_cpu_family: Union[Unset, Any] = UNSET
+    enabled_cpu_microarchitectures: Union[Unset, Any] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled_cpu_family = self.enabled_cpu_family
+
+        enabled_cpu_microarchitectures = self.enabled_cpu_microarchitectures
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if enabled_cpu_family is not UNSET:
+            field_dict["enabled_cpu_family"] = enabled_cpu_family
+        if enabled_cpu_microarchitectures is not UNSET:
+            field_dict["enabled_cpu_microarchitectures"] = enabled_cpu_microarchitectures
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        enabled_cpu_family = d.pop("enabled_cpu_family", UNSET)
+
+        enabled_cpu_microarchitectures = d.pop("enabled_cpu_microarchitectures", UNSET)
+
+        nested_software_catalog_request = cls(
+            enabled_cpu_family=enabled_cpu_family,
+            enabled_cpu_microarchitectures=enabled_cpu_microarchitectures,
+        )
+
+        nested_software_catalog_request.additional_properties = d
+        return nested_software_catalog_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/nested_software_target.py

@@ -0,0 +1,84 @@
+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="NestedSoftwareTarget")
+
+
+@_attrs_define
+class NestedSoftwareTarget:
+    """
+    Attributes:
+        uuid (UUID):
+        cpu_family (str):
+        cpu_microarchitecture (str):
+        path (str):
+    """
+
+    uuid: UUID
+    cpu_family: str
+    cpu_microarchitecture: str
+    path: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        cpu_family = self.cpu_family
+
+        cpu_microarchitecture = self.cpu_microarchitecture
+
+        path = self.path
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "cpu_family": cpu_family,
+                "cpu_microarchitecture": cpu_microarchitecture,
+                "path": path,
+            }
+        )
+
+        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"))
+
+        cpu_family = d.pop("cpu_family")
+
+        cpu_microarchitecture = d.pop("cpu_microarchitecture")
+
+        path = d.pop("path")
+
+        nested_software_target = cls(
+            uuid=uuid,
+            cpu_family=cpu_family,
+            cpu_microarchitecture=cpu_microarchitecture,
+            path=path,
+        )
+
+        nested_software_target.additional_properties = d
+        return nested_software_target
+
+    @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/nested_software_target_request.py

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

@@ -0,0 +1,124 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from ..models.nested_software_target import NestedSoftwareTarget
+
+
+T = TypeVar("T", bound="NestedSoftwareVersion")
+
+
+@_attrs_define
+class NestedSoftwareVersion:
+    """
+    Attributes:
+        uuid (UUID):
+        version (str):
+        targets (list['NestedSoftwareTarget']):
+        release_date (Union[None, Unset, datetime.date]):
+    """
+
+    uuid: UUID
+    version: str
+    targets: list["NestedSoftwareTarget"]
+    release_date: Union[None, Unset, datetime.date] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        version = self.version
+
+        targets = []
+        for targets_item_data in self.targets:
+            targets_item = targets_item_data.to_dict()
+            targets.append(targets_item)
+
+        release_date: Union[None, Unset, str]
+        if isinstance(self.release_date, Unset):
+            release_date = UNSET
+        elif isinstance(self.release_date, datetime.date):
+            release_date = self.release_date.isoformat()
+        else:
+            release_date = self.release_date
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "version": version,
+                "targets": targets,
+            }
+        )
+        if release_date is not UNSET:
+            field_dict["release_date"] = release_date
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.nested_software_target import NestedSoftwareTarget
+
+        d = dict(src_dict)
+        uuid = UUID(d.pop("uuid"))
+
+        version = d.pop("version")
+
+        targets = []
+        _targets = d.pop("targets")
+        for targets_item_data in _targets:
+            targets_item = NestedSoftwareTarget.from_dict(targets_item_data)
+
+            targets.append(targets_item)
+
+        def _parse_release_date(data: object) -> Union[None, Unset, datetime.date]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                release_date_type_0 = isoparse(data).date()
+
+                return release_date_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.date], data)
+
+        release_date = _parse_release_date(d.pop("release_date", UNSET))
+
+        nested_software_version = cls(
+            uuid=uuid,
+            version=version,
+            targets=targets,
+            release_date=release_date,
+        )
+
+        nested_software_version.additional_properties = d
+        return nested_software_version
+
+    @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