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

sky/data/storage_utils.py

@@ -3,8 +3,9 @@ import glob
 import os
 import pathlib
 import shlex
+import stat
 import subprocess
-from typing import Any, Dict, List, Optional, Set, TextIO, Union
+from typing import List, Optional, Set, TextIO, Union
 import warnings
 import zipfile
 
@@ -14,58 +15,12 @@ from sky import exceptions
 from sky import sky_logging
 from sky.skylet import constants
 from sky.utils import common_utils
-from sky.utils import log_utils
 
 logger = sky_logging.init_logger(__name__)
 
 _USE_SKYIGNORE_HINT = (
     'To avoid using .gitignore, you can create a .skyignore file instead.')
 
-_LAST_USE_TRUNC_LENGTH = 25
-
-
-def format_storage_table(storages: List[Dict[str, Any]],
-                         show_all: bool = False) -> str:
-    """Format the storage table for display.
-
-    Args:
-        storage_table (dict): The storage table.
-
-    Returns:
-        str: The formatted storage table.
-    """
-    storage_table = log_utils.create_table([
-        'NAME',
-        'UPDATED',
-        'STORE',
-        'COMMAND',
-        'STATUS',
-    ])
-
-    for row in storages:
-        launched_at = row['launched_at']
-        if show_all:
-            command = row['last_use']
-        else:
-            command = common_utils.truncate_long_string(row['last_use'],
-                                                        _LAST_USE_TRUNC_LENGTH)
-        storage_table.add_row([
-            # NAME
-            row['name'],
-            # LAUNCHED
-            log_utils.readable_time_duration(launched_at),
-            # CLOUDS
-            ', '.join([s.value for s in row['store']]),
-            # COMMAND,
-            command,
-            # STATUS
-            row['status'].value,
-        ])
-    if storages:
-        return str(storage_table)
-    else:
-        return 'No existing storage.'
-
 
 def get_excluded_files_from_skyignore(src_dir_path: str) -> List[str]:
     """List files and patterns ignored by the .skyignore file
@@ -253,17 +208,28 @@ def get_excluded_files(src_dir_path: str) -> List[str]:
 
 def zip_files_and_folders(items: List[str],
                           output_file: Union[str, pathlib.Path],
-                          log_file: Optional[TextIO] = None):
+                          log_file: Optional[TextIO] = None,
+                          relative_to_items: bool = False):
+
+    def _get_archive_name(file_path: str, item_path: str) -> str:
+        """Get the archive name for a file based on the relative parameters."""
+        if relative_to_items:
+            # Make paths relative to the item itself
+            return os.path.relpath(file_path, os.path.dirname(item_path))
+        else:
+            # Default: use full path (existing behavior)
+            return file_path
 
-    def _store_symlink(zipf, path: str, is_dir: bool):
+    def _store_symlink(zipf, path: str, archive_name: str, is_dir: bool):
         # Get the target of the symlink
         target = os.readlink(path)
         # Use relative path as absolute path will not be able to resolve on
         # remote API server.
         if os.path.isabs(target):
             target = os.path.relpath(target, os.path.dirname(path))
-        # Create a ZipInfo instance
-        zi = zipfile.ZipInfo(path + '/') if is_dir else zipfile.ZipInfo(path)
+        # Create a ZipInfo instance using the archive name
+        zi = zipfile.ZipInfo(archive_name +
+                             '/') if is_dir else zipfile.ZipInfo(archive_name)
         # Set external attributes to mark as symlink
         zi.external_attr = 0xA1ED0000
         # Write symlink target as content
@@ -282,8 +248,18 @@ def zip_files_and_folders(items: List[str],
                     # Add the file to the zip archive even if it matches
                     # patterns in dot ignore files, as it was explicitly
                     # specified by user.
-                    zipf.write(item)
+                    archive_name = _get_archive_name(item, item)
+                    zipf.write(item, archive_name)
                 elif os.path.isdir(item):
+                    # Include root dir
+                    archive_name = _get_archive_name(item, item)
+                    # If it's a symlink, store it as a symlink
+                    if os.path.islink(item):
+                        _store_symlink(zipf, item, archive_name, is_dir=True)
+                    else:
+                        zipf.write(item, archive_name)
+
+                    # Include dir contents recursively
                     excluded_files = set([
                         os.path.join(item, f.rstrip('/'))
                         for f in get_excluded_files(item)
@@ -305,19 +281,29 @@ def zip_files_and_folders(items: List[str],
                         # directories)
                         for dir_name in dirs:
                             dir_path = os.path.join(root, dir_name)
+                            archive_name = _get_archive_name(dir_path, item)
                             # If it's a symlink, store it as a symlink
                             if os.path.islink(dir_path):
-                                _store_symlink(zipf, dir_path, is_dir=True)
+                                _store_symlink(zipf,
+                                               dir_path,
+                                               archive_name,
+                                               is_dir=True)
                             else:
-                                zipf.write(dir_path)
+                                zipf.write(dir_path, archive_name)
 
                         for file in files:
                             file_path = os.path.join(root, file)
                             if file_path in excluded_files:
                                 continue
+                            archive_name = _get_archive_name(file_path, item)
                             if os.path.islink(file_path):
-                                _store_symlink(zipf, file_path, is_dir=False)
-                            else:
-                                zipf.write(file_path)
+                                _store_symlink(zipf,
+                                               file_path,
+                                               archive_name,
+                                               is_dir=False)
+                                continue
+                            if stat.S_ISSOCK(os.stat(file_path).st_mode):
+                                continue
+                            zipf.write(file_path, archive_name)
                 if log_file is not None:
                     log_file.write(f'Zipped {item}\n')

sky/exceptions.py

@@ -6,11 +6,12 @@ import types
 import typing
 from typing import Any, Dict, List, Optional, Sequence
 
+from sky.backends import backend
 from sky.utils import env_options
+from sky.utils import serialize_utils
 
 if typing.TYPE_CHECKING:
     from sky import jobs as managed_jobs
-    from sky.backends import backend
     from sky.skylet import job_lib
     from sky.utils import status_lib
 
@@ -92,6 +93,10 @@ def serialize_exception(e: BaseException) -> Dict[str, Any]:
         attr_v = attributes[attr_k]
         if isinstance(attr_v, types.TracebackType):
             attributes[attr_k] = traceback.format_tb(attr_v)
+        if isinstance(attr_v, backend.ResourceHandle):
+            attributes[attr_k] = (
+                serialize_utils.prepare_handle_for_backwards_compatibility(
+                    attr_v))
 
     data = {
         'type': e.__class__.__name__,
@@ -175,6 +180,18 @@ class KubeAPIUnreachableError(ResourcesUnavailableError):
     pass
 
 
+class KubernetesValidationError(Exception):
+    """Raised when the Kubernetes validation fails.
+
+    It stores a list of strings that represent the path to the field which
+    caused the validation error.
+    """
+
+    def __init__(self, path: List[str], message: str):
+        super().__init__(message)
+        self.path = path
+
+
 class InvalidCloudConfigs(Exception):
     """Raised when invalid configurations are provided for a given cloud."""
     pass
@@ -222,7 +239,7 @@ class ManagedJobReachedMaxRetriesError(Exception):
 class ManagedJobStatusError(Exception):
     """Raised when a managed job task status update is invalid.
 
