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

sky/clouds/nebius.py

@@ -4,11 +4,11 @@ import os
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky import exceptions
 from sky import skypilot_config
 from sky.adaptors import nebius
-from sky.clouds import service_catalog
 from sky.utils import annotations
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -92,7 +92,7 @@ class Nebius(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, 'nebius')
 
         if region is not None:
@@ -104,8 +104,8 @@ class Nebius(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='nebius')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='nebius')
 
     @classmethod
     def zones_provision_loop(
@@ -132,11 +132,11 @@ class Nebius(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='nebius')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='nebius')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -165,18 +165,18 @@ class Nebius(clouds.Cloud):
             disk_tier: Optional[resources_utils.DiskTier] = None
     ) -> Optional[str]:
         """Returns the default instance type for Nebius."""
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='nebius')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='nebius')
 
     @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='nebius')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='nebius')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -277,15 +277,15 @@ class Nebius(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,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='nebius')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='nebius')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -368,12 +368,10 @@ class Nebius(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'nebius')
+        return catalog.instance_type_exists(instance_type, 'nebius')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds='nebius')
+        return catalog.validate_region_zone(region, zone, clouds='nebius')
 
     @classmethod
     def get_user_identities(cls) -> Optional[List[List[str]]]:

sky/clouds/oci.py

@@ -25,10 +25,10 @@ import os
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky import exceptions
 from sky.adaptors import oci as oci_adaptor
-from sky.clouds import service_catalog
 from sky.clouds.utils import oci_utils
 from sky.provision.oci.query_utils import query_helper
 from sky.utils import common_utils
@@ -97,7 +97,7 @@ class OCI(clouds.Cloud):
                               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, 'oci')
 
         if region is not None:
@@ -114,8 +114,8 @@ class OCI(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='oci')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='oci')
 
     @classmethod
     def zones_provision_loop(
@@ -143,11 +143,11 @@ class OCI(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='oci')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='oci')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -189,18 +189,18 @@ class OCI(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='oci')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='oci')
 
     @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='oci')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='oci')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -274,7 +274,7 @@ class OCI(clouds.Cloud):
         if zone is None:
             # If zone is not specified, try to get the first zone.
             if zones is None:
-                regions = service_catalog.get_region_zones_for_instance_type(
+                regions = catalog.get_region_zones_for_instance_type(
                     instance_type=original_instance_type,
                     use_spot=resources.use_spot,
                     clouds='oci')
@@ -319,7 +319,7 @@ class OCI(clouds.Cloud):
                 region=region.name)
 
             # pylint: disable=import-outside-toplevel
-            from sky.clouds.service_catalog import oci_catalog
+            from sky.catalog import oci_catalog
             os_type = oci_catalog.get_image_os_from_tag(tag=image_str,
                                                         region=region.name)
         logger.debug(f'OS type for the image {image_id} is {os_type}')
@@ -383,16 +383,16 @@ class OCI(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='oci')
+        (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='oci')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -532,10 +532,10 @@ class OCI(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'oci')
+        return catalog.instance_type_exists(instance_type, 'oci')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region, zone, clouds='oci')
+        return catalog.validate_region_zone(region, zone, clouds='oci')
 
     @classmethod
     def get_image_size(cls, image_id: str, region: Optional[str]) -> float:
@@ -556,9 +556,9 @@ class OCI(clouds.Cloud):
                                            region=region_name)
 
         if image_id_str.startswith('skypilot:'):
-            image_id_str = service_catalog.get_image_id_from_tag(image_id_str,
-                                                                 region_name,
-                                                                 clouds='oci')
+            image_id_str = catalog.get_image_id_from_tag(image_id_str,
+                                                         region_name,
+                                                         clouds='oci')
 
         # Image_id should be impossible be None, except for the case when
         # user specify an image tag which does not exist in the image.csv

sky/clouds/paperspace.py

@@ -3,9 +3,9 @@
 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.paperspace import utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -88,7 +88,7 @@ class Paperspace(clouds.Cloud):
         if use_spot:
             return []
         else:
-            regions = service_catalog.get_region_zones_for_instance_type(
+            regions = catalog.get_region_zones_for_instance_type(
                 instance_type, use_spot, 'paperspace')
 
         if region is not None:
@@ -100,8 +100,8 @@ class Paperspace(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(
-            instance_type, clouds='paperspace')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='paperspace')
 
     @classmethod
     def zones_provision_loop(
@@ -130,7 +130,7 @@ class Paperspace(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,
@@ -163,16 +163,16 @@ class Paperspace(clouds.Cloud):
         disk_tier: Optional[resources_utils.DiskTier] = None,
     ) -> Optional[str]:
         """Returns the default instance type for Paperspace."""
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='paperspace')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='paperspace')
 
     @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='paperspace')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='paperspace')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -240,17 +240,17 @@ class Paperspace(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='paperspace',
-            ))
+        (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='paperspace',
+         ))
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -296,9 +296,7 @@ class Paperspace(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'paperspace')
+        return catalog.instance_type_exists(instance_type, 'paperspace')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds='paperspace')
+        return catalog.validate_region_zone(region, zone, clouds='paperspace')

sky/clouds/runpod.py

@@ -3,8 +3,8 @@
 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 registry
 from sky.utils import resources_utils
 
@@ -72,7 +72,7 @@ class RunPod(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, 'runpod')
 
         if region is not None:
