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

sky/clouds/fluidstack.py

@@ -3,9 +3,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 common as adaptors_common
-from sky.clouds import service_catalog
 from sky.provision.fluidstack import fluidstack_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -96,7 +96,7 @@ class Fluidstack(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, 'fluidstack')
 
         if region is not None:
@@ -128,11 +128,11 @@ class Fluidstack(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='fluidstack')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='fluidstack')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -155,26 +155,26 @@ class Fluidstack(clouds.Cloud):
             cpus: Optional[str] = None,
             memory: Optional[str] = None,
             disk_tier: Optional[DiskTier] = None) -> Optional[str]:
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='fluidstack')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='fluidstack')
 
     @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='fluidstack')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='fluidstack')
 
     @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='fluidstack')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='fluidstack')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -247,16 +247,16 @@ class Fluidstack(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='fluidstack')
+        (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='fluidstack')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -306,12 +306,10 @@ class Fluidstack(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'fluidstack')
+        return catalog.instance_type_exists(instance_type, 'fluidstack')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds='fluidstack')
+        return catalog.validate_region_zone(region, zone, clouds='fluidstack')
 
     @classmethod
     def query_status(

sky/clouds/gcp.py

@@ -10,12 +10,12 @@ from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union
 
 import colorama
 
+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 gcp
-from sky.clouds import service_catalog
 from sky.clouds.utils import gcp_utils
 from sky.provision.gcp import constants
 from sky.provision.gcp import volume_utils
@@ -111,7 +111,7 @@ _IMAGE_NOT_FOUND_UX_MESSAGE = (
 
 # Image ID tags
 _DEFAULT_CPU_IMAGE_ID = 'skypilot:custom-cpu-ubuntu-2204'
-# For GPU-related package version, see sky/clouds/service_catalog/images/provisioners/cuda.sh
+# For GPU-related package version, see sky/clouds/catalog/images/provisioners/cuda.sh
 _DEFAULT_GPU_IMAGE_ID = 'skypilot:custom-gpu-ubuntu-2204'
 _DEFAULT_GPU_K80_IMAGE_ID = 'skypilot:k80-debian-10'
 # Use COS image with GPU Direct support.
@@ -258,20 +258,21 @@ class GCP(clouds.Cloud):
                               use_spot: bool, region: Optional[str],
                               zone: Optional[str]) -> List[clouds.Region]:
         if accelerators is None:
-            regions = service_catalog.get_region_zones_for_instance_type(
-                instance_type, use_spot, clouds='gcp')
+            regions = catalog.get_region_zones_for_instance_type(instance_type,
+                                                                 use_spot,
+                                                                 clouds='gcp')
         else:
             assert len(accelerators) == 1, accelerators
             acc = list(accelerators.keys())[0]
             acc_count = list(accelerators.values())[0]
-            acc_regions = service_catalog.get_region_zones_for_accelerators(
+            acc_regions = catalog.get_region_zones_for_accelerators(
                 acc, acc_count, use_spot, clouds='gcp')
             if instance_type is None:
                 regions = acc_regions
             elif instance_type == 'TPU-VM':
                 regions = acc_regions
             else:
-                vm_regions = service_catalog.get_region_zones_for_instance_type(
+                vm_regions = catalog.get_region_zones_for_instance_type(
                     instance_type, use_spot, clouds='gcp')
                 # Find the intersection between `acc_regions` and `vm_regions`.
                 regions = []
@@ -341,11 +342,11 @@ class GCP(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='gcp')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='gcp')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -354,12 +355,12 @@ class GCP(clouds.Cloud):
                                     zone: Optional[str] = None) -> float:
         assert len(accelerators) == 1, accelerators
         acc, acc_count = list(accelerators.items())[0]
-        return service_catalog.get_accelerator_hourly_cost(acc,
-                                                           acc_count,
-                                                           use_spot=use_spot,
-                                                           region=region,
-                                                           zone=zone,
-                                                           clouds='gcp')
+        return catalog.get_accelerator_hourly_cost(acc,
+                                                   acc_count,
+                                                   use_spot=use_spot,
+                                                   region=region,
+                                                   zone=zone,
+                                                   clouds='gcp')
 
     def get_egress_cost(self, num_gigabytes: float):
         # In general, query this from the cloud:
@@ -439,10 +440,10 @@ class GCP(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='gcp')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='gcp')
 
     @classmethod
     def failover_disk_tier(
@@ -563,8 +564,7 @@ class GCP(clouds.Cloud):
                 assert region_name in resources.image_id, resources.image_id
                 image_id = resources.image_id[region_name]
         if image_id.startswith('skypilot:'):
-            image_id = service_catalog.get_image_id_from_tag(image_id,
-                                                             clouds='gcp')
+            image_id = catalog.get_image_id_from_tag(image_id, clouds='gcp')
 
         assert image_id is not None, (image_id, r)
         resources_vars['image_id'] = image_id
@@ -689,16 +689,16 @@ class GCP(clouds.Cloud):
 
         # For TPU VMs, the instance type is fixed to 'TPU-VM'. However, we still
         # need to call the below function to get the fuzzy candidate list.
-        (instance_list, fuzzy_candidate_list
-        ) = service_catalog.get_instance_type_for_accelerator(
-            acc,
-            acc_count,
-            cpus=resources.cpus if not use_tpu_vm else None,
-            memory=resources.memory if not use_tpu_vm else None,
-            use_spot=resources.use_spot,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='gcp')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             cpus=resources.cpus if not use_tpu_vm else None,
+             memory=resources.memory if not use_tpu_vm else None,
+             use_spot=resources.use_spot,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='gcp')
 
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
@@ -765,16 +765,16 @@ class GCP(clouds.Cloud):
         # GCP handles accelerators separately from regular instance types.
         # This method supports automatically inferring the GPU type for
         # the instance type that come with GPUs pre-attached.
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='gcp')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='gcp')
 
     @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='gcp')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='gcp')
 
     @classmethod
     def _find_application_key_path(cls) -> str:
