skypilot-nightly 1.0.0.dev20250509__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/{clouds/service_catalog → catalog}/data_fetchers/fetch_aws.py

@@ -46,7 +46,7 @@ ALL_REGIONS = [
     'eu-west-1',
     'eu-west-2',
     'eu-south-1',
-    # 'eu-south-2', # no supported AMI
+    'eu-south-2',
     'eu-west-3',
     'eu-north-1',
     'me-south-1',
@@ -67,17 +67,17 @@ US_REGIONS = ['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2']
 # The following columns will be included in the final catalog.
 USEFUL_COLUMNS = [
     'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs', 'MemoryGiB',
-    'GpuInfo', 'Price', 'SpotPrice', 'Region', 'AvailabilityZone'
+    'GpuInfo', 'Price', 'SpotPrice', 'Region', 'AvailabilityZone', 'Arch'
 ]
 
 # NOTE: the hard-coded us-east-1 URL is not a typo. AWS pricing endpoint is
 # only available in this region, but it serves pricing information for all
 # regions.
 PRICING_TABLE_URL_FMT = 'https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/{region}/index.csv'  # pylint: disable=line-too-long
-# Hardcode the regions that offer p4de.24xlarge as our credential does not have
-# the permission to query the offerings of the instance.
-# Ref: https://aws.amazon.com/ec2/instance-types/p4/
-P4DE_REGIONS = ['us-east-1', 'us-west-2']
+# g6f instances have fractional GPUs, but the API returns Count: 1 under
+# GpuInfo. However, the GPU memory is properly scaled. Taking the instance GPU
+# divided by the total memory of an L4 will give us the fraction of the GPU.
+L4_GPU_MEMORY = 22888
 
 regions_enabled: Optional[Set[str]] = None
 
@@ -210,35 +210,6 @@ def _get_spot_pricing_table(region: str) -> 'pd.DataFrame':
     return df
 
 
-def _patch_p4de(region: str, df: 'pd.DataFrame',
-                pricing_df: 'pd.DataFrame') -> 'pd.DataFrame':
-    # Hardcoded patch for p4de.24xlarge, as our credentials doesn't have access
-    # to the instance type.
-    # Columns:
-    # InstanceType,AcceleratorName,AcceleratorCount,vCPUs,MemoryGiB,GpuInfo,
-    # Price,SpotPrice,Region,AvailabilityZone
-    records = []
-    for zone in df[df['Region'] == region]['AvailabilityZone'].unique():
-        records.append({
-            'InstanceType': 'p4de.24xlarge',
-            'AcceleratorName': 'A100-80GB',
-            'AcceleratorCount': 8,
-            'vCPUs': 96,
-            'MemoryGiB': 1152,
-            'GpuInfo':
-                ('{\'Gpus\': [{\'Name\': \'A100-80GB\', \'Manufacturer\': '
-                 '\'NVIDIA\', \'Count\': 8, \'MemoryInfo\': {\'SizeInMiB\': '
-                 '81920}}], \'TotalGpuMemoryInMiB\': 655360}'),
-            'AvailabilityZone': zone,
-            'Region': region,
-            'Price': pricing_df[pricing_df['InstanceType'] == 'p4de.24xlarge']
-                     ['Price'].values[0],
-            'SpotPrice': np.nan,
-        })
-    df = pd.concat([df, pd.DataFrame.from_records(records)])
-    return df
-
-
 def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
     try:
         # Fetch the zone info first to make sure the account has access to the
@@ -271,13 +242,24 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
                 return None, np.nan
             return accelerator['Name'], accelerator['Count']
 
+        def get_arch(row) -> Optional[str]:
+            if 'ProcessorInfo' in row:
+                processor = row['ProcessorInfo']
+                if 'SupportedArchitectures' in processor:
+                    archs = processor['SupportedArchitectures']
+                    if isinstance(archs, list):
+                        return archs[0]
+                    elif isinstance(archs, str):
+                        return archs
+            return None
+
         def get_vcpus(row) -> float:
             if not np.isnan(row['vCPU']):
                 return float(row['vCPU'])
             try:
                 return float(row['VCpuInfo']['DefaultVCpus'])
             except Exception as e:  # pylint: disable=broad-except
-                print('Error occured for row:', row)
+                print('Error occurred for row:', row)
                 print('Error:', e)
                 raise
 
@@ -313,11 +295,22 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
                 # AWS API is 'NVIDIA', which is incorrect. See #4652.
                 acc_name = 'H200'
                 acc_count = 8
+            if (row['InstanceType'].startswith('g6f') or
+                    row['InstanceType'].startswith('gr6f')):
+                # These instance actually have only fractional GPUs, but the API
+                # returns Count: 1 under GpuInfo. We need to check the GPU
+                # memory to get the actual fraction of the GPU.
+                # See also Standard_NV{vcpu}ads_A10_v5 support on Azure.
+                fraction = row['GpuInfo']['TotalGpuMemoryInMiB'] / L4_GPU_MEMORY
+                acc_count = round(fraction, 3)
+            if row['InstanceType'] == 'p5.4xlarge':
+                acc_count = 1
             return pd.Series({
                 'AcceleratorName': acc_name,
                 'AcceleratorCount': acc_count,
                 'vCPUs': get_vcpus(row),
                 'MemoryGiB': get_memory_gib(row),
+                'Arch': get_arch(row),
             })
 
         # The AWS API may not have all the instance types in the pricing table,
@@ -341,9 +334,6 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
         df = pd.concat(
             [df, df.apply(get_additional_columns, axis='columns')],
             axis='columns')
-        # patch the df for p4de.24xlarge
-        if region in P4DE_REGIONS:
-            df = _patch_p4de(region, df, pricing_df)
         if 'GpuInfo' not in df.columns:
             df['GpuInfo'] = np.nan
         df = df[USEFUL_COLUMNS]
@@ -546,7 +536,7 @@ if __name__ == '__main__':
     print('AWS Service Catalog saved to aws/vms.csv')
 
     # Disable refreshing images.csv as we are using skypilot custom AMIs
-    # See sky/clouds/service_catalog/images/README.md for more details.
+    # See sky/clouds/catalog/images/README.md for more details.
     # image_df = get_all_regions_images_df(user_regions)
     # _check_regions_integrity(image_df, 'images')
 

sky/{clouds/service_catalog → catalog}/data_fetchers/fetch_cudo.py

@@ -9,18 +9,11 @@ import os
 
 import cudo_compute
 
-import sky.provision.cudo.cudo_utils as utils
+from sky.provision.cudo import cudo_utils as utils
 
 VMS_CSV = 'cudo/vms.csv'
 
 
-def cudo_api():
-    configuration = cudo_compute.Configuration()
-    configuration.host = 'https://rest.compute.cudo.org'
-    client = cudo_compute.ApiClient(configuration)
-    return cudo_compute.VirtualMachinesApi(client)
-
-
 def get_gpu_info(count, model):
     mem = utils.cudo_gpu_mem[model]
     # pylint: disable=line-too-long
@@ -45,39 +38,46 @@ def get_instance_type(machine_type, vcpu, mem, gpu):
         mem) + 'gb'
 
 
