skypilot-nightly 1.0.0.dev20250603__py3-none-any.whl → 1.0.0.dev20250604__py3-none-any.whl

sky/clouds/aws.py

@@ -10,14 +10,14 @@ import time
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky import exceptions
 from sky import provision as provision_lib
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import aws
-from sky.clouds import service_catalog
-from sky.clouds.service_catalog import common as catalog_common
+from sky.catalog import common as catalog_common
 from sky.clouds.utils import aws_utils
 from sky.skylet import constants
 from sky.utils import annotations
@@ -38,7 +38,7 @@ logger = sky_logging.init_logger(__name__)
 # Image ID tags
 _DEFAULT_CPU_IMAGE_ID = 'skypilot:custom-cpu-ubuntu'
 # For GPU-related package version,
-# see sky/clouds/service_catalog/images/provisioners/cuda.sh
+# see sky/catalog/images/provisioners/cuda.sh
 _DEFAULT_GPU_IMAGE_ID = 'skypilot:custom-gpu-ubuntu'
 _DEFAULT_GPU_K80_IMAGE_ID = 'skypilot:k80-ubuntu-2004'
 _DEFAULT_NEURON_IMAGE_ID = 'skypilot:neuron-ubuntu-2204'
@@ -201,7 +201,7 @@ class AWS(clouds.Cloud):
                               use_spot: bool, region: Optional[str],
                               zone: Optional[str]) -> List[clouds.Region]:
         del accelerators  # unused
-        regions = service_catalog.get_region_zones_for_instance_type(
+        regions = catalog.get_region_zones_for_instance_type(
             instance_type, use_spot, 'aws')
 
         if region is not None:
@@ -256,19 +256,20 @@ class AWS(clouds.Cloud):
     @classmethod
     def _get_default_ami(cls, region_name: str, instance_type: str) -> str:
         acc = cls.get_accelerators_from_instance_type(instance_type)
-        image_id = service_catalog.get_image_id_from_tag(_DEFAULT_CPU_IMAGE_ID,
-                                                         region_name,
-                                                         clouds='aws')
+        image_id = catalog.get_image_id_from_tag(_DEFAULT_CPU_IMAGE_ID,
+                                                 region_name,
+                                                 clouds='aws')
         if acc is not None:
-            image_id = service_catalog.get_image_id_from_tag(
-                _DEFAULT_GPU_IMAGE_ID, region_name, clouds='aws')
+            image_id = catalog.get_image_id_from_tag(_DEFAULT_GPU_IMAGE_ID,
+                                                     region_name,
+                                                     clouds='aws')
             assert len(acc) == 1, acc
             acc_name = list(acc.keys())[0]
             if acc_name == 'K80':
-                image_id = service_catalog.get_image_id_from_tag(
+                image_id = catalog.get_image_id_from_tag(
                     _DEFAULT_GPU_K80_IMAGE_ID, region_name, clouds='aws')
             if acc_name in ['Trainium', 'Inferentia']:
-                image_id = service_catalog.get_image_id_from_tag(
+                image_id = catalog.get_image_id_from_tag(
                     _DEFAULT_NEURON_IMAGE_ID, region_name, clouds='aws')
         if image_id is not None:
             return image_id
@@ -295,9 +296,9 @@ class AWS(clouds.Cloud):
             assert region_name in image_id, image_id
             image_id_str = image_id[region_name]
         if image_id_str.startswith('skypilot:'):
-            image_id_str = service_catalog.get_image_id_from_tag(image_id_str,
-                                                                 region_name,
-                                                                 clouds='aws')
+            image_id_str = catalog.get_image_id_from_tag(image_id_str,
+                                                         region_name,
+                                                         clouds='aws')
             if image_id_str is None:
                 # Raise ResourcesUnavailableError to make sure the failover
                 # in CloudVMRayBackend will be correctly triggered.
@@ -356,11 +357,11 @@ class AWS(clouds.Cloud):
                                      use_spot: bool,
                                      region: Optional[str] = None,
                                      zone: Optional[str] = None) -> float:
-        return service_catalog.get_hourly_cost(instance_type,
-                                               use_spot=use_spot,
-                                               region=region,
-                                               zone=zone,
-                                               clouds='aws')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='aws')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -403,10 +404,10 @@ class AWS(clouds.Cloud):
             memory: Optional[str] = None,
             disk_tier: Optional[resources_utils.DiskTier] = None
     ) -> Optional[str]:
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='aws')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='aws')
 
     # TODO: factor the following three methods, as they are the same logic
     # between Azure and AWS.
