feat(instance-types): sync OpenAPI schema fields

Co-authored-by: imagene-shahar <imagene-shahar@users.noreply.github.com>

Author: cursoragent

tests/unit_tests/instance_types/test_instance_types.py

@@ -14,23 +14,39 @@
 STORAGE_DESCRIPTION = '1800GB NVME'
 STORAGE_SIZE = 1800
 INSTANCE_TYPE_DESCRIPTION = 'Dedicated Bare metal Server'
+BEST_FOR = ['Large model inference', 'Multi-GPU training']
+MODEL = 'V100'
+NAME = 'Tesla V100'
+P2P = '300 GB/s'
 PRICE_PER_HOUR = 5.0
 SPOT_PRICE_PER_HOUR = 2.5
+MAX_DYNAMIC_PRICE = 7.5
+SERVERLESS_PRICE = 1.25
+SERVERLESS_SPOT_PRICE = 0.75
 INSTANCE_TYPE = '8V100.48M'
+CURRENCY = 'eur'
+MANUFACTURER = 'NVIDIA'
+DISPLAY_NAME = 'NVIDIA Tesla V100'
+SUPPORTED_OS = ['ubuntu-24.04-cuda-12.8-open-docker']
 
+PRICE_HISTORY_PAYLOAD = [{'date': '2024-01-01', 'price_per_hour': '2.00'}]
 
