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

sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = 'a480f342522afcd17a3b30a20086f28333ddb7b5'
+_SKYPILOT_COMMIT_SHA = '139a09e3445956740743049d352cd1cb6d202479'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250320'
+__version__ = '1.0.0.dev20250322'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

sky/adaptors/cloudflare.py

@@ -6,7 +6,9 @@ import os
 import threading
 from typing import Dict, Optional, Tuple
 
+from sky import exceptions
 from sky.adaptors import common
+from sky.clouds import cloud
 from sky.utils import annotations
 from sky.utils import ux_utils
 
@@ -23,7 +25,6 @@ R2_CREDENTIALS_PATH = '~/.cloudflare/r2.credentials'
 R2_PROFILE_NAME = 'r2'
 _INDENT_PREFIX = '    '
 NAME = 'Cloudflare'
-SKY_CHECK_NAME = 'Cloudflare (for R2 object store)'
 
 
 @contextlib.contextmanager
@@ -130,8 +131,8 @@ def client(service_name: str, region):
 @common.load_lazy_modules(_LAZY_MODULES)
 def botocore_exceptions():
     """AWS botocore exception."""
-    from botocore import exceptions
-    return exceptions
+    from botocore import exceptions as boto_exceptions
+    return boto_exceptions
 
 
 def create_endpoint():
@@ -148,8 +149,18 @@ def create_endpoint():
     return endpoint
 
 
-def check_credentials() -> Tuple[bool, Optional[str]]:
-    return check_storage_credentials()
+def check_credentials(
+        cloud_capability: cloud.CloudCapability) -> Tuple[bool, Optional[str]]:
+    if cloud_capability == cloud.CloudCapability.COMPUTE:
+        # for backward compatibility,
+        # we check storage credentials for compute.
+        # TODO(seungjin): properly return not supported error for compute.
+        return check_storage_credentials()
+    elif cloud_capability == cloud.CloudCapability.STORAGE:
+        return check_storage_credentials()
+    else:
+        raise exceptions.NotSupportedError(
+            f'{NAME} does not support {cloud_capability}.')
 
 
 def check_storage_credentials() -> Tuple[bool, Optional[str]]:

sky/adaptors/kubernetes.py

@@ -79,10 +79,11 @@ def _load_config(context: Optional[str] = None):
                     '    If you were running a local Kubernetes '
                     'cluster, run `sky local up` to start the cluster.')
             else:
+                kubeconfig_path = os.environ.get('KUBECONFIG', '~/.kube/config')
                 err_str = (
                     f'Failed to load Kubernetes configuration for {context!r}. '
                     'Please check if your kubeconfig file exists at '
-                    f'~/.kube/config and is valid.\n{suffix}')
+                    f'{kubeconfig_path} and is valid.\n{suffix}')
             err_str += '\nTo disable Kubernetes for SkyPilot: run `sky check`.'
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(err_str) from None

sky/adaptors/nebius.py

@@ -1,7 +1,11 @@
 """Nebius cloud adaptor."""
 import os
+import threading
+from typing import Optional
 
 from sky.adaptors import common
+from sky.utils import annotations
+from sky.utils import ux_utils
 
 NEBIUS_TENANT_ID_FILENAME = 'NEBIUS_TENANT_ID.txt'
 NEBIUS_IAM_TOKEN_FILENAME = 'NEBIUS_IAM_TOKEN.txt'
@@ -12,6 +16,10 @@ NEBIUS_IAM_TOKEN_PATH = '~/.nebius/' + NEBIUS_IAM_TOKEN_FILENAME
 NEBIUS_PROJECT_ID_PATH = '~/.nebius/' + NEBIUS_PROJECT_ID_FILENAME
 NEBIUS_CREDENTIALS_PATH = '~/.nebius/' + NEBIUS_CREDENTIALS_FILENAME
 
+DEFAULT_REGION = 'eu-north1'
+
+NEBIUS_PROFILE_NAME = 'nebius'
+
 MAX_RETRIES_TO_DISK_CREATE = 120
 MAX_RETRIES_TO_INSTANCE_STOP = 120
 MAX_RETRIES_TO_INSTANCE_START = 120
