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

sky/provision/cudo/cudo_machine_type.py

@@ -1,7 +1,7 @@
 """Cudo Compute VM spec helper for SkyPilot."""
 import csv
 
-from sky.clouds.service_catalog.common import get_catalog_path
+from sky.catalog.common import get_catalog_path
 
 VMS_CSV = 'cudo/vms.csv'
 

sky/provision/kubernetes/utils.py

@@ -1384,7 +1384,7 @@ def check_credentials(context: Optional[str],
     # Check if $KUBECONFIG envvar consists of multiple paths. We run this before
     # optional checks.
     try:
-        _ = _get_kubeconfig_path()
+        _ = get_kubeconfig_paths()
     except ValueError as e:
         return False, f'{common_utils.format_exception(e, use_bracket=True)}'
 
@@ -1537,15 +1537,11 @@ def is_kubeconfig_exec_auth(
             raise ValueError(f'Kubernetes context {context!r} not found.')
     target_username = context_obj['context']['user']
 
-    # K8s api does not provide a mechanism to get the user details from the
-    # context. We need to load the kubeconfig file and parse it to get the
-    # user details.
-    kubeconfig_path = _get_kubeconfig_path()
-
-    # Load the kubeconfig file as a dictionary
-    with open(kubeconfig_path, 'r', encoding='utf-8') as f:
-        kubeconfig = yaml.safe_load(f)
+    # Load the kubeconfig for the context
+    kubeconfig_text = _get_kubeconfig_text_for_context(context)
+    kubeconfig = yaml.safe_load(kubeconfig_text)
 
+    # Get the user details
     user_details = kubeconfig['users']
 
     # Find user matching the target username
@@ -1573,6 +1569,27 @@ def is_kubeconfig_exec_auth(
     return False, None
 
 
+def _get_kubeconfig_text_for_context(context: Optional[str] = None) -> str:
+    """Get the kubeconfig text for the given context.
+
+    The kubeconfig might be multiple files, this function use kubectl to
+    handle merging automatically.
+    """
+    command = 'kubectl config view --minify'
+    if context is not None:
+        command += f' --context={context}'
+    proc = subprocess.run(command,
+                          shell=True,
+                          check=False,
+                          stdout=subprocess.PIPE,
+                          stderr=subprocess.PIPE)
+    if proc.returncode != 0:
+        raise RuntimeError(
+            f'Failed to get kubeconfig text for context {context}: {proc.stderr.decode("utf-8")}'
+        )
+    return proc.stdout.decode('utf-8')
+
+
 @annotations.lru_cache(scope='request')
 def get_current_kube_config_context_name() -> Optional[str]:
     """Get the current kubernetes context from the kubeconfig file
@@ -3100,18 +3117,14 @@ def get_gpu_resource_key():
     return os.getenv('CUSTOM_GPU_RESOURCE_KEY', default=GPU_RESOURCE_KEY)
 
 
-def _get_kubeconfig_path() -> str:
-    """Get the path to the kubeconfig file.
+def get_kubeconfig_paths() -> List[str]:
+    """Get the path to the kubeconfig files.
     Parses `KUBECONFIG` env var if present, else uses the default path.
-    Currently, specifying multiple KUBECONFIG paths in the envvar is not
-    allowed, hence will raise a ValueError.
     """
-    kubeconfig_path = os.path.expanduser(
-        os.getenv(
-            'KUBECONFIG', kubernetes.kubernetes.config.kube_config.
-            KUBE_CONFIG_DEFAULT_LOCATION))
-    if len(kubeconfig_path.split(os.pathsep)) > 1:
-        raise ValueError('SkyPilot currently only supports one '
-                         'config file path with $KUBECONFIG. Current '
-                         f'path(s) are {kubeconfig_path}.')
-    return kubeconfig_path
+    # We should always use the latest KUBECONFIG environment variable to
+    # make sure env var overrides get respected.
+    paths = os.getenv('KUBECONFIG', kubernetes.DEFAULT_KUBECONFIG_PATH)
+    expanded = []
+    for path in paths.split(kubernetes.ENV_KUBECONFIG_PATH_SEPARATOR):
+        expanded.append(os.path.expanduser(path))
+    return expanded

sky/provision/vast/utils.py

@@ -78,7 +78,7 @@ def launch(name: str, instance_type: str, region: str, disk_size: int,
 		 amount of memory.
 
       *  Vast instance types are an invention for skypilot. Refer to
-         service_catalog/vast_catalog.py for the current construction
+         catalog/vast_catalog.py for the current construction
          of the type.
 
     """

sky/provision/vsphere/common/vim_utils.py

@@ -8,8 +8,7 @@ from typing import List
 
 from sky import sky_logging
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    get_accelerators_from_csv)
+from sky.catalog.data_fetchers.fetch_vsphere import get_accelerators_from_csv
 
 logger = sky_logging.init_logger(__name__)
 DISPLAY_CONTROLLER_CLASS_ID_PREFIXES = ['03']

sky/provision/vsphere/instance.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Optional
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog.common import get_catalog_path
+from sky.catalog.common import get_catalog_path
 from sky.provision import common
 from sky.provision.vsphere import vsphere_utils
 from sky.provision.vsphere.common import custom_script as custom_script_lib

sky/provision/vsphere/vsphere_utils.py

@@ -10,18 +10,14 @@ from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog import vsphere_catalog
-from sky.clouds.service_catalog.common import get_catalog_path
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_accelerators_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_hosts_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_images_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
+from sky.catalog import vsphere_catalog
+from sky.catalog.common import get_catalog_path
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_accelerators_csv
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_hosts_csv
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_images_csv
+from sky.catalog.data_fetchers.fetch_vsphere import (
     initialize_instance_image_mapping_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_vms_csv)
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_vms_csv
 from sky.provision.vsphere.common import vim_utils
 from sky.provision.vsphere.common.cls_api_client import ClsApiClient
 from sky.provision.vsphere.common.cls_api_helper import ClsApiHelper

sky/resources.py

@@ -7,13 +7,13 @@ from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
 import colorama
 
 import sky
+from sky import catalog
 from sky import check as sky_check
 from sky import clouds
 from sky import exceptions
 from sky import sky_logging
 from sky import skypilot_config
 from sky.clouds import cloud as sky_cloud
-from sky.clouds import service_catalog
 from sky.provision import docker_utils
 from sky.provision.gcp import constants as gcp_constants
 from sky.provision.kubernetes import utils as kubernetes_utils
@@ -379,7 +379,7 @@ class Resources:
     # if it fails to fetch some account specific catalog information (e.g., AWS
     # zone mapping). It is fine to use the default catalog as this function is
     # only for display purposes.
-    @service_catalog.fallback_to_default_catalog
+    @catalog.fallback_to_default_catalog
     def __repr__(self) -> str:
         """Returns a string representation for display.
 

sky/serve/server/core.py

@@ -17,7 +17,7 @@ from sky import sky_logging
 from sky import skypilot_config
 from sky import task as task_lib
 from sky.backends import backend_utils
-from sky.clouds.service_catalog import common as service_catalog_common
+from sky.catalog import common as service_catalog_common
 from sky.serve import constants as serve_constants
 from sky.serve import serve_state
 from sky.serve import serve_utils

sky/server/constants.py

@@ -7,7 +7,7 @@ from sky.skylet import constants
 # API server version, whenever there is a change in API server that requires a
 # restart of the local API server or error out when the client does not match
 # the server version.
-API_VERSION = '7'
+API_VERSION = '8'
 
 # Prefix for API request names.
 REQUEST_NAME_PREFIX = 'sky.'

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/server/stream_utils.py

@@ -3,7 +3,7 @@
 import asyncio
 import collections
 import pathlib
-from typing import AsyncGenerator, Deque, List, Optional
+from typing import AsyncGenerator, Deque, Optional
 
 import aiofiles
 import fastapi
@@ -15,12 +15,6 @@ from sky.utils import rich_utils
 
 logger = sky_logging.init_logger(__name__)
 
-# When streaming log lines, buffer the lines in memory and flush them in chunks
-# to improve log tailing throughput. Buffer size is the max size bytes of each
-# chunk and the timeout threshold for flushing the buffer to ensure
-# responsiveness.
-_BUFFER_SIZE = 8 * 1024  # 8KB
-_BUFFER_TIMEOUT = 0.02  # 20ms
 _HEARTBEAT_INTERVAL = 30
 
 
@@ -44,20 +38,6 @@ async def log_streamer(request_id: Optional[str],
                        follow: bool = True) -> AsyncGenerator[str, None]:
     """Streams the logs of a request."""
 
-    # Buffer the lines in memory and flush them in chunks to improve log tailing
-    # throughput.
-    buffer: List[str] = []
-    buffer_bytes = 0
-    last_flush_time = asyncio.get_event_loop().time()
-
-    async def flush_buffer() -> AsyncGenerator[str, None]:
-        nonlocal buffer, buffer_bytes, last_flush_time
-        if buffer:
-            yield ''.join(buffer)
-            buffer.clear()
-            buffer_bytes = 0
-            last_flush_time = asyncio.get_event_loop().time()
-
     if request_id is not None:
         status_msg = rich_utils.EncodedStatusMessage(
             f'[dim]Checking request: {request_id}[/dim]')
@@ -119,14 +99,7 @@ async def log_streamer(request_id: Optional[str],
             # while keeps the loop tight to make log stream responsive.
             await asyncio.sleep(0)
             line: Optional[bytes] = await f.readline()
-
-            current_time = asyncio.get_event_loop().time()
             if not line:
-                if buffer and (current_time -
-                               last_flush_time) >= _BUFFER_TIMEOUT:
-                    async for chunk in flush_buffer():
-                        yield chunk
-
                 if request_id is not None:
                     request_task = requests_lib.get_request(request_id)
                     if request_task.status > requests_lib.RequestStatus.RUNNING:
@@ -165,16 +138,7 @@ async def log_streamer(request_id: Optional[str],
                 # sending invisible characters might be okay.
                 if is_payload:
                     continue
-
-            # Add to buffer
-            buffer.append(line_str)
-            buffer_bytes += len(line_str.encode('utf-8'))
-
-            # Check if we should flush the buffer
-            if (buffer_bytes >= _BUFFER_SIZE or
-                (current_time - last_flush_time) >= _BUFFER_TIMEOUT):
-                async for chunk in flush_buffer():
-                    yield chunk
+            yield line_str
 
 
 def stream_response(

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