skypilot-nightly 1.0.0.dev2024053101__py3-none-any.whl → 1.0.0.dev2025022801__py3-none-any.whl

sky/clouds/service_catalog/data_fetchers/fetch_cudo.py

@@ -9,98 +9,9 @@ import os
 
 import cudo_compute
 
-VMS_CSV = 'cudo/vms.csv'
+import sky.provision.cudo.cudo_utils as utils
 
-cudo_gpu_model = {
-    'NVIDIA V100': 'V100',
-    'NVIDIA A40': 'A40',
-    'RTX 3080': 'RTX3080',
-    'RTX A4000': 'RTXA4000',
-    'RTX A4500': 'RTXA4500',
-    'RTX A5000': 'RTXA5000',
-    'RTX A6000': 'RTXA6000',
-}
-
-cudo_gpu_mem = {
-    'RTX3080': 12,
-    'A40': 48,
-    'RTXA4000': 16,
-    'RTXA4500': 20,
-    'RTXA5000': 24,
-    'RTXA6000': 48,
-    'V100': 16,
-}
-
-machine_specs = [
-    # Low
-    {
-        'vcpu': 2,
-        'mem': 4,
-        'gpu': 1,
-    },
-    {
-        'vcpu': 4,
-        'mem': 8,
-        'gpu': 1,
-    },
-    {
-        'vcpu': 8,
-        'mem': 16,
-        'gpu': 2,
-    },
-    {
-        'vcpu': 16,
-        'mem': 32,
-        'gpu': 2,
-    },
-    {
-        'vcpu': 32,
-        'mem': 64,
-        'gpu': 4,
-    },
-    {
-        'vcpu': 64,
-        'mem': 128,
-        'gpu': 8,
-    },
-    # Mid
-    {
-        'vcpu': 96,
-        'mem': 192,
-        'gpu': 8
-    },
-    {
-        'vcpu': 48,
-        'mem': 96,
-        'gpu': 4
-    },
-    {
-        'vcpu': 24,
-        'mem': 48,
-        'gpu': 2
-    },
-    {
-        'vcpu': 12,
-        'mem': 24,
-        'gpu': 1
-    },
-    # Hi
-    {
-        'vcpu': 96,
-        'mem': 192,
-        'gpu': 4
-    },
-    {
-        'vcpu': 48,
-        'mem': 96,
-        'gpu': 2
-    },
-    {
-        'vcpu': 24,
-        'mem': 48,
-        'gpu': 1
-    },
-]
+VMS_CSV = 'cudo/vms.csv'
 
 
 def cudo_api():
@@ -110,28 +21,8 @@ def cudo_api():
     return cudo_compute.VirtualMachinesApi(client)
 
 
-def cudo_gpu_to_skypilot_gpu(model):
-    if model in cudo_gpu_model:
-        return cudo_gpu_model[model]
-    else:
-        return model
-
-
-def skypilot_gpu_to_cudo_gpu(model):
-    for key, value in cudo_gpu_model.items():
-        if value == model:
-            return key
-    return model
-
-
-def gpu_exists(model):
-    if model in cudo_gpu_model:
-        return True
-    return False
-
-
 def get_gpu_info(count, model):
