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

sky/catalog/data_fetchers/fetch_seeweb.py

@@ -0,0 +1,329 @@
+"""A script that generates the Seeweb catalog.
+
+Usage:
+    python fetch_seeweb.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
+`~/.seeweb_cloud/seeweb_keys` to look for Seeweb API key.
+"""
+import argparse
+import configparser
+import csv
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from sky.adaptors.seeweb import ecsapi
+
+# GPU name mapping from Seeweb to SkyPilot canonical names
+SEEWEB_GPU_NAME_TO_SKYPILOT_GPU_NAME = {
+    'H200 141GB': 'H200',
+    'RTX A6000 48GB': 'RTXA6000',
+    'A100 80GB': 'A100',
+    'L4 24GB': 'L4',
+    'L40s 48GB': 'L40S',
+    'H100 80GB': 'H100',
+    'MI300X': 'MI300X',
+    'A30': 'A30',
+    'RTX 6000 24GB': 'RTX6000',
+    'Tenstorrent Grayskull e75': 'GRAYSKULL-E75',
+    'Tenstorrent Grayskull e150': 'GRAYSKULL-E150',
+}
+
+# GPU VRAM mapping in MB
+VRAM = {
+    'RTXA6000': 48384,  # 48GB
+    'H200': 144384,  # 141GB
+    'A100': 81920,  # 80GB
+    'L4': 24576,  # 24GB
+    'L40S': 49152,  # 48GB
+    'H100': 81920,  # 80GB
+    'MI300X': 192000,  # 192GB
+    'A30': 24576,  # 24GB
+    'RTX6000': 24576,  # 24GB
+    'GRAYSKULL-E75': 8192,  # 8GB
+    'GRAYSKULL-E150': 8192,  # 8GB
+}
+
+
+def is_tenstorrent_gpu_name(gpu_name: Optional[str]) -> bool:
+    """Return True if the given GPU name refers to a Tenstorrent GPU.
+
+    Detects by common identifiers present in normalized names (e.g., GRAYSKULL)
+    or by the vendor name directly.
+    """
+    if not gpu_name:
+        return False
+    upper = str(gpu_name).upper()
+    return 'TENSTORRENT' in upper or 'GRAYSKULL' in upper
+
+
+def is_mi300x_gpu_name(gpu_name: Optional[str]) -> bool:
+    """Return True if the given GPU name refers to AMD MI300X."""
+    if not gpu_name:
+        return False
+    return 'MI300X' in str(gpu_name).upper()
+
+
+def get_api_key(path: Optional[str] = None) -> str:
+    """Get API key from config file or environment variable."""
+    # Step 1: Try to get from config file
+    if path is None:
+        path = os.path.expanduser('~/.seeweb_cloud/seeweb_keys')
+    else:
+        path = os.path.expanduser(path)
+
+    try:
+        parser = configparser.ConfigParser()
+        parser.read(path)
+        return parser['DEFAULT']['api_key'].strip()
+    except (KeyError, FileNotFoundError) as exc:
+        # Step 2: Try environment variable
+        api_key = os.environ.get('SEEWEB_API_KEY')
+        if api_key:
+            return api_key.strip()
+
+        # If neither found, raise error
+        raise ValueError(
+            f'API key not found in {path} or ENV variable SEEWEB_API_KEY'
+        ) from exc
+
+
+def normalize_gpu_name(gpu_name: str) -> str:
+    """Normalize GPU name from Seeweb API to SkyPilot canonical name."""
+    if not gpu_name:
+        return ''
+
+    # Map to canonical name if available
+    canonical_name = SEEWEB_GPU_NAME_TO_SKYPILOT_GPU_NAME.get(gpu_name)
+    if canonical_name:
+        return canonical_name
+
+    # If not found in mapping, return original name
+    print(f'Warning: GPU name "{gpu_name}" not found in mapping,'
+          f'using original name')
+    return gpu_name
+
+
+def parse_plan_info(plan: Any) -> Dict[str, Any]:
+    """Parse plan information from Seeweb API response."""
+    # Handle both dictionary and object formats
+    if hasattr(plan, 'name'):
+        # Object format from API
+        plan_name = getattr(plan, 'name', 'unknown')
+        vcpus = int(getattr(plan, 'cpu', 0))
+
+        # Handle memory conversion safely
+        memory_mb = getattr(plan, 'ram', 0)
+        try:
+            memory_gb = int(
+                memory_mb) / 1024 if memory_mb else 0  # Convert to GB
+        except (ValueError, TypeError):
+            memory_gb = 0
+
+        # Handle price safely
+        try:
+            price = float(getattr(plan, 'hourly_price', 0.0))
+        except (ValueError, TypeError):
+            price = 0.0
+
+        # Handle GPU info
+        try:
+            gpu_count = int(getattr(plan, 'gpu', 0))
+        except (ValueError, TypeError):
+            gpu_count = 0
+
+        gpu_label = getattr(plan, 'gpu_label', None)
+
+        # Determine GPU name - use gpu_label if available,
+        # otherwise try to infer from plan name
+        if gpu_label:
+            gpu_name = normalize_gpu_name(gpu_label)  # Normalize the GPU name
+        else:
+            # Try to extract GPU name from plan name
+            plan_name = getattr(plan, 'name', '')
+            if 'GPU' in plan_name:
+                # Extract GPU type from plan name (e.g., ECS1GPU11 -> GPU11)
+                parts = plan_name.split('GPU')
+                if len(parts) > 1:
+                    gpu_name = 'GPU' + parts[1]
+                else:
+                    gpu_name = 'GPU'
+            else:
+                gpu_name = None
+
+        # Get GPU VRAM from mapping using the normalized name
+        gpu_vram_mb = VRAM.get(gpu_name, 0) if gpu_name else 0
+    else:
+        raise ValueError(f'Unsupported plan format: {type(plan)}')
+
+    return {
+        'plan_name': plan_name,
+        'vcpus': vcpus,
+        'memory_gb': memory_gb,
+        'gpu_name': gpu_name,
+        'gpu_count': gpu_count,
+        'gpu_vram_mb': gpu_vram_mb,
+        'price': price,
+    }
+
+
+def get_gpu_info(gpu_count: int, gpu_name: str, gpu_vram_mb: int = 0) -> str:
+    """Generate GPU info JSON string compatible with SkyPilot."""
+    if not gpu_name or gpu_count == 0:
+        return ''
+
+    # Determine manufacturer based on GPU name
+    gpu_name_upper = str(gpu_name).upper()
+    if 'MI300' in gpu_name_upper or gpu_name_upper == 'MI300X':
+        manufacturer = 'AMD'
+    elif 'GRAYSKULL' in gpu_name_upper:
+        manufacturer = 'TENSTORRENT'
+    else:
+        manufacturer = 'NVIDIA'
+
+    gpu_info = {
+        'Gpus': [{
+            'Name': gpu_name,
+            'Manufacturer': manufacturer,
+            'Count': float(gpu_count),
+            'MemoryInfo': {
+                'SizeInMiB': gpu_vram_mb
+            },
+        }],
+        'TotalGpuMemoryInMiB': gpu_vram_mb * gpu_count if gpu_vram_mb else 0
+    }
+
+    return json.dumps(gpu_info).replace('"', '\'')
+
+
+def fetch_seeweb_data(api_key: str) -> List[Dict]:
+    """Fetch data from Seeweb API."""
+    if ecsapi is None:
+        raise ImportError('ecsapi not available')
+
+    try:
+        client = ecsapi.Api(token=api_key)
+
+        print('Fetching plans from Seeweb API...')
+        api_plans = client.fetch_plans()
+
+        if not api_plans:
+            raise ValueError('No plans returned from API')
+
+        print(f'Successfully fetched {len(api_plans)} plans from API')
+        plans = []
+
+        for plan in api_plans:
+            try:
+                # Parse first so we can filter
+                # Tenstorrent before extra API calls
+                parsed = parse_plan_info(plan)
+
+                if is_tenstorrent_gpu_name(parsed.get('gpu_name')):
+                    print(f'Skipping Tenstorrent plan {plan.name}')
+                    continue
+
+                if is_mi300x_gpu_name(parsed.get('gpu_name')):
+                    print(f'Skipping MI300X plan {plan.name}')
+                    continue
+
+                print(f'Fetching regions available for {plan.name}')
+                regions_available = client.fetch_regions_available(plan.name)
+
+                parsed.update({'regions_available': regions_available})
+                plans.append(parsed)
+            except Exception as e:  # pylint: disable=broad-except
+                print(f'Error parsing plan {plan.name}: {e}')
+                continue
+
+        print(f'Successfully parsed {len(plans)} plans')
+        return plans
+
+    except Exception as e:  # pylint: disable=broad-except
+        raise Exception(f'Error fetching data from Seeweb API: {e}') from e
+
+
+def create_catalog(api_key: str, output_path: str) -> None:
+    """Create Seeweb catalog by fetching data from API."""
+    plans = fetch_seeweb_data(api_key)
+
+    # Create CSV catalog
+    print(f'Writing catalog to {output_path}')
+    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 plan in plans:
+            try:
+                gpu_info_str = ''
+                if plan['gpu_name'] and plan['gpu_count'] > 0:
+                    gpu_info_str = get_gpu_info(plan['gpu_count'],
+                                                plan['gpu_name'],
+                                                plan.get('gpu_vram_mb', 0))
+
+                # Handle regions - create a row for each available region
+                regions_available = plan['regions_available']
+                if isinstance(regions_available,
+                              list) and len(regions_available) > 0:
+                    # Create a row for each region
+                    for region in regions_available:
+                        writer.writerow([
+                            plan['plan_name'],  # InstanceType
+                            plan['gpu_name'],  # AcceleratorName (cleaned)
+                            plan['gpu_count'] if plan['gpu_count'] > 0 else
+                            '',  # AcceleratorCount
+                            plan['vcpus'],  # vCPUs
+                            plan['memory_gb'],  # MemoryGiB
+                            plan['price'],  # Price
+                            region,  # Region (single region per row)
+                            gpu_info_str,  # GpuInfo
+                            ''  # SpotPrice (Seeweb doesn't support spot)
+                        ])
+                else:
+                    # No regions available, create a row with empty region
+                    writer.writerow([
+                        plan['plan_name'],  # InstanceType
+                        plan['gpu_name'],  # AcceleratorName (cleaned)
+                        plan['gpu_count']
+                        if plan['gpu_count'] > 0 else '',  # AcceleratorCount
+                        plan['vcpus'],  # vCPUs
+                        plan['memory_gb'],  # MemoryGiB
+                        plan['price'],  # Price
+                        '',  # Region (empty)
+                        gpu_info_str,  # GpuInfo
+                        ''  # SpotPrice (Seeweb doesn't support spot)
+                    ])
+            except Exception as e:  # pylint: disable=broad-except
+                print(f'Error processing plan {plan["plan_name"]}: {e}')
+                continue
+
+    print(f'Seeweb catalog saved to {output_path}')
+    print(f'Created {len(plans)} instance types')
+
+
+def main() -> None:
+    """Main function to fetch and write Seeweb platform prices to a CSV file."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--api-key', help='Seeweb API key')
+    parser.add_argument('--api-key-path',
+                        help='Path to file containing Seeweb API key')
+    args = parser.parse_args()
+
+    # Get API key
+    if args.api_key:
+        api_key = args.api_key
+    else:
+        api_key = get_api_key(args.api_key_path)
+
+    os.makedirs('seeweb', exist_ok=True)
+    create_catalog(api_key, 'seeweb/vms.csv')
+    print('Seeweb Service Catalog saved to seeweb/vms.csv')
+
+
+if __name__ == '__main__':
+    main()

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
@@ -189,9 +204,11 @@ def _list_accelerators(
     min_quantity_filter = quantity_filter if quantity_filter else 1
 
     for node in nodes:
+        # Check if node is ready
+        node_is_ready = node.is_ready()
+
         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,37 +263,24 @@ 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
-                    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))
-
-                accelerators_available = accelerator_count - allocated_qty
                 # Initialize the total_accelerators_available to make sure the
                 # key exists in the dictionary.
                 total_accelerators_available[accelerator_name] = (
                     total_accelerators_available.get(accelerator_name, 0))
 
+                # Skip availability counting for not-ready nodes
+                if not node_is_ready:
+                    continue
+
+                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
+
+                allocated_qty = allocated_qty_by_node[node.metadata.name]
+                accelerators_available = accelerator_count - allocated_qty
+
                 if accelerators_available >= min_quantity_filter:
                     quantized_availability = min_quantity_filter * (
                         accelerators_available // min_quantity_filter)

sky/catalog/primeintellect_catalog.py

@@ -0,0 +1,95 @@
+"""PrimeIntellect service catalog.
+
+This module loads the service catalog file and can be used to
+query instance types and pricing information for PrimeIntellect.
+"""
+
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+from sky.catalog import common
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+_df = common.read_catalog('primeintellect/vms.csv')
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    return common.instance_type_exists_impl(_df, instance_type)
+
+
+def validate_region_zone(
+        region: Optional[str],
+        zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+    return common.validate_region_zone_impl('primeintellect', _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."""
+    return common.get_hourly_cost_impl(_df, instance_type, use_spot, region,
+                                       zone)
+
+
+def get_vcpus_mem_from_instance_type(
+        instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+    return common.get_vcpus_mem_from_instance_type_impl(_df, instance_type)
+
+
+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]:
+    del disk_tier  # no disk tiers
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory, region,
+                                                      zone)
+
+
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+    return common.get_accelerators_from_instance_type_impl(_df, instance_type)
+
+
+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."""
+    return common.get_instance_type_for_accelerator_impl(df=_df,
+                                                         acc_name=acc_name,
+                                                         acc_count=acc_count,
+                                                         cpus=cpus,
+                                                         memory=memory,
+                                                         use_spot=use_spot,
+                                                         region=region,
+                                                         zone=zone)
+
+
+def get_region_zones_for_instance_type(instance_type: str,
+                                       use_spot: bool) -> List['cloud.Region']:
+    df = _df[_df['InstanceType'] == instance_type]
+    return common.get_region_zones(df, 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 Prime Intellect offering GPUs."""
+    del require_price
+    return common.list_accelerators_impl('PrimeIntellect', _df, gpus_only,
+                                         name_filter, region_filter,
+                                         quantity_filter, case_sensitive,
+                                         all_regions)

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: