skypilot-nightly 1.0.0.dev20250905__py3-none-any.whl → 1.0.0.dev20251203__py3-none-any.whl

sky/adaptors/kubernetes.py

@@ -1,4 +1,5 @@
 """Kubernetes adaptors"""
+import functools
 import logging
 import os
 import platform
@@ -162,8 +163,61 @@ def list_kube_config_contexts():
     return kubernetes.config.list_kube_config_contexts(_get_config_file())
 
 
+class ClientWrapper:
+    """Wrapper around the kubernetes API clients.
+
+    This is needed because we cache kubernetes.client.ApiClient and other typed
+    clients (e.g. kubernetes.client.CoreV1Api) and lru_cache.cache_clear() does
+    not call close() on the client to cleanup external resources like
+    semaphores. This decorator wraps the client with __del__ to ensure the
+    external state of kubernetes clients are properly cleaned up on GC.
+    """
+
+    def __init__(self, client):
+        self._client = client
+
+    def __getattr__(self, name):
+        """Delegate to the underlying client"""
+        return getattr(self._client, name)
+
+    def __del__(self):
+        """Clean up the underlying client"""
+        try:
+            real_client = None
+            if isinstance(self._client, kubernetes.client.ApiClient):
+                real_client = self._client
+            elif isinstance(self._client, kubernetes.watch.Watch):
+                real_client = getattr(self._client, '_api_client', None)
+            else:
+                # Otherwise, the client is a typed client, the typed client
+                # is generated by codegen and all of them should have an
+                # 'api_client' attribute referring to the real client.
+                real_client = getattr(self._client, 'api_client', None)
+            if real_client is not None:
+                real_client.close()
+            else:
+                # logger may already be cleaned up during __del__ at shutdown
+                if logger is not None:
+                    logger.debug(f'No client found for {self._client}')
+        except Exception as e:  # pylint: disable=broad-except
+            if logger is not None:
+                logger.debug(f'Error closing Kubernetes client: {e}')
+
+
+def wrap_kubernetes_client(func):
+    """Wraps kubernetes API clients for proper cleanup."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        obj = func(*args, **kwargs)
+        return ClientWrapper(obj)
+
+    return wrapper
+
+
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def core_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.CoreV1Api()
@@ -171,6 +225,7 @@ def core_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def storage_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.StorageV1Api()
@@ -178,6 +233,7 @@ def storage_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def auth_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.RbacAuthorizationV1Api()
@@ -185,6 +241,7 @@ def auth_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def networking_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.NetworkingV1Api()
@@ -192,6 +249,7 @@ def networking_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def custom_objects_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.CustomObjectsApi()
@@ -199,6 +257,7 @@ def custom_objects_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='global')
+@wrap_kubernetes_client
 def node_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.NodeV1Api()
@@ -206,6 +265,7 @@ def node_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def apps_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.AppsV1Api()
@@ -213,6 +273,7 @@ def apps_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def batch_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.BatchV1Api()
@@ -220,6 +281,7 @@ def batch_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def api_client(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.ApiClient()
@@ -227,6 +289,7 @@ def api_client(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def custom_resources_api(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.client.CustomObjectsApi()
@@ -234,6 +297,7 @@ def custom_resources_api(context: Optional[str] = None):
 
 @_api_logging_decorator('urllib3', logging.ERROR)
 @annotations.lru_cache(scope='request')
+@wrap_kubernetes_client
 def watch(context: Optional[str] = None):
     _load_config(context)
     return kubernetes.watch.Watch()

sky/adaptors/nebius.py

@@ -136,7 +136,9 @@ SKY_CHECK_NAME = 'Nebius (for Nebius Object Storae)'
 
 
 def request_error():
-    return nebius.aio.service_error.RequestError
+    # pylint: disable=import-outside-toplevel
+    from nebius.aio import service_error
+    return service_error.RequestError
 
 
 def compute():

sky/adaptors/primeintellect.py

@@ -0,0 +1 @@
+"""Prime Intellect cloud adaptor."""

sky/adaptors/seeweb.py

@@ -0,0 +1,183 @@
+""" Seeweb Adaptor """
+import configparser
+import pathlib
+from typing import Optional
+
+import pydantic
+import requests  # type: ignore
+
+from sky.adaptors import common
+from sky.utils import annotations
+
+
+class SeewebError(Exception):
+    """Base exception for Seeweb adaptor errors."""
+
+
+class SeewebCredentialsFileNotFound(SeewebError):
+    """Raised when the Seeweb credentials file is missing."""
+
+
+class SeewebApiKeyMissing(SeewebError):
+    """Raised when the Seeweb API key is missing or empty."""
+
+
+class SeewebAuthenticationError(SeewebError):
+    """Raised when authenticating with Seeweb API fails."""
+
+
+_IMPORT_ERROR_MESSAGE = ('Failed to import dependencies for Seeweb.'
+                         'Try pip install "skypilot[seeweb]"')
+
+ecsapi = common.LazyImport(
+    'ecsapi',
+    import_error_message=_IMPORT_ERROR_MESSAGE,
+)
+boto3 = common.LazyImport('boto3', import_error_message=_IMPORT_ERROR_MESSAGE)
+botocore = common.LazyImport('botocore',
+                             import_error_message=_IMPORT_ERROR_MESSAGE)
+
+_LAZY_MODULES = (ecsapi, boto3, botocore)
+
+
+@common.load_lazy_modules(_LAZY_MODULES)
+def check_compute_credentials() -> bool:
+    """Checks if the user has access credentials to Seeweb's compute service.
+
+    Returns True if credentials are valid; otherwise raises a SeewebError.
+    """
+    # Read API key from standard Seeweb configuration file
+    key_path = pathlib.Path('~/.seeweb_cloud/seeweb_keys').expanduser()
+    if not key_path.exists():
+        raise SeewebCredentialsFileNotFound(
+            'Missing Seeweb API key file ~/.seeweb_cloud/seeweb_keys')
+
+    parser = configparser.ConfigParser()
+    parser.read(key_path)
+    try:
+        api_key = parser['DEFAULT']['api_key'].strip()
+    except KeyError as e:
+        raise SeewebApiKeyMissing(
+            'Missing api_key in ~/.seeweb_cloud/seeweb_keys') from e
+    if not api_key:
+        raise SeewebApiKeyMissing(
+            'Empty api_key in ~/.seeweb_cloud/seeweb_keys')
+
+    # Test connection by fetching servers list to validate the key
+    try:
+        seeweb_client = ecsapi.Api(token=api_key)
+        try:
+            seeweb_client.fetch_servers()
+        except pydantic.ValidationError:
+            # Fallback: fetch raw JSON to validate authentication
+            # pylint: disable=protected-access
+            base_url = seeweb_client._Api__generate_base_url()  # type: ignore
+            headers = seeweb_client._Api__generate_authentication_headers(
+            )  # type: ignore
+            url = f'{base_url}/servers'
+            resp = requests.get(url, headers=headers, timeout=15)
+            resp.raise_for_status()
+            # If we get here, authentication worked even if schema mismatches
+    except Exception as e:  # pylint: disable=broad-except
+        raise SeewebAuthenticationError(
+            f'Unable to authenticate with Seeweb API: {e}') from e
+
+    return True
+
+
+@common.load_lazy_modules(_LAZY_MODULES)
+def check_storage_credentials() -> bool:
+    """Checks if the user has access credentials to Seeweb's storage service.
+
+    Mirrors compute credentials validation.
+    """
+    return check_compute_credentials()
+
+
+@common.load_lazy_modules(_LAZY_MODULES)
+@annotations.lru_cache(scope='global', maxsize=1)
+def client():
+    """Returns an authenticated ecsapi.Api object."""
+    # Create authenticated client using the same credential pattern
+    key_path = pathlib.Path('~/.seeweb_cloud/seeweb_keys').expanduser()
+    if not key_path.exists():
+        raise SeewebCredentialsFileNotFound(
+            'Missing Seeweb API key file ~/.seeweb_cloud/seeweb_keys')
+
+    parser = configparser.ConfigParser()
+    parser.read(key_path)
+    try:
+        api_key = parser['DEFAULT']['api_key'].strip()
+    except KeyError as e:
+        raise SeewebApiKeyMissing(
+            'Missing api_key in ~/.seeweb_cloud/seeweb_keys') from e
+    if not api_key:
+        raise SeewebApiKeyMissing(
+            'Empty api_key in ~/.seeweb_cloud/seeweb_keys')
+
+    api = ecsapi.Api(token=api_key)
+
+    # Monkey-patch fetch_servers to be tolerant to API schema mismatches.
+    orig_fetch_servers = api.fetch_servers
+    orig_delete_server = api.delete_server
+
+    def _tolerant_fetch_servers(
+            timeout: Optional[int] = None):  # type: ignore[override]
+        try:
+            return orig_fetch_servers(timeout=timeout)
+        except pydantic.ValidationError:
+            # Fallback path: fetch raw JSON, drop snapshot fields, then validate
+            # pylint: disable=protected-access
+            base_url = api._Api__generate_base_url()  # type: ignore
+            headers = api._Api__generate_authentication_headers(
+            )  # type: ignore
+            url = f'{base_url}/servers'
+            resp = requests.get(url, headers=headers, timeout=timeout or 15)
+            resp.raise_for_status()
+            data = resp.json()
+            try:
+                servers = data.get('server', [])
+                for s in servers:
+                    s.pop('last_restored_snapshot', None)
+                    group = s.get('group')
+                    if isinstance(group, dict):
+                        group_name = group.get('name')
+                        s['group'] = group_name if isinstance(
+                            group_name, str) else str(group_name)
+            except (KeyError, TypeError, ValueError):
+                pass
+            server_list_response_cls = ecsapi._server._ServerListResponse
+            servers_response = server_list_response_cls.model_validate(data)
+            return servers_response.server
+
+    api.fetch_servers = _tolerant_fetch_servers  # type: ignore[assignment]
+
+    def _tolerant_delete_server(server_name: str,
+                                timeout: Optional[int] = None):
+        try:
+            return orig_delete_server(server_name, timeout=timeout)
+        except pydantic.ValidationError:
+            # Fallback: perform raw DELETE and interpret not_found as success
+            # pylint: disable=protected-access
+            base_url = api._Api__generate_base_url()  # type: ignore
+            headers = api._Api__generate_authentication_headers(
+            )  # type: ignore
+            url = f'{base_url}/servers/{server_name}'
+            resp = requests.delete(url, headers=headers, timeout=timeout or 15)
+            # Treat 404 as idempotent success
+            if resp.status_code == 404:
+                return None
+            # Some APIs return {status: 'not_found', message: ...}
+            try:
+                data = resp.json()
+                if isinstance(data, dict) and data.get('status') == 'not_found':
+                    return None
+            except (ValueError, TypeError):
+                pass
+            # If not clearly not_found, re-raise original behavior
+            resp.raise_for_status()
+            # Best-effort: return None to indicate deletion requested
+            return None
+
+    api.delete_server = _tolerant_delete_server  # type: ignore[assignment]
+    return api

sky/adaptors/shadeform.py

@@ -0,0 +1,89 @@
+"""Shadeform cloud adaptor."""
+
+import functools
+import socket
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from sky import sky_logging
+from sky.provision.shadeform import shadeform_utils
+from sky.utils import common_utils
+
+logger = sky_logging.init_logger(__name__)
+
+_shadeform_sdk = None
+
+
+def import_package(func):
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        global _shadeform_sdk
+        if _shadeform_sdk is None:
+            try:
+                import shadeform as _shadeform  # pylint: disable=import-outside-toplevel
+                _shadeform_sdk = _shadeform
+            except ImportError:
+                raise ImportError(
+                    'Failed to import dependencies for Shadeform. '
+                    'Try pip install "skypilot[shadeform]"') from None
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+@import_package
+def shadeform():
+    """Return the shadeform package."""
+    return _shadeform_sdk
+
+
+def list_ssh_keys() -> List[Dict[str, Any]]:
+    """List all SSH keys in Shadeform account."""
+    try:
+        response = shadeform_utils.get_ssh_keys()
+        return response.get('ssh_keys', [])
+    except (ValueError, KeyError, requests.exceptions.RequestException) as e:
+        logger.warning(f'Failed to list SSH keys from Shadeform: {e}')
+        return []
+
+
+def add_ssh_key_to_shadeform(public_key: str) -> Optional[str]:
+    """Add SSH key to Shadeform if it doesn't already exist.
+
+    Args:
+        public_key: The SSH public key string.
+
+    Returns:
+        The name of the key if added successfully, None otherwise.
+    """
+    try:
+        # Check if key already exists
+        existing_keys = list_ssh_keys()
+        key_exists = False
+        key_id = None
+        for key in existing_keys:
+            if key.get('public_key') == public_key:
+                key_exists = True
+                key_id = key.get('id')
+                break
+
+        if key_exists:
+            logger.info('SSH key already exists in Shadeform account')
+            return key_id
+
+        # Generate a unique key name
+        hostname = socket.gethostname()
+        key_name = f'skypilot-{hostname}-{common_utils.get_user_hash()[:8]}'
+
+        # Add the key
+        response = shadeform_utils.add_ssh_key(name=key_name,
+                                               public_key=public_key)
+        key_id = response['id']
+        logger.info(f'Added SSH key to Shadeform: {key_name, key_id}')
+        return key_id
+
+    except (ValueError, KeyError, requests.exceptions.RequestException) as e:
+        logger.warning(f'Failed to add SSH key to Shadeform: {e}')
+        return None

sky/admin_policy.py

@@ -9,7 +9,9 @@ import pydantic
 
 import sky
 from sky import exceptions
+from sky import models
 from sky.adaptors import common as adaptors_common
+from sky.server.requests import request_names
 from sky.utils import common_utils
 from sky.utils import config_utils
 from sky.utils import ux_utils
@@ -49,8 +51,10 @@ class _UserRequestBody(pydantic.BaseModel):
     # will be converted to JSON string, which will lose the None key.
     task: str
     skypilot_config: str
+    request_name: str
     request_options: Optional[RequestOptions] = None
     at_client_side: bool = False
+    user: str
 
 
 @dataclasses.dataclass
@@ -73,32 +77,48 @@ class UserRequest:
         skypilot_config: Global skypilot config to be used in this request.
         request_options: Request options. It is None for jobs and services.
         at_client_side: Is the request intercepted by the policy at client-side?
+        user: User who made the request.
+              Only available on the server side.
+              This value is None if at_client_side is True.
     """
     task: 'sky.Task'
     skypilot_config: 'sky.Config'