@@ -415,16 +416,16 @@ class AWS(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Optional[Dict[str, Union[int, float]]]:
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='aws')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='aws')
 
     @classmethod
     def get_vcpus_mem_from_instance_type(
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='aws')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='aws')
 
     def make_deploy_resources_variables(
             self,
@@ -548,16 +549,16 @@ class AWS(clouds.Cloud):
 
         assert len(accelerators) == 1, resources
         acc, acc_count = list(accelerators.items())[0]
-        (instance_list, fuzzy_candidate_list
-        ) = service_catalog.get_instance_type_for_accelerator(
-            acc,
-            acc_count,
-            use_spot=resources.use_spot,
-            cpus=resources.cpus,
-            memory=resources.memory,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='aws')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             memory=resources.memory,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='aws')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -671,7 +672,7 @@ class AWS(clouds.Cloud):
 
         # Fetch the AWS catalogs
         # pylint: disable=import-outside-toplevel
-        from sky.clouds.service_catalog import aws_catalog
+        from sky.catalog import aws_catalog
 
         # Trigger the fetch of the availability zones mapping.
         try:
@@ -924,7 +925,7 @@ class AWS(clouds.Cloud):
                 identity_type.can_credential_expire())
 
     def instance_type_exists(self, instance_type):
-        return service_catalog.instance_type_exists(instance_type, clouds='aws')
+        return catalog.instance_type_exists(instance_type, clouds='aws')
 
     @classmethod
     def _get_disk_type(cls, disk_tier: resources_utils.DiskTier) -> str:
@@ -980,7 +981,7 @@ class AWS(clouds.Cloud):
         use_spot = resources.use_spot
 
         # pylint: disable=import-outside-toplevel,unused-import
-        from sky.clouds.service_catalog import aws_catalog
+        from sky.catalog import aws_catalog
 
         quota_code = aws_catalog.get_quota_code(instance_type, use_spot)
 

sky/clouds/azure.py

@@ -9,12 +9,12 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 import colorama
 from packaging import version as pversion
 
+from sky import catalog
 from sky import clouds
 from sky import exceptions
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import azure
-from sky.clouds import service_catalog
 from sky.clouds.utils import azure_utils
 from sky.utils import annotations
 from sky.utils import common_utils
@@ -109,11 +109,11 @@ class Azure(clouds.Cloud):
                                      use_spot: bool,
                                      region: Optional[str] = None,
                                      zone: Optional[str] = None) -> float:
-        return service_catalog.get_hourly_cost(instance_type,
-                                               use_spot=use_spot,
-                                               region=region,
-                                               zone=zone,
-                                               clouds='azure')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='azure')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -156,17 +156,16 @@ class Azure(clouds.Cloud):
             memory: Optional[str] = None,
             disk_tier: Optional[resources_utils.DiskTier] = None
     ) -> Optional[str]:
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='azure')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='azure')
 
     @classmethod
     def get_image_size(cls, image_id: str, region: Optional[str]) -> float:
         # Process skypilot images.
         if image_id.startswith('skypilot:'):
-            image_id = service_catalog.get_image_id_from_tag(image_id,
-                                                             clouds='azure')
+            image_id = catalog.get_image_id_from_tag(image_id, clouds='azure')
             if image_id.startswith(_COMMUNITY_IMAGE_PREFIX):
                 # Avoid querying the image size from Azure as
                 # all skypilot custom images have the same size.
@@ -263,7 +262,7 @@ class Azure(clouds.Cloud):
                               zone: Optional[str]) -> List[clouds.Region]:
         del accelerators  # unused
         assert zone is None, 'Azure does not support zones'
-        regions = service_catalog.get_region_zones_for_instance_type(
+        regions = catalog.get_region_zones_for_instance_type(
             instance_type, use_spot, 'azure')
 
         if region is not None:
@@ -298,16 +297,16 @@ class Azure(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Optional[Dict[str, Union[int, float]]]:
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='azure')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='azure')
 
     @classmethod
     def get_vcpus_mem_from_instance_type(
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='azure')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='azure')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -338,7 +337,7 @@ class Azure(clouds.Cloud):
         if (resources.image_id is None or
                 resources.extract_docker_image() is not None):
             # pylint: disable=import-outside-toplevel
