skypilot-nightly 1.0.0.dev20250612__py3-none-any.whl → 1.0.0.dev20250613__py3-none-any.whl

sky/serve/serve_state.py

@@ -1,10 +1,12 @@
 """The database for services information."""
 import collections
 import enum
+import functools
 import json
 import pathlib
 import pickle
 import sqlite3
+import threading
 import typing
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -18,19 +20,6 @@ if typing.TYPE_CHECKING:
     from sky.serve import service_spec
 
 
-def _get_db_path() -> str:
-    """Workaround to collapse multi-step Path ops for type checker.
-    Ensures _DB_PATH is str, avoiding Union[Path, str] inference.
-    """
-    path = pathlib.Path(constants.SKYSERVE_METADATA_DIR) / 'services.db'
-    path = path.expanduser().absolute()
-    path.parents[0].mkdir(parents=True, exist_ok=True)
-    return str(path)
-
-
-_DB_PATH: str = _get_db_path()
-
-
 def create_table(cursor: 'sqlite3.Cursor', conn: 'sqlite3.Connection') -> None:
     """Creates the service and replica tables if they do not exist."""
 
@@ -82,7 +71,37 @@ def create_table(cursor: 'sqlite3.Cursor', conn: 'sqlite3.Connection') -> None:
     conn.commit()
 
 
-db_utils.SQLiteConn(_DB_PATH, create_table)
+def _get_db_path() -> str:
+    """Workaround to collapse multi-step Path ops for type checker.
+    Ensures _DB_PATH is str, avoiding Union[Path, str] inference.
+    """
+    path = pathlib.Path(constants.SKYSERVE_METADATA_DIR) / 'services.db'
+    path = path.expanduser().absolute()
+    path.parents[0].mkdir(parents=True, exist_ok=True)
+    return str(path)
+
+
+_DB_PATH = None
+_db_init_lock = threading.Lock()
+
+
+def init_db(func):
+    """Initialize the database."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        global _DB_PATH
+        if _DB_PATH is not None:
+            return func(*args, **kwargs)
+        with _db_init_lock:
+            if _DB_PATH is None:
+                _DB_PATH = _get_db_path()
+                db_utils.SQLiteConn(_DB_PATH, create_table)
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
 _UNIQUE_CONSTRAINT_FAILED_ERROR_MSG = 'UNIQUE constraint failed: services.name'
 
 
@@ -247,6 +266,7 @@ _SERVICE_STATUS_TO_COLOR = {
 }
 
 
+@init_db
 def add_service(name: str, controller_job_id: int, policy: str,
                 requested_resources_str: str, load_balancing_policy: str,
                 status: ServiceStatus, tls_encrypted: bool) -> bool:
@@ -256,6 +276,7 @@ def add_service(name: str, controller_job_id: int, policy: str,
         True if the service is added successfully, False if the service already
         exists.
     """
+    assert _DB_PATH is not None
     try:
         with db_utils.safe_cursor(_DB_PATH) as cursor:
             cursor.execute(
@@ -275,15 +296,19 @@ def add_service(name: str, controller_job_id: int, policy: str,
     return True
 
 
+@init_db
 def remove_service(service_name: str) -> None:
     """Removes a service from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute("""\
             DELETE FROM services WHERE name=(?)""", (service_name,))
 
 
+@init_db
 def set_service_uptime(service_name: str, uptime: int) -> None:
     """Sets the uptime of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -291,11 +316,13 @@ def set_service_uptime(service_name: str, uptime: int) -> None:
             uptime=(?) WHERE name=(?)""", (uptime, service_name))
 
 
+@init_db
 def set_service_status_and_active_versions(
         service_name: str,
         status: ServiceStatus,
         active_versions: Optional[List[int]] = None) -> None:
     """Sets the service status."""
+    assert _DB_PATH is not None
     vars_to_set = 'status=(?)'
     values: Tuple[str, ...] = (status.value, service_name)
     if active_versions is not None:
@@ -308,9 +335,11 @@ def set_service_status_and_active_versions(
             {vars_to_set} WHERE name=(?)""", values)
 
 
+@init_db
 def set_service_controller_port(service_name: str,
                                 controller_port: int) -> None:
     """Sets the controller port of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -319,9 +348,11 @@ def set_service_controller_port(service_name: str,
             (controller_port, service_name))
 
 
+@init_db
 def set_service_load_balancer_port(service_name: str,
                                    load_balancer_port: int) -> None:
     """Sets the load balancer port of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -355,8 +386,10 @@ def _get_service_from_row(row) -> Dict[str, Any]:
     }
 
 