@@ -1058,7 +1058,7 @@ class GCP(clouds.Cloud):
         return user_identity[0].replace('\n', '')
 
     def instance_type_exists(self, instance_type):
-        return service_catalog.instance_type_exists(instance_type, 'gcp')
+        return catalog.instance_type_exists(instance_type, 'gcp')
 
     def need_cleanup_after_preemption_or_failure(
             self, resources: 'resources.Resources') -> bool:
@@ -1093,9 +1093,9 @@ class GCP(clouds.Cloud):
     def _check_instance_type_accelerators_combination(
             resources: 'resources.Resources') -> None:
         resources = resources.assert_launchable()
-        service_catalog.check_accelerator_attachable_to_host(
-            resources.instance_type, resources.accelerators, resources.zone,
-            'gcp')
+        catalog.check_accelerator_attachable_to_host(resources.instance_type,
+                                                     resources.accelerators,
+                                                     resources.zone, 'gcp')
 
     @classmethod
     def check_disk_tier(
@@ -1322,7 +1322,7 @@ class GCP(clouds.Cloud):
         region = resources.region
 
         # pylint: disable=import-outside-toplevel
-        from sky.clouds.service_catalog import gcp_catalog
+        from sky.catalog import gcp_catalog
 
         quota_code = gcp_catalog.get_quota_code(accelerator, use_spot)
 

sky/clouds/ibm.py

@@ -5,11 +5,11 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import colorama
 
+from sky import catalog
 from sky import clouds
 from sky import sky_logging
 from sky.adaptors import ibm
 from sky.adaptors.ibm import CREDENTIAL_FILE
-from sky.clouds import service_catalog
 from sky.utils import registry
 from sky.utils import resources_utils
 from sky.utils import status_lib
@@ -71,7 +71,7 @@ class IBM(clouds.Cloud):
         del accelerators  # 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, 'ibm')
 
         if region is not None:
@@ -131,11 +131,11 @@ class IBM(clouds.Cloud):
                                      zone: Optional[str] = None) -> float:
         # Currently doesn't support spot instances, hence use_spot set to False.
         del use_spot
-        return service_catalog.get_hourly_cost(instance_type,
-                                               use_spot=False,
-                                               region=region,
-                                               zone=zone,
-                                               clouds='ibm')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=False,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='ibm')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -243,8 +243,8 @@ class IBM(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='ibm')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='ibm')
 
     @classmethod
     def get_accelerators_from_instance_type(
@@ -252,8 +252,8 @@ class IBM(clouds.Cloud):
         instance_type: str,
     ) -> Optional[Dict[str, Union[int, float]]]:
         """Returns {acc: acc_count} held by 'instance_type', if any."""
-        return service_catalog.get_accelerators_from_instance_type(
-            instance_type, clouds='ibm')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='ibm')
 
     @classmethod
     def get_default_instance_type(
@@ -262,10 +262,10 @@ class IBM(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='ibm')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='ibm')
 
     def _get_feasible_launchable_resources(
         self, resources: 'resources_lib.Resources'
@@ -309,15 +309,15 @@ class IBM(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,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='ibm')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             cpus=resources.cpus,
+             memory=resources.memory,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='ibm')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -462,11 +462,11 @@ class IBM(clouds.Cloud):
 
     def instance_type_exists(self, instance_type):
         """Returns whether the instance type exists for this cloud."""
-        return service_catalog.instance_type_exists(instance_type, clouds='ibm')
+        return catalog.instance_type_exists(instance_type, clouds='ibm')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
         """Validates the region and zone."""