-def machine_types(gpu_model, mem_gib, vcpu_count, gpu_count):
-    try:
-        api = cudo_api()
-        types = api.list_vm_machine_types(mem_gib,
-                                          vcpu_count,
-                                          gpu=gpu_count,
-                                          gpu_model=gpu_model)
-        return types.to_dict()
-    except cudo_compute.rest.ApiException as e:
-        raise e
-
-
 def update_prices():
     rows = []
+
+    api = cudo_compute.cudo_api.virtual_machines()
+    all_types = api.list_vm_machine_types2()
+    all_machine_types = all_types.to_dict()['machine_types']
+
     for spec in utils.machine_specs:
-        mts = machine_types('', spec['mem'], spec['vcpu'], spec['gpu'])
-        for hc in mts['host_configs']:
-            if not utils.gpu_exists(hc['gpu_model']):
-                continue
-            accelerator_name = utils.cudo_gpu_to_skypilot_gpu(hc['gpu_model'])
-            row = {
-                'instance_type': get_instance_type(hc['machine_type'],
-                                                   spec['vcpu'], spec['mem'],
-                                                   spec['gpu']),
-                'accelerator_name': accelerator_name,
-                'accelerator_count': str(spec['gpu']) + '.0',
-                'vcpus': str(spec['vcpu']),
-                'memory_gib': str(spec['mem']),
-                'price': hc['total_price_hr']['value'],
-                'region': hc['data_center_id'],
-                'gpu_info': get_gpu_info(spec['gpu'], accelerator_name),
-            }
-            rows.append(row)
+        for machine_type in all_machine_types:
+            if (machine_type['min_vcpu'] <= spec['vcpu'] and
+                    machine_type['min_memory_gib'] <= spec['mem'] and
+                    utils.gpu_exists(machine_type['gpu_model'])):
+
+                accelerator_name = utils.cudo_gpu_to_skypilot_gpu(
+                    machine_type['gpu_model'])
+
+                # Calculate total price per hour based on the given spec
+                vcpu_price = float(
+                    machine_type['vcpu_price_hr']['value']) * spec['vcpu']
+                memory_price = float(
+                    machine_type['memory_gib_price_hr']['value']) * spec['mem']
+                gpu_price = float(
+                    machine_type['gpu_price_hr']['value']) * spec['gpu']
+                # Note: Not including storage and IPv4 prices
+                # for now as they may be optional
+                total_price = vcpu_price + memory_price + gpu_price
+
+                row = {
+                    'instance_type': get_instance_type(
+                        machine_type['machine_type'], spec['vcpu'], spec['mem'],
+                        spec['gpu']),
+                    'accelerator_name': accelerator_name,
+                    'accelerator_count': str(spec['gpu']) + '.0',
+                    'vcpus': str(spec['vcpu']),
+                    'memory_gib': str(spec['mem']),
+                    'price': str(total_price),
+                    'region': machine_type['data_center_id'],
+                    'gpu_info': get_gpu_info(spec['gpu'], accelerator_name),
+                }
+                rows.append(row)
     path = VMS_CSV
     with open(path, 'w', encoding='utf-8') as file:
         file.write(

sky/{clouds/service_catalog → catalog}/data_fetchers/fetch_gcp.py

@@ -179,9 +179,12 @@ TPU_V4_HOST_DF = pd.read_csv(
 # TODO(woosuk): Make this more robust.
 # Refer to: https://github.com/skypilot-org/skypilot/issues/1006
 # Unsupported Series: 'f1', 'm2'
-SERIES_TO_DISCRIPTION = {
+SERIES_TO_DESCRIPTION = {
     'a2': 'A2 Instance',
     'a3': 'A3 Instance',
+    # TODO(zhwu): GCP does not have A4 instance in SKUs API yet. We keep it here
+    # for completeness.
+    'a4': 'A4 Instance',
     'c2': 'Compute optimized',
     'c2d': 'C2D AMD Instance',
     'c3': 'C3 Instance',
@@ -195,9 +198,11 @@ SERIES_TO_DISCRIPTION = {
     'n1': 'N1 Predefined Instance',
     'n2': 'N2 Instance',
     'n2d': 'N2D AMD Instance',
+    'n4': 'N4 Instance',
     't2a': 'T2A Arm Instance',
     't2d': 'T2D AMD Instance',
 }
+
 creds, project_id = google.auth.default()
 gcp_client = discovery.build('compute', 'v1')
 tpu_client = discovery.build('tpu', 'v1')
@@ -334,7 +339,7 @@ def get_vm_df(skus: List[Dict[str, Any]], region_prefix: str) -> 'pd.DataFrame':
 
     # Drop the unsupported series.
     df = df[df['InstanceType'].str.startswith(
-        tuple(f'{series}-' for series in SERIES_TO_DISCRIPTION))]
+        tuple(f'{series}-' for series in SERIES_TO_DESCRIPTION))]
     df = df[~df['AvailabilityZone'].str.startswith(tuple(TPU_V4_ZONES))]
 
     # TODO(woosuk): Make this more efficient.
@@ -352,7 +357,7 @@ def get_vm_df(skus: List[Dict[str, Any]], region_prefix: str) -> 'pd.DataFrame':
 
             # Check if the SKU is for the correct series.
             description = sku['description']
-            if SERIES_TO_DISCRIPTION[series].lower() not in description.lower():
+            if SERIES_TO_DESCRIPTION[series].lower() not in description.lower():
                 continue
             # Special check for M1 instances.
             if series == 'm1' and 'M3' in description:
@@ -434,10 +439,18 @@ def _get_gpus_for_zone(zone: str) -> 'pd.DataFrame':
             gpu_name = gpu_name.upper()
             if 'H100-80GB' in gpu_name:
                 gpu_name = 'H100'
-            if 'H100-MEGA-80GB' in gpu_name:
+
+            if 'H100-MEGA' in gpu_name:
                 gpu_name = 'H100-MEGA'
                 if count != 8:
-                    # H100-MEGA only has 8 cards.
+                    continue
+            elif 'H200' in gpu_name:
+                gpu_name = 'H200'
+                if count != 8:
+                    continue
+            elif 'B200' in gpu_name:
+                gpu_name = 'B200'
+                if count != 8:
                     continue
             if 'VWS' in gpu_name:
                 continue
@@ -468,6 +481,8 @@ def _gpu_info_from_name(name: str) -> Optional[Dict[str, List[Dict[str, Any]]]]:
         'A100': 40 * 1024,
         'H100': 80 * 1024,
         'H100-MEGA': 80 * 1024,
+        'H200': 141 * 1024,
+        'B200': 180 * 1024,
         'P4': 8 * 1024,
         'T4': 16 * 1024,
         'V100': 16 * 1024,
@@ -507,22 +522,30 @@ def get_gpu_df(skus: List[Dict[str, Any]],
         ondemand_or_spot = 'OnDemand' if not spot else 'Preemptible'
         gpu_price = None
         for sku in gpu_skus:
+            row_gpu_name = row['AcceleratorName']
             if row['Region'] not in sku['serviceRegions']:
                 continue
             if sku['category']['usageType'] != ondemand_or_spot:
                 continue
 
-            gpu_names = [row['AcceleratorName']]
-            if gpu_names[0] == 'A100-80GB':
-                gpu_names = ['A100 80GB']
-            if gpu_names[0] == 'H100':
-                gpu_names = ['H100 80GB']
-            if gpu_names[0] == 'H100-MEGA':
+            gpu_names = [f'{row_gpu_name} GPU']
+            if row_gpu_name == 'A100-80GB':
+                gpu_names = ['A100 80GB GPU']
+            elif row_gpu_name == 'H100':
+                gpu_names = ['H100 80GB GPU']
+            elif row_gpu_name == 'H100-MEGA':
                 # Seems that H100-MEGA has two different descriptions in SKUs in
                 # different regions: 'H100 80GB Mega' and 'H100 80GB Plus'.
-                gpu_names = ['H100 80GB Mega', 'H100 80GB Plus']
-            if not any(f'{gpu_name} GPU' in sku['description']
-                       for gpu_name in gpu_names):
+                gpu_names = [
+                    'H100 80GB Mega GPU', 'H100 Mega 80GB GPU',
+                    'H100 80GB Plus GPU'
+                ]
+            elif row_gpu_name == 'H200':
+                gpu_names = ['H200 141GB GPU']
+            elif row_gpu_name == 'B200':
+                gpu_names = ['Nvidia B200 (1 gpu slice)']
+            if not any(
+                    gpu_name in sku['description'] for gpu_name in gpu_names):
                 continue
 
             unit_price = _get_unit_price(sku)
@@ -554,7 +577,7 @@ def _get_tpu_response_for_zone(zone: str) -> list:
     # Sometimes the response is empty ({}) even for enabled zones. Here we
     # retry the request for a few times.
     backoff = common_utils.Backoff(initial_backoff=1)
-    for _ in range(TPU_RETRY_CNT):
+    for retry_cnt in range(TPU_RETRY_CNT):
         tpus_request = (
             tpu_client.projects().locations().acceleratorTypes().list(
                 parent=parent))
@@ -570,6 +593,10 @@ def _get_tpu_response_for_zone(zone: str) -> list:
                 print(f'  An error occurred: {error}')
             # If error happens, fail early.
             return []
+        except TimeoutError:
+            print(f'  TimeoutError: Failed to fetch TPUs for zone {zone!r}, '
+                  f'retry {retry_cnt + 1} of {TPU_RETRY_CNT}')
+
         time_to_sleep = backoff.current_backoff()
         print(f'  Retry zone {zone!r} in {time_to_sleep} seconds...')
         time.sleep(time_to_sleep)

sky/catalog/data_fetchers/fetch_hyperbolic.py

@@ -0,0 +1,136 @@
+"""Script to fetch Hyperbolic instance data and generate catalog."""
+import argparse
+import csv
+import json
+import os
+import sys
+from typing import Any, Dict
+
+import requests
+
+ENDPOINT = 'https://api.hyperbolic.xyz/v2/skypilot/catalog'
+API_KEY_PATH = os.path.expanduser('~/.hyperbolic/api_key')
+
+REQUIRED_FIELDS = [
+    'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs', 'MemoryGiB',
+    'StorageGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+]
+
+
+class HyperbolicCatalogError(Exception):
+    """Base exception for Hyperbolic catalog errors."""
+    pass
+
+
+def get_api_key(api_key=None) -> str:
+    """Get API key from arg, env var, or file."""
+    if api_key:
+        return api_key
+    if api_key := os.environ.get('HYPERBOLIC_API_KEY'):
+        return api_key
+    try:
+        with open(API_KEY_PATH, 'r', encoding='utf-8') as f:
+            return f.read().strip()
+    except FileNotFoundError as exc:
+        raise HyperbolicCatalogError(
+            'No API key found. Please either:\n'
+            '1. Pass --api-key\n'
+            '2. Set HYPERBOLIC_API_KEY environment variable\n'
+            '3. Create ~/.hyperbolic/api_key file') from exc
+
+
+def get_output_path() -> str:
+    """Get output path for catalog file."""
+    current_dir = os.getcwd()
+    if os.path.basename(current_dir) == 'hyperbolic':
+        return 'vms.csv'
+    hyperbolic_dir = os.path.join(current_dir, 'hyperbolic')
+    os.makedirs(hyperbolic_dir, exist_ok=True)
+    return os.path.join(hyperbolic_dir, 'vms.csv')
+
+
+def validate_instance_data(instance: Dict[str, Any]) -> None:
+    """Validate instance data has all required fields."""
+    missing_fields = [
+        field for field in REQUIRED_FIELDS if field not in instance
+    ]
+    if missing_fields:
+        raise HyperbolicCatalogError(
+            f'Instance data missing required fields: {missing_fields}')
+
+
+def create_catalog(api_key=None) -> None:
+    """Generate Hyperbolic catalog CSV file."""
+    try:
+        response = requests.get(
+            ENDPOINT,
+            headers={'Authorization': f'Bearer {get_api_key(api_key)}'},
+            timeout=30)
+        response.raise_for_status()
+
+        try:
+            data = response.json()
+        except json.JSONDecodeError as e:
+            raise HyperbolicCatalogError(
+                f'Invalid JSON response from API: {response.text}') from e
+
+        if 'vms' not in data:
+            raise HyperbolicCatalogError(
+                f'Missing "vms" field in API response: {data}')
+
+        instances = data['vms']
+        if not isinstance(instances, list):
+            raise HyperbolicCatalogError(
+                f'Expected list of instances, got {type(instances)}')
+
+        if not instances:
+            raise HyperbolicCatalogError('No instances found in API response')
+
+        # Validate each instance
+        for instance in instances:
+            validate_instance_data(instance)
+
+    except requests.exceptions.RequestException as e:
+        raise HyperbolicCatalogError(
+            f'Failed to fetch instance data: {e}') from e
+
+    output_path = get_output_path()
+    try:
+        with open(output_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=REQUIRED_FIELDS)
+            writer.writeheader()
+
+            for instance in instances:
+                entry = instance.copy()
+                # Convert GpuInfo to string format
+                entry['GpuInfo'] = json.dumps(entry['GpuInfo'],
+                                              ensure_ascii=False).replace(
+                                                  '"', "'")  # pylint: disable=invalid-string-quote
+                writer.writerow(entry)
+    except (IOError, OSError) as e:
+        raise HyperbolicCatalogError(
+            f'Failed to write catalog file to {output_path}: {e}') from e
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description='Fetch Hyperbolic instance data')
+    parser.add_argument('--api-key', help='Hyperbolic API key')
+    args = parser.parse_args()
+
+    try:
+        create_catalog(args.api_key)
+        print(f'Hyperbolic Service Catalog saved to {get_output_path()}')
+        return 0
+    except HyperbolicCatalogError as e:
+        print(f'Error: {e}', file=sys.stderr)
+        return 1
+    except (requests.exceptions.RequestException, json.JSONDecodeError, IOError,
+            OSError) as e:
+        print(f'Unexpected error: {e}', file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

sky/{clouds/service_catalog → catalog}/data_fetchers/fetch_lambda_cloud.py

@@ -49,6 +49,7 @@ GPU_TO_MEMORY = {
     'V100': 16384,
     'H100': 81920,
     'GH200': 98304,
+    'B200': 184320,  # 180 GB
     'GENERAL': None
 }