+@init_db
 def get_services() -> List[Dict[str, Any]]:
     """Get all existing service records."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute('SELECT v.max_version, s.* FROM services s '
                               'JOIN ('
@@ -369,8 +402,10 @@ def get_services() -> List[Dict[str, Any]]:
     return records
 
 
+@init_db
 def get_service_from_name(service_name: str) -> Optional[Dict[str, Any]]:
     """Get all existing service records."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             'SELECT v.max_version, s.* FROM services s '
@@ -384,8 +419,10 @@ def get_service_from_name(service_name: str) -> Optional[Dict[str, Any]]:
     return None
 
 
+@init_db
 def get_service_versions(service_name: str) -> List[int]:
     """Gets all versions of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             """\
@@ -394,6 +431,7 @@ def get_service_versions(service_name: str) -> List[int]:
     return [row[0] for row in rows]
 
 
+@init_db
 def get_glob_service_names(
         service_names: Optional[List[str]] = None) -> List[str]:
     """Get service names matching the glob patterns.
@@ -405,6 +443,7 @@ def get_glob_service_names(
     Returns:
         A list of non-duplicated service names.
     """
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         if service_names is None:
             rows = cursor.execute('SELECT name FROM services').fetchall()
@@ -419,9 +458,11 @@ def get_glob_service_names(
 
 
 # === Replica functions ===
+@init_db
 def add_or_update_replica(service_name: str, replica_id: int,
                           replica_info: 'replica_managers.ReplicaInfo') -> None:
     """Adds a replica to the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -431,8 +472,10 @@ def add_or_update_replica(service_name: str, replica_id: int,
             (service_name, replica_id, pickle.dumps(replica_info)))
 
 
+@init_db
 def remove_replica(service_name: str, replica_id: int) -> None:
     """Removes a replica from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -441,10 +484,12 @@ def remove_replica(service_name: str, replica_id: int) -> None:
             AND replica_id=(?)""", (service_name, replica_id))
 
 
+@init_db
 def get_replica_info_from_id(
         service_name: str,
         replica_id: int) -> Optional['replica_managers.ReplicaInfo']:
     """Gets a replica info from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             """\
@@ -456,9 +501,11 @@ def get_replica_info_from_id(
     return None
 
 
+@init_db
 def get_replica_infos(
         service_name: str) -> List['replica_managers.ReplicaInfo']:
     """Gets all replica infos of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             """\
@@ -467,8 +514,10 @@ def get_replica_infos(
     return [pickle.loads(row[0]) for row in rows]
 
 
+@init_db
 def total_number_provisioning_replicas() -> int:
     """Returns the total number of provisioning replicas."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute('SELECT replica_info FROM replicas').fetchall()
     provisioning_count = 0
@@ -488,9 +537,10 @@ def get_replicas_at_status(
 
 
 # === Version functions ===
+@init_db
 def add_version(service_name: str) -> int:
     """Adds a version to the database."""
-
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -507,8 +557,10 @@ def add_version(service_name: str) -> int:
     return inserted_version
 
 
+@init_db
 def add_or_update_version(service_name: str, version: int,
                           spec: 'service_spec.SkyServiceSpec') -> None:
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -517,8 +569,10 @@ def add_or_update_version(service_name: str, version: int,
         VALUES (?, ?, ?)""", (service_name, version, pickle.dumps(spec)))
 
 
+@init_db
 def remove_service_versions(service_name: str) -> None:
     """Removes a replica from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -526,9 +580,11 @@ def remove_service_versions(service_name: str) -> None:
             WHERE service_name=(?)""", (service_name,))
 
 
+@init_db
 def get_spec(service_name: str,
              version: int) -> Optional['service_spec.SkyServiceSpec']:
     """Gets spec from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             """\
@@ -540,8 +596,10 @@ def get_spec(service_name: str,
     return None
 
 
+@init_db
 def delete_version(service_name: str, version: int) -> None:
     """Deletes a version from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -550,8 +608,10 @@ def delete_version(service_name: str, version: int) -> None:
             AND version=(?)""", (service_name, version))
 
 
+@init_db
 def delete_all_versions(service_name: str) -> None:
     """Deletes all versions from the database."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\
@@ -559,7 +619,9 @@ def delete_all_versions(service_name: str) -> None:
             WHERE service_name=(?)""", (service_name,))
 
 
+@init_db
 def get_latest_version(service_name: str) -> Optional[int]:
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute(
             """\
@@ -570,8 +632,10 @@ def get_latest_version(service_name: str) -> Optional[int]:
     return rows[0][0]
 
 
+@init_db
 def get_service_controller_port(service_name: str) -> int:
     """Gets the controller port of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute('SELECT controller_port FROM services WHERE name = ?',
                        (service_name,))
@@ -581,8 +645,10 @@ def get_service_controller_port(service_name: str) -> int:
         return row[0]
 
 
+@init_db
 def get_service_load_balancer_port(service_name: str) -> int:
     """Gets the load balancer port of a service."""
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute('SELECT load_balancer_port FROM services WHERE name = ?',
                        (service_name,))

sky/server/requests/preconditions.py

@@ -169,6 +169,6 @@ class ClusterStartCompletePrecondition(Precondition):
             include_request_names=['sky.launch', 'sky.start'],
             cluster_names=[self.cluster_name])
         if len(requests) == 0:
-            # No runnning or pending tasks, the start process is done.
+            # No running or pending tasks, the start process is done.
             return True, None
         return False, f'Waiting for cluster {self.cluster_name} to be UP.'

sky/server/requests/requests.py

@@ -9,6 +9,7 @@ import pathlib
 import shutil
 import signal
 import sqlite3
+import threading
 import time
 import traceback
 from typing import Any, Callable, Dict, Generator, List, Optional, Tuple
@@ -392,10 +393,6 @@ def kill_requests(request_ids: Optional[List[str]] = None,
     return cancelled_request_ids
 
 
-_DB_PATH = os.path.expanduser(server_constants.API_SERVER_REQUEST_DB_PATH)
-pathlib.Path(_DB_PATH).parents[0].mkdir(parents=True, exist_ok=True)
-
-
 def create_table(cursor, conn):
     # Enable WAL mode to avoid locking issues.
     # See: issue #1441 and PR #1509
@@ -433,6 +430,7 @@ def create_table(cursor, conn):
 
 
 _DB = None
+_init_db_lock = threading.Lock()
 
 
 def init_db(func):
@@ -441,8 +439,15 @@ def init_db(func):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         global _DB
-        if _DB is None:
-            _DB = db_utils.SQLiteConn(_DB_PATH, create_table)
+        if _DB is not None:
+            return func(*args, **kwargs)
+        with _init_db_lock:
+            if _DB is None:
+                db_path = os.path.expanduser(
+                    server_constants.API_SERVER_REQUEST_DB_PATH)
+                pathlib.Path(db_path).parents[0].mkdir(parents=True,
+                                                       exist_ok=True)
+                _DB = db_utils.SQLiteConn(db_path, create_table)
         return func(*args, **kwargs)
 
     return wrapper

sky/skylet/configs.py

@@ -2,17 +2,16 @@
 import functools
 import os
 import pathlib
+import threading
 from typing import Callable, Optional, Union
 
 from sky.utils import db_utils
 
-_DB_PATH = os.path.expanduser('~/.sky/skylet_config.db')
-os.makedirs(pathlib.Path(_DB_PATH).parents[0], exist_ok=True)
+_DB_PATH = None
+_db_init_lock = threading.Lock()
 
-_table_created = False
 
-
-def ensure_table(func: Callable):
+def init_db(func: Callable):
     """Ensure the table exists before calling the function.
 
     Since this module will be imported whenever `sky` is imported (due to
@@ -24,25 +23,32 @@ def ensure_table(func: Callable):
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        global _table_created
-        if not _table_created:
-            with db_utils.safe_cursor(
-                    _DB_PATH) as c:  # Call it 'c' to avoid pylint complaining.
-                # Use WAL mode to avoid locking problem in #1507.
-                # Reference: https://stackoverflow.com/a/39265148
-                c.execute('PRAGMA journal_mode=WAL')
-                c.execute("""\
-                    CREATE TABLE IF NOT EXISTS config (
-                        key TEXT PRIMARY KEY,
-                        value TEXT)""")
-        _table_created = True
+        global _DB_PATH
+        if _DB_PATH is not None:
+            return func(*args, **kwargs)
+
+        with _db_init_lock:
+            if _DB_PATH is None:
+                _DB_PATH = os.path.expanduser('~/.sky/skylet_config.db')
+                os.makedirs(pathlib.Path(_DB_PATH).parents[0], exist_ok=True)
+                with db_utils.safe_cursor(
+                        _DB_PATH
+                ) as c:  # Call it 'c' to avoid pylint complaining.
+                    # Use WAL mode to avoid locking problem in #1507.
+                    # Reference: https://stackoverflow.com/a/39265148
+                    c.execute('PRAGMA journal_mode=WAL')
+                    c.execute("""\
+                        CREATE TABLE IF NOT EXISTS config (
+                            key TEXT PRIMARY KEY,
+                            value TEXT)""")
         return func(*args, **kwargs)
 
     return wrapper
 
 
-@ensure_table
+@init_db
 def get_config(key: str) -> Optional[bytes]:
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         rows = cursor.execute('SELECT value FROM config WHERE key = ?', (key,))
         for (value,) in rows:
@@ -50,8 +56,9 @@ def get_config(key: str) -> Optional[bytes]:
         return None
 
 
-@ensure_table
+@init_db
 def set_config(key: str, value: Union[bytes, str]) -> None:
+    assert _DB_PATH is not None
     with db_utils.safe_cursor(_DB_PATH) as cursor:
         cursor.execute(
             """\

sky/skylet/job_lib.py

@@ -64,10 +64,6 @@ class JobInfoLoc(enum.IntEnum):
     PID = 9
 
 
-_DB_PATH = os.path.expanduser('~/.sky/jobs.db')
-os.makedirs(pathlib.Path(_DB_PATH).parents[0], exist_ok=True)
-
-
 def create_table(cursor, conn):
     # Enable WAL mode to avoid locking issues.
     # See: issue #3863, #1441 and PR #1509
@@ -136,7 +132,9 @@ def init_db(func):
 
         with _db_init_lock:
             if _DB is None:
-                _DB = db_utils.SQLiteConn(_DB_PATH, create_table)
+                db_path = os.path.expanduser('~/.sky/jobs.db')
+                os.makedirs(pathlib.Path(db_path).parents[0], exist_ok=True)
+                _DB = db_utils.SQLiteConn(db_path, create_table)
         return func(*args, **kwargs)
 
     return wrapper

sky/task.py

@@ -911,7 +911,7 @@ class Task:
 
         Different from set_file_mounts(), this function updates into the
         existing file_mounts (calls ``dict.update()``), rather than
-        overwritting it.
+        overwriting it.
 
         This should be called before provisioning in order to take effect.
 

sky/templates/kubernetes-ray.yml.j2

@@ -740,7 +740,7 @@ available_node_types:
             spec:
               securityContext:
                 fsGroup: 1000
-              # To prevent the home dir provided by the docker image from being overriden by pvc mounting,
+              # To prevent the home dir provided by the docker image from being overridden by pvc mounting,
               # we use initContainers to copy it first to /mnt/home, which will later be mounted to home dir.
               initContainers:
                 - name: init-copy-home

sky/utils/common_utils.py

@@ -1017,3 +1017,9 @@ def _get_cgroup_memory_limit() -> Optional[int]:
 def _is_cgroup_v2() -> bool:
     """Return True if the environment is running cgroup v2."""
     return os.path.isfile('/sys/fs/cgroup/cgroup.controllers')
+
+
+def removeprefix(string: str, prefix: str) -> str:
+    if string.startswith(prefix):
+        return string[len(prefix):]
+    return string

sky/utils/context.py

@@ -19,7 +19,7 @@ class Context(object):
     This is a wrapper around `contextvars.ContextVar` that provides a typed
     interface for the SkyPilot specific context variables that can be accessed
     at any layer of the call stack. ContextVar is coroutine local, an empty
-    Context will be intialized for each coroutine when it is created.
+    Context will be initialized for each coroutine when it is created.
 
     Adding a new context variable for a new feature is as simple as:
     1. Add a new instance variable to the Context class.

sky/utils/infra_utils.py

@@ -180,7 +180,7 @@ class InfraInfo:
             # Node Pools.
             # TODO(romilb): This is a workaround while we use the global
             # kubeconfig to store the ssh contexts.
-            region_or_zone = self.region.lstrip('ssh-')
+            region_or_zone = common_utils.removeprefix(self.region, 'ssh-')
 
         if region_or_zone is not None and truncate:
             region_or_zone = common_utils.truncate_long_string(

sky/utils/kubernetes/generate_kubeconfig.sh

@@ -316,7 +316,7 @@ EOF
 echo "---
 Done!
 
-Kubeconfig using service acccount '${SKYPILOT_SA}' in namespace '${NAMESPACE}' written at $(pwd)/kubeconfig
+Kubeconfig using service account '${SKYPILOT_SA}' in namespace '${NAMESPACE}' written at $(pwd)/kubeconfig
 
 Copy the generated kubeconfig file to your ~/.kube/ directory to use it with
 kubectl and skypilot:

{skypilot_nightly-1.0.0.dev20250612.dist-info → skypilot_nightly-1.0.0.dev20250613.dist-info}/METADATA

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