+    request_name: request_names.AdminPolicyRequestName
     request_options: Optional['RequestOptions'] = None
     at_client_side: bool = False
+    user: Optional['models.User'] = None
 
     def encode(self) -> str:
         return _UserRequestBody(
             task=yaml_utils.dump_yaml_str(self.task.to_yaml_config()),
             skypilot_config=yaml_utils.dump_yaml_str(dict(
                 self.skypilot_config)),
+            request_name=self.request_name.value,
             request_options=self.request_options,
             at_client_side=self.at_client_side,
+            user=(yaml_utils.dump_yaml_str(self.user.to_dict())
+                  if self.user is not None else ''),
         ).model_dump_json()
 
     @classmethod
     def decode(cls, body: str) -> 'UserRequest':
         user_request_body = _UserRequestBody.model_validate_json(body)
+        user_dict = yaml_utils.read_yaml_str(
+            user_request_body.user) if user_request_body.user != '' else None
+        user = models.User(
+            id=user_dict['id'],
+            name=user_dict['name']) if user_dict is not None else None
         return cls(
             task=sky.Task.from_yaml_config(
                 yaml_utils.read_yaml_all_str(user_request_body.task)[0]),
             skypilot_config=config_utils.Config.from_dict(
                 yaml_utils.read_yaml_all_str(
                     user_request_body.skypilot_config)[0]),
+            request_name=request_names.AdminPolicyRequestName(
+                user_request_body.request_name),
             request_options=user_request_body.request_options,
             at_client_side=user_request_body.at_client_side,
+            user=user,
         )