skypilot-nightly 1.0.0.dev20250523__py3-none-any.whl → 1.0.0.dev20250524__py3-none-any.whl

sky/utils/cli_utils/status_utils.py

@@ -48,7 +48,8 @@ class StatusColumn:
 def show_status_table(cluster_records: List[_ClusterRecord],
                       show_all: bool,
                       show_user: bool,
-                      query_clusters: Optional[List[str]] = None) -> int:
+                      query_clusters: Optional[List[str]] = None,
+                      show_workspaces: bool = False) -> int:
     """Compute cluster table values and display.
 
     Returns:
@@ -56,7 +57,6 @@ def show_status_table(cluster_records: List[_ClusterRecord],
         STOPPED.
     """
     # TODO(zhwu): Update the information for autostop clusters.
-
     status_columns = [
         StatusColumn('NAME', _get_name),
     ]
@@ -66,6 +66,9 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             StatusColumn('USER_ID', _get_user_hash, show_by_default=False))
 
     status_columns += [
+        StatusColumn('WORKSPACE',
+                     _get_workspace,
+                     show_by_default=show_workspaces),
         StatusColumn('INFRA', _get_infra, truncate=not show_all),
         StatusColumn('RESOURCES', _get_resources, truncate=not show_all),
         StatusColumn('STATUS', _get_status_colored),
@@ -106,12 +109,13 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             for cluster in query_clusters
             if cluster not in cluster_names
         ]
-        cluster_str = 'Cluster'
-        if len(not_found_clusters) > 1:
-            cluster_str += 's'
-        cluster_str += ' '
-        cluster_str += ', '.join(not_found_clusters)
-        click.echo(f'{cluster_str} not found.')
+        if not_found_clusters:
+            cluster_str = 'Cluster'
+            if len(not_found_clusters) > 1:
+                cluster_str += 's'
+            cluster_str += ' '
+            cluster_str += ', '.join(not_found_clusters)
+            click.echo(f'{cluster_str} not found.')
     elif not cluster_records:
         click.echo('No existing clusters.')
     return num_pending_autostop