-            from sky.clouds.service_catalog import azure_catalog
+            from sky.catalog import azure_catalog
             gen_version = azure_catalog.get_gen_version_from_instance_type(
                 resources.instance_type)
             image_id = self._get_default_image_tag(gen_version,
@@ -352,8 +351,7 @@ class Azure(clouds.Cloud):
 
         # Checked basic image syntax in resources.py
         if image_id.startswith('skypilot:'):
-            image_id = service_catalog.get_image_id_from_tag(image_id,
-                                                             clouds='azure')
+            image_id = catalog.get_image_id_from_tag(image_id, clouds='azure')
             # Fallback if image does not exist in the specified region.
             # Putting fallback here instead of at image validation
             # when creating the resource because community images are
@@ -364,8 +362,8 @@ class Azure(clouds.Cloud):
             ) and region_name not in azure_catalog.COMMUNITY_IMAGE_AVAILABLE_REGIONS:
                 logger.info(f'Azure image {image_id} does not exist in region '
                             f'{region_name} so use the fallback image instead.')
-                image_id = service_catalog.get_image_id_from_tag(
-                    _FALLBACK_IMAGE_ID, clouds='azure')
+                image_id = catalog.get_image_id_from_tag(_FALLBACK_IMAGE_ID,
+                                                         clouds='azure')
 
         if image_id.startswith(_COMMUNITY_IMAGE_PREFIX):
             image_config = {'community_gallery_image_id': image_id}
@@ -501,16 +499,16 @@ class Azure(clouds.Cloud):
 
         assert len(accelerators) == 1, resources
         acc, acc_count = list(accelerators.items())[0]
-        (instance_list, fuzzy_candidate_list
-        ) = service_catalog.get_instance_type_for_accelerator(
-            acc,
-            acc_count,
-            cpus=resources.cpus,
-            memory=resources.memory,
-            use_spot=resources.use_spot,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='azure')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             cpus=resources.cpus,
+             memory=resources.memory,
+             use_spot=resources.use_spot,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='azure')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -591,8 +589,7 @@ class Azure(clouds.Cloud):
         }
 
     def instance_type_exists(self, instance_type):
-        return service_catalog.instance_type_exists(instance_type,
-                                                    clouds='azure')
+        return catalog.instance_type_exists(instance_type, clouds='azure')
 
     @classmethod
     @annotations.lru_cache(scope='global',

sky/clouds/cloud.py

@@ -16,9 +16,9 @@ from typing import (Any, Dict, Iterable, Iterator, List, Optional, Set, Tuple,
 
 from typing_extensions import assert_never
 
+from sky import catalog
 from sky import exceptions
 from sky import skypilot_config
-from sky.clouds import service_catalog
 from sky.utils import log_utils
 from sky.utils import resources_utils
 from sky.utils import timeline
@@ -188,7 +188,7 @@ class Cloud:
         """Returns the regions that offer the specified resources.
 
         The order of the regions follow the order of the regions returned by
-        service_catalog/common.py#get_region_zones().
+        sky/catalog/common.py#get_region_zones().
         When region or zone is not None, the returned value will be limited to
         the specified region/zone.
 
@@ -367,9 +367,9 @@ class Cloud:
     @classmethod
     def is_image_tag_valid(cls, image_tag: str, region: Optional[str]) -> bool:
         """Validates that the image tag is valid for this cloud."""
-        return service_catalog.is_image_tag_valid(image_tag,
-                                                  region,
-                                                  clouds=cls._REPR.lower())
+        return catalog.is_image_tag_valid(image_tag,
+                                          region,
+                                          clouds=cls._REPR.lower())
 
     @classmethod
     def is_label_valid(cls, label_key: str,
@@ -625,9 +625,9 @@ class Cloud:
         Raises:
             ValueError: If region or zone is invalid or not supported.
         """
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds=self._REPR.lower())
+        return catalog.validate_region_zone(region,
+                                            zone,
+                                            clouds=self._REPR.lower())
 
     def need_cleanup_after_preemption_or_failure(
             self, resources: 'resources_lib.Resources') -> bool:

sky/clouds/cudo.py

@@ -3,8 +3,8 @@ import subprocess
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
-from sky.clouds import service_catalog
 from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -110,7 +110,7 @@ class Cudo(clouds.Cloud):
         if use_spot:
             return []
 
-        regions = service_catalog.get_region_zones_for_instance_type(
+        regions = catalog.get_region_zones_for_instance_type(
             instance_type, use_spot, 'cudo')
 
         if region is not None:
@@ -123,8 +123,8 @@ class Cudo(clouds.Cloud):
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
 
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='cudo')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='cudo')
 
     @classmethod
     def zones_provision_loop(
@@ -151,11 +151,11 @@ class Cudo(clouds.Cloud):
                                      use_spot: bool,
                                      region: Optional[str] = None,
                                      zone: Optional[str] = None) -> float:
