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

waldur_api_client/models/offering_terms_of_service.py

@@ -0,0 +1,142 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+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="OfferingTermsOfService")
+
+
+@_attrs_define
+class OfferingTermsOfService:
+    """
+    Attributes:
+        uuid (UUID):
+        offering_uuid (UUID):
+        offering_name (str):
+        created (datetime.datetime):
+        modified (datetime.datetime):
+        terms_of_service (Union[Unset, str]):
+        terms_of_service_link (Union[Unset, str]):
+        version (Union[Unset, str]):
+        is_active (Union[Unset, bool]):
+        requires_reconsent (Union[Unset, bool]): If True, user will be asked to re-consent to the terms of service when
+            the terms of service are updated.
+    """
+
+    uuid: UUID
+    offering_uuid: UUID
+    offering_name: str
+    created: datetime.datetime
+    modified: datetime.datetime
+    terms_of_service: Union[Unset, str] = UNSET
+    terms_of_service_link: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    is_active: Union[Unset, bool] = UNSET
+    requires_reconsent: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuid = str(self.uuid)
+
+        offering_uuid = str(self.offering_uuid)
+
+        offering_name = self.offering_name
+
+        created = self.created.isoformat()
+
+        modified = self.modified.isoformat()
+
+        terms_of_service = self.terms_of_service
+
+        terms_of_service_link = self.terms_of_service_link
+
+        version = self.version
+
+        is_active = self.is_active
+
+        requires_reconsent = self.requires_reconsent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuid": uuid,
+                "offering_uuid": offering_uuid,
+                "offering_name": offering_name,
+                "created": created,
+                "modified": modified,
+            }
+        )
+        if terms_of_service is not UNSET:
+            field_dict["terms_of_service"] = terms_of_service
+        if terms_of_service_link is not UNSET:
+            field_dict["terms_of_service_link"] = terms_of_service_link
+        if version is not UNSET:
+            field_dict["version"] = version
+        if is_active is not UNSET:
+            field_dict["is_active"] = is_active
+        if requires_reconsent is not UNSET:
+            field_dict["requires_reconsent"] = requires_reconsent
+
+        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"))
+
+        offering_uuid = UUID(d.pop("offering_uuid"))
+
+        offering_name = d.pop("offering_name")
+
+        created = isoparse(d.pop("created"))
+
+        modified = isoparse(d.pop("modified"))
+
+        terms_of_service = d.pop("terms_of_service", UNSET)
+
+        terms_of_service_link = d.pop("terms_of_service_link", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        is_active = d.pop("is_active", UNSET)
+
+        requires_reconsent = d.pop("requires_reconsent", UNSET)
+
+        offering_terms_of_service = cls(
+            uuid=uuid,
+            offering_uuid=offering_uuid,
+            offering_name=offering_name,
+            created=created,
+            modified=modified,
+            terms_of_service=terms_of_service,
+            terms_of_service_link=terms_of_service_link,
+            version=version,
+            is_active=is_active,
+            requires_reconsent=requires_reconsent,
+        )
+
+        offering_terms_of_service.additional_properties = d
+        return offering_terms_of_service
+
+    @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/offering_terms_of_service_create.py

@@ -0,0 +1,107 @@
+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="OfferingTermsOfServiceCreate")
+
+
+@_attrs_define
+class OfferingTermsOfServiceCreate:
+    """
+    Attributes:
+        offering (str):
+        terms_of_service (Union[Unset, str]):
+        terms_of_service_link (Union[Unset, str]):
+        version (Union[Unset, str]):
+        is_active (Union[Unset, bool]):
+        requires_reconsent (Union[Unset, bool]): If True, user will be asked to re-consent to the terms of service when
+            the terms of service are updated.
+    """
+
+    offering: str
+    terms_of_service: Union[Unset, str] = UNSET
+    terms_of_service_link: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    is_active: Union[Unset, bool] = UNSET
+    requires_reconsent: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        offering = self.offering
+
+        terms_of_service = self.terms_of_service
+
+        terms_of_service_link = self.terms_of_service_link
+
+        version = self.version
+
+        is_active = self.is_active
+
+        requires_reconsent = self.requires_reconsent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "offering": offering,
+            }
+        )
+        if terms_of_service is not UNSET:
+            field_dict["terms_of_service"] = terms_of_service
+        if terms_of_service_link is not UNSET:
+            field_dict["terms_of_service_link"] = terms_of_service_link
+        if version is not UNSET:
+            field_dict["version"] = version
+        if is_active is not UNSET:
+            field_dict["is_active"] = is_active
+        if requires_reconsent is not UNSET:
+            field_dict["requires_reconsent"] = requires_reconsent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        offering = d.pop("offering")
+
+        terms_of_service = d.pop("terms_of_service", UNSET)
+
+        terms_of_service_link = d.pop("terms_of_service_link", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        is_active = d.pop("is_active", UNSET)
+
+        requires_reconsent = d.pop("requires_reconsent", UNSET)
+
+        offering_terms_of_service_create = cls(
+            offering=offering,
+            terms_of_service=terms_of_service,
+            terms_of_service_link=terms_of_service_link,
+            version=version,
+            is_active=is_active,
+            requires_reconsent=requires_reconsent,
+        )
+
+        offering_terms_of_service_create.additional_properties = d
+        return offering_terms_of_service_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/offering_terms_of_service_create_request.py

@@ -0,0 +1,107 @@
+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="OfferingTermsOfServiceCreateRequest")
+
+
+@_attrs_define
+class OfferingTermsOfServiceCreateRequest:
+    """
+    Attributes:
+        offering (str):
+        terms_of_service (Union[Unset, str]):
+        terms_of_service_link (Union[Unset, str]):
+        version (Union[Unset, str]):
+        is_active (Union[Unset, bool]):
+        requires_reconsent (Union[Unset, bool]): If True, user will be asked to re-consent to the terms of service when
+            the terms of service are updated.
+    """
+
+    offering: str
+    terms_of_service: Union[Unset, str] = UNSET
+    terms_of_service_link: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    is_active: Union[Unset, bool] = UNSET
+    requires_reconsent: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        offering = self.offering
+
+        terms_of_service = self.terms_of_service
+
+        terms_of_service_link = self.terms_of_service_link
+
+        version = self.version
+
+        is_active = self.is_active
+
+        requires_reconsent = self.requires_reconsent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "offering": offering,
+            }
+        )
+        if terms_of_service is not UNSET:
+            field_dict["terms_of_service"] = terms_of_service
+        if terms_of_service_link is not UNSET:
+            field_dict["terms_of_service_link"] = terms_of_service_link
+        if version is not UNSET:
+            field_dict["version"] = version
+        if is_active is not UNSET:
+            field_dict["is_active"] = is_active
+        if requires_reconsent is not UNSET:
+            field_dict["requires_reconsent"] = requires_reconsent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        offering = d.pop("offering")
+
+        terms_of_service = d.pop("terms_of_service", UNSET)
+
+        terms_of_service_link = d.pop("terms_of_service_link", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        is_active = d.pop("is_active", UNSET)
+
+        requires_reconsent = d.pop("requires_reconsent", UNSET)
+
+        offering_terms_of_service_create_request = cls(
+            offering=offering,
+            terms_of_service=terms_of_service,
+            terms_of_service_link=terms_of_service_link,
+            version=version,
+            is_active=is_active,
+            requires_reconsent=requires_reconsent,
+        )
+
+        offering_terms_of_service_create_request.additional_properties = d
+        return offering_terms_of_service_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/offering_terms_of_service_request.py

@@ -0,0 +1,96 @@
+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="OfferingTermsOfServiceRequest")
+
+
+@_attrs_define
+class OfferingTermsOfServiceRequest:
+    """
+    Attributes:
+        terms_of_service (Union[Unset, str]):
+        terms_of_service_link (Union[Unset, str]):
+        version (Union[Unset, str]):
+        is_active (Union[Unset, bool]):
+        requires_reconsent (Union[Unset, bool]): If True, user will be asked to re-consent to the terms of service when
+            the terms of service are updated.
+    """
+
+    terms_of_service: Union[Unset, str] = UNSET
+    terms_of_service_link: Union[Unset, str] = UNSET
+    version: Union[Unset, str] = UNSET
+    is_active: Union[Unset, bool] = UNSET
+    requires_reconsent: Union[Unset, bool] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        terms_of_service = self.terms_of_service
+
+        terms_of_service_link = self.terms_of_service_link
+
+        version = self.version
+
+        is_active = self.is_active
+
+        requires_reconsent = self.requires_reconsent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if terms_of_service is not UNSET:
+            field_dict["terms_of_service"] = terms_of_service
+        if terms_of_service_link is not UNSET:
+            field_dict["terms_of_service_link"] = terms_of_service_link
+        if version is not UNSET:
+            field_dict["version"] = version
+        if is_active is not UNSET:
+            field_dict["is_active"] = is_active
+        if requires_reconsent is not UNSET:
+            field_dict["requires_reconsent"] = requires_reconsent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        terms_of_service = d.pop("terms_of_service", UNSET)
+
+        terms_of_service_link = d.pop("terms_of_service_link", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        is_active = d.pop("is_active", UNSET)
+
+        requires_reconsent = d.pop("requires_reconsent", UNSET)
+
+        offering_terms_of_service_request = cls(
+            terms_of_service=terms_of_service,
+            terms_of_service_link=terms_of_service_link,
+            version=version,
+            is_active=is_active,
+            requires_reconsent=requires_reconsent,
+        )
+
+        offering_terms_of_service_request.additional_properties = d
+        return offering_terms_of_service_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/open_stack_backend_instance.py

@@ -22,8 +22,8 @@ class OpenStackBackendInstance:
         key_name (Union[Unset, str]):
         start_time (Union[None, Unset, datetime.datetime]):
         runtime_state (Union[Unset, str]):
-        backend_id (Union[None, Unset, str]):
-        hypervisor_hostname (Union[Unset, str]):
+        backend_id (Union[None, Unset, str]): Instance ID in the OpenStack backend
+        hypervisor_hostname (Union[Unset, str]): Name of the hypervisor hosting this instance
     """
 
     name: str

waldur_api_client/models/open_stack_backend_volumes.py

@@ -19,9 +19,9 @@ class OpenStackBackendVolumes:
         state (str):
         availability_zone (str):
         description (Union[Unset, str]):
-        metadata (Union[Unset, str]):
-        backend_id (Union[None, Unset, str]):
-        bootable (Union[Unset, bool]):
+        metadata (Union[Unset, str]): Arbitrary key-value pairs associated with the volume
+        backend_id (Union[None, Unset, str]): Volume ID in the OpenStack backend
+        bootable (Union[Unset, bool]): Indicates if this volume can be used to boot an instance
         runtime_state (Union[Unset, str]):
     """
 

waldur_api_client/models/open_stack_backup.py

@@ -53,7 +53,7 @@ class OpenStackBackup:
         access_url (Union[None, Unset, str]):
         kept_until (Union[None, Unset, datetime.datetime]): Guaranteed time of backup retention. If null - keep forever.
         metadata (Union[Unset, Any]):
-        instance (Union[Unset, str]):
+        instance (Union[Unset, str]): Instance that this backup is created from
         instance_name (Union[Unset, str]):
         instance_marketplace_uuid (Union[Unset, UUID]):
         restorations (Union[Unset, list['OpenStackBackupRestoration']]):

waldur_api_client/models/open_stack_backup_restoration.py

@@ -23,13 +23,16 @@ class OpenStackBackupRestoration:
     """
     Attributes:
         uuid (Union[Unset, UUID]):
-        instance (Union[Unset, str]):
+        instance (Union[Unset, str]): Instance that is being restored from the backup
         created (Union[Unset, datetime.datetime]):
-        flavor (Union[Unset, str]):
+        flavor (Union[Unset, str]): Flavor to be used for the restored instance. If not specified, original instance
+            flavor will be used
         name (Union[Unset, str]): New instance name. Leave blank to use source instance name.
-        floating_ips (Union[Unset, list['OpenStackNestedFloatingIP']]):
-        security_groups (Union[Unset, list['OpenStackNestedSecurityGroup']]):
-        ports (Union[Unset, list['OpenStackNestedPort']]):
+        floating_ips (Union[Unset, list['OpenStackNestedFloatingIP']]): Floating IPs that will be assigned to the
+            restored instance
+        security_groups (Union[Unset, list['OpenStackNestedSecurityGroup']]): Security groups that will be assigned to
+            the restored instance
+        ports (Union[Unset, list['OpenStackNestedPort']]): Network ports that will be attached to the restored instance
     """
 
     uuid: Union[Unset, UUID] = UNSET

waldur_api_client/models/open_stack_backup_restoration_request.py

@@ -9,6 +9,7 @@ from ..types import UNSET, Unset
 if TYPE_CHECKING:
     from ..models.open_stack_nested_floating_ip_request import OpenStackNestedFloatingIPRequest
     from ..models.open_stack_nested_port_request import OpenStackNestedPortRequest
+    from ..models.open_stack_nested_security_group_request import OpenStackNestedSecurityGroupRequest
 
 
 T = TypeVar("T", bound="OpenStackBackupRestorationRequest")
@@ -18,15 +19,21 @@ T = TypeVar("T", bound="OpenStackBackupRestorationRequest")
 class OpenStackBackupRestorationRequest:
     """
     Attributes:
-        flavor (str):
+        flavor (str): Flavor to be used for the restored instance. If not specified, original instance flavor will be
+            used
         name (Union[Unset, str]): New instance name. Leave blank to use source instance name.
-        floating_ips (Union[Unset, list['OpenStackNestedFloatingIPRequest']]):
-        ports (Union[Unset, list['OpenStackNestedPortRequest']]):
+        floating_ips (Union[Unset, list['OpenStackNestedFloatingIPRequest']]): Floating IPs that will be assigned to the
+            restored instance
+        security_groups (Union[Unset, list['OpenStackNestedSecurityGroupRequest']]): Security groups that will be
+            assigned to the restored instance
+        ports (Union[Unset, list['OpenStackNestedPortRequest']]): Network ports that will be attached to the restored
+            instance
     """
 
     flavor: str
     name: Union[Unset, str] = UNSET
     floating_ips: Union[Unset, list["OpenStackNestedFloatingIPRequest"]] = UNSET
+    security_groups: Union[Unset, list["OpenStackNestedSecurityGroupRequest"]] = UNSET
     ports: Union[Unset, list["OpenStackNestedPortRequest"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
@@ -42,6 +49,13 @@ class OpenStackBackupRestorationRequest:
                 floating_ips_item = floating_ips_item_data.to_dict()
                 floating_ips.append(floating_ips_item)
 
+        security_groups: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.security_groups, Unset):
+            security_groups = []
+            for security_groups_item_data in self.security_groups:
+                security_groups_item = security_groups_item_data.to_dict()
+                security_groups.append(security_groups_item)
+
         ports: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.ports, Unset):
             ports = []
@@ -60,6 +74,8 @@ class OpenStackBackupRestorationRequest:
             field_dict["name"] = name
         if floating_ips is not UNSET:
             field_dict["floating_ips"] = floating_ips
+        if security_groups is not UNSET:
+            field_dict["security_groups"] = security_groups
         if ports is not UNSET:
             field_dict["ports"] = ports
 
@@ -69,6 +85,7 @@ class OpenStackBackupRestorationRequest:
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.open_stack_nested_floating_ip_request import OpenStackNestedFloatingIPRequest
         from ..models.open_stack_nested_port_request import OpenStackNestedPortRequest
+        from ..models.open_stack_nested_security_group_request import OpenStackNestedSecurityGroupRequest
 
         d = dict(src_dict)
         flavor = d.pop("flavor")
@@ -82,6 +99,13 @@ class OpenStackBackupRestorationRequest:
 
             floating_ips.append(floating_ips_item)
 
+        security_groups = []
+        _security_groups = d.pop("security_groups", UNSET)
+        for security_groups_item_data in _security_groups or []:
+            security_groups_item = OpenStackNestedSecurityGroupRequest.from_dict(security_groups_item_data)
+
+            security_groups.append(security_groups_item)
+
         ports = []
         _ports = d.pop("ports", UNSET)
         for ports_item_data in _ports or []:
@@ -93,6 +117,7 @@ class OpenStackBackupRestorationRequest:
             flavor=flavor,
             name=name,
             floating_ips=floating_ips,
+            security_groups=security_groups,
             ports=ports,
         )
 