@@ -90,8 +90,8 @@ class RunPod(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Tuple[Optional[float], Optional[float]]:
-        return service_catalog.get_vcpus_mem_from_instance_type(instance_type,
-                                                                clouds='runpod')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='runpod')
 
     @classmethod
     def zones_provision_loop(
@@ -118,11 +118,11 @@ class RunPod(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='runpod')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='runpod')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -144,16 +144,16 @@ class RunPod(clouds.Cloud):
             disk_tier: Optional[resources_utils.DiskTier] = None
     ) -> Optional[str]:
         """Returns the default instance type for RunPod."""
-        return service_catalog.get_default_instance_type(cpus=cpus,
-                                                         memory=memory,
-                                                         disk_tier=disk_tier,
-                                                         clouds='runpod')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='runpod')
 
     @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='runpod')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='runpod')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -245,15 +245,15 @@ class RunPod(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,
-            region=resources.region,
-            zone=resources.zone,
-            clouds='runpod')
+        (instance_list,
+         fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+             acc,
+             acc_count,
+             use_spot=resources.use_spot,
+             cpus=resources.cpus,
+             region=resources.region,
+             zone=resources.zone,
+             clouds='runpod')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -302,12 +302,10 @@ class RunPod(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'runpod')
+        return catalog.instance_type_exists(instance_type, 'runpod')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region,
-                                                    zone,
-                                                    clouds='runpod')
+        return catalog.validate_region_zone(region, zone, clouds='runpod')
 
     @classmethod
     def get_image_size(cls, image_id: str, region: Optional[str]) -> float:

sky/clouds/scp.py

@@ -7,10 +7,10 @@ to access the SCP catalog and check credentials for the SCP access.
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
+from sky import catalog
 from sky import clouds
 from sky import exceptions
 from sky import sky_logging
-from sky.clouds import service_catalog
 from sky.clouds.utils import scp_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -84,7 +84,7 @@ class SCP(clouds.Cloud):
 
     @classmethod
     def regions(cls) -> List['clouds.Region']:
-        return service_catalog.regions(clouds='scp')
+        return catalog.regions(clouds='scp')
 
     @classmethod
     def regions_with_offering(cls, instance_type: Optional[str],
@@ -99,7 +99,7 @@ class SCP(clouds.Cloud):
             # Fall back to default regions
             regions = cls.regions()
         else:
-            regions = service_catalog.get_region_zones_for_instance_type(
+            regions = catalog.get_region_zones_for_instance_type(
                 instance_type, use_spot, 'scp')
 
         if region is not None:
@@ -131,11 +131,11 @@ class SCP(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='scp')
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='scp')
 
     def accelerators_to_hourly_cost(self,
                                     accelerators: Dict[str, int],
@@ -156,26 +156,26 @@ class SCP(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='scp')
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='scp')
 
     @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='scp')
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='scp')
 
     @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='scp')
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='scp')
 
     @classmethod
     def get_zone_shell_cmd(cls) -> Optional[str]:
@@ -223,9 +223,9 @@ class SCP(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='scp')
+            image_id_str = catalog.get_image_id_from_tag(image_id_str,
+                                                         region_name,
+                                                         clouds='scp')
             if image_id_str is None:
                 # Raise ResourcesUnavailableError to make sure the failover
                 # in CloudVMRayBackend will be correctly triggered.
@@ -238,13 +238,14 @@ class SCP(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('skypilot:ubuntu-2004',
-                                                         region_name,
-                                                         clouds='scp')
+        image_id = catalog.get_image_id_from_tag('skypilot:ubuntu-2004',
+                                                 region_name,
+                                                 clouds='scp')
         if acc is not None:
             assert len(acc) == 1, acc
-            image_id = service_catalog.get_image_id_from_tag(
-                'skypilot:gpu-ubuntu-1804', region_name, clouds='scp')
+            image_id = catalog.get_image_id_from_tag('skypilot:gpu-ubuntu-1804',
+                                                     region_name,
+                                                     clouds='scp')
         if image_id is not None:
             return image_id
         # Raise ResourcesUnavailableError to make sure the failover in
@@ -302,16 +303,16 @@ class SCP(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='scp')
+        (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='scp')
         if instance_list is None:
             return resources_utils.FeasibleResources([], fuzzy_candidate_list,
                                                      None)
@@ -351,10 +352,10 @@ class SCP(clouds.Cloud):
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:
-        return service_catalog.instance_type_exists(instance_type, 'scp')
+        return catalog.instance_type_exists(instance_type, 'scp')
 
     def validate_region_zone(self, region: Optional[str], zone: Optional[str]):
-        return service_catalog.validate_region_zone(region, zone, clouds='scp')
+        return catalog.validate_region_zone(region, zone, clouds='scp')
 
     @staticmethod
     def _is_disk_size_allowed(resources):

sky/clouds/utils/gcp_utils.py

@@ -36,7 +36,8 @@ def is_tpu(resources: Optional['resources_lib.Resources']) -> bool:
 def is_tpu_vm(resources: Optional['resources_lib.Resources']) -> bool:
     if not is_tpu(resources):
         return False
-    assert (resources is not None and len(resources.accelerators) == 1)
+    assert (resources is not None and resources.accelerators is not None and
+            len(resources.accelerators) == 1)
     acc, _ = list(resources.accelerators.items())[0]
     if kubernetes_utils.is_tpu_on_gke(acc):
         return False
@@ -48,7 +49,7 @@ def is_tpu_vm(resources: Optional['resources_lib.Resources']) -> bool:
 def is_tpu_vm_pod(resources: Optional['resources_lib.Resources']) -> bool:
     if not is_tpu_vm(resources):
         return False
-    assert resources is not None
+    assert resources is not None and resources.accelerators is not None
     acc, _ = list(resources.accelerators.items())[0]
     return not acc.endswith('-8')