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

sky/clouds/service_catalog/common.py

@@ -5,7 +5,7 @@ import hashlib
 import os
 import time
 import typing
-from typing import Dict, List, NamedTuple, Optional, Tuple
+from typing import Callable, Dict, List, NamedTuple, Optional, Tuple, Union
 
 import filelock
 import requests
@@ -13,8 +13,9 @@ import requests
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.clouds import cloud as cloud_lib
-from sky.clouds import cloud_registry
 from sky.clouds.service_catalog import constants
+from sky.utils import common_utils
+from sky.utils import registry
 from sky.utils import rich_utils
 from sky.utils import ux_utils
 
@@ -58,7 +59,9 @@ class InstanceTypeInfo(NamedTuple):
 
 
 def get_catalog_path(filename: str) -> str:
-    return os.path.join(_ABSOLUTE_VERSIONED_CATALOG_DIR, filename)
+    catalog_path = os.path.join(_ABSOLUTE_VERSIONED_CATALOG_DIR, filename)
+    os.makedirs(os.path.dirname(catalog_path), exist_ok=True)
+    return catalog_path
 
 
 def is_catalog_modified(filename: str) -> bool:
@@ -67,8 +70,7 @@ def is_catalog_modified(filename: str) -> bool:
     meta_path = os.path.join(_ABSOLUTE_VERSIONED_CATALOG_DIR, '.meta', filename)
     md5_filepath = meta_path + '.md5'
     if os.path.exists(md5_filepath):
-        with open(catalog_path, 'rb') as f:
-            file_md5 = hashlib.md5(f.read()).hexdigest()
+        file_md5 = common_utils.hash_file(catalog_path, 'md5').hexdigest()
         with open(md5_filepath, 'r', encoding='utf-8') as f:
             last_md5 = f.read()
         return file_md5 != last_md5
@@ -118,19 +120,21 @@ def get_modified_catalog_file_mounts() -> Dict[str, str]:
 
 
 class LazyDataFrame:
-    """A lazy data frame that reads the catalog on demand.
+    """A lazy data frame that updates and reads the catalog on demand.
 
     We don't need to load the catalog for every SkyPilot call, and this class
     allows us to load the catalog only when needed.
     """
 
-    def __init__(self, filename: str):
+    def __init__(self, filename: str, update_func: Callable[[], None]):
         self._filename = filename
         self._df: Optional['pd.DataFrame'] = None
+        self._update_func = update_func
 
     def _load_df(self) -> 'pd.DataFrame':
         if self._df is None:
             try:
+                self._update_func()
                 self._df = pd.read_csv(self._filename)
             except Exception as e:  # pylint: disable=broad-except
                 # As users can manually modify the catalog, read_csv can fail.
@@ -167,63 +171,69 @@ def read_catalog(filename: str,
     assert (pull_frequency_hours is None or
             pull_frequency_hours >= 0), pull_frequency_hours
     catalog_path = get_catalog_path(filename)
-    cloud = cloud_registry.CLOUD_REGISTRY.from_str(os.path.dirname(filename))
+    cloud = os.path.dirname(filename)
+    if cloud != 'common':
+        cloud = str(registry.CLOUD_REGISTRY.from_str(cloud))
 
     meta_path = os.path.join(_ABSOLUTE_VERSIONED_CATALOG_DIR, '.meta', filename)
     os.makedirs(os.path.dirname(meta_path), exist_ok=True)
 
-    # Atomic check, to avoid conflicts with other processes.
-    # TODO(mraheja): remove pylint disabling when filelock version updated
-    # pylint: disable=abstract-class-instantiated
-    with filelock.FileLock(meta_path + '.lock'):
-
-        def _need_update() -> bool:
-            if not os.path.exists(catalog_path):
-                return True
-            if pull_frequency_hours is None:
-                return False
-            if is_catalog_modified(filename):
-                # If the catalog is modified by a user manually, we should
-                # avoid overwriting the catalog by fetching from GitHub.
-                return False
-
-            last_update = os.path.getmtime(catalog_path)
-            return last_update + pull_frequency_hours * 3600 < time.time()
-
-        if _need_update():
-            url = f'{constants.HOSTED_CATALOG_DIR_URL}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
-            update_frequency_str = ''
-            if pull_frequency_hours is not None:
-                update_frequency_str = f' (every {pull_frequency_hours} hours)'
-            with rich_utils.safe_status((f'Updating {cloud} catalog: '
-                                         f'{filename}'
-                                         f'{update_frequency_str}')):
-                try:
-                    r = requests.get(url)
-                    r.raise_for_status()
-                except requests.exceptions.RequestException as e:
-                    error_str = (f'Failed to fetch {cloud} catalog '
-                                 f'{filename}. ')
-                    if os.path.exists(catalog_path):
-                        logger.warning(
-                            f'{error_str}Using cached catalog files.')
-                        # Update catalog file modification time.
-                        os.utime(catalog_path, None)  # Sets to current time
+    def _need_update() -> bool:
+        if not os.path.exists(catalog_path):
+            return True
+        if pull_frequency_hours is None:
+            return False
+        if is_catalog_modified(filename):
+            # If the catalog is modified by a user manually, we should
+            # avoid overwriting the catalog by fetching from GitHub.
+            return False
+
+        last_update = os.path.getmtime(catalog_path)
+        return last_update + pull_frequency_hours * 3600 < time.time()
+
+    def _update_catalog():
+        # Atomic check, to avoid conflicts with other processes.
+        with filelock.FileLock(meta_path + '.lock'):
+            if _need_update():
+                url = f'{constants.HOSTED_CATALOG_DIR_URL}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
+                update_frequency_str = ''
+                if pull_frequency_hours is not None:
+                    update_frequency_str = (
+                        f' (every {pull_frequency_hours} hours)')
+                with rich_utils.safe_status(
+                        ux_utils.spinner_message(
+                            f'Updating {cloud} catalog: {filename}') +
+                        f'{update_frequency_str}'):
+                    try:
+                        r = requests.get(url=url,
+                                         headers={'User-Agent': 'SkyPilot/0.7'})
+                        r.raise_for_status()
+                    except requests.exceptions.RequestException as e:
+                        error_str = (f'Failed to fetch {cloud} catalog '
+                                     f'{filename}. ')
+                        if os.path.exists(catalog_path):
+                            logger.warning(
+                                f'{error_str}Using cached catalog files.')
+                            # Update catalog file modification time.
+                            os.utime(catalog_path, None)  # Sets to current time
+                        else:
+                            logger.error(
+                                f'{error_str}Please check your internet '
+                                'connection.')
+                            with ux_utils.print_exception_no_traceback():
+                                raise e
                     else:
-                        logger.error(
-                            f'{error_str}Please check your internet connection.'
-                        )
-                        with ux_utils.print_exception_no_traceback():
-                            raise e
-                else:
-                    # Download successful, save the catalog to a local file.
-                    os.makedirs(os.path.dirname(catalog_path), exist_ok=True)
-                    with open(catalog_path, 'w', encoding='utf-8') as f:
-                        f.write(r.text)
-                    with open(meta_path + '.md5', 'w', encoding='utf-8') as f:
-                        f.write(hashlib.md5(r.text.encode()).hexdigest())
-
-    return LazyDataFrame(catalog_path)
+                        # Download successful, save the catalog to a local file.
+                        os.makedirs(os.path.dirname(catalog_path),
+                                    exist_ok=True)
+                        with open(catalog_path, 'w', encoding='utf-8') as f:
+                            f.write(r.text)
+                        with open(meta_path + '.md5', 'w',
+                                  encoding='utf-8') as f:
+                            f.write(hashlib.md5(r.text.encode()).hexdigest())
+                logger.debug(f'Updated {cloud} catalog {filename}.')
+
+    return LazyDataFrame(catalog_path, update_func=_update_catalog)
 
 
 def _get_instance_type(
@@ -262,9 +272,10 @@ def validate_region_zone_impl(
         candidate_loc = difflib.get_close_matches(loc, all_loc, n=5, cutoff=0.9)
         candidate_loc = sorted(candidate_loc)
         candidate_strs = ''
-        if len(candidate_loc) > 0:
+        if candidate_loc:
             candidate_strs = ', '.join(candidate_loc)
             candidate_strs = f'\nDid you mean one of these: {candidate_strs!r}?'
+
         return candidate_strs
 
     def _get_all_supported_regions_str() -> str:
@@ -278,7 +289,7 @@ def validate_region_zone_impl(
     filter_df = df
     if region is not None:
         filter_df = _filter_region_zone(filter_df, region, zone=None)
-        if len(filter_df) == 0:
+        if filter_df.empty:
             with ux_utils.print_exception_no_traceback():
                 error_msg = (f'Invalid region {region!r}')
                 candidate_strs = _get_candidate_str(
@@ -288,7 +299,7 @@ def validate_region_zone_impl(
                         faq_msg = (
                             '\nIf a region is not included in the following '
                             'list, please check the FAQ docs for how to fetch '
-                            'its catalog info.\nhttps://skypilot.readthedocs.io'
+                            'its catalog info.\nhttps://docs.skypilot.co'
                             '/en/latest/reference/faq.html#advanced-how-to-'
                             'make-skypilot-use-all-global-regions')
                         error_msg += faq_msg + _get_all_supported_regions_str()
@@ -302,7 +313,7 @@ def validate_region_zone_impl(
     if zone is not None:
         maybe_region_df = filter_df
         filter_df = filter_df[filter_df['AvailabilityZone'] == zone]
-        if len(filter_df) == 0:
+        if filter_df.empty:
             region_str = f' for region {region!r}' if region else ''
             df = maybe_region_df if region else df
             with ux_utils.print_exception_no_traceback():
@@ -370,7 +381,7 @@ def get_vcpus_mem_from_instance_type_impl(
     instance_type: str,
 ) -> Tuple[Optional[float], Optional[float]]:
     df = _get_instance_type(df, instance_type, None)
-    if len(df) == 0:
+    if df.empty:
         with ux_utils.print_exception_no_traceback():
             raise ValueError(f'No instance type {instance_type} found.')
     assert len(set(df['vCPUs'])) == 1, ('Cannot determine the number of vCPUs '
@@ -474,22 +485,28 @@ def get_instance_type_for_cpus_mem_impl(
 def get_accelerators_from_instance_type_impl(
     df: 'pd.DataFrame',
     instance_type: str,
-) -> Optional[Dict[str, int]]:
+) -> Optional[Dict[str, Union[int, float]]]:
     df = _get_instance_type(df, instance_type, None)
-    if len(df) == 0:
+    if df.empty:
         with ux_utils.print_exception_no_traceback():
             raise ValueError(f'No instance type {instance_type} found.')
     row = df.iloc[0]
     acc_name, acc_count = row['AcceleratorName'], row['AcceleratorCount']
     if pd.isnull(acc_name):
         return None
-    return {acc_name: int(acc_count)}
+
+    def _convert(value):
+        if int(value) == value:
+            return int(value)
+        return float(value)
+
+    return {acc_name: _convert(acc_count)}
 
 
 def get_instance_type_for_accelerator_impl(
     df: 'pd.DataFrame',
     acc_name: str,
-    acc_count: int,
+    acc_count: Union[int, float],
     cpus: Optional[str] = None,
     memory: Optional[str] = None,
     use_spot: bool = False,
@@ -502,9 +519,9 @@ def get_instance_type_for_accelerator_impl(
     accelerators with sorted prices and a list of candidates with fuzzy search.
     """
     result = df[(df['AcceleratorName'].str.fullmatch(acc_name, case=False)) &
-                (df['AcceleratorCount'] == acc_count)]
+                (abs(df['AcceleratorCount'] - acc_count) <= 0.01)]
     result = _filter_region_zone(result, region, zone)
