skypilot-nightly 1.0.0.dev20250602__py3-none-any.whl → 1.0.0.dev20250604__py3-none-any.whl

sky/server/requests/executor.py

@@ -239,8 +239,11 @@ def override_request_env_and_config(
         client_command=request_body.entrypoint_command,
         using_remote_api_server=request_body.using_remote_api_server)
     try:
+        logger.debug(
+            f'override path: {request_body.override_skypilot_config_path}')
         with skypilot_config.override_skypilot_config(
-                request_body.override_skypilot_config):
+                request_body.override_skypilot_config,
+                request_body.override_skypilot_config_path):
             yield
     finally:
         # We need to call the save_timeline() since atexit will not be

sky/server/requests/payloads.py

@@ -82,6 +82,17 @@ def get_override_skypilot_config_from_client() -> Dict[str, Any]:
     return config
 
 
+def get_override_skypilot_config_path_from_client() -> Optional[str]:
+    """Returns the override config path from the client."""
+    if annotations.is_on_api_server:
+        return None
+    # Currently, we don't need to check if the client-side config
+    # has been overridden because we only deal with cases where
+    # client has a project-level config/changed config and the
+    # api server has a different config.
+    return skypilot_config.loaded_config_path_serialized()
+
+
 class RequestBody(pydantic.BaseModel):
     """The request body for the SkyPilot API."""
     env_vars: Dict[str, str] = {}
@@ -89,6 +100,7 @@ class RequestBody(pydantic.BaseModel):
     entrypoint_command: str = ''
     using_remote_api_server: bool = False
     override_skypilot_config: Optional[Dict[str, Any]] = {}
+    override_skypilot_config_path: Optional[str] = None
 
     # Allow extra fields in the request body, which is useful for backward
     # compatibility, i.e., we can add new fields to the request body without
@@ -108,6 +120,9 @@ class RequestBody(pydantic.BaseModel):
         data['override_skypilot_config'] = data.get(
             'override_skypilot_config',
             get_override_skypilot_config_from_client())
+        data['override_skypilot_config_path'] = data.get(
+            'override_skypilot_config_path',
+            get_override_skypilot_config_path_from_client())
         super().__init__(**data)
 
     def to_kwargs(self) -> Dict[str, Any]:
@@ -122,6 +137,7 @@ class RequestBody(pydantic.BaseModel):
         kwargs.pop('entrypoint_command')
         kwargs.pop('using_remote_api_server')
         kwargs.pop('override_skypilot_config')
+        kwargs.pop('override_skypilot_config_path')
         return kwargs
 
     @property

sky/server/requests/serializers/decoders.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from sky import jobs as managed_jobs
 from sky import models
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 from sky.data import storage
 from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.serve import serve_state

sky/server/server.py

@@ -26,6 +26,7 @@ from fastapi.middleware import cors
 import starlette.middleware.base
 
 import sky
+from sky import catalog
 from sky import check as sky_check
 from sky import clouds
 from sky import core
@@ -34,7 +35,6 @@ from sky import execution
 from sky import global_user_state
 from sky import models
 from sky import sky_logging
-from sky.clouds import service_catalog
 from sky.data import storage_utils
 from sky.jobs.server import server as jobs_rest
 from sky.provision.kubernetes import utils as kubernetes_utils