@@ -23,15 +31,27 @@ MAX_RETRIES_TO_INSTANCE_WAIT = 120  # Maximum number of retries
 POLL_INTERVAL = 5
 
 _iam_token = None
+_sdk = None
 _tenant_id = None
 _project_id = None
 
+_IMPORT_ERROR_MESSAGE = ('Failed to import dependencies for Nebius AI Cloud.'
+                         'Try pip install "skypilot[nebius]"')
+
 nebius = common.LazyImport(
     'nebius',
-    import_error_message='Failed to import dependencies for Nebius AI Cloud. '
-    'Try running: pip install "skypilot[nebius]"',
+    import_error_message=_IMPORT_ERROR_MESSAGE,
     # https://github.com/grpc/grpc/issues/37642 to avoid spam in console
     set_loggers=lambda: os.environ.update({'GRPC_VERBOSITY': 'NONE'}))
+boto3 = common.LazyImport('boto3', import_error_message=_IMPORT_ERROR_MESSAGE)
+botocore = common.LazyImport('botocore',
+                             import_error_message=_IMPORT_ERROR_MESSAGE)
+
+_LAZY_MODULES = (boto3, botocore, nebius)
+_session_creation_lock = threading.RLock()
+_INDENT_PREFIX = '    '
+NAME = 'Nebius'
+SKY_CHECK_NAME = 'Nebius (for Nebius Object Storae)'
 
 
 def request_error():
@@ -104,7 +124,109 @@ def get_tenant_id():
 
 
 def sdk():
-    if get_iam_token() is not None:
-        return nebius.sdk.SDK(credentials=get_iam_token())
-    return nebius.sdk.SDK(
-        credentials_file_name=os.path.expanduser(NEBIUS_CREDENTIALS_PATH))
+    global _sdk
+    if _sdk is None:
+        if get_iam_token() is not None:
+            _sdk = nebius.sdk.SDK(credentials=get_iam_token())
+            return _sdk
+        _sdk = nebius.sdk.SDK(
+            credentials_file_name=os.path.expanduser(NEBIUS_CREDENTIALS_PATH))
+    return _sdk
+
+
+def get_nebius_credentials(boto3_session):
+    """Gets the Nebius credentials from the boto3 session object.
+
+    Args:
+        boto3_session: The boto3 session object.
+    Returns:
+        botocore.credentials.ReadOnlyCredentials object with the R2 credentials.
+    """
+    nebius_credentials = boto3_session.get_credentials()
+    if nebius_credentials is None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Nebius credentials not found. Run '
+                             '`sky check` to verify credentials are '
+                             'correctly set up.')
+    return nebius_credentials.get_frozen_credentials()
+
+
+# lru_cache() is thread-safe and it will return the same session object
+# for different threads.
+# Reference: https://docs.python.org/3/library/functools.html#functools.lru_cache # pylint: disable=line-too-long
+@annotations.lru_cache(scope='global')
+def session():
+    """Create an AWS session."""
+    # Creating the session object is not thread-safe for boto3,
+    # so we add a reentrant lock to synchronize the session creation.
+    # Reference: https://github.com/boto/boto3/issues/1592
+    # However, the session object itself is thread-safe, so we are
+    # able to use lru_cache() to cache the session object.
+    with _session_creation_lock:
+        session_ = boto3.session.Session(profile_name=NEBIUS_PROFILE_NAME)
+    return session_
+
+
+@annotations.lru_cache(scope='global')
+def resource(resource_name: str, region: str = DEFAULT_REGION, **kwargs):
+    """Create a Nebius resource.
+
+    Args:
+        resource_name: Nebius resource name (e.g., 's3').
+        kwargs: Other options.
+    """
+    # Need to use the resource retrieved from the per-thread session
+    # to avoid thread-safety issues (Directly creating the client
+    # with boto3.resource() is not thread-safe).
+    # Reference: https://stackoverflow.com/a/59635814
+
+    session_ = session()
+    nebius_credentials = get_nebius_credentials(session_)
+    endpoint = create_endpoint(region)
+
+    return session_.resource(
+        resource_name,
+        endpoint_url=endpoint,
+        aws_access_key_id=nebius_credentials.access_key,
+        aws_secret_access_key=nebius_credentials.secret_key,
+        region_name=region,
+        **kwargs)
+
+
+@annotations.lru_cache(scope='global')
+def client(service_name: str, region):
+    """Create an Nebius client of a certain service.
+
+    Args:
+        service_name: Nebius service name (e.g., 's3').
+        kwargs: Other options.
+    """
+    # Need to use the client retrieved from the per-thread session
+    # to avoid thread-safety issues (Directly creating the client
+    # with boto3.client() is not thread-safe).
+    # Reference: https://stackoverflow.com/a/59635814
+
+    session_ = session()
+    nebius_credentials = get_nebius_credentials(session_)
+    endpoint = create_endpoint(region)
+
+    return session_.client(service_name,
+                           endpoint_url=endpoint,
+                           aws_access_key_id=nebius_credentials.access_key,
+                           aws_secret_access_key=nebius_credentials.secret_key,
+                           region_name=region)
+
+
+@common.load_lazy_modules(_LAZY_MODULES)
+def botocore_exceptions():
+    """AWS botocore exception."""
+    # pylint: disable=import-outside-toplevel
+    from botocore import exceptions
+    return exceptions
+
+
+def create_endpoint(region: Optional[str] = DEFAULT_REGION) -> str:
+    """Reads accountid necessary to interact with Nebius Object Storage"""
+    if region is None:
+        region = DEFAULT_REGION
+    return f'https://storage.{region}.nebius.cloud:443'

