skypilot-nightly 1.0.0.dev20250408__py3-none-any.whl → 1.0.0.dev20250410__py3-none-any.whl

sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = 'e0674be528e87191ade88961c44c6449d01232fa'
+_SKYPILOT_COMMIT_SHA = '022a5c3ffe258f365764b03cb20fac70934f5a60'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250408'
+__version__ = '1.0.0.dev20250410'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

sky/adaptors/azure.py

@@ -232,7 +232,7 @@ def get_client(name: str,
                                 'Must provide resource_group_name keyword '
                                 'arguments for container client.')
                             sky_logger.info(
-                                'Failed to check the existance of the '
+                                'Failed to check the existence of the '
                                 f'container {container_url!r} due to '
                                 'insufficient IAM role for storage '
                                 f'account {storage_account_name!r}.')

sky/adaptors/nebius.py

@@ -1,7 +1,6 @@
 """Nebius cloud adaptor."""
 import os
 import threading
-from typing import Optional
 
 from sky.adaptors import common
 from sky.utils import annotations
@@ -168,7 +167,7 @@ def session():
 
 
 @annotations.lru_cache(scope='global')
-def resource(resource_name: str, region: str = DEFAULT_REGION, **kwargs):
+def resource(resource_name: str, **kwargs):
     """Create a Nebius resource.
 
     Args:
@@ -181,21 +180,13 @@ def resource(resource_name: str, region: str = DEFAULT_REGION, **kwargs):
     # Reference: https://stackoverflow.com/a/59635814
 
     session_ = session()
-    nebius_credentials = get_nebius_credentials(session_)
-    endpoint = create_endpoint(region)
 
-    return session_.resource(
-        resource_name,
-        endpoint_url=endpoint,
-        aws_access_key_id=nebius_credentials.access_key,
-        aws_secret_access_key=nebius_credentials.secret_key,
-        region_name=region,
-        **kwargs)
+    return session_.resource(resource_name, **kwargs)
 
 
 @annotations.lru_cache(scope='global')
-def client(service_name: str, region):
-    """Create an Nebius client of a certain service.
+def client(service_name: str):
+    """Create Nebius client of a certain service.
 
     Args:
         service_name: Nebius service name (e.g., 's3').
@@ -207,14 +198,8 @@ def client(service_name: str, region):
     # Reference: https://stackoverflow.com/a/59635814
 
     session_ = session()
-    nebius_credentials = get_nebius_credentials(session_)
-    endpoint = create_endpoint(region)
 
-    return session_.client(service_name,
-                           endpoint_url=endpoint,
-                           aws_access_key_id=nebius_credentials.access_key,
-                           aws_secret_access_key=nebius_credentials.secret_key,
-                           region_name=region)
+    return session_.client(service_name)
 
 
 @common.load_lazy_modules(_LAZY_MODULES)
@@ -223,10 +208,3 @@ def botocore_exceptions():
     # pylint: disable=import-outside-toplevel
     from botocore import exceptions
     return exceptions
-
-
-def create_endpoint(region: Optional[str] = DEFAULT_REGION) -> str:
-    """Reads accountid necessary to interact with Nebius Object Storage"""
-    if region is None:
-        region = DEFAULT_REGION
-    return f'https://storage.{region}.nebius.cloud:443'

sky/backends/backend.py

@@ -1,6 +1,6 @@
 """Sky backend interface."""
 import typing
-from typing import Dict, Generic, Optional
+from typing import Dict, Generic, Optional, Tuple
 
 from sky.usage import usage_lib
 from sky.utils import cluster_utils
@@ -53,7 +53,7 @@ class Backend(Generic[_ResourceHandleType]):
         cluster_name: Optional[str] = None,
         retry_until_up: bool = False,
         skip_unnecessary_provisioning: bool = False,
-    ) -> Optional[_ResourceHandleType]:
+    ) -> Tuple[Optional[_ResourceHandleType], bool]:
         """Provisions resources for the given task.
 
         Args:
@@ -68,13 +68,15 @@ class Backend(Generic[_ResourceHandleType]):
                 the existing cluster will be reused and re-provisioned.
             retry_until_up: If True, retry provisioning until resources are
                 successfully launched.
