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

sky/provision/kubernetes/volume.py

@@ -1,13 +1,15 @@
 """Kubernetes pvc provisioning."""
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from sky import global_user_state
 from sky import models
 from sky import sky_logging
 from sky.adaptors import kubernetes
+from sky.provision import constants
 from sky.provision.kubernetes import config as config_lib
 from sky.provision.kubernetes import constants as k8s_constants
 from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import resources_utils
 from sky.utils import volume as volume_lib
 
 logger = sky_logging.init_logger(__name__)
@@ -67,7 +69,7 @@ def apply_volume(config: models.VolumeConfig) -> models.VolumeConfig:
         except kubernetes.api_exception() as e:
             raise config_lib.KubernetesError(
                 f'Check storage class {storage_class_name} error: {e}')
-    create_persistent_volume_claim(namespace, context, pvc_spec)
+    create_persistent_volume_claim(namespace, context, pvc_spec, config)
     return config
 
 
@@ -75,7 +77,6 @@ def delete_volume(config: models.VolumeConfig) -> models.VolumeConfig:
     """Deletes a volume."""
     context, namespace = _get_context_namespace(config)
     pvc_name = config.name_on_cloud
-    logger.info(f'Deleting PVC {pvc_name}')
     kubernetes_utils.delete_k8s_resource_with_retry(
         delete_func=lambda pvc_name=pvc_name: kubernetes.core_api(
             context).delete_namespaced_persistent_volume_claim(
@@ -84,6 +85,7 @@ def delete_volume(config: models.VolumeConfig) -> models.VolumeConfig:
                 _request_timeout=config_lib.DELETION_TIMEOUT),
         resource_type='pvc',
         resource_name=pvc_name)
+    logger.info(f'Deleted PVC {pvc_name} in namespace {namespace}')
     return config
 
 
@@ -128,7 +130,7 @@ def _get_volume_usedby(
                 usedby_pods.append(pod.metadata.name)
                 # Get the real cluster name
                 cluster_name_on_cloud = pod.metadata.labels.get(
-                    k8s_constants.TAG_SKYPILOT_CLUSTER_NAME)
+                    constants.TAG_SKYPILOT_CLUSTER_NAME)
                 if cluster_name_on_cloud is None:
                     continue
                 cluster_name = cloud_to_name_map.get(cluster_name_on_cloud)