-    For instance, a RUNNING job cannot become SUBMITTED.
+    For instance, a RUNNING job cannot become PENDING.
     """
     pass
 
@@ -381,6 +398,7 @@ class FetchClusterInfoError(Exception):
     class Reason(enum.Enum):
         HEAD = 'HEAD'
         WORKER = 'WORKER'
+        UNKNOWN = 'UNKNOWN'
 
     def __init__(self, reason: Reason) -> None:
         super().__init__()
@@ -488,11 +506,26 @@ class ApiServerConnectionError(RuntimeError):
             f'Try: curl {server_url}/api/health')
 
 
+class ApiServerAuthenticationError(RuntimeError):
+    """Raised when authentication is required for the API server."""
+
+    def __init__(self, server_url: str):
+        super().__init__(
+            f'Authentication required for SkyPilot API server at {server_url}. '
+            f'Please run:\n'
+            f'  sky api login -e {server_url}')
+
+
 class APIVersionMismatchError(RuntimeError):
     """Raised when the API version mismatch."""
     pass
 
 
+class APINotSupportedError(RuntimeError):
+    """Raised when the API is not supported by the remote peer."""
+    pass
+
+
 class JobExitCode(enum.IntEnum):
     """Job exit code enum.
 
@@ -568,3 +601,94 @@ class JobExitCode(enum.IntEnum):
 
         # Should not hit this case, but included to avoid errors
         return cls.FAILED
+
+
+class ExecutionRetryableError(Exception):
+    """Raised when task execution fails and should be retried."""
+
+    def __init__(self, message: str, hint: str,
+                 retry_wait_seconds: int) -> None:
+        super().__init__(message)
+        self.hint = hint
+        self.retry_wait_seconds = retry_wait_seconds
+
+    def __reduce__(self):
+        # Make sure the exception is picklable
+        return (self.__class__, (str(self), self.hint, self.retry_wait_seconds))
+
+
+class ExecutionPoolFullError(Exception):
+    """Raised when the execution pool is full."""
+
+
+class RequestAlreadyExistsError(Exception):
+    """Raised when a request is already exists."""
+    pass
+
+
+class PermissionDeniedError(Exception):
+    """Raised when a user does not have permission to access a resource."""
+    pass
+
+
+class VolumeNotFoundError(Exception):
+    """Raised when a volume is not found."""
+    pass
+
+
+class VolumeTopologyConflictError(Exception):
+    """Raised when the there is conflict in the volumes and compute topology"""
+    pass
+
+
+class ServerTemporarilyUnavailableError(Exception):
+    """Raised when the server is temporarily unavailable."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self):
+        return ('SkyPilot API server is temporarily unavailable: '
+                f'{self.message}. Please try again later.')
+
+
+class RestfulPolicyError(Exception):
+    """Raised when failed to call a RESTful policy."""
+    pass
+
+
+class GitError(Exception):
+    """Raised when a git operation fails."""
+    pass
+
+
+class RequestInterruptedError(Exception):
+    """Raised when a request is interrupted by the server.
+    Client is expected to retry the request immediately when
+    this error is raised.
+    """
+    pass
+
+
+class SkyletInternalError(Exception):
+    """Raised when a Skylet internal error occurs."""
+    pass
+
+
+class SkyletMethodNotImplementedError(Exception):
+    """Raised when a Skylet gRPC method is not implemented on the server."""
+    pass
+
+
+class ClientError(Exception):
+    """Raised when a there is a client error occurs.
+
+    If a request encounters a ClientError, it will not be retried to the server.
+    """
+    pass
+
+
+class ConcurrentWorkerExhaustedError(Exception):
+    """Raised when the concurrent worker is exhausted."""
+    pass