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

sky/backends/docker_utils.py

@@ -168,7 +168,7 @@ def build_dockerimage(task: task_mod.Task,
                                         build_dir=temp_dir)
 
     dst = os.path.join(temp_dir, SKY_DOCKER_WORKDIR)
-    if task.workdir is not None:
+    if task.workdir is not None and isinstance(task.workdir, str):
         # Copy workdir contents to tempdir
         shutil.copytree(os.path.expanduser(task.workdir), dst)
     else:

sky/backends/local_docker_backend.py

@@ -178,7 +178,8 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
         return handle, False
 
     def _sync_workdir(self, handle: LocalDockerResourceHandle,
-                      workdir: Path) -> None:
+                      workdir: Union[Path, Dict[str, Any]],
+                      envs_and_secrets: Dict[str, str]) -> None:
         """Workdir is sync'd by adding to the docker image.
 
         This happens in the execute step.
@@ -188,6 +189,15 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
                     ' a NoOp. If you are running sky exec, your workdir has not'
                     ' been updated.')
 
+    def _download_file(self, handle: LocalDockerResourceHandle,
+                       local_file_path: str, remote_file_path: str) -> None:
+        """Syncs file from remote to local."""
+        # Copy from docker container to local
+        container = self.containers[handle]
+        copy_cmd = (
+            f'docker cp {container.name}:{remote_file_path} {local_file_path}')
+        subprocess.run(copy_cmd, shell=True, check=True)
+
     def _sync_file_mounts(
         self,
         handle: LocalDockerResourceHandle,
@@ -273,13 +283,8 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
     def _execute(self,
                  handle: LocalDockerResourceHandle,
                  task: 'task_lib.Task',
-                 detach_run: bool,
                  dryrun: bool = False) -> None:
         """ Launches the container."""
-        if detach_run:
-            raise NotImplementedError('detach_run=True is not supported in '
-                                      'LocalDockerBackend.')
-
         if task.num_nodes > 1:
             raise NotImplementedError(
                 'Tasks with num_nodes > 1 is currently not supported in '

sky/backends/wheel_utils.py

@@ -16,6 +16,7 @@ import pathlib
 import re
 import shutil
 import subprocess
+import sys
 import tempfile
 from typing import Optional, Tuple
 
@@ -27,13 +28,14 @@ import sky
 from sky import sky_logging
 from sky.backends import backend_utils
 from sky.server import common
+from sky.utils import directory_utils
 
 logger = sky_logging.init_logger(__name__)
 
 # Local wheel path is same as the remote path.
 WHEEL_DIR = pathlib.Path(os.path.expanduser(backend_utils.SKY_REMOTE_PATH))
 _WHEEL_LOCK_PATH = WHEEL_DIR.parent / '.wheels_lock'
-SKY_PACKAGE_PATH = pathlib.Path(sky.__file__).parent.parent / 'sky'
+SKY_PACKAGE_PATH = pathlib.Path(directory_utils.get_sky_dir())
 
 # NOTE: keep the same as setup.py's setuptools.setup(name=..., ...).
 _PACKAGE_WHEEL_NAME = 'skypilot'
@@ -132,19 +134,45 @@ def _build_sky_wheel() -> pathlib.Path:
         # It is important to normalize the path, otherwise 'pip wheel' would
         # treat the directory as a file and generate an empty wheel.
         norm_path = str(tmp_dir) + os.sep
+        # TODO(#5046): Consider adding native UV support for building wheels.
+        # Use `python -m pip` instead of `pip3` for better compatibility across
+        # different environments (conda, venv, UV, system Python, etc.)
         try:
-            # TODO(suquark): For python>=3.7, 'subprocess.run' supports capture
-            # of the output.
             subprocess.run([
-                'pip3', 'wheel', '--no-deps', norm_path, '--wheel-dir',
+                sys.executable, '-m', 'pip', 'wheel', '--no-deps', norm_path,
+                '--wheel-dir',
                 str(tmp_dir)
             ],
-                           stdout=subprocess.DEVNULL,
-                           stderr=subprocess.PIPE,
-                           check=True)
+                           capture_output=True,
+                           check=True,
+                           text=True)
         except subprocess.CalledProcessError as e:
-            raise RuntimeError('Failed to build pip wheel for SkyPilot. '
-                               f'Error message: {e.stderr.decode()}') from e
+            error_msg = e.stderr
+            if 'No module named pip' in error_msg:
+                # pip module not found - provide helpful suggestions based on
+                # the available package managers
+                if shutil.which('uv'):
+                    msg = ('pip module not found. Since you have UV installed, '
+                           'you can install pip by running:\n'
+                           '  uv pip install pip')
+                elif shutil.which('conda'):
+                    msg = (
+                        'pip module not found. Since you have conda installed, '
+                        'you can install pip by running:\n'
+                        '  conda install pip')
+                else:
+                    msg = ('pip module not found. Please install pip for your '
+                           f'Python environment ({sys.executable}).')
+            else:
+                # Other pip errors
+                msg = f'pip wheel command failed. Error: {error_msg}'
+            raise RuntimeError('Failed to build pip wheel for SkyPilot.\n' +
+                               msg) from e
+        except FileNotFoundError as e:
+            # Python executable not found (extremely rare)
+            raise RuntimeError(
+                f'Failed to build pip wheel for SkyPilot. '
+                f'Python executable not found: {sys.executable}') from e
 
         try:
             wheel_path = next(tmp_dir.glob(_WHEEL_PATTERN))

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

@@ -4,24 +4,21 @@ import importlib
 import typing
 from typing import Dict, List, Optional, Set, Tuple, Union
 
-from sky.clouds.service_catalog.config import fallback_to_default_catalog
-from sky.clouds.service_catalog.constants import ALL_CLOUDS
-from sky.clouds.service_catalog.constants import CATALOG_DIR
-from sky.clouds.service_catalog.constants import CATALOG_SCHEMA_VERSION
-from sky.clouds.service_catalog.constants import HOSTED_CATALOG_DIR_URL
+from sky.catalog.config import fallback_to_default_catalog
+from sky.skylet import constants
 from sky.utils import resources_utils
 from sky.utils import subprocess_utils
 
 if typing.TYPE_CHECKING:
+    from sky.catalog import common
     from sky.clouds import cloud
-    from sky.clouds.service_catalog import common
 
 CloudFilter = Optional[Union[List[str], str]]
 
 
 def _map_clouds_catalog(clouds: CloudFilter, method_name: str, *args, **kwargs):
     if clouds is None:
-        clouds = list(ALL_CLOUDS)
+        clouds = list(constants.ALL_CLOUDS)
 
         # TODO(hemil): Remove this once the common service catalog
         # functions are refactored from clouds/kubernetes.py to
@@ -35,10 +32,10 @@ def _map_clouds_catalog(clouds: CloudFilter, method_name: str, *args, **kwargs):
     def _execute_catalog_method(cloud: str):
         try:
             cloud_module = importlib.import_module(
-                f'sky.clouds.service_catalog.{cloud.lower()}_catalog')
+                f'sky.catalog.{cloud.lower()}_catalog')
         except ModuleNotFoundError:
             raise ValueError(
-                'Cannot find module "sky.clouds.service_catalog'
+                'Cannot find module "sky.catalog'
                 f'.{cloud}_catalog" for cloud "{cloud}".') from None
         try:
             method = getattr(cloud_module, method_name)
@@ -94,7 +91,7 @@ def list_accelerator_counts(
     region_filter: Optional[str] = None,
     quantity_filter: Optional[int] = None,
     clouds: CloudFilter = None,
-) -> Dict[str, List[int]]:
+) -> Dict[str, List[float]]:
     """Lists all accelerators offered by Sky and available counts.
 
     Returns: A dictionary of canonical accelerator names mapped to a list