@@ -160,21 +162,154 @@ def get_volume_usedby(
     return _get_volume_usedby(context, namespace, pvc_name)
 
 
-def create_persistent_volume_claim(namespace: str, context: Optional[str],
-                                   pvc_spec: Dict[str, Any]) -> None:
+def get_all_volumes_usedby(
+    configs: List[models.VolumeConfig],
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    """Gets the usedby resources of all volumes."""
+    field_selector = ','.join([
+        f'status.phase!={phase}'
+        for phase in k8s_constants.PVC_NOT_HOLD_POD_PHASES
+    ])
+    label_selector = 'parent=skypilot'
+    context_to_namespaces: Dict[str, Set[str]] = {}
+    pvc_names = set()
+    for config in configs:
+        context, namespace = _get_context_namespace(config)
+        if context not in context_to_namespaces:
+            context_to_namespaces[context] = set()
+        context_to_namespaces[context].add(namespace)
+        pvc_names.add(config.name_on_cloud)
+    cloud_to_name_map = _get_cluster_name_on_cloud_to_cluster_name_map()
+    # Get all pods in the namespace
+    used_by_pods: Dict[str, Dict[str, Dict[str, List[str]]]] = {}
+    used_by_clusters: Dict[str, Dict[str, Dict[str, List[str]]]] = {}
+    for context, namespaces in context_to_namespaces.items():
+        used_by_pods[context] = {}
+        used_by_clusters[context] = {}
+        for namespace in namespaces:
+            used_by_pods[context][namespace] = {}
+            used_by_clusters[context][namespace] = {}
+            pods = kubernetes.core_api(context).list_namespaced_pod(
+                namespace=namespace,
+                field_selector=field_selector,
+                label_selector=label_selector)
+            for pod in pods.items:
+                if pod.spec.volumes is None:
+                    continue
+                for volume in pod.spec.volumes:
+                    if volume.persistent_volume_claim is None:
+                        continue
+                    volume_name = volume.persistent_volume_claim.claim_name
+                    if volume_name not in pvc_names:
+                        continue
+                    if volume_name not in used_by_pods[context][namespace]:
+                        used_by_pods[context][namespace][volume_name] = []
+                    used_by_pods[context][namespace][volume_name].append(
+                        pod.metadata.name)
+                    cluster_name_on_cloud = pod.metadata.labels.get(
+                        constants.TAG_SKYPILOT_CLUSTER_NAME)
+                    if cluster_name_on_cloud is None:
+                        continue
+                    cluster_name = cloud_to_name_map.get(cluster_name_on_cloud)
+                    if cluster_name is None:
+                        continue
+                    if cluster_name not in used_by_clusters[context][namespace]:
+                        used_by_clusters[context][namespace][cluster_name] = []
+                    used_by_clusters[context][namespace][cluster_name].append(
+                        cluster_name)
+    return used_by_pods, used_by_clusters
+
+
+def map_all_volumes_usedby(
+        used_by_pods: Dict[str, Any], used_by_clusters: Dict[str, Any],
+        config: models.VolumeConfig) -> Tuple[List[str], List[str]]:
+    """Maps the usedby resources of a volume."""
+    context, namespace = _get_context_namespace(config)
+    pvc_name = config.name_on_cloud
+
+    return (used_by_pods.get(context, {}).get(namespace, {}).get(pvc_name, []),
+            used_by_clusters.get(context, {}).get(namespace,
+                                                  {}).get(pvc_name, []))
+
+
+def _populate_config_from_pvc(config: models.VolumeConfig,
+                              pvc_obj: Any) -> None:
+    """Populate missing fields in config from a PVC object.
+
+    Args:
+        config: VolumeConfig to populate
+        pvc_obj: V1PersistentVolumeClaim object from kubernetes client
+    """
+    if pvc_obj is None:
+        return
+    pvc_name = pvc_obj.metadata.name
+
+    # Populate storageClassName if not set
+    if config.config.get('storage_class_name') is None:
+        pvc_storage_class = getattr(pvc_obj.spec, 'storage_class_name', None)
+        if pvc_storage_class:
+            config.config['storage_class_name'] = pvc_storage_class
+
+    # Populate size if not set (prefer bound capacity, fallback to requested)
+    pvc_size = None
+    size_quantity = None
+    # Try status.capacity (dict) - actual bound size
+    capacity = getattr(getattr(pvc_obj, 'status', None), 'capacity', None)
+    if isinstance(capacity, dict) and 'storage' in capacity:
+        size_quantity = capacity['storage']
+    # Fallback to spec.resources.requests (dict) - requested size
+    if size_quantity is None:
+        requests = getattr(getattr(pvc_obj.spec, 'resources', None), 'requests',
+                           None)
+        if isinstance(requests, dict):
+            size_quantity = requests.get('storage')
+    # Parse and normalize the size if found
+    if size_quantity:
+        try:
+            # Normalize to GB string (e.g., '20')
+            pvc_size = resources_utils.parse_memory_resource(
+                size_quantity, 'size', allow_rounding=True)
+        except ValueError as e:
+            # Just log the error since it is not critical.
+            logger.warning(f'Failed to parse PVC size {size_quantity!r} '
+                           f'for PVC {pvc_name}: {e}')
+    if pvc_size is not None:
+        if config.size is not None and config.size != pvc_size:
+            logger.warning(f'PVC {pvc_name} has size {pvc_size} but config '
+                           f'size is {config.size}, overriding the config size'
+                           f' with the PVC size.')
+        config.size = pvc_size
+
+
+def create_persistent_volume_claim(
+    namespace: str,
+    context: Optional[str],
+    pvc_spec: Dict[str, Any],
+    config: Optional[models.VolumeConfig] = None,
+) -> None:
     """Creates a persistent volume claim for SkyServe controller."""
     pvc_name = pvc_spec['metadata']['name']
     try:
-        kubernetes.core_api(context).read_namespaced_persistent_volume_claim(
-            name=pvc_name, namespace=namespace)
+        pvc = kubernetes.core_api(
+            context).read_namespaced_persistent_volume_claim(
+                name=pvc_name, namespace=namespace)
+        if config is not None:
+            _populate_config_from_pvc(config, pvc)
         logger.debug(f'PVC {pvc_name} already exists')
         return
     except kubernetes.api_exception() as e:
         if e.status != 404:  # Not found
             raise
-    logger.info(f'Creating PVC {pvc_name}')
-    kubernetes.core_api(context).create_namespaced_persistent_volume_claim(
-        namespace=namespace, body=pvc_spec)
+    use_existing = config is not None and config.config.get('use_existing')
+    if use_existing:
+        raise ValueError(
+            f'PVC {pvc_name} does not exist while use_existing is True.')
+    pvc = kubernetes.core_api(
+        context).create_namespaced_persistent_volume_claim(namespace=namespace,
+                                                           body=pvc_spec)
+    logger.info(f'Created PVC {pvc_name} in namespace {namespace}')
+    if config is not None:
+        _populate_config_from_pvc(config, pvc)
 
 
 def _get_pvc_spec(namespace: str,
@@ -183,8 +318,8 @@ def _get_pvc_spec(namespace: str,
     access_mode = config.config.get('access_mode')
     size = config.size
     # The previous code assumes that the access_mode and size are always set.
-    assert access_mode is not None
-    assert size is not None
+    assert access_mode is not None, f'access_mode is None for volume ' \
+                                    f'{config.name_on_cloud}'
     pvc_spec: Dict[str, Any] = {
         'metadata': {
             'name': config.name_on_cloud,
@@ -196,13 +331,10 @@ def _get_pvc_spec(namespace: str,
         },
         'spec': {
             'accessModes': [access_mode],
-            'resources': {
-                'requests': {
-                    'storage': f'{size}Gi'
-                }
-            },
         }
     }
+    if size is not None:
+        pvc_spec['spec']['resources'] = {'requests': {'storage': f'{size}Gi'}}
     if config.labels:
         pvc_spec['metadata']['labels'].update(config.labels)
     storage_class = config.config.get('storage_class_name')

sky/provision/lambda_cloud/instance.py

@@ -68,9 +68,10 @@ def _get_private_ip(instance_info: Dict[str, Any], single_node: bool) -> str:
     return private_ip
 
 
-def run_instances(region: str, cluster_name_on_cloud: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Runs instances for the given cluster"""
+    del cluster_name  # unused
     lambda_client = _get_lambda_client()
     pending_status = ['booting']
     while True:
@@ -106,34 +107,35 @@ def run_instances(region: str, cluster_name_on_cloud: str,
     created_instance_ids = []
     remote_ssh_key_name = config.authentication_config['remote_key_name']
 
-    def launch_nodes(node_type: str, quantity: int) -> List[str]:
+    def launch_node(node_type: str) -> str:
         try:
             instance_ids = lambda_client.create_instances(
                 instance_type=config.node_config['InstanceType'],
                 region=region,
                 name=f'{cluster_name_on_cloud}-{node_type}',
-                quantity=quantity,
+                # Quantity cannot actually be greater than 1; see:
+                # https://github.com/skypilot-org/skypilot/issues/7084
+                quantity=1,
                 ssh_key_name=remote_ssh_key_name,
             )
-            logger.info(f'Launched {len(instance_ids)} {node_type} node(s), '
-                        f'instance_ids: {instance_ids}')
-            return instance_ids
+            logger.info(f'Launched {node_type} node, '
+                        f'instance_id: {instance_ids[0]}')
+            return instance_ids[0]
         except Exception as e:
             logger.warning(f'run_instances error: {e}')
             raise
 
     if head_instance_id is None:
-        instance_ids = launch_nodes('head', 1)
-        assert len(instance_ids) == 1
-        created_instance_ids.append(instance_ids[0])
-        head_instance_id = instance_ids[0]
+        head_instance_id = launch_node('head')
+        created_instance_ids.append(head_instance_id)
 
     assert head_instance_id is not None, 'head_instance_id should not be None'
 
     worker_node_count = to_start_count - 1
     if worker_node_count > 0:
-        instance_ids = launch_nodes('worker', worker_node_count)
-        created_instance_ids.extend(instance_ids)
+        for _ in range(worker_node_count):
+            worker_instance_id = launch_node('worker')
+            created_instance_ids.append(worker_instance_id)
 
     while True:
         instances = _filter_instances(cluster_name_on_cloud, ['active'])
@@ -230,9 +232,10 @@ def query_instances(
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
+    retry_if_missing: bool = False,
 ) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """See sky/provision/__init__.py"""
-    del cluster_name  # unused
+    del cluster_name, retry_if_missing  # unused
     assert provider_config is not None, (cluster_name_on_cloud, provider_config)
     instances = _filter_instances(cluster_name_on_cloud, None)
 

sky/provision/nebius/instance.py

@@ -65,9 +65,10 @@ def _wait_until_no_pending(region: str, cluster_name_on_cloud: str) -> None:
                            f' to be ready.')
 
 
-def run_instances(region: str, cluster_name_on_cloud: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Runs instances for the given cluster."""
+    del cluster_name  # unused
     _wait_until_no_pending(region, cluster_name_on_cloud)
     running_instances = _filter_instances(region, cluster_name_on_cloud,
                                           ['RUNNING'])
@@ -137,6 +138,8 @@ def run_instances(region: str, cluster_name_on_cloud: str,
                 use_spot=config.node_config['use_spot'],
                 associate_public_ip_address=(
                     not config.provider_config['use_internal_ips']),
+                use_static_ip_address=config.provider_config.get(
+                    'use_static_ip_address', False),
                 filesystems=config.node_config.get('filesystems', []),
                 network_tier=config.node_config.get('network_tier'))
         except Exception as e:  # pylint: disable=broad-except
@@ -251,9 +254,10 @@ def query_instances(
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
+    retry_if_missing: bool = False,
 ) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """See sky/provision/__init__.py"""
-    del cluster_name  # unused
+    del cluster_name, retry_if_missing  # unused
     assert provider_config is not None, (cluster_name_on_cloud, provider_config)
     instances = _filter_instances(provider_config['region'],
                                   cluster_name_on_cloud, None)

sky/provision/nebius/utils.py

@@ -188,6 +188,7 @@ def launch(cluster_name_on_cloud: str,
            user_data: str,
            associate_public_ip_address: bool,
            filesystems: List[Dict[str, Any]],
+           use_static_ip_address: bool = False,
            use_spot: bool = False,
            network_tier: Optional[resources_utils.NetworkTier] = None) -> str:
     # Each node must have a unique name to avoid conflicts between
@@ -281,93 +282,109 @@ def launch(cluster_name_on_cloud: str,
 
     service = nebius.compute().InstanceServiceClient(nebius.sdk())
     logger.debug(f'Creating instance {instance_name} in project {project_id}.')
-    nebius.sync_call(
-        service.create(nebius.compute().CreateInstanceRequest(
-            metadata=nebius.nebius_common().ResourceMetadata(
-                parent_id=project_id,
-                name=instance_name,
-            ),
-            spec=nebius.compute().InstanceSpec(
-                gpu_cluster=nebius.compute().InstanceGpuClusterSpec(
-                    id=cluster_id,) if cluster_id is not None else None,
-                boot_disk=nebius.compute().AttachedDiskSpec(
-                    attach_mode=nebius.compute(
-                    ).AttachedDiskSpec.AttachMode.READ_WRITE,
-                    existing_disk=nebius.compute().ExistingDisk(id=disk_id)),
-                cloud_init_user_data=user_data,
-                resources=nebius.compute().ResourcesSpec(platform=platform,
-                                                         preset=preset),
-                filesystems=filesystems_spec if filesystems_spec else None,
-                network_interfaces=[
-                    nebius.compute().NetworkInterfaceSpec(
-                        subnet_id=sub_net.items[0].metadata.id,
-                        ip_address=nebius.compute().IPAddress(),
-                        name='network-interface-0',
-                        public_ip_address=nebius.compute().PublicIPAddress()
-                        if associate_public_ip_address else None,
-                    )
-                ],
-                recovery_policy=nebius.compute().InstanceRecoveryPolicy.FAIL
-                if use_spot else None,
-                preemptible=nebius.compute().PreemptibleSpec(
-                    priority=1,
-                    on_preemption=nebius.compute().PreemptibleSpec.
-                    PreemptionPolicy.STOP) if use_spot else None,
-            ))))
-    instance_id = ''
-    retry_count = 0
-    while retry_count < nebius.MAX_RETRIES_TO_INSTANCE_READY:
-        service = nebius.compute().InstanceServiceClient(nebius.sdk())
-        instance = nebius.sync_call(
-            service.get_by_name(nebius.nebius_common().GetByNameRequest(
-                parent_id=project_id,
-                name=instance_name,
-            )))
-        instance_id = instance.metadata.id
-        if instance.status.state.name == 'STARTING':
-            break
-
-        # All Instances initially have state=STOPPED and reconciling=True,
-        # so we need to wait until reconciling is False.
-        if instance.status.state.name == 'STOPPED' and \
-                not instance.status.reconciling:
-            next_token = ''
-            total_operations = 0
-            while True:
-                operations_response = nebius.sync_call(
-                    service.list_operations_by_parent(
-                        nebius.compute().ListOperationsByParentRequest(
-                            parent_id=project_id,
-                            page_size=100,
-                            page_token=next_token,
-                        )))
-                total_operations += len(operations_response.operations)
-                for operation in operations_response.operations:
-                    # Find the most recent operation for the instance.
-                    if operation.resource_id == instance_id:
-                        error_msg = operation.description
-                        if operation.status:
-                            error_msg += f' {operation.status.message}'
-                        raise RuntimeError(error_msg)
-                # If we've fetched too many operations, or there are no more
-                # operations to fetch, just raise a generic error.
-                if total_operations > _MAX_OPERATIONS_TO_FETCH or \
-                        not operations_response.next_page_token:
-                    raise RuntimeError(
-                        f'Instance {instance_name} failed to start.')
-                next_token = operations_response.next_page_token
-        time.sleep(POLL_INTERVAL)
-        logger.debug(f'Waiting for instance {instance_name} to start running. '
-                     f'State: {instance.status.state.name}, '
-                     f'Reconciling: {instance.status.reconciling}')
-        retry_count += 1
+    try:
+        nebius.sync_call(
+            service.create(nebius.compute().CreateInstanceRequest(
+                metadata=nebius.nebius_common().ResourceMetadata(
+                    parent_id=project_id,
+                    name=instance_name,
+                ),
+                spec=nebius.compute().InstanceSpec(
+                    gpu_cluster=nebius.compute().InstanceGpuClusterSpec(
+                        id=cluster_id,) if cluster_id is not None else None,
+                    boot_disk=nebius.compute().AttachedDiskSpec(
+                        attach_mode=nebius.compute(
+                        ).AttachedDiskSpec.AttachMode.READ_WRITE,
+                        existing_disk=nebius.compute().ExistingDisk(
+                            id=disk_id)),
+                    cloud_init_user_data=user_data,
+                    resources=nebius.compute().ResourcesSpec(platform=platform,
+                                                             preset=preset),
+                    filesystems=filesystems_spec if filesystems_spec else None,
+                    network_interfaces=[
+                        nebius.compute().NetworkInterfaceSpec(
+                            subnet_id=sub_net.items[0].metadata.id,
+                            ip_address=nebius.compute().IPAddress(),
+                            name='network-interface-0',
+                            public_ip_address=nebius.compute().PublicIPAddress(
+                                static=use_static_ip_address)
+                            if associate_public_ip_address else None,
+                        )
+                    ],
+                    recovery_policy=nebius.compute().InstanceRecoveryPolicy.FAIL
+                    if use_spot else None,
+                    preemptible=nebius.compute().PreemptibleSpec(
+                        priority=1,
+                        on_preemption=nebius.compute().PreemptibleSpec.
+                        PreemptionPolicy.STOP) if use_spot else None,
+                ))))
+        instance_id = ''
+        retry_count = 0
+        while retry_count < nebius.MAX_RETRIES_TO_INSTANCE_READY:
+            service = nebius.compute().InstanceServiceClient(nebius.sdk())
+            instance = nebius.sync_call(
+                service.get_by_name(nebius.nebius_common().GetByNameRequest(
+                    parent_id=project_id,
+                    name=instance_name,
+                )))
+            instance_id = instance.metadata.id
+            if instance.status.state.name == 'STARTING':
+                break
+
+            # All Instances initially have state=STOPPED and reconciling=True,
+            # so we need to wait until reconciling is False.
+            if instance.status.state.name == 'STOPPED' and \
+                    not instance.status.reconciling:
+                next_token = ''
+                total_operations = 0
+                while True:
+                    operations_response = nebius.sync_call(
+                        service.list_operations_by_parent(
+                            nebius.compute().ListOperationsByParentRequest(
+                                parent_id=project_id,
+                                page_size=100,
+                                page_token=next_token,
+                            )))
+                    total_operations += len(operations_response.operations)
+                    for operation in operations_response.operations:
+                        # Find the most recent operation for the instance.
+                        if operation.resource_id == instance_id:
+                            error_msg = operation.description
+                            if operation.status:
+                                error_msg += f' {operation.status.message}'
+                            raise RuntimeError(error_msg)
+                    # If we've fetched too many operations, or there are no more
+                    # operations to fetch, just raise a generic error.
+                    if total_operations > _MAX_OPERATIONS_TO_FETCH or \
+                            not operations_response.next_page_token:
+                        raise RuntimeError(
+                            f'Instance {instance_name} failed to start.')
+                    next_token = operations_response.next_page_token
+            time.sleep(POLL_INTERVAL)
+            logger.debug(
+                f'Waiting for instance {instance_name} to start running. '
+                f'State: {instance.status.state.name}, '
+                f'Reconciling: {instance.status.reconciling}')
+            retry_count += 1
 
-    if retry_count == nebius.MAX_RETRIES_TO_INSTANCE_READY:
-        raise TimeoutError(
-            f'Exceeded maximum retries '
-            f'({nebius.MAX_RETRIES_TO_INSTANCE_READY * POLL_INTERVAL}'
-            f' seconds) while waiting for instance {instance_name}'
-            f' to be ready.')
+        if retry_count == nebius.MAX_RETRIES_TO_INSTANCE_READY:
+            raise TimeoutError(
+                f'Exceeded maximum retries '
+                f'({nebius.MAX_RETRIES_TO_INSTANCE_READY * POLL_INTERVAL}'
+                f' seconds) while waiting for instance {instance_name}'
+                f' to be ready.')
+    except nebius.request_error() as e:
+        # Handle ResourceExhausted quota limit error. In this case, we need to
+        # clean up the disk as VM creation failed and we can't proceed.
+        # It cannot be handled by the caller (provisioner)'s teardown logic,
+        # as we cannot retrieve the disk id, after the instance creation
+        # fails
+        logger.warning(f'Failed to launch instance {instance_name}: {e}')
+        service = nebius.compute().DiskServiceClient(nebius.sdk())
+        nebius.sync_call(
+            service.delete(nebius.compute().DeleteDiskRequest(id=disk_id)))
+        logger.debug(f'Disk {disk_id} deleted.')
+        raise e
     return instance_id
 
 

sky/provision/oci/instance.py

@@ -36,6 +36,7 @@ def query_instances(
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
+    retry_if_missing: bool = False,
 ) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """Query instances.
 
@@ -44,7 +45,7 @@ def query_instances(
     A None status means the instance is marked as "terminated"
     or "terminating".
     """
-    del cluster_name  # unusedå
+    del cluster_name, retry_if_missing  # unused
     assert provider_config is not None, cluster_name_on_cloud
     region = provider_config['region']
 
@@ -65,9 +66,10 @@ def query_instances(
 
 
 @query_utils.debug_enabled(logger)
-def run_instances(region: str, cluster_name_on_cloud: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Start instances with bootstrapped configuration."""
+    del cluster_name  # unused
     tags = dict(sorted(copy.deepcopy(config.tags).items()))
 
     start_time = round(time.time() * 1000)

sky/provision/paperspace/instance.py

@@ -48,10 +48,10 @@ def _get_head_instance_id(instances: Dict[str, Any]) -> Optional[str]:
     return head_instance_id
 
 
-def run_instances(region: str, cluster_name_on_cloud: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Runs instances for the given cluster."""
-
+    del cluster_name  # unused
     pending_status = [
         'starting', 'restarting', 'upgrading', 'provisioning', 'stopping'
     ]
@@ -281,9 +281,10 @@ def query_instances(
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
+    retry_if_missing: bool = False,
 ) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """See sky/provision/__init__.py"""
-    del cluster_name, non_terminated_only  #unused
+    del cluster_name, non_terminated_only, retry_if_missing  #unused
     assert provider_config is not None, (cluster_name_on_cloud, provider_config)
     instances = _filter_instances(cluster_name_on_cloud, None)
 

sky/provision/primeintellect/__init__.py

@@ -0,0 +1,10 @@
+"""Prime Intellect provisioner for SkyPilot."""
+
+from sky.provision.primeintellect.config import bootstrap_instances
+from sky.provision.primeintellect.instance import cleanup_ports
+from sky.provision.primeintellect.instance import get_cluster_info
+from sky.provision.primeintellect.instance import query_instances
+from sky.provision.primeintellect.instance import run_instances
+from sky.provision.primeintellect.instance import stop_instances
+from sky.provision.primeintellect.instance import terminate_instances
+from sky.provision.primeintellect.instance import wait_instances

sky/provision/primeintellect/config.py

@@ -0,0 +1,11 @@
+"""Prime Intellect configuration bootstrapping."""
+
+from sky.provision import common
+
+
+def bootstrap_instances(
+        region: str, cluster_name: str,
+        config: common.ProvisionConfig) -> common.ProvisionConfig:
+    """Bootstraps instances for the given cluster."""
+    del region, cluster_name  # unused
+    return config