-            skip_if_no_cluster_updates: If True, compare the cluster config to
-                the existing cluster_name's config. Skip provisioning if no
+            skip_unnecessary_provisioning: If True, compare the cluster config
+                to the existing cluster_name's config. Skip provisioning if no
                 updates are needed for the existing cluster.
 
         Returns:
-            A ResourceHandle object for the provisioned resources, or None if
-            dryrun is True.
+            - A ResourceHandle object for the provisioned resources, or None if
+              dryrun is True.
+            - A boolean that is True if the provisioning was skipped, and False
+              if provisioning actually happened. Dryrun always gives False.
         """
         if cluster_name is None:
             cluster_name = cluster_utils.generate_cluster_name()
@@ -159,7 +161,7 @@ class Backend(Generic[_ResourceHandleType]):
         cluster_name: str,
         retry_until_up: bool = False,
         skip_unnecessary_provisioning: bool = False,
-    ) -> Optional[_ResourceHandleType]:
+    ) -> Tuple[Optional[_ResourceHandleType], bool]:
         raise NotImplementedError
 
     def _sync_workdir(self, handle: _ResourceHandleType, workdir: Path) -> None:

sky/backends/cloud_vm_ray_backend.py

@@ -2829,7 +2829,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         cluster_name: str,
         retry_until_up: bool = False,
         skip_unnecessary_provisioning: bool = False,
-    ) -> Optional[CloudVmRayResourceHandle]:
+    ) -> Tuple[Optional[CloudVmRayResourceHandle], bool]:
         """Provisions the cluster, or re-provisions an existing cluster.
 
         Use the SKYPILOT provisioner if it's supported by the cloud, otherwise
@@ -2969,7 +2969,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                             failover_history=e.failover_history) from None
             if dryrun:
                 record = global_user_state.get_cluster_from_name(cluster_name)
-                return record['handle'] if record is not None else None
+                return record['handle'] if record is not None else None, False
 
             if config_dict['provisioning_skipped']:
                 # Skip further provisioning.
@@ -2980,7 +2980,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                 record = global_user_state.get_cluster_from_name(cluster_name)
                 assert record is not None and record['handle'] is not None, (
                     cluster_name, record)
-                return record['handle']
+                return record['handle'], True
 
             if 'provision_record' in config_dict:
                 # New provisioner is used here.
@@ -3022,7 +3022,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
                 self._update_after_cluster_provisioned(
                     handle, to_provision_config.prev_handle, task,
                     prev_cluster_status, lock_path, config_hash)
-                return handle
+                return handle, False
 
             cluster_config_file = config_dict['ray']
             handle = config_dict['handle']
@@ -3094,7 +3094,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
             self._update_after_cluster_provisioned(
                 handle, to_provision_config.prev_handle, task,
                 prev_cluster_status, lock_path, config_hash)
-            return handle
+            return handle, False
 
     def _open_ports(self, handle: CloudVmRayResourceHandle) -> None:
         cloud = handle.launched_resources.cloud
@@ -3435,7 +3435,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         mkdir_code = (f'{cd} && mkdir -p {remote_log_dir} && '
                       f'touch {remote_log_path}')
         encoded_script = shlex.quote(codegen)
