skypilot-nightly 1.0.0.dev20250627__py3-none-any.whl → 1.0.0.dev20250628__py3-none-any.whl

sky/utils/config_utils.py

@@ -226,3 +226,44 @@ def merge_k8s_configs(
                 base_config[key].extend(value)
         else:
             base_config[key] = value
+
+
+def get_cloud_config_value_from_dict(
+        dict_config: Dict[str, Any],
+        cloud: str,
+        keys: Tuple[str, ...],
+        region: Optional[str] = None,
+        default_value: Optional[Any] = None,
+        override_configs: Optional[Dict[str, Any]] = None) -> Any:
+    """Returns the nested key value by reading from config
+    Order to get the property_name value:
+    1. if region is specified,
+       try to get the value from <cloud>/<region_key>/<region>/keys
+    2. if no region or no override,
+       try to get it at the cloud level <cloud>/keys
+    3. if not found at cloud level,
+       return either default_value if specified or None
+    """
+    input_config = Config(dict_config)
+    region_key = None
+    if cloud == 'kubernetes':
+        region_key = 'context_configs'
+
+    per_context_config = None
+    if region is not None and region_key is not None:
+        per_context_config = input_config.get_nested(
+            keys=(cloud, region_key, region) + keys,
+            default_value=None,
+            override_configs=override_configs)
+    # if no override found for specified region
+    general_config = input_config.get_nested(keys=(cloud,) + keys,
+                                             default_value=default_value,
+                                             override_configs=override_configs)
+
+    if (cloud == 'kubernetes' and isinstance(general_config, dict) and
+            isinstance(per_context_config, dict)):
+        merge_k8s_configs(general_config, per_context_config)
+        return general_config
+    else:
+        return (general_config
+                if per_context_config is None else per_context_config)

sky/utils/controller_utils.py

@@ -733,7 +733,11 @@ def _setup_proxy_command_on_controller(
     config = config_utils.Config.from_dict(user_config)
     proxy_command_key = (str(controller_launched_cloud).lower(),
                          'ssh_proxy_command')
-    ssh_proxy_command = config.get_nested(proxy_command_key, None)
+    ssh_proxy_command = skypilot_config.get_effective_region_config(
+        cloud=str(controller_launched_cloud).lower(),
+        region=None,
+        keys=('ssh_proxy_command',),
+        default_value=None)
     if isinstance(ssh_proxy_command, str):
         config.set_nested(proxy_command_key, None)
     elif isinstance(ssh_proxy_command, dict):

sky/utils/resource_checker.py

@@ -0,0 +1,153 @@
+"""Resource checking utilities for finding active clusters and managed jobs."""
+
+import concurrent.futures
+from typing import Any, Callable, Dict, List, Tuple
+
+from sky import exceptions
+from sky import global_user_state
+from sky import sky_logging
+from sky.skylet import constants
+
+logger = sky_logging.init_logger(__name__)
+
+
+def check_no_active_resources_for_users(
+        user_operations: List[Tuple[str, str]]) -> None:
+    """Check if users have active clusters or managed jobs.
+
+    Args:
+        user_operations: List of tuples (user_id, operation) where
+            operation is 'update' or 'delete'.
+
+    Raises:
+        ValueError: If any user has active clusters or managed jobs.
+            The error message will include all users with issues.
+    """
+    if not user_operations:
+        return
+
+    def filter_by_user(user_id: str):
+        return lambda resource: resource.get('user_hash') == user_id
+
+    _check_active_resources(user_operations, filter_by_user, 'user')
+
+
+def check_no_active_resources_for_workspaces(
+        workspace_operations: List[Tuple[str, str]]) -> None:
+    """Check if workspaces have active clusters or managed jobs.
+
+    Args:
+        workspace_operations: List of tuples (workspace_name, operation) where
+            operation is 'update' or 'delete'.
+
+    Raises:
+        ValueError: If any workspace has active clusters or managed jobs.
+            The error message will include all workspaces with issues.
+    """
+    if not workspace_operations:
+        return
+
+    def filter_by_workspace(workspace_name: str):
+        return lambda resource: (resource.get(
+            'workspace', constants.SKYPILOT_DEFAULT_WORKSPACE) == workspace_name
+                                )
+
+    _check_active_resources(workspace_operations, filter_by_workspace,
+                            'workspace')
+
+
+def _check_active_resources(resource_operations: List[Tuple[str, str]],
+                            filter_factory: Callable[[str],
+                                                     Callable[[Dict[str, Any]],
+                                                              bool]],
+                            resource_type: str) -> None:
+    """Check if resource entities have active clusters or managed jobs.
+
+    Args:
+        resource_operations: List of tuples (resource_name, operation) where
+            operation is 'update' or 'delete'.
+        filter_factory: Function that takes a resource_name and returns a filter
+            function for clusters/jobs.
+        resource_type: Type of resource being checked ('user' or 'workspace').
+
+    Raises:
+        ValueError: If any resource has active clusters or managed jobs.
+    """
+
+    def get_all_clusters():
+        return global_user_state.get_clusters()
+
+    def get_all_managed_jobs():
+        # pylint: disable=import-outside-toplevel
+        from sky.jobs.server import core as managed_jobs_core
+        try:
+            return managed_jobs_core.queue(refresh=False,
+                                           skip_finished=True,
+                                           all_users=True)
+        except exceptions.ClusterNotUpError:
+            logger.warning('All jobs should be finished.')
+            return []
+
+    # Fetch both clusters and jobs in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+        clusters_future = executor.submit(get_all_clusters)
+        jobs_future = executor.submit(get_all_managed_jobs)
+
+        all_clusters = clusters_future.result()
+        all_managed_jobs = jobs_future.result()
+
+    # Collect all error messages instead of raising immediately
+    error_messages = []
+
+    # Check each resource against the fetched data
+    for resource_name, operation in resource_operations:
+        resource_filter = filter_factory(resource_name)
+
+        # Filter clusters for this resource
+        resource_clusters = [
+            cluster for cluster in all_clusters if resource_filter(cluster)
+        ]
+
+        # Filter managed jobs for this resource
+        resource_active_jobs = [
+            job for job in all_managed_jobs if resource_filter(job)
+        ]
+
+        # Collect error messages for this resource
+        resource_errors = []
+
+        if resource_clusters:
+            active_cluster_names = [
+                cluster['name'] for cluster in resource_clusters
+            ]
+            cluster_list = ', '.join(active_cluster_names)
+            resource_errors.append(
+                f'{len(resource_clusters)} active cluster(s): {cluster_list}')
+
+        if resource_active_jobs:
+            job_names = [str(job['job_id']) for job in resource_active_jobs]
+            job_list = ', '.join(job_names)
+            resource_errors.append(
+                f'{len(resource_active_jobs)} active managed job(s): '
+                f'{job_list}')
+
+        # If this resource has issues, add to overall error messages
+        if resource_errors:
+            resource_error_summary = ' and '.join(resource_errors)
+            error_messages.append(
+                f'Cannot {operation} {resource_type} {resource_name!r} '
+                f'because it has {resource_error_summary}.')
+
+    # If we collected any errors, raise them all together
+    if error_messages:
+        if len(error_messages) == 1:
+            # Single resource error
+            full_message = error_messages[
+                0] + ' Please terminate these resources first.'
+        else:
+            # Multiple resource errors
+            full_message = (f'Cannot proceed due to active resources in '
+                            f'{len(error_messages)} {resource_type}(s):\n' +
+                            '\n'.join(f'• {msg}' for msg in error_messages) +
+                            '\nPlease terminate these resources first.')
+        raise ValueError(full_message)

sky/utils/resources_utils.py

@@ -273,10 +273,18 @@ def need_to_query_reservations() -> bool:
     clouds that do not use reservations.
     """
     for cloud_str in registry.CLOUD_REGISTRY.keys():
-        cloud_specific_reservations = skypilot_config.get_nested(
-            (cloud_str, 'specific_reservations'), None)
-        cloud_prioritize_reservations = skypilot_config.get_nested(
-            (cloud_str, 'prioritize_reservations'), False)
+        cloud_specific_reservations = (
+            skypilot_config.get_effective_region_config(
+                cloud=cloud_str,
+                region=None,
+                keys=('specific_reservations',),
+                default_value=None))
+        cloud_prioritize_reservations = (
+            skypilot_config.get_effective_region_config(
+                cloud=cloud_str,
+                region=None,
+                keys=('prioritize_reservations',),
+                default_value=False))
         if (cloud_specific_reservations is not None or
                 cloud_prioritize_reservations):
             return True

sky/utils/schemas.py

@@ -7,6 +7,7 @@ import enum
 from typing import Any, Dict, List, Tuple
 
 from sky.skylet import constants
+from sky.utils import kubernetes_enums
 
 
 def _check_not_both_fields_present(field1: str, field2: str):
@@ -1018,10 +1019,73 @@ _REMOTE_IDENTITY_SCHEMA_KUBERNETES = {
     },
 }
 
+_CONTEXT_CONFIG_SCHEMA_KUBERNETES = {
+    'networking': {
+        'type': 'string',
+        'case_insensitive_enum': [
+            type.value for type in kubernetes_enums.KubernetesNetworkingMode
+        ],
+    },
+    'ports': {
+        'type': 'string',
+        'case_insensitive_enum': [
+            type.value for type in kubernetes_enums.KubernetesPortMode
+        ],
+    },
+    'pod_config': {
+        'type': 'object',
+        'required': [],
+        # Allow arbitrary keys since validating pod spec is hard
+        'additionalProperties': True,
+    },
+    'custom_metadata': {
+        'type': 'object',
+        'required': [],
+        # Allow arbitrary keys since validating metadata is hard
+        'additionalProperties': True,
+        # Disallow 'name' and 'namespace' keys in this dict
+        'not': {
+            'anyOf': [{
+                'required': ['name']
+            }, {
+                'required': ['namespace']
+            }]
+        },
+    },
+    'provision_timeout': {
+        'type': 'integer',
+    },
+    'autoscaler': {
+        'type': 'string',
+        'case_insensitive_enum': [
+            type.value for type in kubernetes_enums.KubernetesAutoscalerType
+        ],
+    },
+    'high_availability': {
+        'type': 'object',
+        'required': [],
+        'additionalProperties': False,
+        'properties': {
+            'storage_class_name': {
+                'type': 'string',
+            }
+        },
+    },
+    'kueue': {
+        'type': 'object',
+        'required': [],
+        'additionalProperties': False,
+        'properties': {
+            'local_queue_name': {
+                'type': 'string',
+            },
+        },
+    },
+}
+
 
 def get_config_schema():
     # pylint: disable=import-outside-toplevel
-    from sky.utils import kubernetes_enums
 
     resources_schema = {
         k: v
@@ -1178,70 +1242,21 @@ def get_config_schema():
                         'type': 'string',
                     },
                 },
-                'networking': {
-                    'type': 'string',
-                    'case_insensitive_enum': [
-                        type.value
-                        for type in kubernetes_enums.KubernetesNetworkingMode
-                    ]
-                },
-                'ports': {
-                    'type': 'string',
-                    'case_insensitive_enum': [
-                        type.value
-                        for type in kubernetes_enums.KubernetesPortMode
-                    ]
-                },
-                'pod_config': {
+                'context_configs': {
                     'type': 'object',
                     'required': [],
-                    # Allow arbitrary keys since validating pod spec is hard
-                    'additionalProperties': True,
-                },
-                'custom_metadata': {
-                    'type': 'object',
-                    'required': [],
-                    # Allow arbitrary keys since validating metadata is hard
-                    'additionalProperties': True,
-                    # Disallow 'name' and 'namespace' keys in this dict
-                    'not': {
-                        'anyOf': [{
-                            'required': ['name']
-                        }, {
-                            'required': ['namespace']
-                        }]
-                    }
-                },
-                'provision_timeout': {
-                    'type': 'integer',
-                },
-                'autoscaler': {
-                    'type': 'string',
-                    'case_insensitive_enum': [
-                        type.value
-                        for type in kubernetes_enums.KubernetesAutoscalerType
-                    ]
-                },
-                'high_availability': {
-                    'type': 'object',
-                    'required': [],
-                    'additionalProperties': False,
-                    'properties': {
-                        'storage_class_name': {
-                            'type': 'string',
-                        }
-                    }
-                },
-                'kueue': {
-                    'type': 'object',
-                    'required': [],
-                    'additionalProperties': False,
-                    'properties': {
-                        'local_queue_name': {
-                            'type': 'string',
+                    'properties': {},
+                    # Properties are kubernetes context names.
+                    'additionalProperties': {
+                        'type': 'object',
+                        'required': [],
+                        'additionalProperties': False,
+                        'properties': {
+                            **_CONTEXT_CONFIG_SCHEMA_KUBERNETES,
                         },
                     },
                 },
+                **_CONTEXT_CONFIG_SCHEMA_KUBERNETES,
             }
         },
         'ssh': {
@@ -1400,6 +1415,18 @@ def get_config_schema():
                 # Apply validation for URL
                 'pattern': r'^https?://.*$',
             },
+            'service_account_token': {
+                'anyOf': [
+                    {
+                        'type': 'string',
+                        # Validate that token starts with sky_ prefix
+                        'pattern': r'^sky_.+$',
+                    },
+                    {
+                        'type': 'null',
+                    }
+                ]
+            },
         }
     }
 

sky/utils/subprocess_utils.py

@@ -6,6 +6,7 @@ import random
 import resource
 import shlex
 import subprocess
+import sys
 import threading
 import time
 import typing
@@ -16,7 +17,6 @@ import colorama
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
-from sky.skylet import constants
 from sky.skylet import log_lib
 from sky.utils import common_utils
 from sky.utils import timeline
@@ -322,12 +322,8 @@ def kill_process_daemon(process_pid: int) -> None:
     daemon_script = os.path.join(
         os.path.dirname(os.path.abspath(log_lib.__file__)),
         'subprocess_daemon.py')
-    python_path = subprocess.check_output(constants.SKY_GET_PYTHON_PATH_CMD,
-                                          shell=True,
-                                          stderr=subprocess.DEVNULL,
-                                          encoding='utf-8').strip()
     daemon_cmd = [
-        python_path,
+        sys.executable,
         daemon_script,
         '--parent-pid',
         str(parent_pid),

sky/workspaces/core.py

@@ -1,13 +1,11 @@
 """Workspace management core."""
 
-import concurrent.futures
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Tuple
 
 import filelock
 
 from sky import check as sky_check
 from sky import exceptions
-from sky import global_user_state
 from sky import models
 from sky import sky_logging
 from sky import skypilot_config
@@ -17,6 +15,7 @@ from sky.users import permission
 from sky.utils import annotations
 from sky.utils import common_utils
 from sky.utils import config_utils
+from sky.utils import resource_checker
 from sky.utils import schemas
 from sky.workspaces import utils as workspaces_utils
 
@@ -79,116 +78,6 @@ def _update_workspaces_config(
             f'file if you believe it is stale.') from e
 
 
-def _check_workspace_has_no_active_resources(workspace_name: str,
-                                             operation: str) -> None:
-    """Check if a workspace has active clusters or managed jobs.
-
-    Args:
-        workspace_name: The name of the workspace to check.
-        operation: The operation being performed ('update' or 'delete').
-
-    Raises:
-        ValueError: If the workspace has active clusters or managed jobs.
-    """
-    _check_workspaces_have_no_active_resources([(workspace_name, operation)])
-
-
-def _check_workspaces_have_no_active_resources(
-        workspace_operations: list) -> None:
-    """Check if workspaces have active clusters or managed jobs.
-
-    Args:
-        workspace_operations: List of tuples (workspace_name, operation) where
-            operation is 'update' or 'delete'.
-
-    Raises:
-        ValueError: If any workspace has active clusters or managed jobs.
-            The error message will include all workspaces with issues.
-    """
-    if not workspace_operations:
-        return
-
-    def get_all_clusters():
-        return global_user_state.get_clusters()
-
-    def get_all_managed_jobs():
-        # pylint: disable=import-outside-toplevel
-        from sky.jobs.server import core as managed_jobs_core
-        try:
-            return managed_jobs_core.queue(refresh=False,
-                                           skip_finished=True,
-                                           all_users=True)
-        except exceptions.ClusterNotUpError:
-            logger.warning('All jobs should be finished in workspace.')
-            return []
-
-    # Fetch both clusters and jobs in parallel
-    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
-        clusters_future = executor.submit(get_all_clusters)
-        jobs_future = executor.submit(get_all_managed_jobs)
-
-        all_clusters = clusters_future.result()
-        all_managed_jobs = jobs_future.result()
-
-    # Collect all error messages instead of raising immediately
-    error_messages = []
-
-    # Check each workspace against the fetched data
-    for workspace_name, operation in workspace_operations:
-        # Filter clusters for this workspace
-        workspace_clusters = [
-            cluster for cluster in all_clusters
-            if (cluster.get('workspace', constants.SKYPILOT_DEFAULT_WORKSPACE)
-                == workspace_name)
-        ]
-
-        # Filter managed jobs for this workspace
-        workspace_active_jobs = [
-            job for job in all_managed_jobs
-            if job.get('workspace', constants.SKYPILOT_DEFAULT_WORKSPACE) ==
-            workspace_name
-        ]
-
-        # Collect error messages for this workspace
-        workspace_errors = []
-
-        if workspace_clusters:
-            active_cluster_names = [
-                cluster['name'] for cluster in workspace_clusters
-            ]
-            cluster_list = ', '.join(active_cluster_names)
-            workspace_errors.append(
-                f'{len(workspace_clusters)} active cluster(s): {cluster_list}')
-
-        if workspace_active_jobs:
-            job_names = [str(job['job_id']) for job in workspace_active_jobs]
-            job_list = ', '.join(job_names)
-            workspace_errors.append(
-                f'{len(workspace_active_jobs)} active managed job(s): '
-                f'{job_list}')
-
-        # If this workspace has issues, add to overall error messages
-        if workspace_errors:
-            workspace_error_summary = ' and '.join(workspace_errors)
-            error_messages.append(
-                f'Cannot {operation} workspace {workspace_name!r} because it '
-                f'has {workspace_error_summary}.')
-
-    # If we collected any errors, raise them all together
-    if error_messages:
-        if len(error_messages) == 1:
-            # Single workspace error
-            full_message = error_messages[
-                0] + ' Please terminate these resources first.'
-        else:
-            # Multiple workspace errors
-            full_message = (f'Cannot proceed due to active resources in '
-                            f'{len(error_messages)} workspace(s):\n' +
-                            '\n'.join(f'• {msg}' for msg in error_messages) +
-                            '\nPlease terminate these resources first.')
-        raise ValueError(full_message)
-
-
 def _validate_workspace_config(workspace_name: str,
                                workspace_config: Dict[str, Any]) -> None:
     """Validate the workspace configuration.
@@ -229,7 +118,8 @@ def update_workspace(workspace_name: str, config: Dict[str,
     # Check for active clusters and managed jobs in the workspace
     # TODO(zhwu): we should allow the edits that only contain changes to
     # allowed_users or private.
-    _check_workspace_has_no_active_resources(workspace_name, 'update')
+    resource_checker.check_no_active_resources_for_workspaces([(workspace_name,
+                                                                'update')])
 
     def update_workspace_fn(workspaces: Dict[str, Any]) -> None:
         """Function to update workspace inside the lock."""
@@ -327,7 +217,8 @@ def delete_workspace(workspace_name: str) -> Dict[str, Any]:
         raise ValueError(f'Workspace {workspace_name!r} does not exist.')
 
     # Check for active clusters and managed jobs in the workspace
-    _check_workspace_has_no_active_resources(workspace_name, 'delete')
+    resource_checker.check_no_active_resources_for_workspaces([(workspace_name,
+                                                                'delete')])
 
     def delete_workspace_fn(workspaces: Dict[str, Any]) -> None:
         """Function to delete workspace inside the lock."""
@@ -396,7 +287,7 @@ def update_config(config: Dict[str, Any]) -> Dict[str, Any]:
     new_workspaces = config.get('workspaces', {})
 
     # Collect all workspaces that need to be checked for active resources
-    workspaces_to_check = []
+    workspaces_to_check: List[Tuple[str, str]] = []
     workspaces_to_check_policy: Dict[str, Dict[str, List[str]]] = {
         'add': {},
         'update': {},
@@ -430,7 +321,8 @@ def update_config(config: Dict[str, Any]) -> Dict[str, Any]:
             workspaces_to_check_policy['delete'][workspace_name] = ['*']
 
     # Check all workspaces for active resources in one efficient call
-    _check_workspaces_have_no_active_resources(workspaces_to_check)
+    resource_checker.check_no_active_resources_for_workspaces(
+        workspaces_to_check)
 
     # Use file locking to prevent race conditions
     lock_path = skypilot_config.get_skypilot_config_lock_path()

{skypilot_nightly-1.0.0.dev20250627.dist-info → skypilot_nightly-1.0.0.dev20250628.dist-info}/METADATA

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