skypilot-nightly 1.0.0.dev20250905__py3-none-any.whl → 1.0.0.dev20251210__py3-none-any.whl

sky/client/cli/flags.py

@@ -284,8 +284,10 @@ def config_option(expose_value: bool):
     return return_option_decorator
 
 
-def yes_option():
+def yes_option(helptext: Optional[str] = None):
     """A decorator for the --yes/-y option."""
+    if helptext is None:
+        helptext = 'Skip confirmation prompt.'
 
     def return_option_decorator(func):
         return click.option('--yes',
@@ -293,7 +295,7 @@ def yes_option():
                             is_flag=True,
                             default=False,
                             required=False,
-                            help='Skip confirmation prompt.')(func)
+                            help=helptext)(func)
 
     return return_option_decorator
 

sky/{volumes/utils.py → client/cli/table_utils.py}

@@ -1,4 +1,4 @@
-"""Volume utils."""
+"""Utilities for formatting tables for CLI output."""
 import abc
 from datetime import datetime
 from typing import Any, Dict, List, Optional
@@ -6,6 +6,8 @@ from typing import Any, Dict, List, Optional
 import prettytable
 
 from sky import sky_logging
+from sky.jobs import utils as managed_jobs
+from sky.schemas.api import responses
 from sky.skylet import constants
 from sky.utils import common_utils
 from sky.utils import log_utils
@@ -13,6 +15,98 @@ from sky.utils import volume
 
 logger = sky_logging.init_logger(__name__)
 