-        create_script_code = (f'{{ echo {encoded_script} > {script_path}; }}')
+        create_script_code = f'{{ echo {encoded_script} > {script_path}; }}'
         job_submit_cmd = (
             # JOB_CMD_IDENTIFIER is used for identifying the process retrieved
             # with pid is the same driver process.
@@ -4331,7 +4331,7 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
         cluster_name_on_cloud = handle.cluster_name_on_cloud
         cloud = handle.launched_resources.cloud
 
-        if (terminate and handle.launched_resources.is_image_managed is True):
+        if terminate and handle.launched_resources.is_image_managed is True:
             # Delete the image when terminating a "cloned" cluster, i.e.,
             # whose image is created by SkyPilot (--clone-disk-from)
             logger.debug(f'Deleting image {handle.launched_resources.image_id}')

sky/backends/local_docker_backend.py

@@ -139,7 +139,7 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
         cluster_name: str,
         retry_until_up: bool = False,
         skip_unnecessary_provisioning: bool = False,
-    ) -> Optional[LocalDockerResourceHandle]:
+    ) -> Tuple[Optional[LocalDockerResourceHandle], bool]:
         """Builds docker image for the task and returns cluster name as handle.
 
         Since resource demands are ignored, There's no provisioning in local
@@ -149,7 +149,7 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
         assert task.name is not None, ('Task name cannot be None - have you '
                                        'specified a task name?')
         if dryrun:
-            return None
+            return None, False
         if retry_until_up:
             logger.warning(
                 f'Retrying until up is not supported in backend: {self.NAME}. '
@@ -175,7 +175,7 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
                                                 requested_resources=set(
                                                     task.resources),
                                                 ready=False)
-        return handle
+        return handle, False
 
     def _sync_workdir(self, handle: LocalDockerResourceHandle,
                       workdir: Path) -> None:

sky/cloud_stores.py

@@ -578,13 +578,11 @@ class NebiusCloudStorage(CloudStorage):
         # AWS Sync by default uses 10 threads to upload files to the bucket.
         # To increase parallelism, modify max_concurrent_requests in your
         # aws config file (Default path: ~/.aws/config).
-        endpoint_url = nebius.create_endpoint()
         assert 'nebius://' in source, 'nebius:// is not in source'
         source = source.replace('nebius://', 's3://')
         download_via_awscli = (f'{constants.SKY_REMOTE_PYTHON_ENV}/bin/aws s3 '
                                'sync --no-follow-symlinks '
                                f'{source} {destination} '
-                               f'--endpoint {endpoint_url} '
                                f'--profile={nebius.NEBIUS_PROFILE_NAME}')
 
         all_commands = list(self._GET_AWSCLI)
@@ -593,12 +591,10 @@ class NebiusCloudStorage(CloudStorage):
 
     def make_sync_file_command(self, source: str, destination: str) -> str:
         """Downloads a file using AWS CLI."""
-        endpoint_url = nebius.create_endpoint()
         assert 'nebius://' in source, 'nebius:// is not in source'
         source = source.replace('nebius://', 's3://')
         download_via_awscli = (f'{constants.SKY_REMOTE_PYTHON_ENV}/bin/aws s3 '
                                f'cp {source} {destination} '
-                               f'--endpoint {endpoint_url} '
                                f'--profile={nebius.NEBIUS_PROFILE_NAME}')
 
         all_commands = list(self._GET_AWSCLI)

sky/clouds/do.py

@@ -280,13 +280,12 @@ class DO(clouds.Cloud):
         return True, None
 
     def get_credential_file_mounts(self) -> Dict[str, str]:
-        if do_utils.CREDENTIALS_PATH is None:
+        credential_path = do_utils.get_credentials_path()
+        if credential_path is None:
             return {}
-        if not os.path.exists(os.path.expanduser(do_utils.CREDENTIALS_PATH)):
+        if not os.path.exists(os.path.expanduser(credential_path)):
             return {}
-        return {
-            f'~/.config/doctl/{_CREDENTIAL_FILE}': do_utils.CREDENTIALS_PATH
-        }
+        return {f'~/.config/doctl/{_CREDENTIAL_FILE}': credential_path}
 
     @classmethod
     def get_current_user_identity(cls) -> Optional[List[str]]:

sky/clouds/gcp.py

@@ -688,9 +688,11 @@ class GCP(clouds.Cloud):
         cls,
         instance_type: str,
     ) -> Optional[Dict[str, Union[int, float]]]:
-        # GCP handles accelerators separately from regular instance types,
-        # hence return none here.
-        return None
+        # GCP handles accelerators separately from regular instance types.
+        # This method supports automatically inferring the GPU type for
+        # the instance type that come with GPUs pre-attached.
+        return service_catalog.get_accelerators_from_instance_type(
+            instance_type, clouds='gcp')
 
     @classmethod
     def get_vcpus_mem_from_instance_type(

sky/clouds/nebius.py

@@ -24,18 +24,28 @@ _CREDENTIAL_FILES = [
 _INDENT_PREFIX = '    '
 
 
-def nebius_profile_in_aws_cred() -> bool:
-    """Checks if Nebius Object Storage profile is set in aws credentials."""
-
-    profile_path = os.path.expanduser('~/.aws/credentials')
-    nebius_profile_exists = False
-    if os.path.isfile(profile_path):
-        with open(profile_path, 'r', encoding='utf-8') as file:
+def nebius_profile_in_aws_cred_and_config() -> bool:
+    """Checks if Nebius Object Storage profile is set in aws credentials
+    and profile."""
+
+    credentials_path = os.path.expanduser('~/.aws/credentials')
+    nebius_profile_exists_in_credentials = False
+    if os.path.isfile(credentials_path):
+        with open(credentials_path, 'r', encoding='utf-8') as file:
             for line in file:
                 if f'[{nebius.NEBIUS_PROFILE_NAME}]' in line:
-                    nebius_profile_exists = True
+                    nebius_profile_exists_in_credentials = True
+
+    config_path = os.path.expanduser('~/.aws/config')
+    nebius_profile_exists_in_config = False
+    if os.path.isfile(config_path):
+        with open(config_path, 'r', encoding='utf-8') as file:
+            for line in file:
+                if f'[profile {nebius.NEBIUS_PROFILE_NAME}]' in line:
+                    nebius_profile_exists_in_config = True
 
-    return nebius_profile_exists
+    return (nebius_profile_exists_in_credentials and
+            nebius_profile_exists_in_config)
 
 
 @registry.CLOUD_REGISTRY.register
@@ -308,12 +318,12 @@ class Nebius(clouds.Cloud):
             with a string on unset credential.
         """
         hints = None