waldur_api_client/models/open_stack_fixed_ip.py

@@ -13,8 +13,8 @@ T = TypeVar("T", bound="OpenStackFixedIp")
 class OpenStackFixedIp:
     """
     Attributes:
-        ip_address (Union[Unset, str]):
-        subnet_id (Union[Unset, str]):
+        ip_address (Union[Unset, str]): IP address to assign to the port
+        subnet_id (Union[Unset, str]): ID of the subnet in which to assign the IP address
     """
 
     ip_address: Union[Unset, str] = UNSET

waldur_api_client/models/open_stack_fixed_ip_request.py

@@ -11,8 +11,8 @@ T = TypeVar("T", bound="OpenStackFixedIpRequest")
 class OpenStackFixedIpRequest:
     """
     Attributes:
-        ip_address (str):
-        subnet_id (str):
+        ip_address (str): IP address to assign to the port
+        subnet_id (str): ID of the subnet in which to assign the IP address
     """
 
     ip_address: str

waldur_api_client/models/open_stack_floating_ip.py

@@ -49,13 +49,14 @@ class OpenStackFloatingIP:
         backend_id (Union[Unset, str]):
         access_url (Union[None, Unset, str]):
         runtime_state (Union[Unset, str]):
-        address (Union[None, Unset, str]):
-        backend_network_id (Union[Unset, str]):
-        tenant (Union[Unset, str]):
+        address (Union[None, Unset, str]): The public IPv4 address of the floating IP
+        backend_network_id (Union[Unset, str]): ID of network in OpenStack where this floating IP is allocated
+        tenant (Union[Unset, str]): OpenStack tenant this floating IP belongs to
         tenant_name (Union[Unset, str]):
         tenant_uuid (Union[Unset, UUID]):
         port (Union[Unset, str]):
-        external_address (Union[None, Unset, str]): An optional address that maps to floating IP's address
+        external_address (Union[None, Unset, str]): Optional address that maps to floating IP's address in external
+            networks
         port_fixed_ips (Union[Unset, list['OpenStackFixedIp']]):
         instance_uuid (Union[None, Unset, str]):
         instance_name (Union[None, Unset, str]):