-    mem = cudo_gpu_mem[model]
+    mem = utils.cudo_gpu_mem[model]
     # pylint: disable=line-too-long
     # {'Name': 'A4000', 'Manufacturer': 'NVIDIA', 'Count': 1.0, 'MemoryInfo': {'SizeInMiB': 16384}}], 'TotalGpuMemoryInMiB': 16384}"
     info = {
@@ -168,16 +59,16 @@ def machine_types(gpu_model, mem_gib, vcpu_count, gpu_count):
 
 def update_prices():
     rows = []
-    for spec in machine_specs:
+    for spec in utils.machine_specs:
         mts = machine_types('', spec['mem'], spec['vcpu'], spec['gpu'])
         for hc in mts['host_configs']:
-            if not gpu_exists(hc['gpu_model']):
+            if not utils.gpu_exists(hc['gpu_model']):
                 continue
-            accelerator_name = cudo_gpu_to_skypilot_gpu(hc['gpu_model'])
+            accelerator_name = utils.cudo_gpu_to_skypilot_gpu(hc['gpu_model'])
             row = {
                 'instance_type': get_instance_type(hc['machine_type'],
-                                                   spec['gpu'], spec['vcpu'],
-                                                   spec['mem']),
+                                                   spec['vcpu'], spec['mem'],
+                                                   spec['gpu']),
                 'accelerator_name': accelerator_name,
                 'accelerator_count': str(spec['gpu']) + '.0',
                 'vcpus': str(spec['vcpu']),

sky/clouds/service_catalog/data_fetchers/fetch_fluidstack.py

@@ -11,16 +11,167 @@ from typing import List
 
 import requests
 
-ENDPOINT = 'https://api.fluidstack.io/v1/plans'
+ENDPOINT = 'https://platform.fluidstack.io/list_available_configurations'
 DEFAULT_FLUIDSTACK_API_KEY_PATH = os.path.expanduser('~/.fluidstack/api_key')
-DEFAULT_FLUIDSTACK_API_TOKEN_PATH = os.path.expanduser(
-    '~/.fluidstack/api_token')
+
+plan_vcpus_memory = [{
+    'gpu_type': 'H100_SXM5_80GB',
+    'gpu_count': 1,
+    'min_cpu_count': 52,
+    'min_memory': 450
+}, {
+    'gpu_type': 'H100_SXM5_80GB',
+    'gpu_count': 2,
+    'min_cpu_count': 52,
+    'min_memory': 450
+}, {
+    'gpu_type': 'H100_SXM5_80GB',
+    'gpu_count': 4,
+    'min_cpu_count': 104,
+    'min_memory': 900
+}, {
+    'gpu_type': 'H100_SXM5_80GB',
+    'gpu_count': 8,
+    'min_cpu_count': 192,
+    'min_memory': 1800
+}, {
+    'gpu_type': 'RTX_A6000_48GB',
+    'gpu_count': 2,
+    'min_cpu_count': 12,
+    'min_memory': 110.0
+}, {
+    'gpu_type': 'RTX_A6000_48GB',
+    'gpu_count': 4,
+    'min_cpu_count': 24,
+    'min_memory': 220.0
+}, {
+    'gpu_type': 'A100_NVLINK_80GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 960.0
+}, {
+    'gpu_type': 'H100_PCIE_80GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 1440.0
+}, {
+    'gpu_type': 'RTX_A4000_16GB',
+    'gpu_count': 2,
+    'min_cpu_count': 12,
+    'min_memory': 48.0
+}, {
+    'gpu_type': 'H100_PCIE_80GB',
+    'gpu_count': 2,
+    'min_cpu_count': 60,
+    'min_memory': 360.0
+}, {
+    'gpu_type': 'RTX_A6000_48GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 464.0
+}, {
+    'gpu_type': 'H100_NVLINK_80GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 1440.0
+}, {
+    'gpu_type': 'H100_PCIE_80GB',
+    'gpu_count': 1,
+    'min_cpu_count': 28,
+    'min_memory': 180.0
+}, {
+    'gpu_type': 'RTX_A5000_24GB',
+    'gpu_count': 1,
+    'min_cpu_count': 8,
+    'min_memory': 30.0
+}, {
+    'gpu_type': 'RTX_A5000_24GB',
+    'gpu_count': 2,
+    'min_cpu_count': 16,
+    'min_memory': 60.0
+}, {
+    'gpu_type': 'L40_48GB',
+    'gpu_count': 2,
+    'min_cpu_count': 64,
+    'min_memory': 120.0
+}, {
+    'gpu_type': 'RTX_A4000_16GB',
+    'gpu_count': 8,
+    'min_cpu_count': 48,
+    'min_memory': 192.0
+}, {
+    'gpu_type': 'RTX_A4000_16GB',
+    'gpu_count': 1,
+    'min_cpu_count': 6,
+    'min_memory': 24.0
+}, {
+    'gpu_type': 'RTX_A4000_16GB',
+    'gpu_count': 4,
+    'min_cpu_count': 24,
+    'min_memory': 96.0
+}, {
+    'gpu_type': 'A100_PCIE_80GB',
+    'gpu_count': 4,
+    'min_cpu_count': 124,
+    'min_memory': 480.0
+}, {
+    'gpu_type': 'H100_PCIE_80GB',
+    'gpu_count': 4,
+    'min_cpu_count': 124,
+    'min_memory': 720.0
+}, {
+    'gpu_type': 'L40_48GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 480.0
+}, {
+    'gpu_type': 'RTX_A5000_24GB',
+    'gpu_count': 8,
+    'min_cpu_count': 64,
+    'min_memory': 240.0
+}, {
+    'gpu_type': 'L40_48GB',
+    'gpu_count': 1,
+    'min_cpu_count': 32,
+    'min_memory': 60.0
+}, {
+    'gpu_type': 'RTX_A6000_48GB',
+    'gpu_count': 1,
+    'min_cpu_count': 6,
+    'min_memory': 55.0
+}, {
+    'gpu_type': 'L40_48GB',
+    'gpu_count': 4,
+    'min_cpu_count': 126,
+    'min_memory': 240.0
+}, {
+    'gpu_type': 'A100_PCIE_80GB',
+    'gpu_count': 1,
+    'min_cpu_count': 28,
+    'min_memory': 120.0
+}, {
+    'gpu_type': 'A100_PCIE_80GB',
+    'gpu_count': 8,
+    'min_cpu_count': 252,
+    'min_memory': 1440.0
+}, {
+    'gpu_type': 'A100_PCIE_80GB',
+    'gpu_count': 2,
+    'min_cpu_count': 60,
+    'min_memory': 240.0
+}, {
+    'gpu_type': 'RTX_A5000_24GB',
+    'gpu_count': 4,
+    'min_cpu_count': 32,
+    'min_memory': 120.0
+}]
 
 GPU_MAP = {
     'H100_PCIE_80GB': 'H100',
     'H100_NVLINK_80GB': 'H100',
     'A100_NVLINK_80GB': 'A100-80GB',
-    'A100_SXM4_80GB': 'A100-80GB',
+    'A100_SXM4_80GB': 'A100-80GB-SXM',
+    'H100_SXM5_80GB': 'H100-SXM',
     'A100_PCIE_80GB': 'A100-80GB',
     'A100_SXM4_40GB': 'A100',
     'A100_PCIE_40GB': 'A100',
@@ -47,19 +198,15 @@ def get_regions(plans: List) -> dict:
     regions = {}
     for plan in plans:
         for region in plan.get('regions', []):
-            regions[region['id']] = region['id']
+            regions[region] = region
     return regions
 
 
 def create_catalog(output_dir: str) -> None:
-    response = requests.get(ENDPOINT)
+    with open(DEFAULT_FLUIDSTACK_API_KEY_PATH, 'r', encoding='UTF-8') as f:
+        api_key = f.read().strip()
+    response = requests.get(ENDPOINT, headers={'api-key': api_key})
     plans = response.json()
-    #plans = [plan for plan in plans if len(plan['regions']) > 0]
-    plans = [
-        plan for plan in plans if plan['minimum_commitment'] == 'hourly' and
-        plan['type'] in ['preconfigured'] and
-        plan['gpu_type'] not in ['NO GPU', 'RTX_3080_10GB', 'RTX_3090_24GB']
-    ]
 
     with open(os.path.join(output_dir, 'vms.csv'), mode='w',
               encoding='utf-8') as f:
@@ -81,39 +228,45 @@ def create_catalog(output_dir: str) -> None:
             except KeyError:
                 #print(f'Could not map {plan["gpu_type"]}')
                 continue
-            gpu_memory = int(
-                str(plan['configuration']['gpu_memory']).replace('GB',
-                                                                 '')) * 1024
-            gpu_cnt = int(plan['configuration']['gpu_count'])
-            vcpus = float(plan['configuration']['core_count'])
-            mem = float(plan['configuration']['ram'])
-            price = float(plan['price']['hourly']) * gpu_cnt
-            gpuinfo = {
-                'Gpus': [{
-                    'Name': gpu,
-                    'Manufacturer': 'NVIDIA',
-                    'Count': gpu_cnt,
-                    'MemoryInfo': {
-                        'SizeInMiB': int(gpu_memory)
-                    },
-                }],
-                'TotalGpuMemoryInMiB': int(gpu_memory * gpu_cnt),
-            }
-            gpuinfo = json.dumps(gpuinfo).replace('"', "'")  # pylint: disable=invalid-string-quote
-            for r in plan.get('regions', []):
-                if r['id'] == 'india_2':
+            for gpu_cnt in plan['gpu_counts']:
+                gpu_memory = float(plan['gpu_type'].split('_')[-1].replace(
+                    'GB', '')) * 1024
+                try:
+                    vcpus_mem = [
+                        x for x in plan_vcpus_memory
+                        if x['gpu_type'] == plan['gpu_type'] and
+                        x['gpu_count'] == gpu_cnt
+                    ][0]
+                    vcpus = vcpus_mem['min_cpu_count']
+                    mem = vcpus_mem['min_memory']
+                except IndexError:
                     continue
-                writer.writerow([
-                    plan['plan_id'],
-                    gpu,
-                    gpu_cnt,
-                    vcpus,
-                    mem,
-                    price,
-                    r['id'],
-                    gpuinfo,
-                    '',
-                ])
+                price = float(plan['price_per_gpu_hr']) * gpu_cnt
+                gpuinfo = {
+                    'Gpus': [{
+                        'Name': gpu,
+                        'Manufacturer': 'NVIDIA',
+                        'Count': gpu_cnt,
+                        'MemoryInfo': {
+                            'SizeInMiB': int(gpu_memory)
+                        },
+                    }],
+                    'TotalGpuMemoryInMiB': int(gpu_memory * gpu_cnt),
+                }
+                gpuinfo = json.dumps(gpuinfo).replace('"', "'")  # pylint: disable=invalid-string-quote
+                instance_type = f'{plan["gpu_type"]}::{gpu_cnt}'
+                for region in plan.get('regions', []):
+                    writer.writerow([
+                        instance_type,
+                        gpu,
+                        gpu_cnt,
+                        vcpus,
+                        mem,
+                        price,
+                        region,
+                        gpuinfo,
+                        '',
+                    ])
 
 
 if __name__ == '__main__':