@@ -243,6 +247,12 @@ def _get_status(cluster_record: _ClusterRecord,
     return cluster_record['status']
 
 
+def _get_workspace(cluster_record: _ClusterRecord,
+                   truncate: bool = True) -> str:
+    del truncate
+    return cluster_record['workspace']
+
+
 def _get_status_colored(cluster_record: _ClusterRecord,
                         truncate: bool = True) -> str:
     del truncate

sky/utils/kubernetes/deploy_remote_cluster.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, List, Optional, Set
 
 import yaml
 
+from sky.utils import ux_utils
+
 # Colors for nicer UX
 RED = '\033[0;31m'
 GREEN = '\033[0;32m'
@@ -117,21 +119,19 @@ def parse_args():
 def load_ssh_targets(file_path: str) -> Dict[str, Any]:
     """Load SSH targets from YAML file."""
     if not os.path.exists(file_path):
-        print(f'{RED}Error: SSH Node Pools file not found: {file_path}{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'SSH Node Pools file not found: {file_path}')
 
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             targets = yaml.load(f, Loader=UniqueKeySafeLoader)
         return targets
     except yaml.constructor.ConstructorError as e:
-        print(f'{RED}{e.note}{NC}', file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(e.note) from e
     except (yaml.YAMLError, IOError, OSError) as e:
-        print(f'{RED}Error loading SSH Node Pools file: {e}{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'Error loading SSH Node Pools file: {e}') from e
 
 
 def check_host_in_ssh_config(hostname: str) -> bool:
@@ -181,31 +181,28 @@ def get_cluster_config(targets: Dict[str, Any],
                        file_path: Optional[str] = None) -> Dict[str, Any]:
     """Get configuration for specific clusters or all clusters."""
     if not targets:
-        print(
-            f'{RED}Error: No clusters defined in SSH Node Pools '
-            f'file {file_path}{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No clusters defined in SSH Node Pools file {file_path}')
 
     if cluster_name:
         if cluster_name not in targets:
-            print(
-                f'{RED}Error: Cluster {cluster_name!r} not found in '
-                f'SSH Node Pools file {file_path}{NC}',
-                file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'Cluster {cluster_name!r} not found in '
+                                 f'SSH Node Pools file {file_path}')
         return {cluster_name: targets[cluster_name]}
 
     # Return all clusters if no specific cluster is specified
     return targets
 
 
-def prepare_hosts_info(cluster_config: Dict[str, Any]) -> List[Dict[str, str]]:
+def prepare_hosts_info(cluster_name: str,
+                       cluster_config: Dict[str, Any]) -> List[Dict[str, str]]:
     """Prepare list of hosts with resolved user, identity_file, and password."""
     if 'hosts' not in cluster_config or not cluster_config['hosts']:
-        print(f'{RED}Error: No hosts defined in cluster configuration{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No hosts defined in cluster {cluster_name} configuration')
 
     # Get cluster-level defaults
     cluster_user = cluster_config.get('user', '')
@@ -636,23 +633,20 @@ def main():
         # Using command line arguments - legacy mode
         if args.ssh_key and not os.path.isfile(
                 args.ssh_key) and not global_use_ssh_config:
-            print(f'{RED}Error: SSH key not found: {args.ssh_key}{NC}',
-                  file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'SSH key not found: {args.ssh_key}')
 
         if not os.path.isfile(args.ips_file):
-            print(f'{RED}Error: IPs file not found: {args.ips_file}{NC}',
-                  file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'IPs file not found: {args.ips_file}')
 
         with open(args.ips_file, 'r', encoding='utf-8') as f:
             hosts = [line.strip() for line in f if line.strip()]
 
         if not hosts:
-            print(
-                f'{RED}Error: Hosts file is empty or not formatted correctly.{NC}',
-                file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    'Hosts file is empty or not formatted correctly.')
 
         head_node = hosts[0]
         worker_nodes = hosts[1:]
@@ -688,108 +682,121 @@ def main():
 
         # Process each cluster
         for cluster_name, cluster_config in clusters_config.items():
-            print(f'SKYPILOT_CURRENT_CLUSTER: {cluster_name}')
-            print(f'{YELLOW}==== Deploying cluster: {cluster_name} ====${NC}')
-            hosts_info = prepare_hosts_info(cluster_config)
-
-            if not hosts_info:
+            try:
+                print(f'SKYPILOT_CURRENT_CLUSTER: {cluster_name}')
                 print(
-                    f'{RED}Error: No valid hosts found for cluster {cluster_name!r}. Skipping.{NC}'
-                )
-                continue
-
-            # Generate a unique context name for each cluster
-            context_name = args.context_name
-            if context_name == 'default':
-                context_name = 'ssh-' + cluster_name
-
-            # Check cluster history
-            os.makedirs(NODE_POOLS_INFO_DIR, exist_ok=True)
-            history_yaml_file = os.path.join(NODE_POOLS_INFO_DIR,
-                                             f'{context_name}-history.yaml')
-
-            history = None
-            if os.path.exists(history_yaml_file):
-                print(f'{YELLOW}Loading history from {history_yaml_file}{NC}')
-                with open(history_yaml_file, 'r', encoding='utf-8') as f:
-                    history = yaml.safe_load(f)
-            else:
-                print(f'{YELLOW}No history found for {context_name}.{NC}')
-
-            history_workers_info = None
-            history_worker_nodes = None
-            history_use_ssh_config = None
-            # Do not support changing anything besides hosts for now
-            if history is not None:
-                for key in ['user', 'identity_file', 'password']:
-                    if history.get(key) != cluster_config.get(key):
+                    f'{YELLOW}==== Deploying cluster: {cluster_name} ====${NC}')
+                hosts_info = prepare_hosts_info(cluster_name, cluster_config)
+
+                if not hosts_info:
+                    print(
+                        f'{RED}Error: No valid hosts found for cluster {cluster_name!r}. Skipping.{NC}'
+                    )
+                    continue
+
+                # Generate a unique context name for each cluster
+                context_name = args.context_name
+                if context_name == 'default':
+                    context_name = 'ssh-' + cluster_name
+
+                # Check cluster history
+                os.makedirs(NODE_POOLS_INFO_DIR, exist_ok=True)
+                history_yaml_file = os.path.join(
+                    NODE_POOLS_INFO_DIR, f'{context_name}-history.yaml')
+
+                history = None
+                if os.path.exists(history_yaml_file):
+                    print(
+                        f'{YELLOW}Loading history from {history_yaml_file}{NC}')
+                    with open(history_yaml_file, 'r', encoding='utf-8') as f:
+                        history = yaml.safe_load(f)
+                else:
+                    print(f'{YELLOW}No history found for {context_name}.{NC}')
+
+                history_workers_info = None
+                history_worker_nodes = None
+                history_use_ssh_config = None
+                # Do not support changing anything besides hosts for now
+                if history is not None:
+                    for key in ['user', 'identity_file', 'password']:
+                        if history.get(key) != cluster_config.get(key):
+                            raise ValueError(
+                                f'Cluster configuration has changed for field {key!r}. '
+                                f'Previous value: {history.get(key)}, '
+                                f'Current value: {cluster_config.get(key)}')
+                    history_hosts_info = prepare_hosts_info(
+                        cluster_name, history)
+                    if history_hosts_info[0] != hosts_info[0]:
                         raise ValueError(
-                            f'Cluster configuration has changed for field {key!r}. '
-                            f'Previous value: {history.get(key)}, '
-                            f'Current value: {cluster_config.get(key)}')
-                history_hosts_info = prepare_hosts_info(history)
-                if history_hosts_info[0] != hosts_info[0]:
-                    raise ValueError(
-                        f'Cluster configuration has changed for master node. '
-                        f'Previous value: {history_hosts_info[0]}, '
-                        f'Current value: {hosts_info[0]}')
-                history_workers_info = history_hosts_info[1:] if len(
-                    history_hosts_info) > 1 else []
-                history_worker_nodes = [h['ip'] for h in history_workers_info]
-                history_use_ssh_config = [
-                    h.get('use_ssh_config', False) for h in history_workers_info
+                            f'Cluster configuration has changed for master node. '
+                            f'Previous value: {history_hosts_info[0]}, '
+                            f'Current value: {hosts_info[0]}')
+                    history_workers_info = history_hosts_info[1:] if len(
+                        history_hosts_info) > 1 else []
+                    history_worker_nodes = [
+                        h['ip'] for h in history_workers_info
+                    ]
+                    history_use_ssh_config = [
+                        h.get('use_ssh_config', False)
+                        for h in history_workers_info
+                    ]
+
+                # Use the first host as the head node and the rest as worker nodes
+                head_host = hosts_info[0]
+                worker_hosts = hosts_info[1:] if len(hosts_info) > 1 else []
+
+                head_node = head_host['ip']
+                worker_nodes = [h['ip'] for h in worker_hosts]
+                ssh_user = head_host['user']
+                ssh_key = head_host['identity_file']
+                head_use_ssh_config = global_use_ssh_config or head_host.get(
+                    'use_ssh_config', False)
+                worker_use_ssh_config = [
+                    global_use_ssh_config or h.get('use_ssh_config', False)
+                    for h in worker_hosts
                 ]
+                password = head_host['password']
+
+                # Deploy this cluster
+                unsuccessful_workers = deploy_cluster(
+                    head_node,
+                    worker_nodes,
+                    ssh_user,
+                    ssh_key,
+                    context_name,
+                    password,
+                    head_use_ssh_config,
+                    worker_use_ssh_config,
+                    kubeconfig_path,
+                    args.cleanup,
+                    worker_hosts=worker_hosts,
+                    history_worker_nodes=history_worker_nodes,
+                    history_workers_info=history_workers_info,
+                    history_use_ssh_config=history_use_ssh_config)
+
+                if not args.cleanup:
+                    successful_hosts = []
+                    for host in cluster_config['hosts']:
+                        if isinstance(host, str):
+                            host_node = host
+                        else:
+                            host_node = host['ip']
+                        if host_node not in unsuccessful_workers:
+                            successful_hosts.append(host)
+                    cluster_config['hosts'] = successful_hosts
+                    with open(history_yaml_file, 'w', encoding='utf-8') as f:
+                        print(
+                            f'{YELLOW}Writing history to {history_yaml_file}{NC}'
+                        )
+                        yaml.dump(cluster_config, f)
 
-            # Use the first host as the head node and the rest as worker nodes
-            head_host = hosts_info[0]
-            worker_hosts = hosts_info[1:] if len(hosts_info) > 1 else []
-
-            head_node = head_host['ip']
-            worker_nodes = [h['ip'] for h in worker_hosts]
-            ssh_user = head_host['user']
-            ssh_key = head_host['identity_file']
-            head_use_ssh_config = global_use_ssh_config or head_host.get(
-                'use_ssh_config', False)
-            worker_use_ssh_config = [
-                global_use_ssh_config or h.get('use_ssh_config', False)
-                for h in worker_hosts
-            ]
-            password = head_host['password']
-
-            # Deploy this cluster
-            unsuccessful_workers = deploy_cluster(
-                head_node,
-                worker_nodes,
-                ssh_user,
-                ssh_key,
-                context_name,
-                password,
-                head_use_ssh_config,
-                worker_use_ssh_config,
-                kubeconfig_path,
-                args.cleanup,
-                worker_hosts=worker_hosts,
-                history_worker_nodes=history_worker_nodes,
-                history_workers_info=history_workers_info,
-                history_use_ssh_config=history_use_ssh_config)
-
-            if not args.cleanup:
-                successful_hosts = []
-                for host in cluster_config['hosts']:
-                    if isinstance(host, str):
-                        host_node = host
-                    else:
-                        host_node = host['ip']
-                    if host_node not in unsuccessful_workers:
-                        successful_hosts.append(host)
-                cluster_config['hosts'] = successful_hosts
-                with open(history_yaml_file, 'w', encoding='utf-8') as f:
-                    print(f'{YELLOW}Writing history to {history_yaml_file}{NC}')
-                    yaml.dump(cluster_config, f)
-
-            print(
-                f'{GREEN}==== Completed deployment for cluster: {cluster_name} ====${NC}'
-            )
+                print(
+                    f'{GREEN}==== Completed deployment for cluster: {cluster_name} ====${NC}'
+                )
+            except Exception as e:  # pylint: disable=broad-except
+                print(
+                    f'{RED}Error deploying SSH Node Pool {cluster_name}: {e}{NC}'
+                )
 
 
 def deploy_cluster(head_node,
@@ -839,11 +846,9 @@ def deploy_cluster(head_node,
         # For SkySSHUpLineProcessor
         print_output=True)
     if result is None:
-        print(
-            f'{RED}Failed to SSH to head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(f'Failed to SSH to head node ({head_node}). '
+                               f'Please check the SSH configuration.')
 
     # Checking history
     history_exists = (history_worker_nodes is not None and
@@ -981,10 +986,10 @@ def deploy_cluster(head_node,
         print_output=True,
         use_shell=True)
     if result is None:
-        print(
-            f'{RED}Failed to setup TCP forwarding on head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to setup TCP forwarding on head node ({head_node}). '
+                f'Please check the SSH configuration.')
 
     # Get effective IP for master node if using SSH config - needed for workers to connect
     if head_use_ssh_config:
@@ -1024,9 +1029,9 @@ def deploy_cluster(head_node,
                         ssh_key,
                         use_ssh_config=head_use_ssh_config)
     if result is None:
-        print(f'{RED}Failed to deploy K3s on head node ({head_node}). {NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to deploy K3s on head node ({head_node}).')
     success_message(f'K3s deployed on head node ({head_node}).')
 
     # Check if head node has a GPU
@@ -1045,11 +1050,9 @@ def deploy_cluster(head_node,
                              ssh_key,
                              use_ssh_config=head_use_ssh_config)
     if master_addr is None:
-        print(
-            f'{RED}Failed to SSH to head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(f'Failed to SSH to head node ({head_node}). '
+                               f'Please check the SSH configuration.')
     print(f'{GREEN}Master node internal IP: {master_addr}{NC}')
 
     # Step 2: Install k3s on worker nodes and join them to the master node

sky/utils/log_utils.py

@@ -497,6 +497,10 @@ class SkySSHUpLineProcessor(LineProcessor):
                 f'✗ Failed to setup TCP forwarding on head node {node_name}.'
                 f'{colorama.Style.RESET_ALL}')
 
+        if 'Error in deploying SSH Target' in log_line:
+            logger.info(f'{ux_utils.INDENT_LAST_SYMBOL}{colorama.Fore.RED}'
+                        f'{log_line.strip()}{colorama.Style.RESET_ALL}')
+
     def __exit__(self, except_type: Optional[Type[BaseException]],
                  except_value: Optional[BaseException],
                  traceback: Optional[types.TracebackType]) -> None:

sky/utils/schemas.py

@@ -1173,6 +1173,54 @@ def get_config_schema():
         }
     }
 
+    workspace_schema = {'type': 'string'}
+
+    allowed_workspace_cloud_names = list(
+        service_catalog.ALL_CLOUDS) + ['cloudflare']
+    # Create pattern for non-GCP clouds (all clouds except gcp)
+    non_gcp_clouds = [
+        cloud for cloud in allowed_workspace_cloud_names
+        if cloud.lower() != 'gcp'
+    ]
+    non_gcp_cloud_regex = '|'.join(non_gcp_clouds)
+    workspaces_schema = {
+        'type': 'object',
+        'required': [],
+        # each key is a workspace name
+        'additionalProperties': {
+            'type': 'object',
+            'additionalProperties': False,
+            'patternProperties': {
+                # Pattern for non-GCP clouds - only allows 'disabled' property
+                f'^({non_gcp_cloud_regex})$': {
+                    'type': 'object',
+                    'additionalProperties': False,
+                    'properties': {
+                        'disabled': {
+                            'type': 'boolean'
+                        }
+                    },
+                },
+            },
+            'properties': {
+                # Explicit definition for GCP allows both project_id and
+                # disabled
+                'gcp': {
+                    'type': 'object',
+                    'properties': {
+                        'project_id': {
+                            'type': 'string'
+                        },
+                        'disabled': {
+                            'type': 'boolean'
+                        }
+                    },
+                    'additionalProperties': False,
+                },
+            },
+        },
+    }
+
     provision_configs = {
         'type': 'object',
         'required': [],
@@ -1199,6 +1247,10 @@ def get_config_schema():
         'required': [],
         'additionalProperties': False,
         'properties': {
+            # TODO Replace this with whatever syang cooks up
+            'workspace': {
+                'type': 'string',
+            },
             'jobs': controller_resources_schema,
             'serve': controller_resources_schema,
             'allowed_clouds': allowed_clouds,
@@ -1206,6 +1258,8 @@ def get_config_schema():
             'docker': docker_configs,
             'nvidia_gpus': gpu_configs,
             'api_server': api_server,
+            'active_workspace': workspace_schema,
+            'workspaces': workspaces_schema,
             'provision': provision_configs,
             **cloud_configs,
         },

{skypilot_nightly-1.0.0.dev20250523.dist-info → skypilot_nightly-1.0.0.dev20250524.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250523
+Version: 1.0.0.dev20250524
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0