-    if len(result) == 0:
+    if result.empty:
         fuzzy_result = df[
             (df['AcceleratorName'].str.contains(acc_name, case=False)) &
             (df['AcceleratorCount'] >= acc_count)]
@@ -513,16 +530,19 @@ def get_instance_type_for_accelerator_impl(
         fuzzy_result = fuzzy_result[['AcceleratorName',
                                      'AcceleratorCount']].drop_duplicates()
         fuzzy_candidate_list = []
-        if len(fuzzy_result) > 0:
+        if not fuzzy_result.empty:
             for _, row in fuzzy_result.iterrows():
+                acc_cnt = float(row['AcceleratorCount'])
+                acc_count_display = (int(acc_cnt) if acc_cnt.is_integer() else
+                                     f'{acc_cnt:.2f}')
                 fuzzy_candidate_list.append(f'{row["AcceleratorName"]}:'
-                                            f'{int(row["AcceleratorCount"])}')
+                                            f'{acc_count_display}')
         return (None, fuzzy_candidate_list)
 
     result = _filter_with_cpus(result, cpus)
     result = _filter_with_mem(result, memory)
     result = _filter_region_zone(result, region, zone)
-    if len(result) == 0:
+    if result.empty:
         return ([], [])
 
     # Current strategy: choose the cheapest instance