+
+@responses.activate
 def test_instance_types(http_client):
     # arrange - add response mock
     responses.add(
         responses.GET,
-        http_client._base_url + '/instance-types',
+        http_client._base_url + '/instance-types?currency=eur',
         json=[
             {
                 'id': TYPE_ID,
+                'best_for': BEST_FOR,
                 'cpu': {
                     'description': CPU_DESCRIPTION,
                     'number_of_cores': NUMBER_OF_CORES,
                 },
+                'deploy_warning': 'Use updated drivers',
                 'gpu': {
                     'description': GPU_DESCRIPTION,
                     'number_of_gpus': NUMBER_OF_GPUS,
@@ -48,9 +64,19 @@ def test_instance_types(http_client):
                     'size_in_gigabytes': STORAGE_SIZE,
                 },
                 'description': INSTANCE_TYPE_DESCRIPTION,
+                'model': MODEL,
+                'name': NAME,
+                'p2p': P2P,
                 'price_per_hour': '5.00',
                 'spot_price': '2.50',
+                'max_dynamic_price': '7.50',
+                'serverless_price': '1.25',
+                'serverless_spot_price': '0.75',
                 'instance_type': INSTANCE_TYPE,
+                'currency': CURRENCY,
+                'manufacturer': MANUFACTURER,
+                'display_name': DISPLAY_NAME,
+                'supported_os': SUPPORTED_OS,
             }
         ],
         status=200,
@@ -59,7 +85,7 @@ def test_instance_types(http_client):
     instance_types_service = InstanceTypesService(http_client)
 
     # act
-    instance_types = instance_types_service.get()
+    instance_types = instance_types_service.get(currency='eur')
     instance_type = instance_types[0]
 
     # assert
@@ -71,6 +97,18 @@ def test_instance_types(http_client):
     assert instance_type.price_per_hour == PRICE_PER_HOUR
     assert instance_type.spot_price_per_hour == SPOT_PRICE_PER_HOUR
     assert instance_type.instance_type == INSTANCE_TYPE
+    assert instance_type.best_for == BEST_FOR
+    assert instance_type.model == MODEL
+    assert instance_type.name == NAME
+    assert instance_type.p2p == P2P
+    assert instance_type.currency == CURRENCY
+    assert instance_type.manufacturer == MANUFACTURER
+    assert instance_type.display_name == DISPLAY_NAME
+    assert instance_type.supported_os == SUPPORTED_OS
+    assert instance_type.deploy_warning == 'Use updated drivers'
+    assert instance_type.max_dynamic_price == MAX_DYNAMIC_PRICE
+    assert instance_type.serverless_price == SERVERLESS_PRICE
+    assert instance_type.serverless_spot_price == SERVERLESS_SPOT_PRICE
     assert isinstance(instance_type.cpu, dict)
     assert isinstance(instance_type.gpu, dict)
     assert isinstance(instance_type.memory, dict)
@@ -85,3 +123,22 @@ def test_instance_types(http_client):
     assert instance_type.memory['size_in_gigabytes'] == MEMORY_SIZE
     assert instance_type.gpu_memory['size_in_gigabytes'] == GPU_MEMORY_SIZE
     assert instance_type.storage['size_in_gigabytes'] == STORAGE_SIZE
+
+
+@responses.activate
+def test_instance_type_price_history(http_client):
+    # arrange - add response mock
+    responses.add(
+        responses.GET,
+        http_client._base_url + '/instance-types/price-history',
+        json=PRICE_HISTORY_PAYLOAD,
+        status=200,
+    )
+
+    instance_types_service = InstanceTypesService(http_client)
+
+    # act
+    price_history = instance_types_service.get_price_history()
+
+    # assert
+    assert price_history == PRICE_HISTORY_PAYLOAD

verda/instance_types/_instance_types.py

@@ -1,26 +1,29 @@
 from dataclasses import dataclass
+from typing import Literal
 
 from dataclasses_json import dataclass_json
 
 INSTANCE_TYPES_ENDPOINT = '/instance-types'
 
+Currency = Literal['usd', 'eur']
+
 
 @dataclass_json
 @dataclass
 class InstanceType:
     """Instance type.
 
     Attributes:
-        id: instance type id.
-        instance_type: instance type, e.g. '8V100.48M'.
-        price_per_hour: instance type price per hour.
-        spot_price_per_hour: instance type spot price per hour.
-        description: instance type description.
-        cpu: instance type cpu details.
-        gpu: instance type gpu details.
-        memory: instance type memory details.
-        gpu_memory: instance type gpu memory details.
-        storage: instance type storage details.
+        id: Instance type ID.
+        instance_type: Instance type, e.g. '8V100.48M'.
+        price_per_hour: Instance type price per hour.
+        spot_price_per_hour: Instance type spot price per hour.
+        description: Instance type description.
+        cpu: Instance type CPU details.
+        gpu: Instance type GPU details.
+        memory: Instance type memory details.
+        gpu_memory: Instance type GPU memory details.
+        storage: Instance type storage details.
     """
 
     id: str
@@ -33,6 +36,19 @@ class InstanceType:
     memory: dict
     gpu_memory: dict
     storage: dict
+    best_for: list[str]
+    model: str
+    name: str
+    p2p: str
+    currency: Currency
+    manufacturer: str
+    display_name: str
+    supported_os: list[str]
+    deploy_warning: str | None = None
+    dynamic_price: float | None = None
+    max_dynamic_price: float | None = None
+    serverless_price: float | None = None
+    serverless_spot_price: float | None = None
 
 
 class InstanceTypesService:
@@ -41,13 +57,16 @@ class InstanceTypesService:
     def __init__(self, http_client) -> None:
         self._http_client = http_client
 
-    def get(self) -> list[InstanceType]:
+    def get(self, currency: Currency = 'usd') -> list[InstanceType]:
         """Get all instance types.
 
         :return: list of instance type objects
         :rtype: list[InstanceType]
         """
-        instance_types = self._http_client.get(INSTANCE_TYPES_ENDPOINT).json()
+        instance_types = self._http_client.get(
+            INSTANCE_TYPES_ENDPOINT,
+            params={'currency': currency},
+        ).json()
         instance_type_objects = [
             InstanceType(
                 id=instance_type['id'],
@@ -60,8 +79,41 @@ def get(self) -> list[InstanceType]:
                 memory=instance_type['memory'],
                 gpu_memory=instance_type['gpu_memory'],
                 storage=instance_type['storage'],
+                best_for=instance_type['best_for'],
+                model=instance_type['model'],
+                name=instance_type['name'],
+                p2p=instance_type['p2p'],
+                currency=instance_type['currency'],
+                manufacturer=instance_type['manufacturer'],
+                display_name=instance_type['display_name'],
+                supported_os=instance_type['supported_os'],
+                deploy_warning=instance_type.get('deploy_warning'),
+                dynamic_price=(
+                    float(instance_type['dynamic_price'])
+                    if instance_type.get('dynamic_price') is not None
+                    else None
+                ),
+                max_dynamic_price=(
+                    float(instance_type['max_dynamic_price'])
+                    if instance_type.get('max_dynamic_price') is not None
+                    else None
+                ),
+                serverless_price=(
+                    float(instance_type['serverless_price'])
+                    if instance_type.get('serverless_price') is not None
+                    else None
+                ),
+                serverless_spot_price=(
+                    float(instance_type['serverless_spot_price'])
+                    if instance_type.get('serverless_spot_price') is not None
+                    else None
+                ),
             )
             for instance_type in instance_types
         ]
 
         return instance_type_objects
+
+    def get_price_history(self):
+        """Get the deprecated dynamic price history endpoint as raw JSON."""
+        return self._http_client.get(f'{INSTANCE_TYPES_ENDPOINT}/price-history').json()