hyperstack 1.25.0a0__py3-none-any.whl → 1.41.0a0__py3-none-any.whl

hyperstack/models/{internal_instance_flavor_fields.py → cluster_node_group_fields.py}

@@ -20,23 +20,22 @@ import json
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from ..models.cluster_flavor_fields import ClusterFlavorFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class InternalInstanceFlavorFields(BaseModel):
+class ClusterNodeGroupFields(BaseModel):
     """
-    InternalInstanceFlavorFields
+    ClusterNodeGroupFields
     """ # noqa: E501
-    cpu: Optional[StrictInt] = None
+    count: Optional[StrictInt] = None
     created_at: Optional[datetime] = None
-    disk: Optional[StrictInt] = None
-    gpu: Optional[StrictStr] = None
-    gpu_count: Optional[StrictInt] = None
+    flavor: Optional[ClusterFlavorFields] = None
     id: Optional[StrictInt] = None
     name: Optional[StrictStr] = None
-    ram: Optional[StrictInt] = None
-    region_name: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["cpu", "created_at", "disk", "gpu", "gpu_count", "id", "name", "ram", "region_name"]
+    role: Optional[StrictStr] = None
+    updated_at: Optional[datetime] = None
+    __properties: ClassVar[List[str]] = ["count", "created_at", "flavor", "id", "name", "role", "updated_at"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -56,7 +55,7 @@ class InternalInstanceFlavorFields(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of InternalInstanceFlavorFields from a JSON string"""
+        """Create an instance of ClusterNodeGroupFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -77,11 +76,14 @@ class InternalInstanceFlavorFields(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 InternalInstanceFlavorFields from a dict"""
+        """Create an instance of ClusterNodeGroupFields from a dict"""
         if obj is None:
             return None
 
@@ -89,15 +91,13 @@ class InternalInstanceFlavorFields(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "cpu": obj.get("cpu"),
+            "count": obj.get("count"),
             "created_at": obj.get("created_at"),
-            "disk": obj.get("disk"),
-            "gpu": obj.get("gpu"),
-            "gpu_count": obj.get("gpu_count"),
+            "flavor": ClusterFlavorFields.from_dict(obj["flavor"]) if obj.get("flavor") is not None else None,
             "id": obj.get("id"),
             "name": obj.get("name"),
-            "ram": obj.get("ram"),
-            "region_name": obj.get("region_name")
+            "role": obj.get("role"),
+            "updated_at": obj.get("updated_at")
         })
         return _obj
 

hyperstack/models/{create_update_policy_response_model.py → cluster_node_groups_create_response.py}

@@ -19,18 +19,20 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.policy_fields import PolicyFields
+from ..models.cluster_node_fields import ClusterNodeFields
+from ..models.cluster_node_group_fields import ClusterNodeGroupFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CreateUpdatePolicyResponseModel(BaseModel):
+class ClusterNodeGroupsCreateResponse(BaseModel):
     """
-    CreateUpdatePolicyResponseModel
+    ClusterNodeGroupsCreateResponse
     """ # noqa: E501
     message: Optional[StrictStr] = None
-    policy: Optional[PolicyFields] = None
+    node_group: Optional[ClusterNodeGroupFields] = None
+    nodes: Optional[List[ClusterNodeFields]] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["message", "policy", "status"]
+    __properties: ClassVar[List[str]] = ["message", "node_group", "nodes", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +52,7 @@ class CreateUpdatePolicyResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CreateUpdatePolicyResponseModel from a JSON string"""
+        """Create an instance of ClusterNodeGroupsCreateResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +73,21 @@ class CreateUpdatePolicyResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of policy
-        if self.policy:
-            _dict['policy'] = self.policy.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of node_group
+        if self.node_group:
+            _dict['node_group'] = self.node_group.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in nodes (list)
+        _items = []
+        if self.nodes:
+            for _item_nodes in self.nodes:
+                if _item_nodes:
+                    _items.append(_item_nodes.to_dict())
+            _dict['nodes'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CreateUpdatePolicyResponseModel from a dict"""
+        """Create an instance of ClusterNodeGroupsCreateResponse from a dict"""
         if obj is None:
             return None
 
@@ -87,7 +96,8 @@ class CreateUpdatePolicyResponseModel(BaseModel):
 
         _obj = cls.model_validate({
             "message": obj.get("message"),
-            "policy": PolicyFields.from_dict(obj["policy"]) if obj.get("policy") is not None else None,
+            "node_group": ClusterNodeGroupFields.from_dict(obj["node_group"]) if obj.get("node_group") is not None else None,
+            "nodes": [ClusterNodeFields.from_dict(_item) for _item in obj["nodes"]] if obj.get("nodes") is not None else None,
             "status": obj.get("status")
         })
         return _obj

hyperstack/models/{create_update_permission_response_model.py → cluster_node_groups_get_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.permission_fields import PermissionFields
+from ..models.cluster_node_group_fields import ClusterNodeGroupFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class CreateUpdatePermissionResponseModel(BaseModel):
+class ClusterNodeGroupsGetResponse(BaseModel):
     """
-    CreateUpdatePermissionResponseModel
+    ClusterNodeGroupsGetResponse
     """ # noqa: E501
     message: Optional[StrictStr] = None
-    permission: Optional[PermissionFields] = None
+    node_group: Optional[ClusterNodeGroupFields] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["message", "permission", "status"]
+    __properties: ClassVar[List[str]] = ["message", "node_group", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class CreateUpdatePermissionResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of CreateUpdatePermissionResponseModel from a JSON string"""
+        """Create an instance of ClusterNodeGroupsGetResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +71,14 @@ class CreateUpdatePermissionResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of permission
-        if self.permission:
-            _dict['permission'] = self.permission.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of node_group
+        if self.node_group:
+            _dict['node_group'] = self.node_group.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of CreateUpdatePermissionResponseModel from a dict"""
+        """Create an instance of ClusterNodeGroupsGetResponse from a dict"""
         if obj is None:
             return None
 
@@ -87,7 +87,7 @@ class CreateUpdatePermissionResponseModel(BaseModel):
 
         _obj = cls.model_validate({
             "message": obj.get("message"),
-            "permission": PermissionFields.from_dict(obj["permission"]) if obj.get("permission") is not None else None,
+            "node_group": ClusterNodeGroupFields.from_dict(obj["node_group"]) if obj.get("node_group") is not None else None,
             "status": obj.get("status")
         })
         return _obj

hyperstack/models/{auth_request_login_response_model.py → cluster_node_groups_list_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.auth_request_login_fields import AuthRequestLoginFields
+from ..models.cluster_node_group_fields import ClusterNodeGroupFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class AuthRequestLoginResponseModel(BaseModel):
+class ClusterNodeGroupsListResponse(BaseModel):
     """
-    AuthRequestLoginResponseModel
+    ClusterNodeGroupsListResponse
     """ # noqa: E501
-    data: Optional[AuthRequestLoginFields] = None
     message: Optional[StrictStr] = None
+    node_groups: Optional[List[ClusterNodeGroupFields]] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["data", "message", "status"]
+    __properties: ClassVar[List[str]] = ["message", "node_groups", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class AuthRequestLoginResponseModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of AuthRequestLoginResponseModel from a JSON string"""
+        """Create an instance of ClusterNodeGroupsListResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,14 +71,18 @@ class AuthRequestLoginResponseModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of data
-        if self.data:
-            _dict['data'] = self.data.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in node_groups (list)
+        _items = []
+        if self.node_groups:
+            for _item_node_groups in self.node_groups:
+                if _item_node_groups:
+                    _items.append(_item_node_groups.to_dict())
+            _dict['node_groups'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of AuthRequestLoginResponseModel from a dict"""
+        """Create an instance of ClusterNodeGroupsListResponse from a dict"""
         if obj is None:
             return None
 
@@ -86,8 +90,8 @@ class AuthRequestLoginResponseModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "data": AuthRequestLoginFields.from_dict(obj["data"]) if obj.get("data") is not None else None,
             "message": obj.get("message"),
+            "node_groups": [ClusterNodeGroupFields.from_dict(_item) for _item in obj["node_groups"]] if obj.get("node_groups") is not None else None,
             "status": obj.get("status")
         })
         return _obj

hyperstack/models/{contract_eligible_instance_fields.py → cluster_node_instance_fields.py}

@@ -22,18 +22,19 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ContractEligibleInstanceFields(BaseModel):
+class ClusterNodeInstanceFields(BaseModel):
     """
-    ContractEligibleInstanceFields
+    ClusterNodeInstanceFields
     """ # noqa: E501
     contract_id: Optional[StrictInt] = None
-    host: Optional[StrictStr] = None
+    fixed_ip: Optional[StrictStr] = None
+    floating_ip: Optional[StrictStr] = None
+    floating_ip_status: Optional[StrictStr] = None
     id: Optional[StrictInt] = None
+    image_id: Optional[StrictInt] = None
     name: Optional[StrictStr] = None
-    openstack_id: Optional[StrictStr] = None
-    public_ip: Optional[StrictStr] = None
     status: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["contract_id", "host", "id", "name", "openstack_id", "public_ip", "status"]
+    __properties: ClassVar[List[str]] = ["contract_id", "fixed_ip", "floating_ip", "floating_ip_status", "id", "image_id", "name", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -53,7 +54,7 @@ class ContractEligibleInstanceFields(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ContractEligibleInstanceFields from a JSON string"""
+        """Create an instance of ClusterNodeInstanceFields from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -78,7 +79,7 @@ class ContractEligibleInstanceFields(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ContractEligibleInstanceFields from a dict"""
+        """Create an instance of ClusterNodeInstanceFields from a dict"""
         if obj is None:
             return None
 
@@ -87,11 +88,12 @@ class ContractEligibleInstanceFields(BaseModel):
 
         _obj = cls.model_validate({
             "contract_id": obj.get("contract_id"),
-            "host": obj.get("host"),
+            "fixed_ip": obj.get("fixed_ip"),
+            "floating_ip": obj.get("floating_ip"),
+            "floating_ip_status": obj.get("floating_ip_status"),
             "id": obj.get("id"),
+            "image_id": obj.get("image_id"),
             "name": obj.get("name"),
-            "openstack_id": obj.get("openstack_id"),
-            "public_ip": obj.get("public_ip"),
             "status": obj.get("status")
         })
         return _obj

hyperstack/models/{image_logos.py → cluster_nodes_list_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.logo_get_response import LogoGetResponse
+from ..models.cluster_node_fields import ClusterNodeFields
 from typing import Optional, Set
 from typing_extensions import Self
 
-class ImageLogos(BaseModel):
+class ClusterNodesListResponse(BaseModel):
     """
-    ImageLogos
+    ClusterNodesListResponse
     """ # noqa: E501
-    logos: Optional[List[LogoGetResponse]] = None
     message: Optional[StrictStr] = None
+    nodes: Optional[List[ClusterNodeFields]] = None
     status: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["logos", "message", "status"]
+    __properties: ClassVar[List[str]] = ["message", "nodes", "status"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -50,7 +50,7 @@ class ImageLogos(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ImageLogos from a JSON string"""
+        """Create an instance of ClusterNodesListResponse from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -71,18 +71,18 @@ class ImageLogos(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in logos (list)
+        # override the default output from pydantic by calling `to_dict()` of each item in nodes (list)
         _items = []
-        if self.logos:
-            for _item_logos in self.logos:
-                if _item_logos:
-                    _items.append(_item_logos.to_dict())
-            _dict['logos'] = _items
+        if self.nodes:
+            for _item_nodes in self.nodes:
+                if _item_nodes:
+                    _items.append(_item_nodes.to_dict())
+            _dict['nodes'] = _items
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ImageLogos from a dict"""
+        """Create an instance of ClusterNodesListResponse from a dict"""
         if obj is None:
             return None
 
@@ -90,8 +90,8 @@ class ImageLogos(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "logos": [LogoGetResponse.from_dict(_item) for _item in obj["logos"]] if obj.get("logos") is not None else None,
             "message": obj.get("message"),
+            "nodes": [ClusterNodeFields.from_dict(_item) for _item in obj["nodes"]] if obj.get("nodes") is not None else None,
             "status": obj.get("status")
         })
         return _obj

hyperstack/models/{internal_environment_fields.py → cluster_version.py}

@@ -23,15 +23,17 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
 
-class InternalEnvironmentFields(BaseModel):
+class ClusterVersion(BaseModel):
     """
-    InternalEnvironmentFields
+    ClusterVersion
     """ # noqa: E501
     created_at: Optional[datetime] = None
     id: Optional[StrictInt] = None
-    name: Optional[StrictStr] = None
-    region: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["created_at", "id", "name", "region"]
+    image: Optional[Dict[str, Any]] = None
+    region: Optional[Dict[str, Any]] = None
+    updated_at: Optional[datetime] = None
+    version: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["created_at", "id", "image", "region", "updated_at", "version"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -51,7 +53,7 @@ class InternalEnvironmentFields(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of InternalEnvironmentFields from a JSON string"""
+        """Create an instance of ClusterVersion from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -76,7 +78,7 @@ class InternalEnvironmentFields(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of InternalEnvironmentFields from a dict"""
+        """Create an instance of ClusterVersion from a dict"""
         if obj is None:
             return None
 
@@ -86,8 +88,10 @@ class InternalEnvironmentFields(BaseModel):
         _obj = cls.model_validate({
             "created_at": obj.get("created_at"),
             "id": obj.get("id"),
-            "name": obj.get("name"),
-            "region": obj.get("region")
+            "image": obj.get("image"),
+            "region": obj.get("region"),
+            "updated_at": obj.get("updated_at"),
+            "version": obj.get("version")
         })
         return _obj
 

hyperstack/models/cluster_versions.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
+from ..models.cluster_version import ClusterVersion
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,7 +29,7 @@ class ClusterVersions(BaseModel):
     """ # noqa: E501
     message: Optional[StrictStr] = None
     status: Optional[StrictBool] = None
-    versions: Optional[List[StrictStr]] = None
+    versions: Optional[List[ClusterVersion]] = None
     __properties: ClassVar[List[str]] = ["message", "status", "versions"]
 
     model_config = ConfigDict(
@@ -70,6 +71,13 @@ class ClusterVersions(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each item in versions (list)
+        _items = []
+        if self.versions:
+            for _item_versions in self.versions:
+                if _item_versions:
+                    _items.append(_item_versions.to_dict())
+            _dict['versions'] = _items
         return _dict
 
     @classmethod
@@ -84,7 +92,7 @@ class ClusterVersions(BaseModel):
         _obj = cls.model_validate({
             "message": obj.get("message"),
             "status": obj.get("status"),
-            "versions": obj.get("versions")
+            "versions": [ClusterVersion.from_dict(_item) for _item in obj["versions"]] if obj.get("versions") is not None else None
         })
         return _obj
 

hyperstack/models/{future_nodes_stock_model.py → colors.py}

@@ -19,16 +19,18 @@ import json
 
 from pydantic import BaseModel, ConfigDict
 from typing import Any, ClassVar, Dict, List, Optional
-from ..models.future_node_response_model import FutureNodeResponseModel
+from ..models.primary_color import PrimaryColor
+from ..models.secondary_color import SecondaryColor
 from typing import Optional, Set
 from typing_extensions import Self
 
-class FutureNodesStockModel(BaseModel):
+class Colors(BaseModel):
     """
-    FutureNodesStockModel
+    Colors
     """ # noqa: E501
-    future_stocks: Optional[List[FutureNodeResponseModel]] = None
-    __properties: ClassVar[List[str]] = ["future_stocks"]
+    primary: Optional[PrimaryColor] = None
+    secondary: Optional[SecondaryColor] = None
+    __properties: ClassVar[List[str]] = ["primary", "secondary"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -48,7 +50,7 @@ class FutureNodesStockModel(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of FutureNodesStockModel from a JSON string"""
+        """Create an instance of Colors from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -69,18 +71,17 @@ class FutureNodesStockModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in future_stocks (list)
-        _items = []
-        if self.future_stocks:
-            for _item_future_stocks in self.future_stocks:
-                if _item_future_stocks:
-                    _items.append(_item_future_stocks.to_dict())
-            _dict['future_stocks'] = _items
+        # override the default output from pydantic by calling `to_dict()` of primary
+        if self.primary:
+            _dict['primary'] = self.primary.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of secondary
+        if self.secondary:
+            _dict['secondary'] = self.secondary.to_dict()
         return _dict
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of FutureNodesStockModel from a dict"""
+        """Create an instance of Colors from a dict"""
         if obj is None:
             return None
 
@@ -88,7 +89,8 @@ class FutureNodesStockModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "future_stocks": [FutureNodeResponseModel.from_dict(_item) for _item in obj["future_stocks"]] if obj.get("future_stocks") is not None else None
+            "primary": PrimaryColor.from_dict(obj["primary"]) if obj.get("primary") is not None else None,
+            "secondary": SecondaryColor.from_dict(obj["secondary"]) if obj.get("secondary") is not None else None
         })
         return _obj
 

hyperstack/models/contract_discount_plan_fields.py

@@ -32,10 +32,11 @@ class ContractDiscountPlanFields(BaseModel):
     discount_status: Optional[StrictStr] = None
     discount_type: Optional[StrictStr] = None
     id: Optional[StrictInt] = None
+    remaining_count: Optional[StrictInt] = None
     resource_count: Optional[StrictInt] = None
     resource_id: Optional[StrictInt] = None
     resource_name: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["discount_amount", "discount_code", "discount_percent", "discount_status", "discount_type", "id", "resource_count", "resource_id", "resource_name"]
+    __properties: ClassVar[List[str]] = ["discount_amount", "discount_code", "discount_percent", "discount_status", "discount_type", "id", "remaining_count", "resource_count", "resource_id", "resource_name"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -94,6 +95,7 @@ class ContractDiscountPlanFields(BaseModel):
             "discount_status": obj.get("discount_status"),
             "discount_type": obj.get("discount_type"),
             "id": obj.get("id"),
+            "remaining_count": obj.get("remaining_count"),
             "resource_count": obj.get("resource_count"),
             "resource_id": obj.get("resource_id"),
             "resource_name": obj.get("resource_name")

hyperstack/models/contract_instance_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.cluster_fields import ClusterFields
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,6 +28,7 @@ class ContractInstanceFields(BaseModel):
     """
     ContractInstanceFields
     """ # noqa: E501
+    cluster: Optional[ClusterFields] = None
     created_at: Optional[datetime] = None
     flavor_name: Optional[StrictStr] = None
     gpu_count: Optional[StrictInt] = None
@@ -35,7 +37,7 @@ class ContractInstanceFields(BaseModel):
     status: Optional[StrictStr] = None
     termination_time: Optional[datetime] = None
     total_usage_time: Optional[StrictInt] = None
-    __properties: ClassVar[List[str]] = ["created_at", "flavor_name", "gpu_count", "id", "name", "status", "termination_time", "total_usage_time"]
+    __properties: ClassVar[List[str]] = ["cluster", "created_at", "flavor_name", "gpu_count", "id", "name", "status", "termination_time", "total_usage_time"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -76,6 +78,9 @@ class ContractInstanceFields(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of cluster
+        if self.cluster:
+            _dict['cluster'] = self.cluster.to_dict()
         return _dict
 
     @classmethod
@@ -88,6 +93,7 @@ class ContractInstanceFields(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
+            "cluster": ClusterFields.from_dict(obj["cluster"]) if obj.get("cluster") is not None else None,
             "created_at": obj.get("created_at"),
             "flavor_name": obj.get("flavor_name"),
             "gpu_count": obj.get("gpu_count"),