-        return service_catalog.get_hourly_cost(instance_type,
-                                               use_spot=use_spot,
-                                               region=region,
-                                               zone=zone,
-                                               clouds='cudo')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='cudo')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -177,17 +177,17 @@ class Cudo(clouds.Cloud):
             memory: Optional[str] = None,
             disk_tier: Optional[resources_utils.DiskTier] = None
     ) -> Optional[str]:
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         clouds='cudo')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 clouds='cudo')
 
     @classmethod
     def get_accelerators_from_instance_type(
         cls,
         instance_type: str,
     ) -> Optional[Dict[str, Union[int, float]]]:
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='cudo')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='cudo')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -255,16 +255,16 @@ class Cudo(clouds.Cloud):
 
         assert len(accelerators) == 1, resources
         acc, acc_count = list(accelerators.items())[0]
-        (instance_list, fuzzy_candidate_list
-        ) = service_catalog.get_instance_type_for_accelerator(
-            acc,
-            acc_count,
-            use_spot=resources.use_spot,
-            cpus=resources.cpus,
-            memory=resources.memory,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='cudo')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             memory=resources.memory,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='cudo')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -338,7 +338,7 @@ class Cudo(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'cudo')
+        return catalog.instance_type_exists(instance_type, 'cudo')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region, zone, clouds='cudo')
+        return catalog.validate_region_zone(region, zone, clouds='cudo')

sky/clouds/do.py

@@ -5,9 +5,9 @@ import os
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky.adaptors import do
-from sky.clouds import service_catalog
 from sky.provision.do import utils as do_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -84,7 +84,7 @@ class DO(clouds.Cloud):
         del accelerators, zone  # unused
         if use_spot:
             return []
-        regions = service_catalog.get_region_zones_for_instance_type(
+        regions = catalog.get_region_zones_for_instance_type(
             instance_type, use_spot, 'DO')
         if region is not None:
             regions = [r for r in regions if r.name == region]
@@ -95,8 +95,8 @@ class DO(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='DO')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='DO')
 
     @classmethod
     def zones_provision_loop(
@@ -125,7 +125,7 @@ class DO(clouds.Cloud):
         region: Optional[str] = None,
         zone: Optional[str] = None,
     ) -> float:
-        return service_catalog.get_hourly_cost(
+        return catalog.get_hourly_cost(
             instance_type,
             use_spot=use_spot,
             region=region,
@@ -159,16 +159,16 @@ class DO(clouds.Cloud):
         disk_tier: Optional[resources_utils.DiskTier] = None,
     ) -> Optional[str]:
         """Returns the default instance type for DO."""
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='DO')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='DO')
 
     @classmethod
     def get_accelerators_from_instance_type(
             cls, instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='DO')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='DO')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -249,17 +249,17 @@ class DO(clouds.Cloud):
 
         assert len(accelerators) == 1, resources
         acc, acc_count = list(accelerators.items())[0]
-        (instance_list, fuzzy_candidate_list) = (
-            service_catalog.get_instance_type_for_accelerator(
-                acc,
-                acc_count,
-                use_spot=resources.use_spot,
-                cpus=resources.cpus,
-                memory=resources.memory,
-                region=resources.region,
-                zone=resources.zone,
-                clouds='DO',
-            ))
+        (instance_list,
+         fuzzy_candidate_list) = (catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             memory=resources.memory,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='DO',
+         ))
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -316,7 +316,7 @@ class DO(clouds.Cloud):
                 f'No image_id `{image_id}` found') from err
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'DO')
+        return catalog.instance_type_exists(instance_type, 'DO')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region, zone, clouds='DO')
+        return catalog.validate_region_zone(region, zone, clouds='DO')