skypilot-nightly 1.0.0.dev20250320__py3-none-any.whl → 1.0.0.dev20250322__py3-none-any.whl

sky/cloud_stores.py

@@ -19,6 +19,7 @@ from sky.adaptors import aws
 from sky.adaptors import azure
 from sky.adaptors import cloudflare
 from sky.adaptors import ibm
+from sky.adaptors import nebius
 from sky.adaptors import oci
 from sky.clouds import gcp
 from sky.data import data_utils
@@ -543,6 +544,70 @@ class OciCloudStorage(CloudStorage):
         return download_via_ocicli
 
 
+class NebiusCloudStorage(CloudStorage):
+    """Nebius Cloud Storage."""
+
+    # List of commands to install AWS CLI
+    _GET_AWSCLI = [
+        'aws --version >/dev/null 2>&1 || '
+        f'{constants.SKY_UV_PIP_CMD} install awscli',
+    ]
+
+    def is_directory(self, url: str) -> bool:
+        """Returns whether nebius 'url' is a directory.
+
+        In cloud object stores, a "directory" refers to a regular object whose
+        name is a prefix of other objects.
+        """
+        nebius_s3 = nebius.resource('s3')
+        bucket_name, path = data_utils.split_nebius_path(url)
+        bucket = nebius_s3.Bucket(bucket_name)
+
+        num_objects = 0
+        for obj in bucket.objects.filter(Prefix=path):
+            num_objects += 1
+            if obj.key == path:
+                return False
+            # If there are more than 1 object in filter, then it is a directory
+            if num_objects == 3:
+                return True
+
+        # A directory with few or no items
+        return True
+
+    def make_sync_dir_command(self, source: str, destination: str) -> str:
+        """Downloads using AWS CLI."""
+        # AWS Sync by default uses 10 threads to upload files to the bucket.
+        # To increase parallelism, modify max_concurrent_requests in your
+        # aws config file (Default path: ~/.aws/config).
+        endpoint_url = nebius.create_endpoint()
+        assert 'nebius://' in source, 'nebius:// is not in source'
+        source = source.replace('nebius://', 's3://')
+        download_via_awscli = (f'{constants.SKY_REMOTE_PYTHON_ENV}/bin/aws s3 '
+                               'sync --no-follow-symlinks '
+                               f'{source} {destination} '
+                               f'--endpoint {endpoint_url} '
+                               f'--profile={nebius.NEBIUS_PROFILE_NAME}')
+
+        all_commands = list(self._GET_AWSCLI)
+        all_commands.append(download_via_awscli)
+        return ' && '.join(all_commands)
+
+    def make_sync_file_command(self, source: str, destination: str) -> str:
+        """Downloads a file using AWS CLI."""
+        endpoint_url = nebius.create_endpoint()
+        assert 'nebius://' in source, 'nebius:// is not in source'
+        source = source.replace('nebius://', 's3://')
+        download_via_awscli = (f'{constants.SKY_REMOTE_PYTHON_ENV}/bin/aws s3 '
+                               f'cp {source} {destination} '
+                               f'--endpoint {endpoint_url} '
+                               f'--profile={nebius.NEBIUS_PROFILE_NAME}')
+
+        all_commands = list(self._GET_AWSCLI)
+        all_commands.append(download_via_awscli)
+        return ' && '.join(all_commands)
+
+
 def get_storage_from_path(url: str) -> CloudStorage:
     """Returns a CloudStorage by identifying the scheme:// in a URL."""
     result = urllib.parse.urlsplit(url)