+
+def format_job_queue(jobs: List[responses.ClusterJobRecord]):
+    """Format the job queue for display.
+
+    Usage:
+        jobs = get_job_queue()
+        print(format_job_queue(jobs))
+    """
+    job_table = log_utils.create_table([
+        'ID', 'NAME', 'USER', 'SUBMITTED', 'STARTED', 'DURATION', 'RESOURCES',
+        'STATUS', 'LOG', 'GIT COMMIT'
+    ])
+    for job in jobs:
+        job_table.add_row([
+            job.job_id,
+            job.job_name,
+            job.username,
+            log_utils.readable_time_duration(job.submitted_at),
+            log_utils.readable_time_duration(job.start_at),
+            log_utils.readable_time_duration(job.start_at,
+                                             job.end_at,
+                                             absolute=True),
+            job.resources,
+            job.status.colored_str(),
+            job.log_path,
+            job.metadata.get('git_commit', '-'),
+        ])
+    return job_table
+
+
+def format_storage_table(storages: List[responses.StorageRecord],
+                         show_all: bool = False) -> str:
+    """Format the storage table for display.
+
+    Args:
+        storage_table (dict): The storage table.
+
+    Returns:
+        str: The formatted storage table.
+    """
+    storage_table = log_utils.create_table([
+        'NAME',
+        'UPDATED',
+        'STORE',
+        'COMMAND',
+        'STATUS',
+    ])
+
+    for row in storages:
+        launched_at = row.launched_at
+        if show_all:
+            command = row.last_use
+        else:
+            command = common_utils.truncate_long_string(
+                row.last_use, constants.LAST_USE_TRUNC_LENGTH)
+        storage_table.add_row([
+            # NAME
+            row.name,
+            # LAUNCHED
+            log_utils.readable_time_duration(launched_at),
+            # CLOUDS
+            ', '.join([s.value for s in row.store]),
+            # COMMAND,
+            command,
+            # STATUS
+            row.status.value,
+        ])
+    if storages:
+        return str(storage_table)
+    else:
+        return 'No existing storage.'
+
+
+def format_job_table(
+    jobs: List[responses.ManagedJobRecord],
+    show_all: bool,
+    show_user: bool,
+    pool_status: Optional[List[Dict[str, Any]]] = None,
+    max_jobs: Optional[int] = None,
+    status_counts: Optional[Dict[str, int]] = None,
+):
+    jobs = [job.model_dump() for job in jobs]
+    return managed_jobs.format_job_table(
+        jobs,
+        pool_status=pool_status,
+        show_all=show_all,
+        show_user=show_user,
+        max_jobs=max_jobs,
+        job_status_counts=status_counts,
+    )
+
+
 _BASIC_COLUMNS = [
     'NAME',
     'TYPE',
@@ -43,13 +137,15 @@ def _get_infra_str(cloud: Optional[str], region: Optional[str],
 class VolumeTable(abc.ABC):
     """The volume table."""
 
-    def __init__(self, volumes: List[Dict[str, Any]], show_all: bool = False):
+    def __init__(self,
+                 volumes: List[responses.VolumeRecord],
+                 show_all: bool = False):
         super().__init__()
         self.table = self._create_table(show_all)
         self._add_rows(volumes, show_all)
 
     def _get_row_base_columns(self,
-                              row: Dict[str, Any],
+                              row: responses.VolumeRecord,
                               show_all: bool = False) -> List[str]:
         """Get the base columns for a row."""
         # Convert last_attached_at timestamp to human readable string
@@ -94,7 +190,7 @@ class VolumeTable(abc.ABC):
         raise NotImplementedError
 
     def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
+                  volumes: List[responses.VolumeRecord],
                   show_all: bool = False) -> None:
         """Add rows to the volume table."""
         raise NotImplementedError
@@ -112,30 +208,32 @@ class PVCVolumeTable(VolumeTable):
         """Create the PVC volume table."""
         #  If show_all is False, show the table with the columns:
         #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY
+        #   AGE, STATUS, LAST_USE, USED_BY, IS_EPHEMERAL
         #  If show_all is True, show the table with the columns:
         #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY, NAME_ON_CLOUD
+        #   AGE, STATUS, LAST_USE, USED_BY, IS_EPHEMERAL, NAME_ON_CLOUD
         #   STORAGE_CLASS, ACCESS_MODE
 
+        columns = _BASIC_COLUMNS + [
+            'IS_EPHEMERAL',
+        ]
         if show_all:
-            columns = _BASIC_COLUMNS + [
+            columns = columns + [
                 'NAME_ON_CLOUD',
                 'STORAGE_CLASS',
                 'ACCESS_MODE',
             ]
-        else:
-            columns = _BASIC_COLUMNS
 
         table = log_utils.create_table(columns)
         return table
 
     def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
+                  volumes: List[responses.VolumeRecord],
                   show_all: bool = False) -> None:
         """Add rows to the PVC volume table."""
         for row in volumes:
             table_row = self._get_row_base_columns(row, show_all)
+            table_row.append(row.get('is_ephemeral', False))
             if show_all:
                 table_row.append(row.get('name_on_cloud', ''))
                 table_row.append(
@@ -170,7 +268,7 @@ class RunPodVolumeTable(VolumeTable):
         return table
 
     def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
+                  volumes: List[responses.VolumeRecord],
                   show_all: bool = False) -> None:
         """Add rows to the RunPod volume table."""
         for row in volumes:
@@ -185,7 +283,7 @@ class RunPodVolumeTable(VolumeTable):
         return 'RunPod Network Volumes:\n' + str(self.table)
 
 
-def format_volume_table(volumes: List[Dict[str, Any]],
+def format_volume_table(volumes: List[responses.VolumeRecord],
                         show_all: bool = False) -> str:
     """Format the volume table for display.
 
@@ -195,7 +293,7 @@ def format_volume_table(volumes: List[Dict[str, Any]],
     Returns:
         str: The formatted volume table.
     """
-    volumes_per_type: Dict[str, List[Dict[str, Any]]] = {}
+    volumes_per_type: Dict[str, List[responses.VolumeRecord]] = {}
     supported_volume_types = [
         volume_type.value for volume_type in volume.VolumeType
     ]

sky/client/cli/utils.py

@@ -0,0 +1,79 @@
+"""Utility functions for the CLI."""
+import enum
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+from sky import exceptions
+from sky import jobs as managed_jobs
+from sky.schemas.api import responses
+from sky.server import common as server_common
+
+
+class QueueResultVersion(enum.Enum):
+    """The version of the queue result.
+
+    V1: The old version of the queue result.
+        - job_records (List[responses.ManagedJobRecord]): A list of dicts,
+           with each dict containing the information of a job.
+    V2: The new version of the queue result.
+        - job_records (List[responses.ManagedJobRecord]): A list of dicts,
+           with each dict containing the information of a job.
+        - total (int): Total number of jobs after filter.
+        - status_counts (Dict[str, int]): Status counts after filter.
+        - total_no_filter (int): Total number of jobs before filter.
+    """
+    V1 = 'v1'
+    V2 = 'v2'
+
+    def v2(self) -> bool:
+        return self == QueueResultVersion.V2
+
+
+def get_managed_job_queue(
+    refresh: bool,
+    skip_finished: bool = False,
+    all_users: bool = False,
+    job_ids: Optional[List[int]] = None,
+    limit: Optional[int] = None,
+    fields: Optional[List[str]] = None,
+) -> Tuple[server_common.RequestId[Union[List[responses.ManagedJobRecord],
+                                         Tuple[List[responses.ManagedJobRecord],
+                                               int, Dict[str, int], int]]],
+           QueueResultVersion]:
+    """Gets statuses of managed jobs.
+
+    Please refer to sky.cli.job_queue for documentation.
+
+    Args:
+        refresh: Whether to restart the jobs controller if it is stopped.
+        skip_finished: Whether to skip finished jobs.
+        all_users: Whether to show all users' jobs.
+        job_ids: IDs of the managed jobs to show.
+        limit: Number of jobs to show.
+        fields: Fields to get for the managed jobs.
+
+    Returns:
+        - the request ID of the queue request
+        - the version of the queue result
+
+    Request Raises:
+        sky.exceptions.ClusterNotUpError: the jobs controller is not up or
+          does not exist.
+        RuntimeError: if failed to get the managed jobs with ssh.
+    """
+    try:
+        return typing.cast(
+            server_common.RequestId[
+                Union[List[responses.ManagedJobRecord],
+                      Tuple[List[responses.ManagedJobRecord], int,
+                            Dict[str, int], int]]],
+            managed_jobs.queue_v2(refresh, skip_finished, all_users, job_ids,
+                                  limit, fields)), QueueResultVersion.V2
+    except exceptions.APINotSupportedError:
+        return typing.cast(
+            server_common.RequestId[
+                Union[List[responses.ManagedJobRecord],
+                      Tuple[List[responses.ManagedJobRecord], int,
+                            Dict[str, int], int]]],
+            managed_jobs.queue(refresh, skip_finished, all_users,
+                               job_ids)), QueueResultVersion.V1

sky/client/common.py

@@ -44,8 +44,10 @@ logger = sky_logging.init_logger(__name__)
 _DOWNLOAD_CHUNK_BYTES = 8192
 # The chunk size for the zip file to be uploaded to the API server. We split
 # the zip file into chunks to avoid network issues for large request body that
-# can be caused by NGINX's client_max_body_size.
-_UPLOAD_CHUNK_BYTES = 512 * 1024 * 1024
+# can be caused by NGINX's client_max_body_size or Cloudflare's upload limit.
+# As of 09/25/2025, the upload limit for Cloudflare's free plan is 100MiB:
+# https://developers.cloudflare.com/support/troubleshooting/http-status-codes/4xx-client-error/error-413/
+_UPLOAD_CHUNK_BYTES = 100 * 1024 * 1024
 
 FILE_UPLOAD_LOGS_DIR = os.path.join(constants.SKY_LOGS_DIRECTORY,
                                     'file_uploads')
@@ -81,6 +83,14 @@ def download_logs_from_api_server(
             remote_machine_prefix,
             local_machine_prefix) for remote_path in paths_on_api_server
     }
+    # Check if any local log directories already exist before downloading
+    for local_path in remote2local_path_dict.values():
+        expanded_path = os.path.expanduser(local_path)
+        if os.path.exists(expanded_path):
+            logger.warning(
+                f'Log directory {local_path} already exists. '
+                f'This may overwrite logs from a previous cluster with the '
+                f'same name and job ID.')
     body = payloads.DownloadBody(folder_paths=list(paths_on_api_server),)
     response = server_common.make_authenticated_request(
         'POST',