@@ -663,7 +683,7 @@ def get_image_id_from_tag_impl(df: 'pd.DataFrame', tag: str,
     df = _filter_region_zone(df, region, zone=None)
     assert len(df) <= 1, ('Multiple images found for tag '
                           f'{tag} in region {region}')
-    if len(df) == 0:
+    if df.empty:
         return None
     image_id = df['ImageId'].iloc[0]
     if pd.isna(image_id):
@@ -677,4 +697,4 @@ def is_image_tag_valid_impl(df: 'pd.DataFrame', tag: str,
     df = df[df['Tag'] == tag]
     df = _filter_region_zone(df, region, zone=None)
     df = df.dropna(subset=['ImageId'])
-    return len(df) > 0
+    return not df.empty

sky/clouds/service_catalog/constants.py

@@ -1,7 +1,7 @@
 """Constants used for service catalog."""
 HOSTED_CATALOG_DIR_URL = 'https://raw.githubusercontent.com/skypilot-org/skypilot-catalog/master/catalogs'  # pylint: disable=line-too-long
-CATALOG_SCHEMA_VERSION = 'v5'
+CATALOG_SCHEMA_VERSION = 'v6'
 CATALOG_DIR = '~/.sky/catalogs'
 ALL_CLOUDS = ('aws', 'azure', 'gcp', 'ibm', 'lambda', 'scp', 'oci',
-              'kubernetes', 'runpod', 'vsphere', 'cudo', 'fluidstack',
-              'paperspace')
+              'kubernetes', 'runpod', 'vast', 'vsphere', 'cudo', 'fluidstack',
+              'paperspace', 'do', 'nebius')

sky/clouds/service_catalog/cudo_catalog.py

@@ -1,7 +1,7 @@
 """Cudo Compute Offerings Catalog."""
 
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.clouds.service_catalog import common
 import sky.provision.cudo.cudo_machine_type as cudo_mt
@@ -14,6 +14,9 @@ _PULL_FREQUENCY_HOURS = 1
 _df = common.read_catalog(cudo_mt.VMS_CSV,
                           pull_frequency_hours=_PULL_FREQUENCY_HOURS)
 
+_DEFAULT_NUM_VCPUS = 8
+_DEFAULT_MEMORY_CPU_RATIO = 2
+
 
 def instance_type_exists(instance_type: str) -> bool:
     return common.instance_type_exists_impl(_df, instance_type)
@@ -52,11 +55,18 @@ def get_default_instance_type(cpus: Optional[str] = None,
     del disk_tier
     # NOTE: After expanding catalog to multiple entries, you may
     # want to specify a default instance type or family.
-    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+    if cpus is None and memory is None:
+        cpus = f'{_DEFAULT_NUM_VCPUS}+'
+
+    memory_gb_or_ratio = memory
+    if memory is None:
+        memory_gb_or_ratio = f'{_DEFAULT_MEMORY_CPU_RATIO}x'
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus,
+                                                      memory_gb_or_ratio)
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(_df, instance_type)
 
 

sky/clouds/service_catalog/data_fetchers/fetch_aws.py

@@ -306,6 +306,12 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
                 assert find_num_in_name is not None, row['InstanceType']
                 num_in_name = find_num_in_name.group(1)
                 acc_count = int(num_in_name) // 2
+            if row['InstanceType'] == 'p5en.48xlarge':
+                # TODO(andyl): Check if this workaround still needed after
+                # v0.10.0 released. Currently, the acc_name returned by the
+                # AWS API is 'NVIDIA', which is incorrect. See #4652.
+                acc_name = 'H200'
+                acc_count = 8
             return pd.Series({
                 'AcceleratorName': acc_name,
                 'AcceleratorCount': acc_count,
@@ -379,26 +385,33 @@ def get_all_regions_instance_types_df(regions: Set[str]) -> 'pd.DataFrame':
 #
 # Deep Learning AMI GPU PyTorch 1.10.0 (Ubuntu 18.04) 20211208
 #   Nvidia driver: 470.57.02, CUDA Version: 11.4
-_GPU_UBUNTU_DATE_PYTORCH = [
-    ('gpu', '20.04', '20231103', '2.1.0'),
-    ('gpu', '18.04', '20221114', '1.10.0'),
-    ('k80', '20.04', '20211208', '1.10.0'),
-    ('k80', '18.04', '20211208', '1.10.0'),
+#
+# Neuron (Inferentia / Trainium):
+# https://aws.amazon.com/releasenotes/aws-deep-learning-ami-base-neuron-ubuntu-20-04/  # pylint: disable=line-too-long
+# Deep Learning Base Neuron AMI (Ubuntu 20.04) 20240923
+# TODO(tian): find out the driver version.
+#   Neuron driver:
+_GPU_DESC_UBUNTU_DATE = [
+    ('gpu', 'AMI GPU PyTorch 2.1.0', '20.04', '20231103'),
+    ('gpu', 'AMI GPU PyTorch 1.10.0', '18.04', '20221114'),
+    ('k80', 'AMI GPU PyTorch 1.10.0', '20.04', '20211208'),
+    ('k80', 'AMI GPU PyTorch 1.10.0', '18.04', '20211208'),
+    ('neuron', 'Base Neuron AMI', '22.04', '20240923'),
 ]
 
 
-def _fetch_image_id(region: str, ubuntu_version: str, creation_date: str,
-                    pytorch_version: str) -> Optional[str]:
+def _fetch_image_id(region: str, description: str, ubuntu_version: str,
+                    creation_date: str) -> Optional[str]:
     try:
         image = subprocess.check_output(f"""\
             aws ec2 describe-images --region {region} --owners amazon \\
-                --filters 'Name=name,Values="Deep Learning AMI GPU PyTorch {pytorch_version} (Ubuntu {ubuntu_version}) {creation_date}"' \\
+                --filters 'Name=name,Values="Deep Learning {description} (Ubuntu {ubuntu_version}) {creation_date}"' \\
                     'Name=state,Values=available' --query 'Images[:1].ImageId' --output text
             """,
                                         shell=True)
     except subprocess.CalledProcessError as e:
-        print(f'Failed {region}, {ubuntu_version}, {creation_date}. '
-              'Trying next date.')
+        print(f'Failed {region}, {description}, {ubuntu_version}, '
+              f'{creation_date}. Trying next date.')
         print(f'{type(e)}: {e}')
         image_id = None
     else:
@@ -407,21 +420,21 @@ def _fetch_image_id(region: str, ubuntu_version: str, creation_date: str,
     return image_id
 
 
-def _get_image_row(
-        region: str, gpu: str, ubuntu_version: str, date: str,
-        pytorch_version) -> Tuple[str, str, str, str, Optional[str], str]:
-    print(f'Getting image for {region}, {ubuntu_version}, {gpu}')
-    image_id = _fetch_image_id(region, ubuntu_version, date, pytorch_version)
+def _get_image_row(region: str, gpu: str, description: str, ubuntu_version: str,
+                   date: str) -> Tuple[str, str, str, str, Optional[str], str]:
+    print(f'Getting image for {region}, {description}, {ubuntu_version}, {gpu}')
+    image_id = _fetch_image_id(region, description, ubuntu_version, date)
     if image_id is None:
         # not found
-        print(f'Failed to find image for {region}, {ubuntu_version}, {gpu}')
+        print(f'Failed to find image for {region}, {description}, '
+              f'{ubuntu_version}, {gpu}')
     tag = f'skypilot:{gpu}-ubuntu-{ubuntu_version.replace(".", "")}'
     return tag, region, 'ubuntu', ubuntu_version, image_id, date
 
 
 def get_all_regions_images_df(regions: Set[str]) -> 'pd.DataFrame':
     image_metas = [
-        (r, *i) for r, i in itertools.product(regions, _GPU_UBUNTU_DATE_PYTORCH)
+        (r, *i) for r, i in itertools.product(regions, _GPU_DESC_UBUNTU_DATE)
     ]
     with mp_pool.Pool() as pool:
         results = pool.starmap(_get_image_row, image_metas)
@@ -531,11 +544,13 @@ if __name__ == '__main__':
     instance_df.to_csv('aws/vms.csv', index=False)
     print('AWS Service Catalog saved to aws/vms.csv')
 
-    image_df = get_all_regions_images_df(user_regions)
-    _check_regions_integrity(image_df, 'images')
+    # Disable refreshing images.csv as we are using skypilot custom AMIs
+    # See sky/clouds/service_catalog/images/README.md for more details.
+    # image_df = get_all_regions_images_df(user_regions)
+    # _check_regions_integrity(image_df, 'images')
 
-    image_df.to_csv('aws/images.csv', index=False)
-    print('AWS Images saved to aws/images.csv')
+    # image_df.to_csv('aws/images.csv', index=False)
+    # print('AWS Images saved to aws/images.csv')
 
     if args.az_mappings:
         az_mappings_df = fetch_availability_zone_mappings()

sky/clouds/service_catalog/data_fetchers/fetch_azure.py

@@ -64,7 +64,7 @@ FAMILY_NAME_TO_SKYPILOT_GPU_NAME = {
     'standardNVSv2Family': 'M60',
     'standardNVSv3Family': 'M60',
     'standardNVPromoFamily': 'M60',
-    'standardNVSv4Family': 'Radeon MI25',
+    'standardNVSv4Family': 'MI25',
     'standardNDSFamily': 'P40',
     'StandardNVADSA10v5Family': 'A10',
     'StandardNCadsH100v5Family': 'H100',
@@ -93,6 +93,16 @@ def get_regions() -> List[str]:
 # We have to manually remove it.
 DEPRECATED_FAMILIES = ['standardNVSv2Family']
 
+# Azure has those fractional A10 instance types, which still shows has 1 A10 GPU
+# in the API response. We manually changing the number of GPUs to a float here.
+# Ref: https://learn.microsoft.com/en-us/azure/virtual-machines/nva10v5-series
+# TODO(zhwu,tian): Support fractional GPUs on k8s as well.
+# TODO(tian): Maybe we should support literally fractional count, i.e. A10:1/6
+# instead of float point count (A10:0.167).
+AZURE_FRACTIONAL_A10_INS_TYPE_TO_NUM_GPUS = {
+    f'Standard_NV{vcpu}ads_A10_v5': round(vcpu / 36, 3) for vcpu in [6, 12, 18]
+}
+
 USEFUL_COLUMNS = [
     'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs', 'MemoryGiB',
     'GpuInfo', 'Price', 'SpotPrice', 'Region', 'Generation'
@@ -124,15 +134,19 @@ def get_pricing_df(region: Optional[str] = None) -> 'pd.DataFrame':
         content_str = r.content.decode('ascii')
         content = json.loads(content_str)
         items = content.get('Items', [])
-        if len(items) == 0:
+        if not items:
             break
         all_items += items
         url = content.get('NextPageLink')
     print(f'Done fetching pricing {region}')
     df = pd.DataFrame(all_items)
     assert 'productName' in df.columns, (region, df.columns)
-    return df[(~df['productName'].str.contains(' Windows')) &
-              (df['unitPrice'] > 0)]
+    # Filter out the cloud services and windows products.
+    # Some H100 series use ' Win' instead of ' Windows', e.g.
+    # Virtual Machines NCCadsv5 Srs Win
+    return df[
+        (~df['productName'].str.contains(' Win| Cloud Services| CloudServices'))
+        & (df['unitPrice'] > 0)]
 
 
 def get_sku_df(region_set: Set[str]) -> 'pd.DataFrame':
@@ -261,6 +275,19 @@ def get_all_regions_instance_types_df(region_set: Set[str]):
         axis='columns',
     )
 
+    def _upd_a10_gpu_count(row):
+        new_gpu_cnt = AZURE_FRACTIONAL_A10_INS_TYPE_TO_NUM_GPUS.get(
+            row['InstanceType'])
+        if new_gpu_cnt is not None:
+            return new_gpu_cnt
+        return row['AcceleratorCount']
+
+    # Manually update the GPU count for fractional A10 instance types.
+    # Those instance types have fractional GPU count, but Azure API returns
+    # 1 GPU count for them. We manually update the GPU count here.
+    df_ret['AcceleratorCount'] = df_ret.apply(_upd_a10_gpu_count,
+                                              axis='columns')
+
     # As of Dec 2023, a few H100 instance types fetched from Azure APIs do not
     # have pricing:
     #