@@ -559,6 +624,7 @@ _REGISTRY = {
     'r2': R2CloudStorage(),
     'cos': IBMCosCloudStorage(),
     'oci': OciCloudStorage(),
+    'nebius': NebiusCloudStorage(),
     # TODO: This is a hack, as Azure URL starts with https://, we should
     # refactor the registry to be able to take regex, so that Azure blob can
     # be identified with `https://(.*?)\.blob\.core\.windows\.net`

sky/clouds/aws.py

@@ -558,11 +558,23 @@ class AWS(clouds.Cloud):
         return resources_utils.FeasibleResources(_make(instance_list),
                                                  fuzzy_candidate_list, None)
 
+    @classmethod
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this AWS's compute service."""
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this AWS's storage service."""
+        # TODO(seungjin): Implement separate check for
+        # if the user has access to S3.
+        return cls._check_credentials()
+
     @classmethod
     @annotations.lru_cache(scope='global',
                            maxsize=1)  # Cache since getting identity is slow.
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Checks if the user has access credentials to this cloud."""
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to AWS."""
 
         dependency_installation_hints = (
             'AWS dependencies are not installed. '
@@ -666,11 +678,6 @@ class AWS(clouds.Cloud):
                 f'{common_utils.format_exception(e, use_bracket=True)}')
         return True, hints
 
-    @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        # TODO(seungjin): Check if the user has access to S3.
-        return cls.check_credentials()
-
     @classmethod
     def _current_identity_type(cls) -> Optional[AWSIdentityType]:
         stdout = cls._aws_configure_list()

sky/clouds/azure.py

@@ -512,7 +512,19 @@ class Azure(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this cloud's compute service."""
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this cloud's storage service."""
+        # TODO(seungjin): Implement separate check for
+        # if the user has access to Azure Blob Storage.
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
         """Checks if the user has access credentials to this cloud."""
         help_str = (
             ' Run the following commands:'
@@ -574,11 +586,6 @@ class Azure(clouds.Cloud):
         return service_catalog.instance_type_exists(instance_type,
                                                     clouds='azure')
 
-    @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        # TODO(seungjin): Check if the user has access to Azure Blob Storage.
-        return cls.check_credentials()
-
     @classmethod
     @annotations.lru_cache(scope='global',
                            maxsize=1)  # Cache since getting identity is slow.

sky/clouds/cloud.py

@@ -13,6 +13,8 @@ import math
 import typing
 from typing import Dict, Iterable, Iterator, List, Optional, Set, Tuple, Union
 
+from typing_extensions import assert_never
+
 from sky import exceptions
 from sky import skypilot_config
 from sky.clouds import service_catalog
@@ -48,6 +50,17 @@ class CloudImplementationFeatures(enum.Enum):
     AUTO_TERMINATE = 'auto_terminate'  # Pod/VM can stop or down itself
 
 
+# Use str, enum.Enum to allow CloudCapability to be used as a string.
+class CloudCapability(str, enum.Enum):
+    # Compute capability.
+    COMPUTE = 'compute'
+    # Storage capability.
+    STORAGE = 'storage'
+
+
+ALL_CAPABILITIES = [CloudCapability.COMPUTE, CloudCapability.STORAGE]
+
+
 class Region(collections.namedtuple('Region', ['name'])):
     """A region."""
     name: str
@@ -435,25 +448,36 @@ class Cloud:
         return {reservation: 0 for reservation in specific_reservations}
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def check_credentials(
+            cls,
+            cloud_capability: CloudCapability) -> Tuple[bool, Optional[str]]:
         """Checks if the user has access credentials to this cloud.
 
         Returns a boolean of whether the user can access this cloud, and a
         string describing the reason if the user cannot access.
+
+        Raises NotSupportedError if the capability is
+        not supported by this cloud.
         """
-        raise NotImplementedError
+        if cloud_capability == CloudCapability.COMPUTE:
+            return cls._check_compute_credentials()
+        elif cloud_capability == CloudCapability.STORAGE:
+            return cls._check_storage_credentials()
+        assert_never(cloud_capability)
 
     @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Checks if the user has access credentials to this cloud's storage.
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        this cloud's compute service."""
+        raise exceptions.NotSupportedError(
+            f'{cls._REPR} does not support {CloudCapability.COMPUTE.value}.')
 
-        Returns a boolean of whether the user can access this cloud's storage,
-        and a string describing the reason if the user cannot access.
-        """
-        # A given cloud does not support storage
-        # unless it overrides this method.
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        this cloud's storage service."""
         raise exceptions.NotSupportedError(
-            f'{cls._REPR} does not support storage.')
+            f'{cls._REPR} does not support {CloudCapability.STORAGE.value}.')
 
     # TODO(zhwu): Make the return type immutable.
     @classmethod

sky/clouds/cudo.py

@@ -267,8 +267,9 @@ class Cudo(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        Cudo's compute service."""
         try:
             # pylint: disable=import-outside-toplevel,unused-import
             from cudo_compute import cudo_api

sky/clouds/do.py

@@ -259,8 +259,9 @@ class DO(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Verify that the user has valid credentials for DO."""
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Verify that the user has valid credentials for
+        DO's compute service."""
 
         try:
             do.exceptions()

sky/clouds/fluidstack.py

@@ -255,8 +255,9 @@ class Fluidstack(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        FluidStack's compute service."""
         try:
             assert os.path.exists(
                 os.path.expanduser(fluidstack_utils.FLUIDSTACK_API_KEY_PATH))

sky/clouds/gcp.py

@@ -719,9 +719,9 @@ class GCP(clouds.Cloud):
         return DEFAULT_GCP_APPLICATION_CREDENTIAL_PATH
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Checks if the user has compute access credentials to this cloud."""
-        return cls._check_credentials(  # Check APIs.
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this cloud's compute service."""
+        return cls._check_credentials(
             [
                 ('compute', 'Compute Engine'),
                 ('cloudresourcemanager', 'Cloud Resource Manager'),
@@ -731,12 +731,11 @@ class GCP(clouds.Cloud):
             gcp_utils.get_minimal_compute_permissions())
 
     @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Checks if the user has compute access credentials to this cloud."""
-        return cls._check_credentials(  # Check APIs.
-            [
-                ('storage', 'Cloud Storage'),
-            ], gcp_utils.get_minimal_storage_permissions())
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to this cloud's storage service."""
+        return cls._check_credentials(
+            [('storage', 'Cloud Storage')],
+            gcp_utils.get_minimal_storage_permissions())
 
     @classmethod
     def _check_credentials(

sky/clouds/ibm.py

@@ -395,7 +395,21 @@ class IBM(clouds.Cloud):
         return image_size
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        IBM's compute service."""
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        IBM's storage service."""
+        # TODO(seungjin): Implement separate check for
+        # if the user has access to IBM COS.
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
         """Checks if the user has access credentials to this cloud."""
 
         required_fields = ['iam_api_key', 'resource_group_id']
@@ -433,11 +447,6 @@ class IBM(clouds.Cloud):
         except Exception as e:
             return (False, f'{str(e)}' + help_str)
 
-    @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        # TODO(seungjin): Check if the user has access to IBM COS.
-        return cls.check_credentials()
-
     def get_credential_file_mounts(self) -> Dict[str, str]:
         """Returns a {remote:local} credential path mapping
          written to the cluster's file_mounts segment

sky/clouds/kubernetes.py

@@ -655,7 +655,9 @@ class Kubernetes(clouds.Cloud):
                                                  [], None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        Kubernetes."""
         # Test using python API
         try:
             existing_allowed_contexts = cls.existing_allowed_contexts()

sky/clouds/lambda_cloud.py

@@ -241,7 +241,9 @@ class Lambda(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        Lambda's compute service."""
         try:
             lambda_utils.LambdaCloudClient().list_instances()
         except (AssertionError, KeyError, lambda_utils.LambdaCloudError):

sky/clouds/nebius.py

@@ -1,5 +1,6 @@
 """ Nebius Cloud. """
 import logging
+import os
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
@@ -20,6 +21,22 @@ _CREDENTIAL_FILES = [
     nebius.NEBIUS_CREDENTIALS_FILENAME
 ]
 
+_INDENT_PREFIX = '    '
+
+
+def nebius_profile_in_aws_cred() -> bool:
+    """Checks if Nebius Object Storage profile is set in aws credentials."""
+
+    profile_path = os.path.expanduser('~/.aws/credentials')
+    nebius_profile_exists = False
+    if os.path.isfile(profile_path):
+        with open(profile_path, 'r', encoding='utf-8') as file:
+            for line in file:
+                if f'[{nebius.NEBIUS_PROFILE_NAME}]' in line:
+                    nebius_profile_exists = True
+
+    return nebius_profile_exists
+
 
 @registry.CLOUD_REGISTRY.register
 class Nebius(clouds.Cloud):
@@ -250,17 +267,19 @@ class Nebius(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """ Verify that the user has valid credentials for Nebius. """
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        Nebius's compute service."""
         logging.debug('Nebius cloud check credentials')
-        token_cred_msg = ('    Credentials can be set up by running: \n'\
-                    f'        $ nebius iam get-access-token > {nebius.NEBIUS_IAM_TOKEN_PATH} \n'\
-                          '    or generate  ~/.nebius/credentials.json')  # pylint: disable=line-too-long
-
-        tenant_msg = ('   Copy your tenat ID from the web console and save it to file \n'  # pylint: disable=line-too-long
-                      f'        $ echo $NEBIUS_TENANT_ID_PATH > {nebius.NEBIUS_TENANT_ID_PATH} \n'  # pylint: disable=line-too-long
-                      '   Or if you have 1 tenant you can run:\n'  # pylint: disable=line-too-long
-                      f'        $ nebius --format json iam whoami|jq -r \'.user_profile.tenants[0].tenant_id\' > {nebius.NEBIUS_TENANT_ID_PATH} \n')  # pylint: disable=line-too-long
+        token_cred_msg = (
+            f'{_INDENT_PREFIX}Credentials can be set up by running: \n'
+            f'{_INDENT_PREFIX}  $ nebius iam get-access-token > {nebius.NEBIUS_IAM_TOKEN_PATH} \n'  # pylint: disable=line-too-long
+            f'{_INDENT_PREFIX} or generate  ~/.nebius/credentials.json')
+
+        tenant_msg = (f'{_INDENT_PREFIX}Copy your tenat ID from the web console and save it to file \n'  # pylint: disable=line-too-long
+                      f'{_INDENT_PREFIX}  $ echo $NEBIUS_TENANT_ID_PATH > {nebius.NEBIUS_TENANT_ID_PATH} \n'  # pylint: disable=line-too-long
+                      f'{_INDENT_PREFIX} Or if you have 1 tenant you can run:\n'  # pylint: disable=line-too-long
+                      f'{_INDENT_PREFIX}  $ nebius --format json iam whoami|jq -r \'.user_profile.tenants[0].tenant_id\' > {nebius.NEBIUS_TENANT_ID_PATH} \n')  # pylint: disable=line-too-long
         if not nebius.is_token_or_cred_file_exist():
             return False, f'{token_cred_msg}'
         sdk = nebius.sdk()
@@ -278,11 +297,40 @@ class Nebius(clouds.Cloud):
                 f'{tenant_msg}')
         return True, None
 
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to Nebius Object Storage.
+
+        Returns:
+            A tuple of a boolean value and a hint message where the bool
+            is True when credentials needed for Nebius Object Storage is set.
+            It is False when either of those are not set, which would hint
+            with a string on unset credential.
+        """
+        hints = None
+        if not nebius_profile_in_aws_cred():
+            hints = (f'[{nebius.NEBIUS_PROFILE_NAME}] profile '
+                     'is not set in ~/.aws/credentials.')
+        if hints:
+            hints += ' Run the following commands:'
+            if not nebius_profile_in_aws_cred():
+                hints += (
+                    f'\n{_INDENT_PREFIX}  $ pip install boto3'
+                    f'\n{_INDENT_PREFIX}  $ aws configure --profile nebius')
+            hints += (
+                f'\n{_INDENT_PREFIX}For more info: '
+                'https://docs.skypilot.co/en/latest/getting-started/installation.html#nebius'  # pylint: disable=line-too-long
+            )
+        return (False, hints) if hints else (True, hints)
+
     def get_credential_file_mounts(self) -> Dict[str, str]:
-        return {
+        credential_file_mounts = {
             f'~/.nebius/{filename}': f'~/.nebius/{filename}'
             for filename in _CREDENTIAL_FILES
         }
+        credential_file_mounts['~/.aws/credentials'] = '~/.aws/credentials'
+
+        return credential_file_mounts
 
     @classmethod
     def get_current_user_identity(cls) -> Optional[List[str]]:

sky/clouds/oci.py

@@ -396,7 +396,21 @@ class OCI(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        OCI's compute service."""
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        OCI's storage service."""
+        # TODO(seungjin): Implement separate check for
+        # if the user has access to OCI Object Storage.
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
         """Checks if the user has access credentials to this cloud."""
 
         short_credential_help_str = (
@@ -456,11 +470,6 @@ class OCI(clouds.Cloud):
                 f'{cls._INDENT_PREFIX}Error details: '
                 f'{common_utils.format_exception(e, use_bracket=True)}')
 
-    @classmethod
-    def check_storage_credentials(cls) -> Tuple[bool, Optional[str]]:
-        # TODO(seungjin): Check if the user has access to OCI Object Storage.
-        return cls.check_credentials()
-
     @classmethod
     def check_disk_tier(
             cls, instance_type: Optional[str],

sky/clouds/paperspace.py

@@ -249,8 +249,9 @@ class Paperspace(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Verify that the user has valid credentials for Paperspace."""
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        Paperspace's compute service."""
         try:
             # attempt to make a CURL request for listing instances
             utils.PaperspaceCloudClient().list_instances()

sky/clouds/runpod.py

@@ -248,7 +248,13 @@ class RunPod(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        RunPod's compute service."""
+        return cls._check_credentials()
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
         """ Verify that the user has valid credentials for RunPod. """
         try:
             import runpod  # pylint: disable=import-outside-toplevel

sky/clouds/scp.py

@@ -312,7 +312,9 @@ class SCP(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        SCP's compute service."""
         try:
             scp_utils.SCPClient().list_instances()
         except (AssertionError, KeyError, scp_utils.SCPClientError,

sky/clouds/service_catalog/kubernetes_catalog.py

@@ -12,6 +12,7 @@ from sky import clouds as sky_clouds
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import kubernetes
+from sky.clouds import cloud
 from sky.clouds.service_catalog import CloudFilter
 from sky.clouds.service_catalog import common
 from sky.provision.kubernetes import utils as kubernetes_utils
@@ -132,7 +133,8 @@ def _list_accelerators(
 
     # First check if Kubernetes is enabled. This ensures k8s python client is
     # installed. Do not put any k8s-specific logic before this check.
-    enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh()
+    enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh(
+        cloud.CloudCapability.COMPUTE)
     if not sky_clouds.cloud_in_iterable(sky_clouds.Kubernetes(),
                                         enabled_clouds):
         return {}, {}, {}

sky/clouds/vast.py

@@ -234,8 +234,9 @@ class Vast(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """ Verify that the user has valid credentials for Vast. """
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has valid credentials for
+        Vast's compute service. """
         try:
             import vastai_sdk as _vast  # pylint: disable=import-outside-toplevel
             vast = _vast.VastAI()

sky/clouds/vsphere.py

@@ -254,8 +254,9 @@ class Vsphere(clouds.Cloud):
                                                  fuzzy_candidate_list, None)
 
     @classmethod
-    def check_credentials(cls) -> Tuple[bool, Optional[str]]:
-        """Checks if the user has access credentials to this cloud."""
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        """Checks if the user has access credentials to
+        vSphere's compute service."""
 
         try:
             # pylint: disable=import-outside-toplevel,unused-import

sky/core.py

@@ -19,6 +19,7 @@ from sky import optimizer
 from sky import sky_logging
 from sky import task as task_lib
 from sky.backends import backend_utils
+from sky.clouds import cloud as sky_cloud
 from sky.clouds import service_catalog
 from sky.jobs.server import core as managed_jobs_core
 from sky.provision.kubernetes import constants as kubernetes_constants
@@ -1001,7 +1002,8 @@ def storage_delete(name: str) -> None:
 # ===================
 @usage_lib.entrypoint
 def enabled_clouds() -> List[clouds.Cloud]:
-    return global_user_state.get_cached_enabled_clouds()
+    return global_user_state.get_cached_enabled_clouds(
+        sky_cloud.CloudCapability.COMPUTE)
 
 
 @usage_lib.entrypoint
@@ -1134,9 +1136,9 @@ def local_down() -> None:
         # Run sky check
         with rich_utils.safe_status(
                 ux_utils.spinner_message('Running sky check...')):
-            sky_check.check(clouds=['kubernetes'],
-                            quiet=True,
-                            capability=sky_check.CloudCapability.COMPUTE)
+            sky_check.check_capability(sky_cloud.CloudCapability.COMPUTE,
+                                       clouds=['kubernetes'],
+                                       quiet=True)
         logger.info(
             ux_utils.finishing_message('Local cluster removed.',
                                        log_path=log_path,