hyperstack 0.1.23__py3-none-any.whl → 1.41.0a0__py3-none-any.whl

hyperstack/models/{getcreditandthresholdinfo.py → get_credit_and_threshold_info.py}

@@ -22,9 +22,9 @@ from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Getcreditandthresholdinfo(BaseModel):
+class GetCreditAndThresholdInfo(BaseModel):
     """
-    Getcreditandthresholdinfo
+    GetCreditAndThresholdInfo
     """ # noqa: E501
     can_create_instance: Optional[StrictBool] = None
     credit: Optional[Union[StrictFloat, StrictInt]] = None
@@ -49,7 +49,7 @@ class Getcreditandthresholdinfo(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Getcreditandthresholdinfo from a JSON string"""
+        """Create an instance of GetCreditAndThresholdInfo from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -74,7 +74,7 @@ class Getcreditandthresholdinfo(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Getcreditandthresholdinfo from a dict"""
+        """Create an instance of GetCreditAndThresholdInfo from a dict"""
         if obj is None:
             return None
 

hyperstack/models/{getcreditandthresholdinfoinresponse.py → get_credit_and_threshold_info_in_response.py}

@@ -19,15 +19,15 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.getcreditandthresholdinfo import Getcreditandthresholdinfo
+from ..models.get_credit_and_threshold_info import GetCreditAndThresholdInfo
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Getcreditandthresholdinfoinresponse(BaseModel):
+class GetCreditAndThresholdInfoInResponse(BaseModel):
     """
-    Getcreditandthresholdinfoinresponse
+    GetCreditAndThresholdInfoInResponse
     """ # noqa: E501
-    data: Optional[Getcreditandthresholdinfo] = None
+    data: Optional[GetCreditAndThresholdInfo] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
     __properties: ClassVar[List[str]] = ["data", "message", "status"]
@@ -50,7 +50,7 @@ class Getcreditandthresholdinfoinresponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Getcreditandthresholdinfoinresponse from a JSON string"""
+        """Create an instance of GetCreditAndThresholdInfoInResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -78,7 +78,7 @@ class Getcreditandthresholdinfoinresponse(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Getcreditandthresholdinfoinresponse from a dict"""
+        """Create an instance of GetCreditAndThresholdInfoInResponse from a dict"""
         if obj is None:
             return None
 
@@ -86,7 +86,7 @@ class Getcreditandthresholdinfoinresponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": Getcreditandthresholdinfo.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "data": GetCreditAndThresholdInfo.from_dict(obj["data"]) if obj.get("data") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{region_payload.py → get_instance_logs_response.py}

@@ -22,13 +22,12 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class RegionPayload(BaseModel):
+class GetInstanceLogsResponse(BaseModel):
     """
-    RegionPayload
+    GetInstanceLogsResponse
     """ # noqa: E501
-    description: Optional[StrictStr] = None
-    name: StrictStr
-    __properties: ClassVar[List[str]] = ["description", "name"]
+    logs: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["logs"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +47,7 @@ class RegionPayload(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of RegionPayload from a JSON string"""
+        """Create an instance of GetInstanceLogsResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,7 +72,7 @@ class RegionPayload(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of RegionPayload from a dict"""
+        """Create an instance of GetInstanceLogsResponse from a dict"""
         if obj is None:
             return None
 
@@ -81,8 +80,7 @@ class RegionPayload(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "description": obj.get("description"),
-            "name": obj.get("name")
+            "logs": obj.get("logs")
         })
         return _obj
 

hyperstack/models/instance_fields.py

@@ -24,7 +24,7 @@ from ..models.instance_environment_fields import InstanceEnvironmentFields
 from ..models.instance_flavor_fields import InstanceFlavorFields
 from ..models.instance_image_fields import InstanceImageFields
 from ..models.instance_keypair_fields import InstanceKeypairFields
-from ..models.security_rules_fieldsfor_instance import SecurityRulesFieldsforInstance
+from ..models.security_rules_fields_for_instance import SecurityRulesFieldsForInstance
 from ..models.volume_attachment_fields import VolumeAttachmentFields
 from typing import Optional, Set
 from typing_extensions import Self
@@ -33,9 +33,11 @@ class InstanceFields(BaseModel):
     """
     InstanceFields
     """ # noqa: E501
+    callback_url: Optional[StrictStr] = None
     contract_id: Optional[StrictInt] = None
     created_at: Optional[datetime] = None
     environment: Optional[InstanceEnvironmentFields] = None
+    features: Optional[Dict[str, Any]] = None
     fixed_ip: Optional[StrictStr] = None
     flavor: Optional[InstanceFlavorFields] = None
     floating_ip: Optional[StrictStr] = None
@@ -47,12 +49,15 @@ class InstanceFields(BaseModel):
     locked: Optional[StrictBool] = None
     name: Optional[StrictStr] = None
     os: Optional[StrictStr] = None
+    port_randomization: Optional[StrictBool] = None
+    port_randomization_status: Optional[StrictStr] = None
     power_state: Optional[StrictStr] = None
-    security_rules: Optional[List[SecurityRulesFieldsforInstance]] = None
+    requires_public_ip: Optional[StrictBool] = None
+    security_rules: Optional[List[SecurityRulesFieldsForInstance]] = None
     status: Optional[StrictStr] = None
     vm_state: Optional[StrictStr] = None
     volume_attachments: Optional[List[VolumeAttachmentFields]] = None
-    __properties: ClassVar[List[str]] = ["contract_id", "created_at", "environment", "fixed_ip", "flavor", "floating_ip", "floating_ip_status", "id", "image", "keypair", "labels", "locked", "name", "os", "power_state", "security_rules", "status", "vm_state", "volume_attachments"]
+    __properties: ClassVar[List[str]] = ["callback_url", "contract_id", "created_at", "environment", "features", "fixed_ip", "flavor", "floating_ip", "floating_ip_status", "id", "image", "keypair", "labels", "locked", "name", "os", "port_randomization", "port_randomization_status", "power_state", "requires_public_ip", "security_rules", "status", "vm_state", "volume_attachments"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -131,9 +136,11 @@ class InstanceFields(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "callback_url": obj.get("callback_url"),
             "contract_id": obj.get("contract_id"),
             "created_at": obj.get("created_at"),
             "environment": InstanceEnvironmentFields.from_dict(obj["environment"]) if obj.get("environment") is not None else None,
+            "features": obj.get("features"),
             "fixed_ip": obj.get("fixed_ip"),
             "flavor": InstanceFlavorFields.from_dict(obj["flavor"]) if obj.get("flavor") is not None else None,
             "floating_ip": obj.get("floating_ip"),
@@ -145,8 +152,11 @@ class InstanceFields(BaseModel):
             "locked": obj.get("locked"),
             "name": obj.get("name"),
             "os": obj.get("os"),
+            "port_randomization": obj.get("port_randomization"),
+            "port_randomization_status": obj.get("port_randomization_status"),
             "power_state": obj.get("power_state"),
-            "security_rules": [SecurityRulesFieldsforInstance.from_dict(_item) for _item in obj["security_rules"]] if obj.get("security_rules") is not None else None,
+            "requires_public_ip": obj.get("requires_public_ip"),
+            "security_rules": [SecurityRulesFieldsForInstance.from_dict(_item) for _item in obj["security_rules"]] if obj.get("security_rules") is not None else None,
             "status": obj.get("status"),
             "vm_state": obj.get("vm_state"),
             "volume_attachments": [VolumeAttachmentFields.from_dict(_item) for _item in obj["volume_attachments"]] if obj.get("volume_attachments") is not None else None

hyperstack/models/instance_flavor_fields.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
+from ..models.flavor_label_fields import FlavorLabelFields
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,12 +30,14 @@ class InstanceFlavorFields(BaseModel):
     cpu: Optional[StrictInt] = None
     disk: Optional[StrictInt] = None
     ephemeral: Optional[StrictInt] = None
+    features: Optional[Dict[str, Any]] = None
     gpu: Optional[StrictStr] = None
     gpu_count: Optional[StrictInt] = None
     id: Optional[StrictInt] = None
+    labels: Optional[List[FlavorLabelFields]] = None
     name: Optional[StrictStr] = None
     ram: Optional[Union[StrictFloat, StrictInt]] = None
-    __properties: ClassVar[List[str]] = ["cpu", "disk", "ephemeral", "gpu", "gpu_count", "id", "name", "ram"]
+    __properties: ClassVar[List[str]] = ["cpu", "disk", "ephemeral", "features", "gpu", "gpu_count", "id", "labels", "name", "ram"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -75,6 +78,13 @@ class InstanceFlavorFields(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each item in labels (list)
+        _items = []
+        if self.labels:
+            for _item_labels in self.labels:
+                if _item_labels:
+                    _items.append(_item_labels.to_dict())
+            _dict['labels'] = _items
         return _dict
 
     @classmethod
@@ -90,9 +100,11 @@ class InstanceFlavorFields(BaseModel):
             "cpu": obj.get("cpu"),
             "disk": obj.get("disk"),
             "ephemeral": obj.get("ephemeral"),
+            "features": obj.get("features"),
             "gpu": obj.get("gpu"),
             "gpu_count": obj.get("gpu_count"),
             "id": obj.get("id"),
+            "labels": [FlavorLabelFields.from_dict(_item) for _item in obj["labels"]] if obj.get("labels") is not None else None,
             "name": obj.get("name"),
             "ram": obj.get("ram")
         })

hyperstack/models/{flavor_response.py → keypair_environment_features.py}

@@ -17,20 +17,28 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.flavor_fields import FlavorFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class FlavorResponse(BaseModel):
+class KeypairEnvironmentFeatures(BaseModel):
     """
-    FlavorResponse
+    KeypairEnvironmentFeatures
     """ # noqa: E501
-    flavor: Optional[FlavorFields] = None
-    message: Optional[StrictStr] = None
-    status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["flavor", "message", "status"]
+    green_status: Optional[StrictStr] = None
+    network_optimised: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["green_status", "network_optimised"]
+
+    @field_validator('green_status')
+    def green_status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['GREEN', 'PARTIALLY_GREEN', 'NOT_GREEN']):
+            raise ValueError("must be one of enum values ('GREEN', 'PARTIALLY_GREEN', 'NOT_GREEN')")
+        return value
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +58,7 @@ class FlavorResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of FlavorResponse from a JSON string"""
+        """Create an instance of KeypairEnvironmentFeatures from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +79,11 @@ class FlavorResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of flavor
-        if self.flavor:
-            _dict['flavor'] = self.flavor.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of FlavorResponse from a dict"""
+        """Create an instance of KeypairEnvironmentFeatures from a dict"""
         if obj is None:
             return None
 
@@ -86,9 +91,8 @@ class FlavorResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "flavor": FlavorFields.from_dict(obj["flavor"]) if obj.get("flavor") is not None else None,
-            "message": obj.get("message"),
-            "status": obj.get("status")
+            "green_status": obj.get("green_status"),
+            "network_optimised": obj.get("network_optimised")
         })
         return _obj
 

hyperstack/models/{internal_instance_keypair_fields.py → keypair_environment_fields.py}

@@ -20,20 +20,20 @@ import json
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from ..models.keypair_environment_features import KeypairEnvironmentFeatures
 from typing import Optional, Set
 from typing_extensions import Self
 
-class InternalInstanceKeypairFields(BaseModel):
+class KeypairEnvironmentFields(BaseModel):
     """
-    InternalInstanceKeypairFields
+    KeypairEnvironmentFields
     """ # noqa: E501
     created_at: Optional[datetime] = None
-    environment: Optional[StrictStr] = None
-    fingerprint: Optional[StrictStr] = None
+    features: Optional[KeypairEnvironmentFeatures] = None
     id: Optional[StrictInt] = None
     name: Optional[StrictStr] = None
-    public_key: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["created_at", "environment", "fingerprint", "id", "name", "public_key"]
+    region: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["created_at", "features", "id", "name", "region"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -53,7 +53,7 @@ class InternalInstanceKeypairFields(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of InternalInstanceKeypairFields from a JSON string"""
+        """Create an instance of KeypairEnvironmentFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -74,11 +74,14 @@ class InternalInstanceKeypairFields(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of features
+        if self.features:
+            _dict['features'] = self.features.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of InternalInstanceKeypairFields from a dict"""
+        """Create an instance of KeypairEnvironmentFields from a dict"""
         if obj is None:
             return None
 
@@ -87,11 +90,10 @@ class InternalInstanceKeypairFields(BaseModel):
 
         _obj = cls.model_validate({
             "created_at": obj.get("created_at"),
-            "environment": obj.get("environment"),
-            "fingerprint": obj.get("fingerprint"),
+            "features": KeypairEnvironmentFeatures.from_dict(obj["features"]) if obj.get("features") is not None else None,
             "id": obj.get("id"),
             "name": obj.get("name"),
-            "public_key": obj.get("public_key")
+            "region": obj.get("region")
         })
         return _obj
 

hyperstack/models/keypair_fields.py

@@ -20,6 +20,7 @@ import json
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from ..models.keypair_environment_fields import KeypairEnvironmentFields
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +29,7 @@ class KeypairFields(BaseModel):
     KeypairFields
     """ # noqa: E501
     created_at: Optional[datetime] = None
-    environment: Optional[StrictStr] = None
+    environment: Optional[KeypairEnvironmentFields] = None
     fingerprint: Optional[StrictStr] = None
     id: Optional[StrictInt] = None
     name: Optional[StrictStr] = None
@@ -74,6 +75,9 @@ class KeypairFields(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of environment
+        if self.environment:
+            _dict['environment'] = self.environment.to_dict()
         return _dict
 
     @classmethod
@@ -87,7 +91,7 @@ class KeypairFields(BaseModel):
 
         _obj = cls.model_validate({
             "created_at": obj.get("created_at"),
-            "environment": obj.get("environment"),
+            "environment": KeypairEnvironmentFields.from_dict(obj["environment"]) if obj.get("environment") is not None else None,
             "fingerprint": obj.get("fingerprint"),
             "id": obj.get("id"),
             "name": obj.get("name"),

hyperstack/models/{lastdaycostfields.py → last_day_cost_fields.py}

@@ -22,9 +22,9 @@ from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Lastdaycostfields(BaseModel):
+class LastDayCostFields(BaseModel):
     """
-    Lastdaycostfields
+    LastDayCostFields
     """ # noqa: E501
     clusters_cost: Optional[Union[StrictFloat, StrictInt]] = None
     instances_cost: Optional[Union[StrictFloat, StrictInt]] = None
@@ -50,7 +50,7 @@ class Lastdaycostfields(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Lastdaycostfields from a JSON string"""
+        """Create an instance of LastDayCostFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -75,7 +75,7 @@ class Lastdaycostfields(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Lastdaycostfields from a dict"""
+        """Create an instance of LastDayCostFields from a dict"""
         if obj is None:
             return None
 

hyperstack/models/{lastdaycostresponse.py → last_day_cost_response.py}

@@ -19,15 +19,15 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.lastdaycostfields import Lastdaycostfields
+from ..models.last_day_cost_fields import LastDayCostFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Lastdaycostresponse(BaseModel):
+class LastDayCostResponse(BaseModel):
     """
-    Lastdaycostresponse
+    LastDayCostResponse
     """ # noqa: E501
-    data: Optional[Lastdaycostfields] = None
+    data: Optional[LastDayCostFields] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
     __properties: ClassVar[List[str]] = ["data", "message", "status"]
@@ -50,7 +50,7 @@ class Lastdaycostresponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Lastdaycostresponse from a JSON string"""
+        """Create an instance of LastDayCostResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -78,7 +78,7 @@ class Lastdaycostresponse(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Lastdaycostresponse from a dict"""
+        """Create an instance of LastDayCostResponse from a dict"""
         if obj is None:
             return None
 
@@ -86,7 +86,7 @@ class Lastdaycostresponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": Lastdaycostfields.from_dict(obj["data"]) if obj.get("data") is not None else None,
+            "data": LastDayCostFields.from_dict(obj["data"]) if obj.get("data") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{export_billing_data_response.py → logos.py}

@@ -22,13 +22,15 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ExportBillingDataResponse(BaseModel):
+class Logos(BaseModel):
     """
-    ExportBillingDataResponse
+    Logos
     """ # noqa: E501
-    measures: Optional[List[Dict[str, Any]]] = None
-    message: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["measures", "message"]
+    dark: Optional[StrictStr] = None
+    email: Optional[StrictStr] = None
+    favicon: Optional[StrictStr] = None
+    light: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["dark", "email", "favicon", "light"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +50,7 @@ class ExportBillingDataResponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ExportBillingDataResponse from a JSON string"""
+        """Create an instance of Logos from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,7 +75,7 @@ class ExportBillingDataResponse(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ExportBillingDataResponse from a dict"""
+        """Create an instance of Logos from a dict"""
         if obj is None:
             return None
 
@@ -81,8 +83,10 @@ class ExportBillingDataResponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "measures": obj.get("measures"),
-            "message": obj.get("message")
+            "dark": obj.get("dark"),
+            "email": obj.get("email"),
+            "favicon": obj.get("favicon"),
+            "light": obj.get("light")
         })
         return _obj
 

hyperstack/models/{creditrequestresponse.py → master_flavors_response.py}

@@ -19,18 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.creditrequests import Creditrequests
+from ..models.cluster_flavor_fields import ClusterFlavorFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class Creditrequestresponse(BaseModel):
+class MasterFlavorsResponse(BaseModel):
     """
-    Creditrequestresponse
+    MasterFlavorsResponse
     """ # noqa: E501
-    data: Optional[List[Creditrequests]] = None
+    flavors: Optional[List[ClusterFlavorFields]] = None
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["data", "message", "status"]
+    __properties: ClassVar[List[str]] = ["flavors", "message", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class Creditrequestresponse(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Creditrequestresponse from a JSON string"""
+        """Create an instance of MasterFlavorsResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,18 +71,18 @@ class Creditrequestresponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in flavors (list)
         _items = []
-        if self.data:
-            for _item_data in self.data:
-                if _item_data:
-                    _items.append(_item_data.to_dict())
-            _dict['data'] = _items
+        if self.flavors:
+            for _item_flavors in self.flavors:
+                if _item_flavors:
+                    _items.append(_item_flavors.to_dict())
+            _dict['flavors'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Creditrequestresponse from a dict"""
+        """Create an instance of MasterFlavorsResponse from a dict"""
         if obj is None:
             return None
 
@@ -90,7 +90,7 @@ class Creditrequestresponse(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": [Creditrequests.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "flavors": [ClusterFlavorFields.from_dict(_item) for _item in obj["flavors"]] if obj.get("flavors") is not None else None,
             "message": obj.get("message"),
             "status": obj.get("status")
         })

hyperstack/models/{customer_payload.py → mfa_status_fields.py}

@@ -17,18 +17,17 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CustomerPayload(BaseModel):
+class MFAStatusFields(BaseModel):
     """
-    CustomerPayload
+    MFAStatusFields
     """ # noqa: E501
-    id: StrictInt
-    plan_type: StrictStr
-    __properties: ClassVar[List[str]] = ["id", "plan_type"]
+    mfa_enabled: StrictBool = Field(description="Whether MFA is enabled for the user")
+    __properties: ClassVar[List[str]] = ["mfa_enabled"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +47,7 @@ class CustomerPayload(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CustomerPayload from a JSON string"""
+        """Create an instance of MFAStatusFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -73,7 +72,7 @@ class CustomerPayload(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CustomerPayload from a dict"""
+        """Create an instance of MFAStatusFields from a dict"""
         if obj is None:
             return None
 
@@ -81,8 +80,7 @@ class CustomerPayload(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "id": obj.get("id"),
-            "plan_type": obj.get("plan_type")
+            "mfa_enabled": obj.get("mfa_enabled")
         })
         return _obj