@@ -389,7 +389,7 @@ async def list_accelerators(
         request_id=request.state.request_id,
         request_name='list_accelerators',
         request_body=list_accelerator_counts_body,
-        func=service_catalog.list_accelerators,
+        func=catalog.list_accelerators,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
 
@@ -404,7 +404,7 @@ async def list_accelerator_counts(
         request_id=request.state.request_id,
         request_name='list_accelerator_counts',
         request_body=list_accelerator_counts_body,
-        func=service_catalog.list_accelerator_counts,
+        func=catalog.list_accelerator_counts,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
 

sky/skypilot_config.py

@@ -55,7 +55,7 @@ import os
 import tempfile
 import threading
 import typing
-from typing import Any, Dict, Iterator, List, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import filelock
 
@@ -163,11 +163,23 @@ def _set_loaded_config(config: config_utils.Config) -> None:
     _get_config_context().config = config
 
 
-def _get_loaded_config_path() -> Optional[str]:
-    return _get_config_context().config_path
+def _get_loaded_config_path() -> List[Optional[str]]:
+    serialized = _get_config_context().config_path
+    if not serialized:
+        return []
+    return json.loads(serialized)
+
+
+def _set_loaded_config_path(
+        path: Optional[Union[str, List[Optional[str]]]]) -> None:
+    if not path:
+        _get_config_context().config_path = None
+    if isinstance(path, str):
+        path = [path]
+    _get_config_context().config_path = json.dumps(path)
 
 
-def _set_loaded_config_path(path: Optional[str]) -> None:
+def _set_loaded_config_path_serialized(path: Optional[str]) -> None:
     _get_config_context().config_path = path
 
 
@@ -184,9 +196,14 @@ def get_user_config_path() -> str:
     return _GLOBAL_CONFIG_PATH
 
 
-def get_user_config() -> config_utils.Config:
-    """Returns the user config."""
-    # find the user config file
+def _get_config_from_path(path: Optional[str]) -> config_utils.Config:
+    if path is None:
+        return config_utils.Config()
+    return parse_and_validate_config_file(path)
+
+
+def _resolve_user_config_path() -> Optional[str]:
+    # find the user config file path, None if not resolved.
     user_config_path = _get_config_file_path(ENV_VAR_GLOBAL_CONFIG)
     if user_config_path:
         logger.debug('using user config file specified by '
@@ -203,16 +220,17 @@ def get_user_config() -> config_utils.Config:
         user_config_path = get_user_config_path()
         logger.debug(f'using default user config file: {user_config_path}')
         user_config_path = os.path.expanduser(user_config_path)
-
-    # load the user config file
     if os.path.exists(user_config_path):
-        user_config = parse_and_validate_config_file(user_config_path)
-    else:
-        user_config = config_utils.Config()
-    return user_config
+        return user_config_path
+    return None
 
 
-def _get_project_config() -> config_utils.Config:
+def get_user_config() -> config_utils.Config:
+    """Returns the user config."""
+    return _get_config_from_path(_resolve_user_config_path())
+
+
+def _resolve_project_config_path() -> Optional[str]:
     # find the project config file
     project_config_path = _get_config_file_path(ENV_VAR_PROJECT_CONFIG)
     if project_config_path:
@@ -231,17 +249,17 @@ def _get_project_config() -> config_utils.Config:
             f'using default project config file: {_PROJECT_CONFIG_PATH}')
         project_config_path = _PROJECT_CONFIG_PATH
         project_config_path = os.path.expanduser(project_config_path)
-
-    # load the project config file
     if os.path.exists(project_config_path):
-        project_config = parse_and_validate_config_file(project_config_path)
-    else:
-        project_config = config_utils.Config()
-    return project_config
+        return project_config_path
+    return None
 
 
-def get_server_config() -> config_utils.Config:
-    """Returns the server config."""
+def _get_project_config() -> config_utils.Config:
+    """Returns the project config."""
+    return _get_config_from_path(_resolve_project_config_path())
+
+
+def _resolve_server_config_path() -> Optional[str]:
     # find the server config file
     server_config_path = _get_config_file_path(ENV_VAR_GLOBAL_CONFIG)
     if server_config_path:
@@ -259,13 +277,14 @@ def get_server_config() -> config_utils.Config:
         server_config_path = _GLOBAL_CONFIG_PATH
         logger.debug(f'using default server config file: {server_config_path}')
         server_config_path = os.path.expanduser(server_config_path)
-
-    # load the server config file
     if os.path.exists(server_config_path):
-        server_config = parse_and_validate_config_file(server_config_path)
-    else:
-        server_config = config_utils.Config()
-    return server_config
+        return server_config_path
+    return None
+
+
+def get_server_config() -> config_utils.Config:
+    """Returns the server config."""
+    return _get_config_from_path(_resolve_server_config_path())
 
 
 def get_nested(keys: Tuple[str, ...],
@@ -487,9 +506,11 @@ def _reload_config_from_internal_file(internal_config_path: str) -> None:
 def _reload_config_as_server() -> None:
     # Reset the global variables, to avoid using stale values.
     _set_loaded_config(config_utils.Config())
+    _set_loaded_config_path(None)
 
     overrides: List[config_utils.Config] = []
-    server_config = get_server_config()
+    server_config_path = _resolve_server_config_path()
+    server_config = _get_config_from_path(server_config_path)
     if server_config:
         overrides.append(server_config)
 
@@ -503,17 +524,21 @@ def _reload_config_as_server() -> None:
             f'server config: \n'
             f'{common_utils.dump_yaml_str(dict(overlaid_server_config))}')
     _set_loaded_config(overlaid_server_config)
+    _set_loaded_config_path(server_config_path)
 
 
 def _reload_config_as_client() -> None:
     # Reset the global variables, to avoid using stale values.
     _set_loaded_config(config_utils.Config())
+    _set_loaded_config_path(None)
 
     overrides: List[config_utils.Config] = []
-    user_config = get_user_config()
+    user_config_path = _resolve_user_config_path()
+    user_config = _get_config_from_path(user_config_path)
     if user_config:
         overrides.append(user_config)
-    project_config = _get_project_config()
+    project_config_path = _resolve_project_config_path()
+    project_config = _get_config_from_path(project_config_path)
     if project_config:
         overrides.append(project_config)
 
@@ -527,14 +552,26 @@ def _reload_config_as_client() -> None:
             f'client config (before task and CLI overrides): \n'
             f'{common_utils.dump_yaml_str(dict(overlaid_client_config))}')
     _set_loaded_config(overlaid_client_config)
+    _set_loaded_config_path([user_config_path, project_config_path])
 
 
 def loaded_config_path() -> Optional[str]:
-    """Returns the path to the loaded config file, or
-    '<overridden>' if the config is overridden."""
-    if _is_config_overridden():
-        return '<overridden>'
-    return _get_loaded_config_path()
+    """Returns the path to the loaded config file, or '<overridden>' if the
+    config is overridden."""
+    path = [p for p in set(_get_loaded_config_path()) if p is not None]
+    if len(path) == 0:
+        return '<overridden>' if _is_config_overridden() else None
+    if len(path) == 1:
+        return path[0]
+
+    header = 'overridden' if _is_config_overridden() else 'merged'
+    path_str = ', '.join(p for p in path if p is not None)
+    return f'<{header} ({path_str})>'
+
+
+def loaded_config_path_serialized() -> Optional[str]:
+    """Returns the json serialized config path list"""
+    return _get_config_context().config_path
 
 
 # Load on import, synchronization is guaranteed by python interpreter.
@@ -548,7 +585,9 @@ def loaded() -> bool:
 
 @contextlib.contextmanager
 def override_skypilot_config(
-        override_configs: Optional[Dict[str, Any]]) -> Iterator[None]:
+        override_configs: Optional[Dict[str, Any]],
+        override_config_path_serialized: Optional[str] = None
+) -> Iterator[None]:
     """Overrides the user configurations."""
     # TODO(SKY-1215): allow admin user to extend the disallowed keys or specify
     # allowed keys.