sky/backends/cloud_vm_ray_backend.py

@@ -38,6 +38,7 @@ from sky import sky_logging
 from sky import task as task_lib
 from sky.backends import backend_utils
 from sky.backends import wheel_utils
+from sky.clouds import cloud as sky_cloud
 from sky.clouds import service_catalog
 from sky.clouds.utils import gcp_utils
 from sky.data import data_utils
@@ -1981,7 +1982,8 @@ class RetryingVmProvisioner(object):
         # is running. Here we check the enabled clouds and expiring credentials
         # and raise a warning to the user.
         if task.is_controller_task():
-            enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh()
+            enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh(
+                sky_cloud.CloudCapability.COMPUTE)
             expirable_clouds = backend_utils.get_expirable_clouds(
                 enabled_clouds)
 

sky/benchmark/benchmark_utils.py

@@ -172,8 +172,9 @@ def _create_benchmark_bucket() -> Tuple[str, str]:
     bucket_name = f'sky-bench-{uuid.uuid4().hex[:4]}-{getpass.getuser()}'
 
     # Select the bucket type.
-    enabled_clouds = storage_lib.get_cached_enabled_storage_clouds_or_refresh(
-        raise_if_no_cloud_access=True)
+    enabled_clouds = (
+        storage_lib.get_cached_enabled_storage_cloud_names_or_refresh(
+            raise_if_no_cloud_access=True))
     # Sky Benchmark only supports S3 (see _download_remote_dir and
     # _delete_remote_dir).
     enabled_clouds = [

sky/check.py

@@ -1,9 +1,9 @@
 """Credential checks: check cloud credentials and enable clouds."""
-import enum
 import os
 import traceback
 from types import ModuleType
-from typing import Dict, Iterable, List, Optional, Set, Tuple, Union
+from typing import (Any, Callable, Dict, Iterable, List, Optional, Set, Tuple,
+                    Union)
 
 import click
 import colorama
@@ -13,6 +13,7 @@ from sky import exceptions
 from sky import global_user_state
 from sky import skypilot_config
 from sky.adaptors import cloudflare
+from sky.clouds import cloud as sky_cloud
 from sky.utils import registry
 from sky.utils import rich_utils
 from sky.utils import ux_utils
@@ -21,98 +22,55 @@ CHECK_MARK_EMOJI = '\U00002714'  # Heavy check mark unicode
 PARTY_POPPER_EMOJI = '\U0001F389'  # Party popper unicode
 
 
-# Declaring CloudCapability as a subclass of str
-# allows it to be JSON serializable.
-class CloudCapability(str, enum.Enum):
-    # Compute capability.
-    COMPUTE = 'compute'
-    # Storage capability.
-    STORAGE = 'storage'
-
-
-ALL_CAPABILITIES = [CloudCapability.COMPUTE, CloudCapability.STORAGE]
-
-
 def check_capabilities(
     quiet: bool = False,
     verbose: bool = False,
     clouds: Optional[Iterable[str]] = None,
-    capabilities: Optional[List[CloudCapability]] = None,
-) -> Dict[str, List[CloudCapability]]:
+    capabilities: Optional[List[sky_cloud.CloudCapability]] = None,
+) -> Dict[str, List[sky_cloud.CloudCapability]]:
     echo = (lambda *_args, **_kwargs: None
            ) if quiet else lambda *args, **kwargs: click.echo(
                *args, **kwargs, color=True)
     echo('Checking credentials to enable clouds for SkyPilot.')
     if capabilities is None:
-        capabilities = ALL_CAPABILITIES
+        capabilities = sky_cloud.ALL_CAPABILITIES
     assert capabilities is not None
-    enabled_clouds: Dict[str, List[CloudCapability]] = {}
-    disabled_clouds: Dict[str, List[CloudCapability]] = {}
-
-    def check_credentials(
-            cloud: Union[sky_clouds.Cloud, ModuleType],
-            capability: CloudCapability) -> Tuple[bool, Optional[str]]:
-        if capability == CloudCapability.COMPUTE:
-            return cloud.check_credentials()
-        elif capability == CloudCapability.STORAGE:
-            return cloud.check_storage_credentials()
-        else:
-            raise ValueError(f'Invalid capability: {capability}')
-
-    def get_cached_state(capability: CloudCapability) -> List[sky_clouds.Cloud]:
-        if capability == CloudCapability.COMPUTE:
-            return global_user_state.get_cached_enabled_clouds()
-        elif capability == CloudCapability.STORAGE:
-            return global_user_state.get_cached_enabled_storage_clouds()
-        else:
-            raise ValueError(f'Invalid capability: {capability}')
-
-    def set_cached_state(clouds: List[str],
-                         capability: CloudCapability) -> None:
-        if capability == CloudCapability.COMPUTE:
-            global_user_state.set_enabled_clouds(clouds)
-        elif capability == CloudCapability.STORAGE:
-            global_user_state.set_enabled_storage_clouds(clouds)
-        else:
-            raise ValueError(f'Invalid capability: {capability}')
+    enabled_clouds: Dict[str, List[sky_cloud.CloudCapability]] = {}
+    disabled_clouds: Dict[str, List[sky_cloud.CloudCapability]] = {}
 
     def check_one_cloud(
             cloud_tuple: Tuple[str, Union[sky_clouds.Cloud,
                                           ModuleType]]) -> None:
         cloud_repr, cloud = cloud_tuple
         assert capabilities is not None
+        # cloud_capabilities is a list of (capability, ok, reason)
+        # where ok is True if the cloud credentials are valid for the capability
+        cloud_capabilities: List[Tuple[sky_cloud.CloudCapability, bool,
+                                       Optional[str]]] = []
         for capability in capabilities:
             with rich_utils.safe_status(f'Checking {cloud_repr}...'):
                 try:
-                    ok, reason = check_credentials(cloud, capability)
+                    ok, reason = cloud.check_credentials(capability)
                 except exceptions.NotSupportedError:
                     continue
                 except Exception:  # pylint: disable=broad-except
                     # Catch all exceptions to prevent a single cloud
                     # from blocking the check for other clouds.
                     ok, reason = False, traceback.format_exc()
-            status_msg = ('enabled' if ok else 'disabled')
-            styles = {'fg': 'green', 'bold': False} if ok else {'dim': True}
-            echo('  ' + click.style(f'{cloud_repr}: {status_msg}', **styles) +
-                 ' ' * 30)
+            cloud_capabilities.append(
+                (capability, ok, reason.strip() if reason else None))
             if ok:
                 enabled_clouds.setdefault(cloud_repr, []).append(capability)