@@ -110,12 +107,12 @@ def list_accelerator_counts(
                                   require_price=False)
     if not isinstance(results, list):
         results = [results]
-    accelerator_counts: Dict[str, Set[int]] = collections.defaultdict(set)
+    accelerator_counts: Dict[str, Set[float]] = collections.defaultdict(set)
     for result in results:
         for gpu, items in result.items():
             for item in items:
                 accelerator_counts[gpu].add(item.accelerator_count)
-    ret: Dict[str, List[int]] = {}
+    ret: Dict[str, List[float]] = {}
     for gpu, counts in accelerator_counts.items():
         ret[gpu] = sorted(counts)
     return ret
@@ -224,6 +221,8 @@ 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,
                               clouds: CloudFilter = None) -> Optional[str]:
     """Returns the cloud's default instance type for given #vCPUs and memory.
 
@@ -237,7 +236,7 @@ def get_default_instance_type(cpus: Optional[str] = None,
     the given CPU and memory requirement.
     """
     return _map_clouds_catalog(clouds, 'get_default_instance_type', cpus,
-                               memory, disk_tier)
+                               memory, disk_tier, region, zone)
 
 
 def get_accelerators_from_instance_type(
@@ -248,9 +247,16 @@ def get_accelerators_from_instance_type(
                                instance_type)
 
 
+def get_arch_from_instance_type(instance_type: str,
+                                clouds: CloudFilter = None) -> Optional[str]:
+    """Returns the arch from a instance type."""
+    return _map_clouds_catalog(clouds, 'get_arch_from_instance_type',
+                               instance_type)
+
+
 def get_instance_type_for_accelerator(
     acc_name: str,
-    acc_count: int,
+    acc_count: Union[int, float],
     cpus: Optional[str] = None,
     memory: Optional[str] = None,
     use_spot: bool = False,
@@ -327,6 +333,7 @@ def get_common_gpus() -> List[str]:
         'A10G',
         'A100',
         'A100-80GB',
+        'B200',
         'H100',
         'H200',
         'L4',
@@ -380,9 +387,4 @@ __all__ = [
     'is_image_tag_valid',
     # Configuration
     'fallback_to_default_catalog',
-    # Constants
-    'ALL_CLOUDS',
-    'HOSTED_CATALOG_DIR_URL',
-    'CATALOG_SCHEMA_VERSION',
-    'CATALOG_DIR',
 ]

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

@@ -13,10 +13,10 @@ from typing import Dict, List, Optional, Tuple, Union
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
+from sky.catalog import common
+from sky.catalog import config
+from sky.catalog.data_fetchers import fetch_aws
 from sky.clouds import aws
-from sky.clouds.service_catalog import common
-from sky.clouds.service_catalog import config
-from sky.clouds.service_catalog.data_fetchers import fetch_aws
 from sky.utils import common_utils
 from sky.utils import resources_utils
 from sky.utils import rich_utils
@@ -38,14 +38,26 @@ _DEFAULT_INSTANCE_FAMILY = [
     # CPU: Intel Ice Lake 8375C.
     # Memory: 4 GiB RAM per 1 vCPU;
     'm6i',
+    # This is the latest general-purpose instance family as of Jul 2025.
+    # CPU: Intel Sapphire Rapids.
+    # Memory: 4 GiB RAM per 1 vCPU;
+    'm7i',
     # This is the latest memory-optimized instance family as of Mar 2023.
     # CPU: Intel Ice Lake 8375C
     # Memory: 8 GiB RAM per 1 vCPU;
     'r6i',
+    # This is the latest memory-optimized instance family as of Jul 2025.
+    # CPU: Intel Sapphire Rapids.
+    # Memory: 8 GiB RAM per 1 vCPU;
+    'r7i',
     # This is the latest compute-optimized instance family as of Mar 2023.
     # CPU: Intel Ice Lake 8375C
     # Memory: 2 GiB RAM per 1 vCPU;
     'c6i',
+    # This is the latest compute-optimized instance family as of Jul 2025.
+    # CPU: Intel Sapphire Rapids.
+    # Memory: 2 GiB RAM per 1 vCPU;
+    'c7i',
 ]
 _DEFAULT_NUM_VCPUS = 8
 _DEFAULT_MEMORY_CPU_RATIO = 4
@@ -230,10 +242,12 @@ def get_vcpus_mem_from_instance_type(
                                                         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]:
     del disk_tier  # unused
     if cpus is None and memory is None:
         cpus = f'{_DEFAULT_NUM_VCPUS}+'
@@ -247,7 +261,8 @@ def get_default_instance_type(
     df = _get_df()
     df = df[df['InstanceType'].str.startswith(instance_type_prefix)]
     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(
@@ -256,6 +271,10 @@ def get_accelerators_from_instance_type(
         _get_df(), instance_type)
 
 
+def get_arch_from_instance_type(instance_type: str) -> Optional[str]:
+    return common.get_arch_from_instance_type_impl(_get_df(), instance_type)
+
+
 def get_instance_type_for_accelerator(
     acc_name: str,
     acc_count: int,

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

@@ -8,8 +8,8 @@ from typing import Dict, List, Optional, Tuple, Union
 
 from sky import clouds as cloud_lib
 from sky import sky_logging
+from sky.catalog import common
 from sky.clouds import Azure
-from sky.clouds.service_catalog import common
 from sky.utils import resources_utils
 from sky.utils import ux_utils
 
@@ -17,7 +17,7 @@ logger = sky_logging.init_logger(__name__)
 
 # This list should match the list of regions in
 # skypilot image generation Packer script's replication_regions
-# sky/clouds/service_catalog/images/skypilot-azure-cpu-ubuntu.pkr.hcl
+# sky/clouds/catalog/images/skypilot-azure-cpu-ubuntu.pkr.hcl
 COMMUNITY_IMAGE_AVAILABLE_REGIONS = {
     'centralus',
     'eastus',
@@ -114,10 +114,12 @@ def _get_instance_family(instance_type: str) -> str:
     return instance_family
 
 
-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:
@@ -133,7 +135,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(

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

@@ -12,7 +12,8 @@ import filelock
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.clouds import cloud as cloud_lib
-from sky.clouds.service_catalog import constants
+from sky.skylet import constants
+from sky.utils import annotations
 from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import rich_utils
@@ -50,7 +51,7 @@ class InstanceTypeInfo(NamedTuple):
     cloud: str
     instance_type: Optional[str]
     accelerator_name: str
-    accelerator_count: int
+    accelerator_count: float
     cpu_count: Optional[float]
     device_memory: Optional[float]
     memory: Optional[float]
@@ -125,17 +126,21 @@ class LazyDataFrame:
 
     We don't need to load the catalog for every SkyPilot call, and this class
     allows us to load the catalog only when needed.
+
+    Use update_if_stale_func to pass in a function that decides whether to
+    update the catalog on disk, updates it if needed, and returns
+    a bool indicating whether the update was done.
     """
 
-    def __init__(self, filename: str, update_func: Callable[[], None]):
+    def __init__(self, filename: str, update_if_stale_func: Callable[[], bool]):
         self._filename = filename
         self._df: Optional['pd.DataFrame'] = None
-        self._update_func = update_func
+        self._update_if_stale_func = update_if_stale_func
 
+    @annotations.lru_cache(scope='request')
     def _load_df(self) -> 'pd.DataFrame':
-        if self._df is None:
+        if self._update_if_stale_func() or 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.
@@ -193,48 +198,60 @@ def read_catalog(filename: str,
         return last_update + pull_frequency_hours * 3600 < time.time()
 
     def _update_catalog():
+        # Fast path: Exit early to avoid lock contention.
+        if not _need_update():
+            return False
+
         # 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
+            # Double check after acquiring the lock.
+            if not _need_update():
+                return False
+
+            url = f'{constants.HOSTED_CATALOG_DIR_URL}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
+            url_fallback = f'{constants.HOSTED_CATALOG_DIR_URL_S3_MIRROR}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
+            headers = {'User-Agent': 'SkyPilot/0.7'}
+            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=headers)
+                    if r.status_code == 429:
+                        # fallback to s3 mirror, github introduced rate
+                        # limit after 2025-05, see
+                        # https://github.com/skypilot-org/skypilot/issues/5438
+                        # for more details
+                        r = requests.get(url=url_fallback, headers=headers)
+                    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:
-                        # 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}.')
+                        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())
+            logger.debug(f'Updated {cloud} catalog {filename}.')
+        return True
 
-    return LazyDataFrame(catalog_path, update_func=_update_catalog)
+    return LazyDataFrame(catalog_path, update_if_stale_func=_update_catalog)
 
 
 def _get_instance_type(
@@ -337,7 +354,7 @@ def get_hourly_cost_impl(
 ) -> float:
     """Returns the hourly price of a VM instance in the given region and zone.
 
-    Refer to get_hourly_cost in service_catalog/__init__.py for the docstring.
+    Refer to get_hourly_cost in catalog/__init__.py for the docstring.
     """
     df = _get_instance_type(df, instance_type, region, zone)
     if df.empty:
@@ -459,8 +476,11 @@ def _filter_region_zone(df: 'pd.DataFrame', region: Optional[str],
 
 
 def get_instance_type_for_cpus_mem_impl(
-        df: 'pd.DataFrame', cpus: Optional[str],
-        memory_gb_or_ratio: Optional[str]) -> Optional[str]:
+        df: 'pd.DataFrame',
+        cpus: Optional[str],
+        memory_gb_or_ratio: Optional[str],
+        region: Optional[str] = None,
+        zone: Optional[str] = None) -> Optional[str]:
     """Returns the cheapest instance type that satisfies the requirements.
 
     Args:
@@ -473,7 +493,10 @@ def get_instance_type_for_cpus_mem_impl(
             returned instance type should have at least the given memory size.
             If the string ends with "x", then the returned instance type should
             have at least the given number of vCPUs times the given ratio.
+        region: The region to filter by.
+        zone: The zone to filter by.
     """
+    df = _filter_region_zone(df, region, zone)
     df = _filter_with_cpus(df, cpus)
     df = _filter_with_mem(df, memory_gb_or_ratio)
     if df.empty:
@@ -504,6 +527,24 @@ def get_accelerators_from_instance_type_impl(
     return {acc_name: _convert(acc_count)}
 
 
+def get_arch_from_instance_type_impl(
+    df: 'pd.DataFrame',
+    instance_type: str,
+) -> Optional[str]:
+    df = _get_instance_type(df, instance_type, None)
+    if df.empty:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'No instance type {instance_type} found.')
+    row = df.iloc[0]
+    if 'Arch' not in row:
+        return None
+    arch = row['Arch']
+    if pd.isnull(arch):
+        return None
+
+    return arch
+
+
 def get_instance_type_for_accelerator_impl(
     df: 'pd.DataFrame',
     acc_name: str,
@@ -608,7 +649,7 @@ def list_accelerators_impl(
         df = df[df['Region'].str.contains(region_filter,
                                           case=case_sensitive,
                                           regex=True)]
-    df['AcceleratorCount'] = df['AcceleratorCount'].astype(int)
+    df['AcceleratorCount'] = df['AcceleratorCount'].astype(float)
     if quantity_filter is not None:
         df = df[df['AcceleratorCount'] == quantity_filter]
     grouped = df.groupby('AcceleratorName')

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

@@ -3,14 +3,14 @@
 import typing
 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
+from sky.catalog import common
+from sky.provision.cudo import cudo_machine_type as cudo_mt
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
     from sky.clouds import cloud
 
-_PULL_FREQUENCY_HOURS = 1
+_PULL_FREQUENCY_HOURS = 7
 _df = common.read_catalog(cudo_mt.VMS_CSV,
                           pull_frequency_hours=_PULL_FREQUENCY_HOURS)
 
@@ -51,7 +51,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
     # NOTE: After expanding catalog to multiple entries, you may
     # want to specify a default instance type or family.
@@ -62,7 +64,8 @@ def get_default_instance_type(cpus: Optional[str] = None,
     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)
+                                                      memory_gb_or_ratio,
+                                                      region, zone)
 
 
 def get_accelerators_from_instance_type(

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

@@ -3,7 +3,7 @@ import typing
 from typing import List
 
 from sky.adaptors import common as adaptors_common
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 
 if typing.TYPE_CHECKING:
     import pandas as pd