skypilot-nightly 1.0.0.dev20250502__py3-none-any.whl → 1.0.0.dev20251203__py3-none-any.whl

sky/catalog/data_fetchers/fetch_seeweb.py

@@ -0,0 +1,329 @@
+"""A script that generates the Seeweb catalog.
+
+Usage:
+    python fetch_seeweb.py [-h] [--api-key API_KEY]
+    [--api-key-path API_KEY_PATH]
+
+If neither --api-key nor --api-key-path are provided, this script will parse
+`~/.seeweb_cloud/seeweb_keys` to look for Seeweb API key.
+"""
+import argparse
+import configparser
+import csv
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from sky.adaptors.seeweb import ecsapi
+
+# GPU name mapping from Seeweb to SkyPilot canonical names
+SEEWEB_GPU_NAME_TO_SKYPILOT_GPU_NAME = {
+    'H200 141GB': 'H200',
+    'RTX A6000 48GB': 'RTXA6000',
+    'A100 80GB': 'A100',
+    'L4 24GB': 'L4',
+    'L40s 48GB': 'L40S',
+    'H100 80GB': 'H100',
+    'MI300X': 'MI300X',
+    'A30': 'A30',
+    'RTX 6000 24GB': 'RTX6000',
+    'Tenstorrent Grayskull e75': 'GRAYSKULL-E75',
+    'Tenstorrent Grayskull e150': 'GRAYSKULL-E150',
+}
+
+# GPU VRAM mapping in MB
+VRAM = {
+    'RTXA6000': 48384,  # 48GB
+    'H200': 144384,  # 141GB
+    'A100': 81920,  # 80GB
+    'L4': 24576,  # 24GB
+    'L40S': 49152,  # 48GB
+    'H100': 81920,  # 80GB
+    'MI300X': 192000,  # 192GB
+    'A30': 24576,  # 24GB
+    'RTX6000': 24576,  # 24GB
+    'GRAYSKULL-E75': 8192,  # 8GB
+    'GRAYSKULL-E150': 8192,  # 8GB
+}
+
+
+def is_tenstorrent_gpu_name(gpu_name: Optional[str]) -> bool:
+    """Return True if the given GPU name refers to a Tenstorrent GPU.
+
+    Detects by common identifiers present in normalized names (e.g., GRAYSKULL)
+    or by the vendor name directly.
+    """
+    if not gpu_name:
+        return False
+    upper = str(gpu_name).upper()
+    return 'TENSTORRENT' in upper or 'GRAYSKULL' in upper
+
+
+def is_mi300x_gpu_name(gpu_name: Optional[str]) -> bool:
+    """Return True if the given GPU name refers to AMD MI300X."""
+    if not gpu_name:
+        return False
+    return 'MI300X' in str(gpu_name).upper()
+
+
+def get_api_key(path: Optional[str] = None) -> str:
+    """Get API key from config file or environment variable."""
+    # Step 1: Try to get from config file
+    if path is None:
+        path = os.path.expanduser('~/.seeweb_cloud/seeweb_keys')
+    else:
+        path = os.path.expanduser(path)
+
+    try:
+        parser = configparser.ConfigParser()
+        parser.read(path)
+        return parser['DEFAULT']['api_key'].strip()
+    except (KeyError, FileNotFoundError) as exc:
+        # Step 2: Try environment variable
+        api_key = os.environ.get('SEEWEB_API_KEY')
+        if api_key:
+            return api_key.strip()
+
+        # If neither found, raise error
+        raise ValueError(
+            f'API key not found in {path} or ENV variable SEEWEB_API_KEY'
+        ) from exc
+
+
+def normalize_gpu_name(gpu_name: str) -> str:
+    """Normalize GPU name from Seeweb API to SkyPilot canonical name."""
+    if not gpu_name:
+        return ''
+
+    # Map to canonical name if available
+    canonical_name = SEEWEB_GPU_NAME_TO_SKYPILOT_GPU_NAME.get(gpu_name)
+    if canonical_name:
+        return canonical_name
+
+    # If not found in mapping, return original name
+    print(f'Warning: GPU name "{gpu_name}" not found in mapping,'
+          f'using original name')
+    return gpu_name
+
+
+def parse_plan_info(plan: Any) -> Dict[str, Any]:
+    """Parse plan information from Seeweb API response."""
+    # Handle both dictionary and object formats
+    if hasattr(plan, 'name'):
+        # Object format from API
+        plan_name = getattr(plan, 'name', 'unknown')
+        vcpus = int(getattr(plan, 'cpu', 0))
+
+        # Handle memory conversion safely
+        memory_mb = getattr(plan, 'ram', 0)
+        try:
+            memory_gb = int(
+                memory_mb) / 1024 if memory_mb else 0  # Convert to GB
+        except (ValueError, TypeError):
+            memory_gb = 0
+
+        # Handle price safely
+        try:
+            price = float(getattr(plan, 'hourly_price', 0.0))
+        except (ValueError, TypeError):
+            price = 0.0
+
+        # Handle GPU info
+        try:
+            gpu_count = int(getattr(plan, 'gpu', 0))
+        except (ValueError, TypeError):
+            gpu_count = 0
+
+        gpu_label = getattr(plan, 'gpu_label', None)
+
+        # Determine GPU name - use gpu_label if available,
+        # otherwise try to infer from plan name
+        if gpu_label:
+            gpu_name = normalize_gpu_name(gpu_label)  # Normalize the GPU name
+        else:
+            # Try to extract GPU name from plan name
+            plan_name = getattr(plan, 'name', '')
+            if 'GPU' in plan_name:
+                # Extract GPU type from plan name (e.g., ECS1GPU11 -> GPU11)
+                parts = plan_name.split('GPU')
+                if len(parts) > 1:
+                    gpu_name = 'GPU' + parts[1]
+                else:
+                    gpu_name = 'GPU'
+            else:
+                gpu_name = None
+
+        # Get GPU VRAM from mapping using the normalized name
+        gpu_vram_mb = VRAM.get(gpu_name, 0) if gpu_name else 0
+    else:
+        raise ValueError(f'Unsupported plan format: {type(plan)}')
+
+    return {
+        'plan_name': plan_name,
+        'vcpus': vcpus,
+        'memory_gb': memory_gb,
+        'gpu_name': gpu_name,
+        'gpu_count': gpu_count,
+        'gpu_vram_mb': gpu_vram_mb,
+        'price': price,
+    }
+
+
+def get_gpu_info(gpu_count: int, gpu_name: str, gpu_vram_mb: int = 0) -> str:
+    """Generate GPU info JSON string compatible with SkyPilot."""
+    if not gpu_name or gpu_count == 0:
+        return ''
+
+    # Determine manufacturer based on GPU name
+    gpu_name_upper = str(gpu_name).upper()
+    if 'MI300' in gpu_name_upper or gpu_name_upper == 'MI300X':
+        manufacturer = 'AMD'
+    elif 'GRAYSKULL' in gpu_name_upper:
+        manufacturer = 'TENSTORRENT'
+    else:
+        manufacturer = 'NVIDIA'
+
+    gpu_info = {
+        'Gpus': [{
+            'Name': gpu_name,
+            'Manufacturer': manufacturer,
+            'Count': float(gpu_count),
+            'MemoryInfo': {
+                'SizeInMiB': gpu_vram_mb
+            },
+        }],
+        'TotalGpuMemoryInMiB': gpu_vram_mb * gpu_count if gpu_vram_mb else 0
+    }
+
+    return json.dumps(gpu_info).replace('"', '\'')
+
+
+def fetch_seeweb_data(api_key: str) -> List[Dict]:
+    """Fetch data from Seeweb API."""
+    if ecsapi is None:
+        raise ImportError('ecsapi not available')
+
+    try:
+        client = ecsapi.Api(token=api_key)
+
+        print('Fetching plans from Seeweb API...')
+        api_plans = client.fetch_plans()
+
+        if not api_plans:
+            raise ValueError('No plans returned from API')
+
+        print(f'Successfully fetched {len(api_plans)} plans from API')
+        plans = []
+
+        for plan in api_plans:
+            try:
+                # Parse first so we can filter
+                # Tenstorrent before extra API calls
+                parsed = parse_plan_info(plan)
+
+                if is_tenstorrent_gpu_name(parsed.get('gpu_name')):
+                    print(f'Skipping Tenstorrent plan {plan.name}')
+                    continue
+
+                if is_mi300x_gpu_name(parsed.get('gpu_name')):
+                    print(f'Skipping MI300X plan {plan.name}')
+                    continue
+
+                print(f'Fetching regions available for {plan.name}')
+                regions_available = client.fetch_regions_available(plan.name)
+
+                parsed.update({'regions_available': regions_available})
+                plans.append(parsed)
+            except Exception as e:  # pylint: disable=broad-except
+                print(f'Error parsing plan {plan.name}: {e}')
+                continue
+
+        print(f'Successfully parsed {len(plans)} plans')
+        return plans
+
+    except Exception as e:  # pylint: disable=broad-except
+        raise Exception(f'Error fetching data from Seeweb API: {e}') from e
+
+
+def create_catalog(api_key: str, output_path: str) -> None:
+    """Create Seeweb catalog by fetching data from API."""
+    plans = fetch_seeweb_data(api_key)
+
+    # Create CSV catalog
+    print(f'Writing catalog to {output_path}')
+    with open(output_path, mode='w', encoding='utf-8') as f:
+        writer = csv.writer(f, delimiter=',', quotechar='"')
+        writer.writerow([
+            'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs',
+            'MemoryGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+        ])
+
+        for plan in plans:
+            try:
+                gpu_info_str = ''
+                if plan['gpu_name'] and plan['gpu_count'] > 0:
+                    gpu_info_str = get_gpu_info(plan['gpu_count'],
+                                                plan['gpu_name'],
+                                                plan.get('gpu_vram_mb', 0))
+
+                # Handle regions - create a row for each available region
+                regions_available = plan['regions_available']
+                if isinstance(regions_available,
+                              list) and len(regions_available) > 0:
+                    # Create a row for each region
+                    for region in regions_available:
+                        writer.writerow([
+                            plan['plan_name'],  # InstanceType
+                            plan['gpu_name'],  # AcceleratorName (cleaned)
+                            plan['gpu_count'] if plan['gpu_count'] > 0 else
+                            '',  # AcceleratorCount
+                            plan['vcpus'],  # vCPUs
+                            plan['memory_gb'],  # MemoryGiB
+                            plan['price'],  # Price
+                            region,  # Region (single region per row)
+                            gpu_info_str,  # GpuInfo
+                            ''  # SpotPrice (Seeweb doesn't support spot)
+                        ])
+                else:
+                    # No regions available, create a row with empty region
+                    writer.writerow([
+                        plan['plan_name'],  # InstanceType
+                        plan['gpu_name'],  # AcceleratorName (cleaned)
+                        plan['gpu_count']
+                        if plan['gpu_count'] > 0 else '',  # AcceleratorCount
+                        plan['vcpus'],  # vCPUs
+                        plan['memory_gb'],  # MemoryGiB
+                        plan['price'],  # Price
+                        '',  # Region (empty)
+                        gpu_info_str,  # GpuInfo
+                        ''  # SpotPrice (Seeweb doesn't support spot)
+                    ])
+            except Exception as e:  # pylint: disable=broad-except
+                print(f'Error processing plan {plan["plan_name"]}: {e}')
+                continue
+
+    print(f'Seeweb catalog saved to {output_path}')
+    print(f'Created {len(plans)} instance types')
+
+
+def main() -> None:
+    """Main function to fetch and write Seeweb platform prices to a CSV file."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--api-key', help='Seeweb API key')
+    parser.add_argument('--api-key-path',
+                        help='Path to file containing Seeweb API key')
+    args = parser.parse_args()
+
+    # Get API key
+    if args.api_key:
+        api_key = args.api_key
+    else:
+        api_key = get_api_key(args.api_key_path)
+
+    os.makedirs('seeweb', exist_ok=True)
+    create_catalog(api_key, 'seeweb/vms.csv')
+    print('Seeweb Service Catalog saved to seeweb/vms.csv')
+
+
+if __name__ == '__main__':
+    main()

sky/catalog/data_fetchers/fetch_shadeform.py

@@ -0,0 +1,142 @@
+"""A script that generates the Shadeform catalog.
+
+Usage:
+    python fetch_shadeform.py [-h] [--api-key API_KEY]
+                               [--api-key-path API_KEY_PATH]
+
+If neither --api-key nor --api-key-path are provided, this script will parse
+`~/.shadeform/api_key` to look for Shadeform API key.
+"""
+import argparse
+import csv
+import json
+import os
+from typing import Dict
+
+import requests
+
+ENDPOINT = 'https://api.shadeform.ai/v1/instances/types'
+DEFAULT_SHADEFORM_API_KEY_PATH = os.path.expanduser('~/.shadeform/api_key')
+
+
+def parse_gpu_info(gpu_type: str, num_gpus: int, ram_per_gpu: int) -> Dict:
+    """Parse GPU information for the catalog."""
+
+    manufacturer = 'NVIDIA'
+    if gpu_type == 'MI300X':
+        manufacturer = 'AMD'
+    elif gpu_type == 'GAUDI2':
+        manufacturer = 'Intel'
+
+    return {
+        'Gpus': [{
+            'Name': gpu_type,
+            'Manufacturer': manufacturer,
+            'Count': float(num_gpus),
+            'MemoryInfo': {
+                'SizeInMiB': ram_per_gpu
+            },
+            'TotalGpuMemoryInMiB': ram_per_gpu * num_gpus
+        }]
+    }
+
+
+def create_catalog(api_key: str, output_path: str) -> None:
+    """Create Shadeform catalog by fetching from API."""
+    headers = {'X-API-KEY': api_key}
+
+    params = {'available': 'true'}
+
+    response = requests.get(ENDPOINT,
+                            headers=headers,
+                            params=params,
+                            timeout=30)
+    response.raise_for_status()
+
+    data = response.json()
+    instance_types = data.get('instance_types', [])
+
+    with open(output_path, mode='w', encoding='utf-8') as f:
+        writer = csv.writer(f, delimiter=',', quotechar='"')
+        writer.writerow([
+            'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs',
+            'MemoryGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+        ])
+
+        for instance in instance_types:
+            config = instance['configuration']
+
+            cloud = instance['cloud']
+            shade_instance_type = instance['shade_instance_type']
+            instance_type = f'{cloud}_{shade_instance_type.replace("_", "-")}'
+            gpu_type = config['gpu_type'].replace('_', '-')
+            gpu_count = float(config['num_gpus'])
+            vcpus = float(config['vcpus'])
+            memory_gb = int(config['memory_in_gb'])
+
+            # Append "B" to instance_type and gpu_type if they end with "G"
+            if instance_type.endswith('G'):
+                instance_type += 'B'
+            if gpu_type.endswith('G'):
+                gpu_type += 'B'
+
+            # Replace "Gx" with "GBx" (case sensitive)
+            if 'Gx' in instance_type:
+                instance_type = instance_type.replace('Gx', 'GBx')
+
+            # Price is in cents per hour, convert to dollars
+            price = float(instance['hourly_price']) / 100
+
+            # Create GPU info
+            gpuinfo = None
+            if gpu_count > 0:
+                gpuinfo_dict = parse_gpu_info(gpu_type, int(gpu_count),
+                                              int(config['vram_per_gpu_in_gb']))
+                gpuinfo = json.dumps(gpuinfo_dict).replace('"', '\'')
+
+            # Write entry for each available region
+            for availability in instance.get('availability', []):
+                if availability['available'] and gpu_count > 0:
+                    region = availability['region']
+                    writer.writerow([
+                        instance_type,
+                        gpu_type,
+                        gpu_count,
+                        vcpus,
+                        memory_gb,
+                        price,
+                        region,
+                        gpuinfo,
+                        ''  # No spot pricing info available
+                    ])
+
+
+def get_api_key(cmdline_args: argparse.Namespace) -> str:
+    """Get Shadeform API key from cmdline or default path."""
+    api_key = cmdline_args.api_key
+    if api_key is None:
+        if cmdline_args.api_key_path is not None:
+            with open(cmdline_args.api_key_path, mode='r',
+                      encoding='utf-8') as f:
+                api_key = f.read().strip()
+        else:
+            # Read from ~/.shadeform/api_key
+            with open(DEFAULT_SHADEFORM_API_KEY_PATH,
+                      mode='r',
+                      encoding='utf-8') as f:
+                api_key = f.read().strip()
+    assert api_key is not None, (
+        f'API key not found. Please provide via --api-key or place in '
+        f'{DEFAULT_SHADEFORM_API_KEY_PATH}')
+    return api_key
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--api-key', help='Shadeform API key.')
+    parser.add_argument('--api-key-path',
+                        help='path of file containing Shadeform API key.')
+    args = parser.parse_args()
+    os.makedirs('shadeform', exist_ok=True)
+    create_catalog(get_api_key(args), 'shadeform/vms.csv')
+    print('Shadeform catalog saved to shadeform/vms.csv')

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

@@ -2,7 +2,7 @@
 
 #
 # Due to the design of the sdk, pylint has a false
-# positive for the fnctions.
+# positive for the functions.
 #
 # pylint: disable=assignment-from-no-return
 import collections

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

@@ -6,7 +6,7 @@ import typing
 
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog.common import get_catalog_path
+from sky.catalog.common import get_catalog_path
 from sky.provision.vsphere.common.cls_api_client import ClsApiClient
 
 if typing.TYPE_CHECKING:

sky/{clouds/service_catalog → catalog}/do_catalog.py

@@ -7,7 +7,7 @@ query instance types and pricing information for digital ocean.
 import typing
 from typing import Dict, List, Optional, Tuple, Union
 
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
@@ -52,11 +52,14 @@ def get_default_instance_type(
     cpus: Optional[str] = None,
     memory: Optional[str] = None,
     disk_tier: Optional[str] = None,
+    region: Optional[str] = None,
+    zone: Optional[str] = None,
 ) -> Optional[str]:
     # NOTE: After expanding catalog to multiple entries, you may
     # want to specify a default instance type or family.
     del disk_tier  # unused
-    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory, region,
+                                                      zone)
 
 
 def get_accelerators_from_instance_type(

sky/{clouds/service_catalog → catalog}/fluidstack_catalog.py

@@ -6,7 +6,7 @@ instance types and pricing information for FluidStack.
 import typing
 from typing import Dict, List, Optional, Tuple, Union
 
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
@@ -52,7 +52,9 @@ def get_vcpus_mem_from_instance_type(
 
 def get_default_instance_type(cpus: Optional[str] = None,
                               memory: Optional[str] = None,
-                              disk_tier: Optional[str] = None) -> Optional[str]:
+                              disk_tier: Optional[str] = None,
+                              region: Optional[str] = None,
+                              zone: Optional[str] = None) -> Optional[str]:
     del disk_tier  # unused
     if cpus is None and memory is None:
         cpus = f'{_DEFAULT_NUM_VCPUS}+'
@@ -61,7 +63,8 @@ def get_default_instance_type(cpus: Optional[str] = None,
     else:
         memory_gb_or_ratio = memory
     return common.get_instance_type_for_cpus_mem_impl(_df, cpus,
-                                                      memory_gb_or_ratio)
+                                                      memory_gb_or_ratio,
+                                                      region, zone)
 
 
 def get_accelerators_from_instance_type(

sky/{clouds/service_catalog → catalog}/gcp_catalog.py

@@ -9,8 +9,8 @@ from typing import Dict, List, Optional, Tuple
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
+from sky.catalog import common
 from sky.clouds import GCP
-from sky.clouds.service_catalog import common
 from sky.utils import resources_utils
 from sky.utils import ux_utils
 
@@ -37,20 +37,37 @@ _image_df = common.read_catalog('gcp/images.csv',
 _quotas_df = common.read_catalog('gcp/accelerator_quota_mapping.csv',
                                  pull_frequency_hours=_PULL_FREQUENCY_HOURS)
 
-# We will select from the following three CPU instance families:
+# We will select from the following six CPU instance families:
 _DEFAULT_INSTANCE_FAMILY = [
-    # This is the latest general-purpose instance family as of Mar 2023.
-    # CPU: Intel Ice Lake 8373C or Cascade Lake 6268CL.
+    # This is a widely used general-purpose instance family as of July 2025.
+    # CPU: Primarily Intel Ice Lake (3rd Gen Intel Xeon Scalable Processors)
+    #  or Cascade Lake (2nd Gen Intel Xeon Scalable Processors).
     # Memory: 4 GiB RAM per 1 vCPU;
     'n2-standard',
-    # This is the latest memory-optimized instance family as of Mar 2023.
-    # CPU: Intel Ice Lake 8373C or Cascade Lake 6268CL.
+    # This is a memory-optimized instance family as of July 2025.
+    # CPU: Primarily Intel Ice Lake (3rd Gen Intel Xeon Scalable Processors)
+    # or Cascade Lake (2nd Gen Intel Xeon Scalable Processors).
     # Memory: 8 GiB RAM per 1 vCPU;
     'n2-highmem',
-    # This is the latest compute-optimized instance family as of Mar 2023.
-    # CPU: Intel Ice Lake 8373C or Cascade Lake 6268CL.
+    # This is a compute-optimized instance family as of July 2025.
+    # CPU: Primarily Intel Ice Lake (3rd Gen Intel Xeon Scalable Processors)
+    #  or Cascade Lake (2nd Gen Intel Xeon Scalable Processors).
     # Memory: 1 GiB RAM per 1 vCPU;
     'n2-highcpu',
+    # This is the latest general-purpose instance family as of July 2025.
+    # CPU: Intel 5th Gen Xeon Scalable processor (Emerald Rapids).
+    # Memory: 4 GiB RAM per 1 vCPU;
+    'n4-standard',
+    # This is the latest general-purpose instance family
+    # with a higher vCPU to memory ratio as of July 2025.
+    # CPU: Intel 5th Gen Xeon Scalable processor (Emerald Rapids).
+    # Memory: 2 GiB RAM per 1 vCPU;
+    'n4-highcpu',
+    # This is the latest general-purpose instance family
+    # with a lower vCPU to memory ratio as of July 2025.
+    # CPU: Intel 5th Gen Xeon Scalable processor (Emerald Rapids).
+    # Memory: 8 GiB RAM per 1 vCPU;
+    'n4-highmem',
 ]
 # n2 is not allowed for launching GPUs for now.
 _DEFAULT_HOST_VM_FAMILY = (
@@ -104,7 +121,13 @@ _ACC_INSTANCE_TYPE_DICTS = {
     },
     'H100-MEGA': {
         8: ['a3-megagpu-8g'],
-    }
+    },
+    'H200': {
+        8: ['a3-ultragpu-8g'],
+    },
+    'B200': {
+        8: ['a4-highgpu-8g'],
+    },
 }
 # Enable GPU type inference from instance types
 _INSTANCE_TYPE_TO_ACC = {
@@ -119,7 +142,7 @@ GCP_ACC_INSTANCE_TYPES = list(_INSTANCE_TYPE_TO_ACC.keys())
 
 # Number of CPU cores per GPU based on the AWS setting.
 # GCP A100 has its own instance type mapping.
-# Refer to sky/clouds/service_catalog/gcp_catalog.py
+# Refer to sky/clouds/catalog/gcp_catalog.py
 _NUM_ACC_TO_NUM_CPU = {
     # Based on p2 on AWS.
     'K80': {
@@ -256,10 +279,12 @@ def get_vcpus_mem_from_instance_type(
     return common.get_vcpus_mem_from_instance_type_impl(_df, instance_type)
 
 
-def get_default_instance_type(
-        cpus: Optional[str] = None,
-        memory: Optional[str] = None,
-        disk_tier: Optional[resources_utils.DiskTier] = None) -> Optional[str]:
+def get_default_instance_type(cpus: Optional[str] = None,
+                              memory: Optional[str] = None,
+                              disk_tier: Optional[
+                                  resources_utils.DiskTier] = None,
+                              region: Optional[str] = None,
+                              zone: Optional[str] = None) -> Optional[str]:
     if cpus is None and memory is None:
         cpus = f'{_DEFAULT_NUM_VCPUS}+'
     if memory is None:
@@ -277,7 +302,8 @@ def get_default_instance_type(
 
     df = df.loc[df['InstanceType'].apply(_filter_disk_type)]
     return common.get_instance_type_for_cpus_mem_impl(df, cpus,
-                                                      memory_gb_or_ratio)
+                                                      memory_gb_or_ratio,
+                                                      region, zone)
 
 
 def get_accelerators_from_instance_type(