-        if not nebius_profile_in_aws_cred():
+        if not nebius_profile_in_aws_cred_and_config():
             hints = (f'[{nebius.NEBIUS_PROFILE_NAME}] profile '
                      'is not set in ~/.aws/credentials.')
         if hints:
             hints += ' Run the following commands:'
-            if not nebius_profile_in_aws_cred():
+            if not nebius_profile_in_aws_cred_and_config():
                 hints += (
                     f'\n{_INDENT_PREFIX}  $ pip install boto3'
                     f'\n{_INDENT_PREFIX}  $ aws configure --profile nebius')
@@ -329,7 +339,7 @@ class Nebius(clouds.Cloud):
             for filename in _CREDENTIAL_FILES
         }
         credential_file_mounts['~/.aws/credentials'] = '~/.aws/credentials'
-
+        credential_file_mounts['~/.aws/config'] = '~/.aws/config'
         return credential_file_mounts
 
     @classmethod

sky/clouds/service_catalog/data_fetchers/fetch_ibm.py

@@ -1,4 +1,4 @@
-"""A script that generates the Lambda Cloud catalog.
+"""A script that generates the IBM Cloud catalog.
 
 Usage:
     python fetch_ibm.py [-h] [--api-key API_KEY]
@@ -19,7 +19,6 @@ import yaml
 
 TOKEN_ENDPOINT = 'https://iam.cloud.ibm.com/identity/token'
 REGIONS_ENDPOINT = f'https://us-south.iaas.cloud.ibm.com/v1/regions?version={datetime.today().strftime("%Y-%m-%d")}&generation=2'  # pylint: disable=line-too-long
-ENDPOINT = 'https://cloud.lambdalabs.com/api/v1/instance-types'
 DEFAULT_IBM_CREDENTIALS_PATH = os.path.expanduser('~/.ibm/credentials.yaml')
 
 

sky/clouds/service_catalog/gcp_catalog.py

@@ -106,6 +106,16 @@ _ACC_INSTANCE_TYPE_DICTS = {
         8: ['a3-megagpu-8g'],
     }
 }
+# Enable GPU type inference from instance types
+_INSTANCE_TYPE_TO_ACC = {
+    instance_type: {
+        acc_name: acc_count
+    } for acc_name, acc_count_to_instance_type in
+    _ACC_INSTANCE_TYPE_DICTS.items()
+    for acc_count, instance_types in acc_count_to_instance_type.items()
+    for instance_type in instance_types
+}
+GCP_ACC_INSTANCE_TYPES = list(_INSTANCE_TYPE_TO_ACC.keys())
 
 # Number of CPU cores per GPU based on the AWS setting.
 # GCP A100 has its own instance type mapping.
