skypilot-nightly 1.0.0.dev20250204__py3-none-any.whl → 1.0.0.dev20250206__py3-none-any.whl

sky/jobs/scheduler.py

@@ -60,6 +60,14 @@ logger = sky_logging.init_logger('sky.jobs.controller')
 _MANAGED_JOB_SCHEDULER_LOCK = '~/.sky/locks/managed_job_scheduler.lock'
 _ALIVE_JOB_LAUNCH_WAIT_INTERVAL = 0.5
 
+# Based on testing, assume a running job uses 350MB memory.
+JOB_MEMORY_MB = 350
+# Past 2000 simultaneous jobs, we become unstable.
+# See https://github.com/skypilot-org/skypilot/issues/4649.
+MAX_JOB_LIMIT = 2000
+# Number of ongoing launches launches allowed per CPU.
+LAUNCHES_PER_CPU = 4
+
 
 @lru_cache(maxsize=1)
 def _get_lock_path() -> str:
@@ -247,15 +255,16 @@ def _set_alive_waiting(job_id: int) -> None:
 
 
 def _get_job_parallelism() -> int:
-    # Assume a running job uses 350MB memory.
-    # We observe 230-300 in practice.
-    job_memory = 350 * 1024 * 1024
-    return max(psutil.virtual_memory().total // job_memory, 1)
+    job_memory = JOB_MEMORY_MB * 1024 * 1024
+
+    job_limit = min(psutil.virtual_memory().total // job_memory, MAX_JOB_LIMIT)
+
+    return max(job_limit, 1)
 
 
 def _get_launch_parallelism() -> int:
     cpus = os.cpu_count()
-    return cpus * 4 if cpus is not None else 1
+    return cpus * LAUNCHES_PER_CPU if cpus is not None else 1
 
 
 def _can_start_new_job() -> bool:

sky/jobs/utils.py

@@ -965,7 +965,8 @@ def format_job_table(
         'STATUS',
     ]
     if show_all:
-        columns += ['STARTED', 'CLUSTER', 'REGION', 'DESCRIPTION']
+        # TODO: move SCHED. STATE to a separate flag (e.g. --debug)
+        columns += ['STARTED', 'CLUSTER', 'REGION', 'SCHED. STATE', 'DETAILS']
     if tasks_have_user:
         columns.insert(0, 'USER')
     job_table = log_utils.create_table(columns)
@@ -984,20 +985,10 @@ def format_job_table(
         # by the task_id.
         jobs[get_hash(task)].append(task)
 
-    def generate_description(failure_reason: Optional[str],
-                             schedule_state: Optional[str]) -> str:
-        description = ''
-        if schedule_state is not None:
-            description += f'Scheduler: {schedule_state}'
-            if failure_reason is not None:
-                description += ', '
+    def generate_details(failure_reason: Optional[str]) -> str:
         if failure_reason is not None:
-            description += f'Failure: {failure_reason}'
-
-        if description == '':
-            return '-'
-
-        return description
+            return f'Failure: {failure_reason}'
+        return '-'
 
     for job_hash, job_tasks in jobs.items():
         if show_all:
@@ -1050,13 +1041,13 @@ def format_job_table(
                 status_str,
             ]
             if show_all:
-                schedule_state = job_tasks[0]['schedule_state']
                 failure_reason = job_tasks[current_task_id]['failure_reason']
                 job_values.extend([
                     '-',
                     '-',
                     '-',
-                    generate_description(failure_reason, schedule_state),
+                    job_tasks[0]['schedule_state'],
+                    generate_details(failure_reason),
                 ])
             if tasks_have_user:
                 job_values.insert(0, job_tasks[0].get('user', '-'))
@@ -1087,14 +1078,14 @@ def format_job_table(
                 # schedule_state is only set at the job level, so if we have
                 # more than one task, only display on the aggregated row.
                 schedule_state = (task['schedule_state']
-                                  if len(job_tasks) == 1 else None)
+                                  if len(job_tasks) == 1 else '-')
                 values.extend([
                     # STARTED
                     log_utils.readable_time_duration(task['start_at']),
                     task['cluster_resources'],
                     task['region'],
-                    generate_description(task['failure_reason'],
-                                         schedule_state),
+                    schedule_state,
+                    generate_details(task['failure_reason']),
                 ])
             if tasks_have_user:
                 values.insert(0, task.get('user', '-'))

sky/provision/__init__.py

@@ -22,6 +22,7 @@ from sky.provision import kubernetes
 from sky.provision import lambda_cloud
 from sky.provision import oci
 from sky.provision import runpod
+from sky.provision import vast
 from sky.provision import vsphere
 from sky.utils import command_runner
 from sky.utils import timeline

sky/provision/vast/__init__.py

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

sky/provision/vast/config.py

@@ -0,0 +1,11 @@
+"""Vast 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

sky/provision/vast/instance.py

@@ -0,0 +1,247 @@
+"""Vast instance provisioning."""
+import time
+from typing import Any, Dict, List, Optional
+
+from sky import sky_logging
+from sky import status_lib
+from sky.provision import common
+from sky.provision.vast import utils
+from sky.utils import common_utils
+from sky.utils import ux_utils
+
+POLL_INTERVAL = 10
+
+logger = sky_logging.init_logger(__name__)
+# a much more convenient method
+status_filter = lambda machine_dict, stat_list: {
+    k: v for k, v in machine_dict.items() if v['status'] in stat_list
+}
+
+
+def _filter_instances(cluster_name_on_cloud: str,
+                      status_filters: Optional[List[str]],
+                      head_only: bool = False) -> Dict[str, Any]:
+
+    instances = utils.list_instances()
+    possible_names = [f'{cluster_name_on_cloud}-head']
+    if not head_only:
+        possible_names.append(f'{cluster_name_on_cloud}-worker')
+
+    filtered_instances = {}
+    for instance_id, instance in instances.items():
+        if (status_filters is not None and
+                instance['status'] not in status_filters):
+            continue
+        if instance.get('name') in possible_names:
+            filtered_instances[instance_id] = instance
+    return filtered_instances
+
+
+def _get_head_instance_id(instances: Dict[str, Any]) -> Optional[str]:
+    for inst_id, inst in instances.items():
+        if inst['name'].endswith('-head'):
+            return inst_id
+    return None
+
+
+def run_instances(region: str, cluster_name_on_cloud: str,
+                  config: common.ProvisionConfig) -> common.ProvisionRecord:
+    """Runs instances for the given cluster."""
+    pending_status = ['CREATED', 'RESTARTING']
+
+    created_instance_ids = []
+    instances: Dict[str, Any] = {}
+
+    while True:
+        instances = _filter_instances(cluster_name_on_cloud, None)
+        if not status_filter(instances, pending_status):
+            break
+        logger.info(f'Waiting for {len(instances)} instances to be ready.')
+        time.sleep(POLL_INTERVAL)
+
+    running_instances = status_filter(instances, ['RUNNING'])
+    head_instance_id = _get_head_instance_id(running_instances)
+    stopped_instances = status_filter(instances, ['EXITED', 'STOPPED'])
+
+    if config.resume_stopped_nodes and stopped_instances:
+        for instance in stopped_instances.values():
+            utils.start(instance['id'])
+    else:
+        to_start_count = config.count - (len(running_instances) +
+                                         len(stopped_instances))
+        if to_start_count < 0:
+            raise RuntimeError(f'Cluster {cluster_name_on_cloud} already has '
+                               f'{len(running_instances)} nodes,'
+                               f'but {config.count} are required.')
+        if to_start_count == 0:
+            if head_instance_id is None:
+                raise RuntimeError(
+                    f'Cluster {cluster_name_on_cloud} has no head node.')
+            logger.info(
+                f'Cluster {cluster_name_on_cloud} already has '
+                f'{len(running_instances)} nodes, no need to start more.')
+            return common.ProvisionRecord(provider_name='vast',
+                                          cluster_name=cluster_name_on_cloud,
+                                          region=region,
+                                          zone=None,
+                                          head_instance_id=head_instance_id,
+                                          resumed_instance_ids=[],
+                                          created_instance_ids=[])
+
+        for _ in range(to_start_count):
+            node_type = 'head' if head_instance_id is None else 'worker'
+            try:
+                instance_id = utils.launch(
+                    name=f'{cluster_name_on_cloud}-{node_type}',
+                    instance_type=config.node_config['InstanceType'],
+                    region=region,
+                    disk_size=config.node_config['DiskSize'],
+                    preemptible=config.node_config['Preemptible'],
+                    image_name=config.node_config['ImageId'])
+            except Exception as e:  # pylint: disable=broad-except
+                logger.warning(f'run_instances error: {e}')
+                raise
+            logger.info(f'Launched instance {instance_id}.')
+            created_instance_ids.append(instance_id)
+            if head_instance_id is None:
+                head_instance_id = instance_id
+
+    # Wait for instances to be ready.
+    while True:
+        instances = _filter_instances(cluster_name_on_cloud, ['RUNNING'])
+        ready_instance_cnt = 0
+        for instance_id, instance in instances.items():
+            if instance.get('ssh_port') is not None:
+                ready_instance_cnt += 1
+        logger.info('Waiting for instances to be ready: '
+                    f'({ready_instance_cnt}/{config.count}).')
+        if ready_instance_cnt == config.count:
+            break
+
+        time.sleep(POLL_INTERVAL)
+
+    head_instance_id = _get_head_instance_id(utils.list_instances())
+    assert head_instance_id is not None, 'head_instance_id should not be None'
+    return common.ProvisionRecord(provider_name='vast',
+                                  cluster_name=cluster_name_on_cloud,
+                                  region=region,
+                                  zone=None,
+                                  head_instance_id=head_instance_id,
+                                  resumed_instance_ids=[],
+                                  created_instance_ids=created_instance_ids)
+
+
+def wait_instances(region: str, cluster_name_on_cloud: str,
+                   state: Optional[status_lib.ClusterStatus]) -> None:
+    del region, cluster_name_on_cloud, state
+
+
+def stop_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    return action_instances('stop', cluster_name_on_cloud, provider_config,
+                            worker_only)
+
+
+def terminate_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    return action_instances('remove', cluster_name_on_cloud, provider_config,
+                            worker_only)
+
+
+def action_instances(
+    fn: str,
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    """See sky/provision/__init__.py"""
+    del provider_config  # unused
+    instances = _filter_instances(cluster_name_on_cloud, None)
+    for inst_id, inst in instances.items():
+        logger.debug(f'Instance {fn} {inst_id}: {inst}')
+        if worker_only and inst['name'].endswith('-head'):
+            continue
+        try:
+            getattr(utils, fn)(inst_id)
+        except Exception as e:  # pylint: disable=broad-except
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError(
+                    f'Failed to {fn} instance {inst_id}: '
+                    f'{common_utils.format_exception(e, use_bracket=False)}'
+                ) from e
+
+
+def get_cluster_info(
+        region: str,
+        cluster_name_on_cloud: str,
+        provider_config: Optional[Dict[str, Any]] = None) -> common.ClusterInfo:
+    del region  # unused
+    running_instances = _filter_instances(cluster_name_on_cloud, ['RUNNING'])
+    instances: Dict[str, List[common.InstanceInfo]] = {}
+    head_instance_id = None
+    for instance_id, instance_info in running_instances.items():
+        instances[instance_id] = [
+            common.InstanceInfo(
+                instance_id=instance_id,
+                internal_ip=instance_info['local_ipaddrs'].strip(),
+                external_ip=instance_info['public_ipaddr'],
+                ssh_port=instance_info['ports']['22/tcp'][0]['HostPort'],
+                tags={},
+            )
+        ]
+        if instance_info['name'].endswith('-head'):
+            head_instance_id = instance_id
+
+    return common.ClusterInfo(
+        instances=instances,
+        head_instance_id=head_instance_id,
+        provider_name='vast',
+        provider_config=provider_config,
+    )
+
+
+def open_ports(
+    cluster_name_on_cloud: str,
+    ports: List[str],
+    provider_config: Optional[Dict[str, Any]] = None,
+) -> None:
+    raise NotImplementedError('open_ports is not supported for Vast')
+
+
+def query_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    non_terminated_only: bool = True,
+) -> Dict[str, Optional[status_lib.ClusterStatus]]:
+    """See sky/provision/__init__.py"""
+
+    assert provider_config is not None, (cluster_name_on_cloud, provider_config)
+    instances = _filter_instances(cluster_name_on_cloud, None)
+    # "running", "frozen", "stopped", "unknown", "loading"
+    status_map = {
+        'LOADING': status_lib.ClusterStatus.INIT,
+        'EXITED': status_lib.ClusterStatus.STOPPED,
+        'STOPPED': status_lib.ClusterStatus.STOPPED,
+        'RUNNING': status_lib.ClusterStatus.UP,
+    }
+    statuses: Dict[str, Optional[status_lib.ClusterStatus]] = {}
+    for inst_id, inst in instances.items():
+        status = status_map[inst['status']]
+        if non_terminated_only and status is None:
+            continue
+        statuses[inst_id] = status
+    return statuses
+
+
+def cleanup_ports(
+    cluster_name_on_cloud: str,
+    ports: List[str],
+    provider_config: Optional[Dict[str, Any]] = None,
+) -> None:
+    del cluster_name_on_cloud, ports, provider_config  # Unused.

sky/provision/vast/utils.py

@@ -0,0 +1,161 @@
+# pylint: disable=assignment-from-no-return
+#
+# The pylint exception above is an accomodation for
+# false positives generated by pylint for the Vast
+# python sdk.
+#
+"""Vast library wrapper for SkyPilot."""
+from typing import Any, Dict, List
+
+from sky import sky_logging
+from sky.adaptors import vast
+
+logger = sky_logging.init_logger(__name__)
+
+
+def list_instances() -> Dict[str, Dict[str, Any]]:
+    """Lists instances associated with API key."""
+    instances = vast.vast().show_instances()
+
+    instance_dict: Dict[str, Dict[str, Any]] = {}
+    for instance in instances:
+        instance['id'] = str(instance['id'])
+        info = instance
+
+        if isinstance(instance['actual_status'], str):
+            info['status'] = instance['actual_status'].upper()
+        else:
+            info['status'] = 'UNKNOWN'
+        info['name'] = instance['label']
+
+        instance_dict[instance['id']] = info
+
+    return instance_dict
+
+
+def launch(name: str, instance_type: str, region: str, disk_size: int,
+           image_name: str, preemptible: bool) -> str:
+    """Launches an instance with the given parameters.
+
+    Converts the instance_type to the Vast GPU name, finds the specs for the
+    GPU, and launches the instance.
+
+    Notes:
+
+      *  `georegion`: This is a feature flag to provide an additional
+         scope of geographical specificy while maintaining backward
+         compatibility.
+
+      *  `chunked`: This is a feature flag to give breadth to the
+         snowflake nature of the vast catalog marketplace. It rounds
+         down various specifications of machines to emulate an instance
+         type and make them more interchangeable.
+
+      *  `disk_size`: We look for instances that are of the requested
+         size or greater than it. For instance, `disk_size=100` might
+         return something with `disk_size` at 102 or even 1000.
+
+         The disk size {xx} GB is not exactly matched the requested
+         size {yy} GB. It is possible to charge extra cost on disk.
+
+      *  `geolocation`: Geolocation on Vast can be as specific as the
+         host chooses to be. They can say, for instance, "Yutakachō,
+         Shinagawa District, Tokyo, JP." Such a specific geolocation
+         as ours would fail to return this host in a simple string
+         comparison if a user searched for "JP".
+
+         Since regardless of specificity, all our geolocations end
+         in two-letter country codes we just snip that to conform
+         to how many providers state their geolocation.
+
+      *  Since the catalog is cached, we can't gaurantee availability
+         of any machine at the point of inquiry.  As a consequence we
+         search for the machine again and potentially return a failure
+         if there is no availability.
+
+	  *  We pass in the cpu_ram here as a guarantor to make sure the
+		 instance we match with will be compliant with the requested
+		 amount of memory.
+
+      *  Vast instance types are an invention for skypilot. Refer to
+         service_catalog/vast_catalog.py for the current construction
+         of the type.
+
+    """
+    cpu_ram = float(instance_type.split('-')[-1]) / 1024
+    gpu_name = instance_type.split('-')[1].replace('_', ' ')
+    num_gpus = int(instance_type.split('-')[0].replace('x', ''))
+
+    query = ' '.join([
+        'chunked=true',
+        'georegion=true',
+        f'geolocation="{region[-2:]}"',
+        f'disk_space>={disk_size}',
+        f'num_gpus={num_gpus}',
+        f'gpu_name="{gpu_name}"',
+        f'cpu_ram>="{cpu_ram}"',
+    ])
+
+    instance_list = vast.vast().search_offers(query=query)
+
+    if isinstance(instance_list, int) or len(instance_list) == 0:
+        raise RuntimeError('Failed to create instances, could not find an '
+                           f'offer that satisfies the requirements "{query}".')
+
+    instance_touse = instance_list[0]
+
+    launch_params = {
+        'id': instance_touse['id'],
+        'direct': True,
+        'ssh': True,
+        'env': '-e __SOURCE=skypilot',
+        'onstart_cmd': ';'.join([
+            'touch ~/.no_auto_tmux',
+            f'echo "{vast.vast().api_key_access}" > ~/.vast_api_key',
+        ]),
+        'label': name,
+        'image': image_name
+    }
+
+    if preemptible:
+        launch_params['min_bid'] = instance_touse['min_bid']
+
+    new_instance_contract = vast.vast().create_instance(**launch_params)
+
+    new_instance = vast.vast().show_instance(
+        id=new_instance_contract['new_contract'])
+
+    return new_instance['id']
+
+
+def start(instance_id: str) -> None:
+    """Starts the given instance."""
+    vast.vast().start_instance(id=instance_id)
+
+
+def stop(instance_id: str) -> None:
+    """Stops the given instance."""
+    vast.vast().stop_instance(id=instance_id)
+
+
+def remove(instance_id: str) -> None:
+    """Terminates the given instance."""
+    vast.vast().destroy_instance(id=instance_id)
+
+
+def get_ssh_ports(cluster_name: str) -> List[int]:
+    """Gets the SSH ports for the given cluster."""
+    logger.debug(f'Getting SSH ports for cluster {cluster_name}.')
+
+    instances = list_instances()
+    possible_names = [f'{cluster_name}-head', f'{cluster_name}-worker']
+
+    ssh_ports = []
+
+    for instance in instances.values():
+        if instance['name'] in possible_names:
+            ssh_ports.append(instance['ssh_port'])
+    assert ssh_ports, (
+        f'Could not find any instances for cluster {cluster_name}.')
+
+    return ssh_ports

sky/setup_files/dependencies.py

@@ -131,6 +131,7 @@ extras_require: Dict[str, List[str]] = {
     'cudo': ['cudo-compute>=0.1.10'],
     'paperspace': [],  # No dependencies needed for paperspace
     'do': ['pydo>=0.3.0', 'azure-core>=1.24.0', 'azure-common'],
+    'vast': ['vastai-sdk>=0.1.12'],
     'vsphere': [
         'pyvmomi==8.0.1.0.2',
         # vsphere-automation-sdk is also required, but it does not have

sky/templates/vast-ray.yml.j2

@@ -0,0 +1,70 @@
+cluster_name: {{cluster_name_on_cloud}}
+
+# The maximum number of workers nodes to launch in addition to the head node.
+max_workers: {{num_nodes - 1}}
+upscaling_speed: {{num_nodes - 1}}
+idle_timeout_minutes: 60
+
+provider:
+  type: external
+  module: sky.provision.vast
+  region: "{{region}}"
+  disable_launch_config_check: true
+
+auth:
+  ssh_user: root
+  ssh_private_key: {{ssh_private_key}}
+
+available_node_types:
+  ray_head_default:
+    resources: {}
+    node_config:
+      InstanceType: {{instance_type}}
+      DiskSize: {{disk_size}}
+      ImageId: {{image_id}}
+      Preemptible: {{use_spot}}
+      PublicKey: |-
+        skypilot:ssh_public_key_content
+
+head_node_type: ray_head_default
+
+# Format: `REMOTE_PATH : LOCAL_PATH`
+file_mounts: {
+  "{{sky_ray_yaml_remote_path}}": "{{sky_ray_yaml_local_path}}",
+  "{{sky_remote_path}}/{{sky_wheel_hash}}": "{{sky_local_path}}",
+{%- for remote_path, local_path in credentials.items() %}
+  "{{remote_path}}": "{{local_path}}",
+{%- endfor %}
+}
+
+rsync_exclude: []
+
+initialization_commands: []
+
+# List of shell commands to run to set up nodes.
+# NOTE: these are very performance-sensitive. Each new item opens/closes an SSH
+# connection, which is expensive. Try your best to co-locate commands into fewer
+# items!
+#
+# Increment the following for catching performance bugs easier:
+#   current num items (num SSH connections): 1
+setup_commands:
+  # Create ~/.ssh/config file in case the file does not exist in the image.
+  # Line 'rm ..': there is another installation of pip.
+  # Line 'sudo bash ..': set the ulimit as suggested by ray docs for performance. https://docs.ray.io/en/latest/cluster/vms/user-guides/large-cluster-best-practices.html#system-configuration
+  # Line 'sudo grep ..': set the number of threads per process to unlimited to avoid ray job submit stucking issue when the number of running ray jobs increase.
+  # Line 'mkdir -p ..': disable host key check
+  # Line 'python3 -c ..': patch the buggy ray files and enable `-o allow_other` option for `goofys`
+  - {%- for initial_setup_command in initial_setup_commands %}
+    {{ initial_setup_command }}
+    {%- endfor %}
+    mkdir -p ~/.ssh; touch ~/.ssh/config; which patch > /dev/null || sudo apt install -y patch;
+    {{ conda_installation_commands }}
+    {{ ray_skypilot_installation_commands }}
+    sudo bash -c 'rm -rf /etc/security/limits.d; echo "* soft nofile 1048576" >> /etc/security/limits.conf; echo "* hard nofile 1048576" >> /etc/security/limits.conf';
+    sudo grep -e '^DefaultTasksMax' /etc/systemd/system.conf || (sudo bash -c 'echo "DefaultTasksMax=infinity" >> /etc/systemd/system.conf'); sudo systemctl set-property user-$(id -u $(whoami)).slice TasksMax=infinity; sudo systemctl daemon-reload;
+    (grep -Pzo -q "Host \*\n  StrictHostKeyChecking no" ~/.ssh/config) || printf "Host *\n  StrictHostKeyChecking no\n" >> ~/.ssh/config;
+   
+
+# Command to start ray clusters are now placed in `sky.provision.instance_setup`.
+# We do not need to list it here anymore.

sky/utils/controller_utils.py

@@ -261,6 +261,11 @@ def _get_cloud_dependencies_installation_commands(
             if controller != Controllers.JOBS_CONTROLLER:
                 # We only need IBM deps on the jobs controller.
                 cloud_python_dependencies = []
+        elif isinstance(cloud, clouds.Vast):
+            step_prefix = prefix_str.replace('<step>', str(len(commands) + 1))
+            commands.append(f'echo -en "\\r{step_prefix}Vast{empty_str}" && '
+                            'pip list | grep vastai_sdk > /dev/null 2>&1 || '
+                            'pip install "vastai_sdk>=0.1.12" > /dev/null 2>&1')
 
         python_packages.update(cloud_python_dependencies)
 

{skypilot_nightly-1.0.0.dev20250204.dist-info → skypilot_nightly-1.0.0.dev20250206.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: skypilot-nightly
-Version: 1.0.0.dev20250204
+Version: 1.0.0.dev20250206
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0
@@ -99,6 +99,8 @@ Provides-Extra: do
 Requires-Dist: pydo>=0.3.0; extra == "do"
 Requires-Dist: azure-core>=1.24.0; extra == "do"
 Requires-Dist: azure-common; extra == "do"
+Provides-Extra: vast
+Requires-Dist: vastai-sdk>=0.1.12; extra == "vast"
 Provides-Extra: vsphere
 Requires-Dist: pyvmomi==8.0.1.0.2; extra == "vsphere"
 Provides-Extra: all
@@ -145,6 +147,7 @@ Requires-Dist: cudo-compute>=0.1.10; extra == "all"
 Requires-Dist: pydo>=0.3.0; extra == "all"
 Requires-Dist: azure-core>=1.24.0; extra == "all"
 Requires-Dist: azure-common; extra == "all"
+Requires-Dist: vastai-sdk>=0.1.12; extra == "all"
 Requires-Dist: pyvmomi==8.0.1.0.2; extra == "all"
 Dynamic: author
 Dynamic: classifier