skypilot-nightly 1.0.0.dev20251009__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/catalog/data_fetchers/fetch_shadeform.py

@@ -0,0 +1,142 @@
+"""A script that generates the Shadeform catalog.
+
+Usage:
+    python fetch_shadeform.py [-h] [--api-key API_KEY]
+                               [--api-key-path API_KEY_PATH]
+
+If neither --api-key nor --api-key-path are provided, this script will parse
+`~/.shadeform/api_key` to look for Shadeform API key.
+"""
+import argparse
+import csv
+import json
+import os
+from typing import Dict
+
+import requests
+
+ENDPOINT = 'https://api.shadeform.ai/v1/instances/types'
+DEFAULT_SHADEFORM_API_KEY_PATH = os.path.expanduser('~/.shadeform/api_key')
+
+
+def parse_gpu_info(gpu_type: str, num_gpus: int, ram_per_gpu: int) -> Dict:
+    """Parse GPU information for the catalog."""
+
+    manufacturer = 'NVIDIA'
+    if gpu_type == 'MI300X':
+        manufacturer = 'AMD'
+    elif gpu_type == 'GAUDI2':
+        manufacturer = 'Intel'
+
+    return {
+        'Gpus': [{
+            'Name': gpu_type,
+            'Manufacturer': manufacturer,
+            'Count': float(num_gpus),
+            'MemoryInfo': {
+                'SizeInMiB': ram_per_gpu
+            },
+            'TotalGpuMemoryInMiB': ram_per_gpu * num_gpus
+        }]
+    }
+
+
+def create_catalog(api_key: str, output_path: str) -> None:
+    """Create Shadeform catalog by fetching from API."""
+    headers = {'X-API-KEY': api_key}
+
+    params = {'available': 'true'}
+
+    response = requests.get(ENDPOINT,
+                            headers=headers,
+                            params=params,
+                            timeout=30)
+    response.raise_for_status()
+
+    data = response.json()
+    instance_types = data.get('instance_types', [])
+
+    with open(output_path, mode='w', encoding='utf-8') as f:
+        writer = csv.writer(f, delimiter=',', quotechar='"')
+        writer.writerow([
+            'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs',
+            'MemoryGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+        ])
+
+        for instance in instance_types:
+            config = instance['configuration']
+
+            cloud = instance['cloud']
+            shade_instance_type = instance['shade_instance_type']
+            instance_type = f'{cloud}_{shade_instance_type.replace("_", "-")}'
+            gpu_type = config['gpu_type'].replace('_', '-')
+            gpu_count = float(config['num_gpus'])
+            vcpus = float(config['vcpus'])
+            memory_gb = int(config['memory_in_gb'])
+
+            # Append "B" to instance_type and gpu_type if they end with "G"
+            if instance_type.endswith('G'):
+                instance_type += 'B'
+            if gpu_type.endswith('G'):
+                gpu_type += 'B'
+
+            # Replace "Gx" with "GBx" (case sensitive)
+            if 'Gx' in instance_type:
+                instance_type = instance_type.replace('Gx', 'GBx')
+
+            # Price is in cents per hour, convert to dollars
+            price = float(instance['hourly_price']) / 100
+
+            # Create GPU info
+            gpuinfo = None
+            if gpu_count > 0:
+                gpuinfo_dict = parse_gpu_info(gpu_type, int(gpu_count),
+                                              int(config['vram_per_gpu_in_gb']))
+                gpuinfo = json.dumps(gpuinfo_dict).replace('"', '\'')
+
+            # Write entry for each available region
+            for availability in instance.get('availability', []):
+                if availability['available'] and gpu_count > 0:
+                    region = availability['region']
+                    writer.writerow([
+                        instance_type,
+                        gpu_type,
+                        gpu_count,
+                        vcpus,
+                        memory_gb,
+                        price,
+                        region,
+                        gpuinfo,
+                        ''  # No spot pricing info available
+                    ])
+
+
+def get_api_key(cmdline_args: argparse.Namespace) -> str:
+    """Get Shadeform API key from cmdline or default path."""
+    api_key = cmdline_args.api_key
+    if api_key is None:
+        if cmdline_args.api_key_path is not None:
+            with open(cmdline_args.api_key_path, mode='r',
+                      encoding='utf-8') as f:
+                api_key = f.read().strip()
+        else:
+            # Read from ~/.shadeform/api_key
+            with open(DEFAULT_SHADEFORM_API_KEY_PATH,
+                      mode='r',
+                      encoding='utf-8') as f:
+                api_key = f.read().strip()
+    assert api_key is not None, (
+        f'API key not found. Please provide via --api-key or place in '
+        f'{DEFAULT_SHADEFORM_API_KEY_PATH}')
+    return api_key
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--api-key', help='Shadeform API key.')
+    parser.add_argument('--api-key-path',
+                        help='path of file containing Shadeform API key.')
+    args = parser.parse_args()
+    os.makedirs('shadeform', exist_ok=True)
+    create_catalog(get_api_key(args), 'shadeform/vms.csv')
+    print('Shadeform catalog saved to shadeform/vms.csv')

sky/catalog/kubernetes_catalog.py

@@ -3,6 +3,7 @@
 Kubernetes does not require a catalog of instances, but we need an image catalog
 mapping SkyPilot image tags to corresponding container image tags.
 """
+import collections
 import re
 import typing
 from typing import Dict, List, Optional, Set, Tuple
@@ -167,12 +168,25 @@ def _list_accelerators(
     accelerators_qtys: Set[Tuple[str, int]] = set()
     keys = lf.get_label_keys()
     nodes = kubernetes_utils.get_kubernetes_nodes(context=context)
-    pods = None
-    if realtime:
-        # Get the pods to get the real-time GPU usage
+
+    # Check if any nodes have accelerators before fetching pods
+    has_accelerator_nodes = False
+    for node in nodes:
+        for key in keys:
+            if key in node.metadata.labels:
+                has_accelerator_nodes = True
+                break
+        if has_accelerator_nodes:
+            break
+
+    # Only fetch pods if we have accelerator nodes and realtime is requested
+    allocated_qty_by_node: Dict[str, int] = collections.defaultdict(int)
+    error_on_get_allocated_gpu_qty_by_node = False
+    if realtime and has_accelerator_nodes:
+        # Get the allocated GPU quantity by each node
         try:
-            pods = kubernetes_utils.get_all_pods_in_kubernetes_cluster(
-                context=context)
+            allocated_qty_by_node = (
+                kubernetes_utils.get_allocated_gpu_qty_by_node(context=context))
         except kubernetes.api_exception() as e:
             if e.status == 403:
                 logger.warning(
@@ -180,6 +194,7 @@ def _list_accelerators(
                     '(forbidden). Please check if your account has '
                     'necessary permissions to list pods. Realtime GPU '
                     'availability information may be incorrect.')
+                error_on_get_allocated_gpu_qty_by_node = True
             else:
                 raise
     # Total number of GPUs in the cluster
@@ -191,7 +206,6 @@ def _list_accelerators(
     for node in nodes:
         for key in keys:
             if key in node.metadata.labels:
-                allocated_qty = 0
                 accelerator_name = lf.get_accelerator_from_label_value(
                     node.metadata.labels.get(key))
 
@@ -246,31 +260,13 @@ def _list_accelerators(
                         total_accelerators_capacity[
                             accelerator_name] += quantized_count
 
-                if pods is None:
-                    # If we can't get the pods, we can't get the GPU usage
+                if error_on_get_allocated_gpu_qty_by_node:
+                    # If we can't get the allocated GPU quantity by each node,
+                    # we can't get the GPU usage.
                     total_accelerators_available[accelerator_name] = -1
                     continue
 
-                for pod in pods:
-                    # Get all the pods running on the node
-                    if (pod.spec.node_name == node.metadata.name and
-                            pod.status.phase in ['Running', 'Pending']):
-                        # Skip pods that should not count against GPU count
-                        if (kubernetes_utils.
-                                should_exclude_pod_from_gpu_allocation(pod)):
-                            logger.debug(
-                                f'Excluding pod '
-                                f'{pod.metadata.name} from GPU count '
-                                f'calculations on node {node.metadata.name}')
-                            continue
-                        # Iterate over all the containers in the pod and sum
-                        # the GPU requests
-                        for container in pod.spec.containers:
-                            if container.resources.requests:
-                                allocated_qty += (
-                                    kubernetes_utils.get_node_accelerator_count(
-                                        context, container.resources.requests))
-
+                allocated_qty = allocated_qty_by_node[node.metadata.name]
                 accelerators_available = accelerator_count - allocated_qty
                 # Initialize the total_accelerators_available to make sure the
                 # key exists in the dictionary.

sky/catalog/runpod_catalog.py

@@ -12,7 +12,11 @@ from sky.catalog import common
 if typing.TYPE_CHECKING:
     from sky.clouds import cloud
 
-_df = common.read_catalog('runpod/vms.csv')
+# Runpod has no set updated schedule for their catalog. We pull the catalog
+# every 7 hours to make sure we have the latest information.
+_PULL_FREQUENCY_HOURS = 7
+_df = common.read_catalog('runpod/vms.csv',
+                          pull_frequency_hours=_PULL_FREQUENCY_HOURS)
 
 
 def instance_type_exists(instance_type: str) -> bool:

sky/catalog/shadeform_catalog.py

@@ -0,0 +1,165 @@
+""" Shadeform | Catalog
+
+This module loads pricing and instance information from the Shadeform API
+and can be used to query instance types and pricing information for Shadeform.
+"""
+
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+import pandas as pd
+
+from sky.catalog import common
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+# We'll use dynamic fetching, so no static CSV file to load
+_df = None
+
+
+def _get_df():
+    """Get the dataframe, fetching from API if needed."""
+    global _df
+    if _df is None:
+        # For now, we'll fall back to a minimal static catalog
+        # In a full implementation, this would call the Shadeform API
+        # to dynamically fetch the latest instance types and pricing
+        try:
+            df = common.read_catalog('shadeform/vms.csv')
+        except FileNotFoundError:
+            # If no static catalog exists, create an empty one
+            # This would be replaced with dynamic API fetching
+            _df = pd.DataFrame(columns=[
+                'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs',
+                'MemoryGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+            ])
+        else:
+            df = df[df['InstanceType'].notna()]
+            if 'AcceleratorName' in df.columns:
+                df = df[df['AcceleratorName'].notna()]
+                df = df.assign(AcceleratorName=df['AcceleratorName'].astype(
+                    str).str.strip())
+            _df = df.reset_index(drop=True)
+    return _df
+
+
+def _is_not_found_error(err: ValueError) -> bool:
+    msg = str(err).lower()
+    return 'not found' in msg or 'not supported' in msg
+
+
+def _call_or_default(func, default):
+    try:
+        return func()
+    except ValueError as err:
+        if _is_not_found_error(err):
+            return default
+        raise
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    """Check if an instance type exists."""
+    return common.instance_type_exists_impl(_get_df(), instance_type)
+
+
+def validate_region_zone(
+        region: Optional[str],
+        zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+    """Validate region and zone for Shadeform."""
+    return common.validate_region_zone_impl('shadeform', _get_df(), region,
+                                            zone)
+
+
+def get_hourly_cost(instance_type: str,
+                    use_spot: bool = False,
+                    region: Optional[str] = None,
+                    zone: Optional[str] = None) -> float:
+    """Returns the cost, or the cheapest cost among all zones for spot."""
+    # Shadeform doesn't support spot instances currently
+    if use_spot:
+        raise ValueError('Spot instances are not supported on Shadeform')
+
+    return common.get_hourly_cost_impl(_get_df(), instance_type, use_spot,
+                                       region, zone)
+
+
+def get_vcpus_mem_from_instance_type(
+        instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+    """Get vCPUs and memory from instance type."""
+    return _call_or_default(
+        lambda: common.get_vcpus_mem_from_instance_type_impl(
+            _get_df(), instance_type), (None, None))
+
+
+def get_default_instance_type(cpus: Optional[str] = None,
+                              memory: Optional[str] = None,
+                              disk_tier: Optional[str] = None,
+                              region: Optional[str] = None,
+                              zone: Optional[str] = None) -> Optional[str]:
+    """Get default instance type based on requirements."""
+    del disk_tier  # Shadeform doesn't support custom disk tiers yet
+    return _call_or_default(
+        lambda: common.get_instance_type_for_cpus_mem_impl(
+            _get_df(), cpus, memory, region, zone), None)
+
+
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+    """Get accelerator information from instance type."""
+    return _call_or_default(
+        lambda: common.get_accelerators_from_instance_type_impl(
+            _get_df(), instance_type), None)
+
+
+def get_instance_type_for_accelerator(
+        acc_name: str,
+        acc_count: int,
+        cpus: Optional[str] = None,
+        memory: Optional[str] = None,
+        use_spot: bool = False,
+        region: Optional[str] = None,
+        zone: Optional[str] = None) -> Tuple[Optional[List[str]], List[str]]:
+    """Returns a list of instance types that have the given accelerator."""
+    if use_spot:
+        # Return empty lists since spot is not supported
+        return None, ['Spot instances are not supported on Shadeform']
+
+    return _call_or_default(
+        lambda: common.get_instance_type_for_accelerator_impl(
+            df=_get_df(),
+            acc_name=acc_name,
+            acc_count=acc_count,
+            cpus=cpus,
+            memory=memory,
+            use_spot=use_spot,
+            region=region,
+            zone=zone), (None, []))
+
+
+def get_region_zones_for_instance_type(instance_type: str,
+                                       use_spot: bool) -> List['cloud.Region']:
+    """Get regions and zones for an instance type."""
+    if use_spot:
+        return []  # No spot support
+
+    df = _get_df()
+    df_filtered = df[df['InstanceType'] == instance_type]
+    return _call_or_default(
+        lambda: common.get_region_zones(df_filtered, use_spot), [])
+
+
+def list_accelerators(
+        gpus_only: bool,
+        name_filter: Optional[str],
+        region_filter: Optional[str],
+        quantity_filter: Optional[int],
+        case_sensitive: bool = True,
+        all_regions: bool = False,
+        require_price: bool = True) -> Dict[str, List[common.InstanceTypeInfo]]:
+    """Returns all instance types in Shadeform offering GPUs."""
+    del require_price  # Unused.
+    return common.list_accelerators_impl('Shadeform', _get_df(), gpus_only,
+                                         name_filter, region_filter,
+                                         quantity_filter, case_sensitive,
+                                         all_regions)

sky/check.py

@@ -14,6 +14,7 @@ from sky import global_user_state
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import cloudflare
+from sky.adaptors import coreweave
 from sky.clouds import cloud as sky_cloud
 from sky.skylet import constants
 from sky.utils import common_utils
@@ -33,7 +34,8 @@ def _get_workspace_allowed_clouds(workspace: str) -> List[str]:
     # clouds. Also validate names with get_cloud_tuple.
     config_allowed_cloud_names = skypilot_config.get_nested(
         ('allowed_clouds',),
-        [repr(c) for c in registry.CLOUD_REGISTRY.values()] + [cloudflare.NAME])
+        [repr(c) for c in registry.CLOUD_REGISTRY.values()] +
+        [cloudflare.NAME, coreweave.NAME])
     # filter out the clouds that are disabled in the workspace config
     workspace_disabled_clouds = []
     for cloud in config_allowed_cloud_names:
@@ -81,7 +83,7 @@ def check_capabilities(
 
     def get_all_clouds() -> Tuple[str, ...]:
         return tuple([repr(c) for c in registry.CLOUD_REGISTRY.values()] +
-                     [cloudflare.NAME])
+                     [cloudflare.NAME, coreweave.NAME])
 
     def _execute_check_logic_for_workspace(
         current_workspace_name: str,
@@ -121,9 +123,12 @@ def check_capabilities(
                 cloud_name: str
         ) -> Tuple[str, Union[sky_clouds.Cloud, ModuleType]]:
             # Validates cloud_name and returns a tuple of the cloud's name and
-            # the cloud object. Includes special handling for Cloudflare.
+            # the cloud object. Includes special handling for Cloudflare and
+            # CoreWeave.
             if cloud_name.lower().startswith('cloudflare'):
                 return cloudflare.NAME, cloudflare
+            elif cloud_name.lower().startswith('coreweave'):
+                return coreweave.NAME, coreweave
             else:
                 cloud_obj = registry.CLOUD_REGISTRY.from_str(cloud_name)
                 assert cloud_obj is not None, f'Cloud {cloud_name!r} not found'
@@ -219,23 +224,24 @@ def check_capabilities(
         # allowed_clouds in config.yaml, it will be disabled.
         all_enabled_clouds: Set[str] = set()
         for capability in capabilities:
-            # Cloudflare is not a real cloud in registry.CLOUD_REGISTRY, and
-            # should not be inserted into the DB (otherwise `sky launch` and
-            # other code would error out when it's trying to look it up in the
-            # registry).
+            # Cloudflare and CoreWeave are not real clouds in
+            # registry.CLOUD_REGISTRY, and should not be inserted into the DB
+            # (otherwise `sky launch` and other code would error out when it's
+            # trying to look it up in the registry).
             enabled_clouds_set = {
                 cloud for cloud, capabilities in enabled_clouds.items()
-                if capability in capabilities and
-                not cloud.startswith('Cloudflare')
+                if capability in capabilities and not cloud.startswith(
+                    'Cloudflare') and not cloud.startswith('CoreWeave')
             }
             disabled_clouds_set = {
                 cloud for cloud, capabilities in disabled_clouds.items()
-                if capability in capabilities and
-                not cloud.startswith('Cloudflare')
+                if capability in capabilities and not cloud.startswith(
+                    'Cloudflare') and not cloud.startswith('CoreWeave')
             }
             config_allowed_clouds_set = {
                 cloud for cloud in config_allowed_cloud_names
-                if not cloud.startswith('Cloudflare')
+                if not cloud.startswith('Cloudflare') and
+                not cloud.startswith('CoreWeave')
             }
             previously_enabled_clouds_set = {
                 repr(cloud)
@@ -430,6 +436,12 @@ def get_cloud_credential_file_mounts(
     if r2_is_enabled:
         r2_credential_mounts = cloudflare.get_credential_file_mounts()
         file_mounts.update(r2_credential_mounts)
+
+    # Similarly, handle CoreWeave storage credentials
+    coreweave_is_enabled, _ = coreweave.check_storage_credentials()
+    if coreweave_is_enabled:
+        coreweave_credential_mounts = coreweave.get_credential_file_mounts()
+        file_mounts.update(coreweave_credential_mounts)
     return file_mounts
 
 
@@ -494,7 +506,7 @@ def _print_checked_cloud(
         style_str = f'{colorama.Fore.GREEN}{colorama.Style.NORMAL}'
         status_msg = 'enabled'
         capability_string = f'[{", ".join(enabled_capabilities)}]'
-        if verbose and cloud is not cloudflare:
+        if verbose and cloud is not cloudflare and cloud is not coreweave:
             activated_account = cloud.get_active_user_identity_str()
         if isinstance(cloud_tuple[1], (sky_clouds.SSH, sky_clouds.Kubernetes)):
             detail_string = _format_context_details(cloud_tuple[1],