@@ -270,6 +280,26 @@ def get_default_instance_type(
                                                       memory_gb_or_ratio)
 
 
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, int]]:
+    """Infer the GPU type from the instance type.
+
+    This inference logic is GCP-specific. Unlike other clouds, we don't call
+    the internal implementation defined in common.py.
+
+    Args:
+        instance_type: the instance type to use.
+
+    Returns:
+        A dictionary mapping from the accelerator name to the accelerator count.
+    """
+    if instance_type in GCP_ACC_INSTANCE_TYPES:
+        return _INSTANCE_TYPE_TO_ACC[instance_type]
+    else:
+        # General CPU instance types don't come with pre-attached accelerators.
+        return None
+
+
 def get_instance_type_for_accelerator(
         acc_name: str,
         acc_count: int,
@@ -528,16 +558,13 @@ def check_accelerator_attachable_to_host(instance_type: str,
             attached to the host.
     """
     if accelerators is None:
-        for acc_name, val in _ACC_INSTANCE_TYPE_DICTS.items():
-            if instance_type in sum(val.values(), []):
-                # NOTE: While it is allowed to use A2/G2 VMs as CPU-only nodes,
-                # we exclude this case as it is uncommon and undesirable.
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.ResourcesMismatchError(
-                        f'{instance_type} instance types should be used with '
-                        f'{acc_name} GPUs. Either use other instance types or '
-                        f'specify the accelerators as {acc_name}.')
-        return
+        if instance_type in GCP_ACC_INSTANCE_TYPES:
+            # Infer the GPU type from the instance type
+            accelerators = _INSTANCE_TYPE_TO_ACC[instance_type]
+        else:
+            # Skip the following checks if instance_type is a general CPU
+            # instance without accelerators
+            return
 
     acc = list(accelerators.items())
     assert len(acc) == 1, acc

sky/core.py

@@ -372,12 +372,12 @@ def _start(
     with dag_lib.Dag():
         dummy_task = task_lib.Task().set_resources(handle.launched_resources)
         dummy_task.num_nodes = handle.launched_nodes
-    handle = backend.provision(dummy_task,
-                               to_provision=handle.launched_resources,
-                               dryrun=False,
-                               stream_logs=True,
-                               cluster_name=cluster_name,
-                               retry_until_up=retry_until_up)
+    (handle, _) = backend.provision(dummy_task,
+                                    to_provision=handle.launched_resources,
+                                    dryrun=False,
+                                    stream_logs=True,
+                                    cluster_name=cluster_name,
+                                    retry_until_up=retry_until_up)
     storage_mounts = backend.get_storage_mounts_metadata(handle.cluster_name)
     # Passing all_file_mounts as None ensures the local source set in Storage
     # to not redundantly sync source to the bucket.

sky/data/data_utils.py

@@ -322,14 +322,9 @@ def create_r2_client(region: str = 'auto') -> Client:
     return cloudflare.client('s3', region)
 
 
-def create_nebius_client(region: Optional[str]) -> Client:
-    """Helper method that connects to Boto3 client for Nebius Object Storage
-
-    Args:
-      region: str; Region for Nebius Object Storage
-    """
-    region = region if region is not None else nebius.DEFAULT_REGION
-    return nebius.client('s3', region)
+def create_nebius_client() -> Client:
+    """Helper method that connects to Boto3 client for Nebius Object Storage"""
+    return nebius.client('s3')
 
 
 def verify_r2_bucket(name: str) -> bool:
@@ -566,7 +561,8 @@ def run_upload_cli(command: str, access_denied_message: str, bucket_name: str,
         require_outputs=True,
         # We need to use bash as some of the cloud commands uses bash syntax,
         # such as [[ ... ]]
-        executable='/bin/bash')
+        executable='/bin/bash',
+        log_cmd=True)
     if access_denied_message in stderr:
         with ux_utils.print_exception_no_traceback():
             raise PermissionError('Failed to upload files to '

sky/data/mounting_utils.py

@@ -64,8 +64,8 @@ def get_s3_mount_cmd(bucket_name: str,
 
 
 def get_nebius_mount_cmd(nebius_profile_name: str,
-                         endpoint_url: str,
                          bucket_name: str,
+                         endpoint_url: str,
                          mount_path: str,
                          _bucket_sub_path: Optional[str] = None) -> str:
     """Returns a command to install Nebius mount utility goofys."""