-        return service_catalog.validate_region_zone(region, zone, clouds='ibm')
+        return catalog.validate_region_zone(region, zone, clouds='ibm')
 
     @classmethod
     def query_status(cls, name: str, tag_filters: Dict[str, str],

sky/clouds/kubernetes.py

@@ -1,17 +1,18 @@
 """Kubernetes."""
-import os
 import re
+import subprocess
+import tempfile
 import typing
 from typing import Dict, Iterator, List, Optional, Set, Tuple, Union
 
 import colorama
 
+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 kubernetes
-from sky.clouds import service_catalog
 from sky.provision import instance_setup
 from sky.provision.kubernetes import network_utils
 from sky.provision.kubernetes import utils as kubernetes_utils
@@ -28,10 +29,6 @@ if typing.TYPE_CHECKING:
 
 logger = sky_logging.init_logger(__name__)
 
-# Check if KUBECONFIG is set, and use it if it is.
-DEFAULT_KUBECONFIG_PATH = '~/.kube/config'
-CREDENTIAL_PATH = os.environ.get('KUBECONFIG', DEFAULT_KUBECONFIG_PATH)
-
 # Namespace for SkyPilot resources shared across multiple tenants on the
 # same cluster (even if they might be running in different namespaces).
 # E.g., FUSE device manager daemonset is run in this namespace.
@@ -471,14 +468,14 @@ class Kubernetes(clouds.Cloud):
                 # Select image based on whether we are using GPUs or not.
                 image_id = self.IMAGE_GPU if acc_count > 0 else self.IMAGE_CPU
                 # Get the container image ID from the service catalog.
-                image_id = service_catalog.get_image_id_from_tag(
-                    image_id, clouds='kubernetes')
+                image_id = catalog.get_image_id_from_tag(image_id,
+                                                         clouds='kubernetes')
             return image_id
 
         image_id = _get_image_id(resources)
         # TODO(romilb): Create a lightweight image for SSH jump host
-        ssh_jump_image = service_catalog.get_image_id_from_tag(
-            self.IMAGE_CPU, clouds='kubernetes')
+        ssh_jump_image = catalog.get_image_id_from_tag(self.IMAGE_CPU,
+                                                       clouds='kubernetes')
 
         # Set environment variables for the pod. Note that SkyPilot env vars
         # are set separately when the task is run. These env vars are
@@ -788,6 +785,7 @@ class Kubernetes(clouds.Cloud):
         """Checks if the user has access credentials to
         Kubernetes."""
         # Check for port forward dependencies
+        logger.info(f'Checking compute credentials for {cls.canonical_name()}')
         reasons = kubernetes_utils.check_port_forward_mode_dependencies(False)
         if reasons is not None:
             formatted = '\n'.join(
@@ -850,10 +848,24 @@ class Kubernetes(clouds.Cloud):
         return ''.join(message_parts)
 
     def get_credential_file_mounts(self) -> Dict[str, str]:
-        if os.path.exists(os.path.expanduser(CREDENTIAL_PATH)):
+        credential_paths = kubernetes_utils.get_kubeconfig_paths()
+        if credential_paths:
+            # For single kubeconfig path, keep the original path.
+            kubeconfig_file = credential_paths[0]
+            if len(credential_paths) > 1:
+                # For multiple kubeconfig paths, merge them into a single file.
+                # TODO(aylei): GC merged kubeconfig files.
+                kubeconfig_file = tempfile.NamedTemporaryFile(
+                    prefix='merged-kubeconfig-', suffix='.yaml',
+                    delete=False).name
+                subprocess.run(
+                    'kubectl config view --flatten '
+                    f'> {kubeconfig_file}',
+                    shell=True,
+                    check=True)
             # Upload kubeconfig to the default path to avoid having to set
             # KUBECONFIG in the environment.
-            return {DEFAULT_KUBECONFIG_PATH: CREDENTIAL_PATH}
+            return {kubernetes.DEFAULT_KUBECONFIG_PATH: kubeconfig_file}
         else:
             return {}
 

sky/clouds/lambda_cloud.py

@@ -2,9 +2,9 @@
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky.adaptors import common as adaptors_common
-from sky.clouds import service_catalog
 from sky.provision.lambda_cloud import lambda_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -73,7 +73,7 @@ class Lambda(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, 'lambda')
 
         if region is not None:
@@ -105,11 +105,11 @@ class Lambda(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='lambda')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='lambda')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -133,26 +133,26 @@ class Lambda(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='lambda')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='lambda')
 
     @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='lambda')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='lambda')
 
     @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='lambda')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='lambda')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -230,16 +230,16 @@ class Lambda(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='lambda')
+        (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='lambda')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -278,16 +278,14 @@ class Lambda(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'lambda')
+        return catalog.instance_type_exists(instance_type, 'lambda')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds='lambda')
+        return catalog.validate_region_zone(region, zone, clouds='lambda')
 
     @classmethod
     def regions(cls) -> List['clouds.Region']:
-        return service_catalog.regions(clouds='lambda')
+        return catalog.regions(clouds='lambda')
 
     @classmethod
     def query_status(cls, name: str, tag_filters: Dict[str, str],