-                if verbose and cloud is not cloudflare:
-                    activated_account = cloud.get_active_user_identity_str()
-                    if activated_account is not None:
-                        echo(f'    Activated account: {activated_account}')
-                if reason is not None:
-                    echo(f'    Hint: {reason}')
             else:
                 disabled_clouds.setdefault(cloud_repr, []).append(capability)
-                echo(f'    Reason: {reason}')
+        _print_checked_cloud(echo, verbose, cloud_tuple, cloud_capabilities)
 
     def get_cloud_tuple(
             cloud_name: str) -> Tuple[str, Union[sky_clouds.Cloud, ModuleType]]:
         # Validates cloud_name and returns a tuple of the cloud's name and
         # the cloud object. Includes special handling for Cloudflare.
         if cloud_name.lower().startswith('cloudflare'):
-            return cloudflare.SKY_CHECK_NAME, cloudflare
+            return cloudflare.NAME, cloudflare
         else:
             cloud_obj = registry.CLOUD_REGISTRY.from_str(cloud_name)
             assert cloud_obj is not None, f'Cloud {cloud_name!r} not found'
@@ -120,7 +78,7 @@ def check_capabilities(
 
     def get_all_clouds():
         return tuple([repr(c) for c in registry.CLOUD_REGISTRY.values()] +
-                     [cloudflare.SKY_CHECK_NAME])
+                     [cloudflare.NAME])
 
     if clouds is not None:
         cloud_list = clouds
@@ -170,12 +128,14 @@ def check_capabilities(
             if not cloud.startswith('Cloudflare')
         }
         previously_enabled_clouds_set = {
-            repr(cloud) for cloud in get_cached_state(capability)
+            repr(cloud)
+            for cloud in global_user_state.get_cached_enabled_clouds(capability)
         }
         enabled_clouds_for_capability = (config_allowed_clouds_set & (
             (previously_enabled_clouds_set | enabled_clouds_set) -
             disabled_clouds_set))
-        set_cached_state(list(enabled_clouds_for_capability), capability)
+        global_user_state.set_enabled_clouds(
+            list(enabled_clouds_for_capability), capability)
         all_enabled_clouds = all_enabled_clouds.union(
             enabled_clouds_for_capability)
     disallowed_clouds_hint = None