@@ -557,7 +596,13 @@ def override_skypilot_config(
         yield
         return
     original_config = _get_loaded_config()
+    original_config_path = loaded_config_path_serialized()
     override_configs = config_utils.Config(override_configs)
+    if override_config_path_serialized is None:
+        override_config_path = []
+    else:
+        override_config_path = json.loads(override_config_path_serialized)
+
     disallowed_diff_keys = []
     for key in constants.SKIPPED_CLIENT_OVERRIDE_KEYS:
         value = override_configs.pop_nested(key, default_value=None)
@@ -602,6 +647,8 @@ def override_skypilot_config(
             skip_none=False)
         _set_config_overridden(True)
         _set_loaded_config(config)
+        _set_loaded_config_path(_get_loaded_config_path() +
+                                override_config_path)
         yield
     except exceptions.InvalidSkyPilotConfigError as e:
         with ux_utils.print_exception_no_traceback():
@@ -616,6 +663,7 @@ def override_skypilot_config(
     finally:
         _set_loaded_config(original_config)
         _set_config_overridden(False)
+        _set_loaded_config_path_serialized(original_config_path)
 
 
 @contextlib.contextmanager
@@ -628,6 +676,7 @@ def replace_skypilot_config(new_configs: config_utils.Config) -> Iterator[None]:
        sky_utils.context for more details.
     """
     original_config = _get_loaded_config()
+    original_config_path = loaded_config_path_serialized()
     original_env_var = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
     if new_configs != original_config:
         # Modify the global config of current process or context
@@ -642,9 +691,11 @@ def replace_skypilot_config(new_configs: config_utils.Config) -> Iterator[None]:
         # Note that this code modifies os.environ directly because it
         # will be hijacked to be context-aware if a context is active.
         os.environ[ENV_VAR_SKYPILOT_CONFIG] = temp_file.name
+        _set_loaded_config_path(temp_file.name)
         yield
         # Restore the original config and env var.
         _set_loaded_config(original_config)
+        _set_loaded_config_path_serialized(original_config_path)
         if original_env_var:
             os.environ[ENV_VAR_SKYPILOT_CONFIG] = original_env_var
         else:

sky/usage/usage_lib.py

@@ -205,8 +205,8 @@ class UsageMessageToReport(MessageToReport):
                     logger.debug('Multiple accelerators are not supported: '
                                  f'{resources.accelerators}.')
                 self.task_accelerators = list(resources.accelerators.keys())[0]
-                self.task_num_accelerators = resources.accelerators[
-                    self.task_accelerators]
+                self.task_num_accelerators = int(
+                    resources.accelerators[self.task_accelerators])
             else:
                 self.task_accelerators = None
                 self.task_num_accelerators = None
@@ -245,7 +245,8 @@ class UsageMessageToReport(MessageToReport):
                 logger.debug('Multiple accelerators are not supported: '
                              f'{resources.accelerators}.')
             self.accelerators = list(resources.accelerators.keys())[0]
-            self.num_accelerators = resources.accelerators[self.accelerators]
+            self.num_accelerators = int(
+                resources.accelerators[self.accelerators])
         else:
             self.accelerators = None
             self.num_accelerators = None

sky/utils/accelerator_registry.py

@@ -2,7 +2,7 @@
 import typing
 from typing import Optional
 
-from sky.clouds import service_catalog
+from sky import catalog
 from sky.utils import rich_utils
 from sky.utils import ux_utils
 
@@ -34,7 +34,7 @@ if typing.TYPE_CHECKING:
 
 # Use a cached version of accelerators to cloud mapping, so that we don't have
 # to download and read the catalog file for every cloud locally.
-_accelerator_df = service_catalog.common.read_catalog('common/accelerators.csv')
+_accelerator_df = catalog.common.read_catalog('common/accelerators.csv')
 
 # List of non-GPU accelerators that are supported by our backend for job queue
 # scheduling.
@@ -80,7 +80,7 @@ def canonicalize_accelerator_name(accelerator: str,
     if not names and cloud_str in ['Kubernetes', None]:
         with rich_utils.safe_status(
                 ux_utils.spinner_message('Listing accelerators on Kubernetes')):
-            searched = service_catalog.list_accelerators(
+            searched = catalog.list_accelerators(
                 name_filter=accelerator,
                 case_sensitive=False,
                 clouds=cloud_str,

sky/utils/controller_utils.py

@@ -206,8 +206,7 @@ class Controllers(enum.Enum):
         return None
 
 
-def high_availability_specified(cluster_name: Optional[str],
-                                skip_warning: bool = True) -> bool:
+def high_availability_specified(cluster_name: Optional[str]) -> bool:
     """Check if the controller high availability is specified in user config.
     """
     controller = Controllers.from_name(cluster_name)
@@ -215,18 +214,9 @@ def high_availability_specified(cluster_name: Optional[str],
         return False
 
     if skypilot_config.loaded():
-        high_availability = skypilot_config.get_nested(
-            (controller.value.controller_type, 'controller',
-             'high_availability'), False)
-        if high_availability:
-            if controller.value.controller_type != 'serve':
-                if not skip_warning:
-                    print(f'{colorama.Fore.RED}High availability controller is'
-                          'only supported for SkyServe controller. It cannot'
-                          f'be enabled for {controller.value.name}.'
-                          f'Skipping this flag.{colorama.Style.RESET_ALL}')
-            else:
-                return True
+        return skypilot_config.get_nested((controller.value.controller_type,
+                                           'controller', 'high_availability'),
+                                          False)
     return False
 
 

sky/utils/kubernetes/deploy_remote_cluster.py

@@ -7,6 +7,7 @@ import os
 import random
 import re
 import shlex
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -1356,7 +1357,7 @@ def deploy_cluster(head_node,
                 merged_file.write(result)
 
         # Replace the kubeconfig with the merged config
-        os.replace(merged_config, kubeconfig_path)
+        shutil.move(merged_config, kubeconfig_path)
 
         # Set the new context as the current context
         run_command(['kubectl', 'config', 'use-context', context_name],

sky/utils/schemas.py

@@ -6,6 +6,7 @@ https://json-schema.org/
 import enum
 from typing import Any, Dict, List, Tuple
 
+from sky.catalog import constants as service_catalog_constants
 from sky.skylet import constants
 
 
@@ -66,14 +67,10 @@ _AUTOSTOP_SCHEMA = {
 
 def _get_single_resources_schema():
     """Schema for a single resource in a resources list."""
-    # To avoid circular imports, only import when needed.
-    # pylint: disable=import-outside-toplevel
-    from sky.clouds import service_catalog
-
     # Building the regex pattern for the infra field
     # Format: cloud[/region[/zone]] or wildcards or kubernetes context
     # Match any cloud name (case insensitive)
-    all_clouds = list(service_catalog.ALL_CLOUDS)
+    all_clouds = list(service_catalog_constants.ALL_CLOUDS)
     all_clouds.remove('kubernetes')
     cloud_pattern = f'(?i:({"|".join(all_clouds)}))'
 
@@ -110,7 +107,8 @@ def _get_single_resources_schema():
         'properties': {
             'cloud': {
                 'type': 'string',
-                'case_insensitive_enum': list(service_catalog.ALL_CLOUDS)
+                'case_insensitive_enum': list(
+                    service_catalog_constants.ALL_CLOUDS)
             },
             'region': {
                 'type': 'string',
@@ -856,7 +854,6 @@ _REMOTE_IDENTITY_SCHEMA_KUBERNETES = {
 
 def get_config_schema():
     # pylint: disable=import-outside-toplevel
-    from sky.clouds import service_catalog
     from sky.utils import kubernetes_enums
 
     resources_schema = {
@@ -1165,7 +1162,7 @@ def get_config_schema():
         'items': {
             'type': 'string',
             'case_insensitive_enum':
-                (list(service_catalog.ALL_CLOUDS) + ['cloudflare'])
+                (list(service_catalog_constants.ALL_CLOUDS) + ['cloudflare'])
         }
     }
 
@@ -1213,7 +1210,7 @@ def get_config_schema():
     workspace_schema = {'type': 'string'}
 
     allowed_workspace_cloud_names = list(
-        service_catalog.ALL_CLOUDS) + ['cloudflare']
+        service_catalog_constants.ALL_CLOUDS) + ['cloudflare']
     # Create pattern for not supported clouds, i.e.
     # all clouds except gcp, kubernetes, ssh
     not_supported_clouds = [

{skypilot_nightly-1.0.0.dev20250602.dist-info → skypilot_nightly-1.0.0.dev20250604.dist-info}/METADATA

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