skypilot-nightly 1.0.0.dev20250912__py3-none-any.whl → 1.0.0.dev20250914__py3-none-any.whl

sky/catalog/data_fetchers/fetch_aws.py

@@ -74,10 +74,6 @@ USEFUL_COLUMNS = [
 # only available in this region, but it serves pricing information for all
 # regions.
 PRICING_TABLE_URL_FMT = 'https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/{region}/index.csv'  # pylint: disable=line-too-long
-# Hardcode the regions that offer p4de.24xlarge as our credential does not have
-# the permission to query the offerings of the instance.
-# Ref: https://aws.amazon.com/ec2/instance-types/p4/
-P4DE_REGIONS = ['us-east-1', 'us-west-2']
 # g6f instances have fractional GPUs, but the API returns Count: 1 under
 # GpuInfo. However, the GPU memory is properly scaled. Taking the instance GPU
 # divided by the total memory of an L4 will give us the fraction of the GPU.
@@ -214,35 +210,6 @@ def _get_spot_pricing_table(region: str) -> 'pd.DataFrame':
     return df
 
 
-def _patch_p4de(region: str, df: 'pd.DataFrame',
-                pricing_df: 'pd.DataFrame') -> 'pd.DataFrame':
-    # Hardcoded patch for p4de.24xlarge, as our credentials doesn't have access
-    # to the instance type.
-    # Columns:
-    # InstanceType,AcceleratorName,AcceleratorCount,vCPUs,MemoryGiB,GpuInfo,
-    # Price,SpotPrice,Region,AvailabilityZone
-    records = []
-    for zone in df[df['Region'] == region]['AvailabilityZone'].unique():
-        records.append({
-            'InstanceType': 'p4de.24xlarge',
-            'AcceleratorName': 'A100-80GB',
-            'AcceleratorCount': 8,
-            'vCPUs': 96,
-            'MemoryGiB': 1152,
-            'GpuInfo':
-                ('{\'Gpus\': [{\'Name\': \'A100-80GB\', \'Manufacturer\': '
-                 '\'NVIDIA\', \'Count\': 8, \'MemoryInfo\': {\'SizeInMiB\': '
-                 '81920}}], \'TotalGpuMemoryInMiB\': 655360}'),
-            'AvailabilityZone': zone,
-            'Region': region,
-            'Price': pricing_df[pricing_df['InstanceType'] == 'p4de.24xlarge']
-                     ['Price'].values[0],
-            'SpotPrice': np.nan,
-        })
-    df = pd.concat([df, pd.DataFrame.from_records(records)])
-    return df
-
-
 def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
     try:
         # Fetch the zone info first to make sure the account has access to the
@@ -367,9 +334,6 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
         df = pd.concat(
             [df, df.apply(get_additional_columns, axis='columns')],
             axis='columns')
-        # patch the df for p4de.24xlarge
-        if region in P4DE_REGIONS:
-            df = _patch_p4de(region, df, pricing_df)
         if 'GpuInfo' not in df.columns:
             df['GpuInfo'] = np.nan
         df = df[USEFUL_COLUMNS]

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/seeweb_catalog.py

@@ -0,0 +1,184 @@
+"""Seeweb service catalog.
+
+This module loads the service catalog file and can be used to
+query instance types and pricing information for Seeweb.
+"""
+
+import typing
+from typing import Dict, List, Optional, Tuple
+
+import pandas as pd
+
+from sky.catalog import common
+from sky.utils import resources_utils
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+_PULL_FREQUENCY_HOURS = 8
+_df = common.read_catalog('seeweb/vms.csv',
+                          pull_frequency_hours=_PULL_FREQUENCY_HOURS)
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    result = common.instance_type_exists_impl(_df, instance_type)
+    return result
+
+
+def validate_region_zone(
+        region: Optional[str],
+        zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Seeweb does not support zones.')
+
+    result = common.validate_region_zone_impl('Seeweb', _df, region, zone)
+    return result
+
+
+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."""
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Seeweb does not support zones.')
+
+    result = common.get_hourly_cost_impl(_df, instance_type, use_spot, region,
+                                         zone)
+    return result
+
+
+def get_vcpus_mem_from_instance_type(
+        instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+    result = common.get_vcpus_mem_from_instance_type_impl(_df, instance_type)
+    return result
+
+
+def get_default_instance_type(cpus: Optional[str] = None,
+                              memory: Optional[str] = None,
+                              disk_tier: Optional[
+                                  resources_utils.DiskTier] = None,
+                              region: Optional[str] = None,
+                              zone: Optional[str] = None) -> Optional[str]:
+    del disk_tier  # unused
+    result = common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory,
+                                                        region, zone)
+    return result
+
+
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, int]]:
+    # Filter the dataframe for the specific instance type
+    df_filtered = _df[_df['InstanceType'] == instance_type]
+    if df_filtered.empty:
+        return None
+
+    # Get the first row (all rows for same instance
+    # type should have same accelerator info)
+    row = df_filtered.iloc[0]
+    acc_name = row['AcceleratorName']
+    acc_count = row['AcceleratorCount']
+
+    # Check if the instance has accelerators
+    if pd.isna(acc_name) or pd.isna(
+            acc_count) or acc_name == '' or acc_count == '':
+        return None
+
+    # Convert accelerator count to int/float
+    try:
+        if int(acc_count) == acc_count:
+            acc_count = int(acc_count)
+        else:
+            acc_count = float(acc_count)
+    except (ValueError, TypeError):
+        return None
+
+    result = {acc_name: acc_count}
+    return result
+
+
+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 satisfying
+    the required count of accelerators."""
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Seeweb does not support zones.')
+
+    result = 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)
+    return result
+
+
+def regions() -> List['cloud.Region']:
+    result = common.get_region_zones(_df, use_spot=False)
+    return result
+
+
+def get_region_zones_for_instance_type(instance_type: str,
+                                       use_spot: bool = False
+                                      ) -> List['cloud.Region']:
+    """Returns a list of regions for a given instance type."""
+    # Filter the dataframe for the specific instance type
+    df_filtered = _df[_df['InstanceType'] == instance_type]
+    if df_filtered.empty:
+        return []
+
+    # Use common.get_region_zones() like all other providers
+    region_list = common.get_region_zones(df_filtered, use_spot)
+
+    # Default region: Frosinone (it-fr2)
+    # Other regions: Milano (it-mi2), Lugano (ch-lug1), Bulgaria (bg-sof1)
+    priority_regions = ['it-fr2']
+    prioritized_regions = []
+    other_regions = []
+
+    # First, add regions in priority order if they exist
+    for priority_region in priority_regions:
+        for region in region_list:
+            if region.name == priority_region:
+                prioritized_regions.append(region)
+                break
+
+    # Then, add any remaining regions that weren't in the priority list
+    for region in region_list:
+        if region.name not in priority_regions:
+            other_regions.append(region)
+
+    result = prioritized_regions + other_regions
+    return result
+
+
+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]]:
+    """Lists accelerators offered in Seeweb."""
+    # Filter out rows with empty or null regions (indicating unavailability)
+    df_filtered = _df.dropna(subset=['Region'])
+    df_filtered = df_filtered[df_filtered['Region'].str.strip() != '']
+
+    result = common.list_accelerators_impl('Seeweb', df_filtered, gpus_only,
+                                           name_filter, region_filter,
+                                           quantity_filter, case_sensitive,
+                                           all_regions, require_price)
+    return result

sky/clouds/__init__.py

@@ -28,6 +28,7 @@ from sky.clouds.oci import OCI
 from sky.clouds.paperspace import Paperspace
 from sky.clouds.runpod import RunPod
 from sky.clouds.scp import SCP
+from sky.clouds.seeweb import Seeweb
 from sky.clouds.ssh import SSH
 from sky.clouds.vast import Vast
 from sky.clouds.vsphere import Vsphere
@@ -58,6 +59,7 @@ __all__ = [
     'Fluidstack',
     'Nebius',
     'Hyperbolic',
+    'Seeweb',
     # Utility functions
     'cloud_in_iterable',
 ]

sky/clouds/kubernetes.py

@@ -841,6 +841,8 @@ class Kubernetes(clouds.Cloud):
                                  from_instance_type(default_instance_type))
 
             gpu_task_cpus = k8s_instance_type.cpus
+            if resources.cpus is None:
+                gpu_task_cpus = gpu_task_cpus * acc_count
             # Special handling to bump up memory multiplier for GPU instances
             gpu_task_memory = (float(resources.memory.strip('+')) if
                                resources.memory is not None else gpu_task_cpus *