@@ -195,8 +155,8 @@ def check_capabilities(
             echo(click.style(disallowed_clouds_hint, dim=True))
         raise SystemExit()
     else:
-        clouds_arg = (' ' +
-                      ' '.join(disabled_clouds) if clouds is not None else '')
+        clouds_arg = (f' {" ".join(disabled_clouds).lower()}'
+                      if clouds is not None else '')
         echo(
             click.style(
                 '\nTo enable a cloud, follow the hints above and rerun: ',
@@ -212,7 +172,8 @@ def check_capabilities(
         # Pretty print for UX.
         if not quiet:
             enabled_clouds_str = '\n  ' + '\n  '.join([
-                _format_enabled_cloud(cloud) for cloud in sorted(enabled_clouds)
+                _format_enabled_cloud(cloud, capabilities)
+                for cloud, capabilities in enabled_clouds.items()
             ])
             echo(f'\n{colorama.Fore.GREEN}{PARTY_POPPER_EMOJI} '
                  f'Enabled clouds {PARTY_POPPER_EMOJI}'
@@ -220,14 +181,11 @@ def check_capabilities(
     return enabled_clouds
 
 
-# 'sky check' command and associated '/check' server endpoint
-# only checks compute capability for backward compatibility.
-# This necessitates setting default capability to CloudCapability.COMPUTE.
-def check(
+def check_capability(
+    capability: sky_cloud.CloudCapability,
     quiet: bool = False,
     verbose: bool = False,
     clouds: Optional[Iterable[str]] = None,
-    capability: CloudCapability = CloudCapability.COMPUTE,
 ) -> List[str]:
     clouds_with_capability = []
     enabled_clouds = check_capabilities(quiet, verbose, clouds, [capability])
@@ -237,7 +195,18 @@ def check(
     return clouds_with_capability
 
 
+def check(
+    quiet: bool = False,
+    verbose: bool = False,
+    clouds: Optional[Iterable[str]] = None,
+) -> List[str]:
+    return list(
+        check_capabilities(quiet, verbose, clouds,
+                           sky_cloud.ALL_CAPABILITIES).keys())
+
+
 def get_cached_enabled_clouds_or_refresh(
+        capability: sky_cloud.CloudCapability,
         raise_if_no_cloud_access: bool = False) -> List[sky_clouds.Cloud]:
     """Returns cached enabled clouds and if no cloud is enabled, refresh.
 
@@ -251,16 +220,18 @@ def get_cached_enabled_clouds_or_refresh(
         exceptions.NoCloudAccessError: if no public cloud is enabled and
             raise_if_no_cloud_access is set to True.
     """
-    cached_enabled_clouds = global_user_state.get_cached_enabled_clouds()
+    cached_enabled_clouds = global_user_state.get_cached_enabled_clouds(
+        capability)
     if not cached_enabled_clouds:
         try:
-            check(quiet=True, capability=CloudCapability.COMPUTE)
+            check_capability(sky_cloud.CloudCapability.COMPUTE, quiet=True)
         except SystemExit:
             # If no cloud is enabled, check() will raise SystemExit.
             # Here we catch it and raise the exception later only if
             # raise_if_no_cloud_access is set to True.
             pass
-        cached_enabled_clouds = global_user_state.get_cached_enabled_clouds()
+        cached_enabled_clouds = global_user_state.get_cached_enabled_clouds(
+            capability)
     if raise_if_no_cloud_access and not cached_enabled_clouds:
         with ux_utils.print_exception_no_traceback():
             raise exceptions.NoCloudAccessError(
@@ -269,41 +240,6 @@ def get_cached_enabled_clouds_or_refresh(
     return cached_enabled_clouds
 
 
-def get_cached_enabled_storage_clouds_or_refresh(
-        raise_if_no_cloud_access: bool = False) -> List[sky_clouds.Cloud]:
-    """Returns cached enabled storage clouds and if no cloud is enabled,
-    refresh.
-
-    This function will perform a refresh if no public cloud is enabled.
-
-    Args:
-        raise_if_no_cloud_access: if True, raise an exception if no public
-            cloud is enabled.
-
-    Raises:
-        exceptions.NoCloudAccessError: if no public cloud is enabled and
-            raise_if_no_cloud_access is set to True.
-    """
-    cached_enabled_storage_clouds = (
-        global_user_state.get_cached_enabled_storage_clouds())
-    if not cached_enabled_storage_clouds:
-        try:
-            check(quiet=True, capability=CloudCapability.STORAGE)
-        except SystemExit:
-            # If no cloud is enabled, check() will raise SystemExit.
-            # Here we catch it and raise the exception later only if
-            # raise_if_no_cloud_access is set to True.
-            pass
-        cached_enabled_storage_clouds = (
-            global_user_state.get_cached_enabled_storage_clouds())
-    if raise_if_no_cloud_access and not cached_enabled_storage_clouds:
-        with ux_utils.print_exception_no_traceback():
-            raise exceptions.NoCloudAccessError(
-                'Cloud access is not set up. Run: '
-                f'{colorama.Style.BRIGHT}sky check{colorama.Style.RESET_ALL}')
-    return cached_enabled_storage_clouds
-
-
 def get_cloud_credential_file_mounts(
         excluded_clouds: Optional[Iterable[sky_clouds.Cloud]]
 ) -> Dict[str, str]:
@@ -336,16 +272,80 @@ def get_cloud_credential_file_mounts(
     return file_mounts
 
 
-def _format_enabled_cloud(cloud_name: str) -> str:
+def _print_checked_cloud(
+    echo: Callable,
+    verbose: bool,
+    cloud_tuple: Tuple[str, Union[sky_clouds.Cloud, ModuleType]],
+    cloud_capabilities: List[Tuple[sky_cloud.CloudCapability, bool,
+                                   Optional[str]]],
+) -> None:
+    """Prints whether a cloud is enabled, and the capabilities that are enabled.
+    If any hints (for enabled capabilities) or
+    reasons (for disabled capabilities) are provided, they will be printed.
+
+    Args:
+        echo: The function to use to print the message.
+        verbose: Whether to print the verbose output.
+        cloud_tuple: The cloud to print the capabilities for.
+        cloud_capabilities: The capabilities for the cloud.
+    """
+    cloud_repr, cloud = cloud_tuple
+    # Print the capabilities for the cloud.
+    # consider cloud enabled if any capability is enabled.
+    enabled_capabilities: List[sky_cloud.CloudCapability] = []
+    hints_to_capabilities: Dict[str, List[sky_cloud.CloudCapability]] = {}
+    reasons_to_capabilities: Dict[str, List[sky_cloud.CloudCapability]] = {}
+    for capability, ok, reason in cloud_capabilities:
+        if ok:
+            enabled_capabilities.append(capability)
+            if reason is not None:
+                hints_to_capabilities.setdefault(reason, []).append(capability)
+        elif reason is not None:
+            reasons_to_capabilities.setdefault(reason, []).append(capability)
+    status_msg: str = 'disabled'
+    styles: Dict[str, Any] = {'dim': True}
+    capability_string: str = ''
+    activated_account: Optional[str] = None
+    if enabled_capabilities:
+        status_msg = 'enabled'
+        styles = {'fg': 'green', 'bold': False}
+        capability_string = f'[{", ".join(enabled_capabilities)}]'
+        if verbose and cloud is not cloudflare:
+            activated_account = cloud.get_active_user_identity_str()
+
+    echo(
+        click.style(f'  {cloud_repr}: {status_msg} {capability_string}',
+                    **styles))
+    if activated_account is not None:
+        echo(f'    Activated account: {activated_account}')
+    for reason, caps in hints_to_capabilities.items():
+        echo(f'    Hint [{", ".join(caps)}]: {reason}')
+    for reason, caps in reasons_to_capabilities.items():
+        echo(f'    Reason [{", ".join(caps)}]: {reason}')
+
+
+def _format_enabled_cloud(cloud_name: str,
+                          capabilities: List[sky_cloud.CloudCapability]) -> str:
+    """Format the summary of enabled cloud and its enabled capabilities.
+
+    Args:
+        cloud_name: The name of the cloud.
+        capabilities: The capabilities of the cloud.
+
+    Returns:
+        A string of the formatted cloud and capabilities.
+    """
+    cloud_and_capabilities = f'{cloud_name} [{", ".join(capabilities)}]'
 
-    def _green_color(cloud_name: str) -> str:
-        return f'{colorama.Fore.GREEN}{cloud_name}{colorama.Style.RESET_ALL}'
+    def _green_color(str_to_format: str) -> str:
+        return (
+            f'{colorama.Fore.GREEN}{str_to_format}{colorama.Style.RESET_ALL}')
 
     if cloud_name == repr(sky_clouds.Kubernetes()):
         # Get enabled contexts for Kubernetes
         existing_contexts = sky_clouds.Kubernetes.existing_allowed_contexts()
         if not existing_contexts:
-            return _green_color(cloud_name)
+            return _green_color(cloud_and_capabilities)
 
         # Check if allowed_contexts is explicitly set in config
         allowed_contexts = skypilot_config.get_nested(
@@ -363,7 +363,7 @@ def _format_enabled_cloud(cloud_name: str) -> str:
         else:
             context_info = f'Active context: {existing_contexts[0]}'
 
-        return (f'{_green_color(cloud_name)}\n'
+        return (f'{_green_color(cloud_and_capabilities)}\n'
                 f'  {colorama.Style.DIM}{context_info}'
                 f'{colorama.Style.RESET_ALL}')
-    return _green_color(cloud_name)
+    return _green_color(cloud_and_capabilities)