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

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/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/catalog/slurm_catalog.py

@@ -0,0 +1,243 @@
+"""Slurm Catalog."""
+
+import collections
+import re
+from typing import Dict, List, Optional, Set, Tuple
+
+from sky import check as sky_check
+from sky import clouds as sky_clouds
+from sky import sky_logging
+from sky.catalog import common
+from sky.clouds import cloud
+from sky.provision.slurm import utils as slurm_utils
+from sky.utils import resources_utils
+
+logger = sky_logging.init_logger(__name__)
+
+_DEFAULT_NUM_VCPUS = 2
+_DEFAULT_MEMORY_CPU_RATIO = 1
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    """Check if the given instance type is valid for Slurm."""
+    return slurm_utils.SlurmInstanceType.is_valid_instance_type(instance_type)
+
+
+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]:
+    # Delete unused parameters.
+    del disk_tier, region, zone
+
+    # Slurm provisions resources via --cpus-per-task and --mem.
+    instance_cpus = float(
+        cpus.strip('+')) if cpus is not None else _DEFAULT_NUM_VCPUS
+    if memory is not None:
+        if memory.endswith('+'):
+            instance_mem = float(memory[:-1])
+        elif memory.endswith('x'):
+            instance_mem = float(memory[:-1]) * instance_cpus
+        else:
+            instance_mem = float(memory)
+    else:
+        instance_mem = instance_cpus * _DEFAULT_MEMORY_CPU_RATIO
+    virtual_instance_type = slurm_utils.SlurmInstanceType(
+        instance_cpus, instance_mem).name
+    return virtual_instance_type
+
+
+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]]:
+    """List accelerators in Slurm clusters.
+
+    Returns a dictionary mapping GPU type to a list of InstanceTypeInfo objects.
+    """
+    return list_accelerators_realtime(gpus_only, name_filter, region_filter,
+                                      quantity_filter, case_sensitive,
+                                      all_regions, require_price)[0]
+
+
+def list_accelerators_realtime(
+    gpus_only: bool = True,
+    name_filter: Optional[str] = None,
+    region_filter: Optional[str] = None,
+    quantity_filter: Optional[int] = None,
+    case_sensitive: bool = True,
+    all_regions: bool = False,
+    require_price: bool = False,
+) -> Tuple[Dict[str, List[common.InstanceTypeInfo]], Dict[str, int], Dict[str,
+                                                                          int]]:
+    """Fetches real-time accelerator information from the Slurm cluster.
+
+    Uses the `get_slurm_node_info_list` helper function.
+
+    Args:
+        gpus_only: If True, only return GPU accelerators.
+        name_filter: Regex filter for accelerator names (e.g., 'V100', 'gpu').
+        region_filter: Optional filter for Slurm partitions.
+        quantity_filter: Minimum number of accelerators required per node.
+        case_sensitive: Whether name_filter is case-sensitive.
+        all_regions: Unused in Slurm context.
+        require_price: Unused in Slurm context.
+
+    Returns:
+        A tuple of three dictionaries:
+        - qtys_map: Maps GPU type to set of InstanceTypeInfo objects for unique
+          counts found per node.
+        - total_capacity: Maps GPU type to total count across all nodes.
+        - total_available: Maps GPU type to total free count across all nodes.
+    """
+    del gpus_only, all_regions, require_price
+
+    enabled_clouds = sky_check.get_cached_enabled_clouds_or_refresh(
+        cloud.CloudCapability.COMPUTE)
+    if not sky_clouds.cloud_in_iterable(sky_clouds.Slurm(), enabled_clouds):
+        return {}, {}, {}
+
+    if region_filter is None:
+        # Get the first available cluster as default
+        all_clusters = slurm_utils.get_all_slurm_cluster_names()
+        if not all_clusters:
+            return {}, {}, {}
+        slurm_cluster = all_clusters[0]
+    else:
+        slurm_cluster = region_filter
+
+    partition_filter = slurm_utils.get_cluster_default_partition(slurm_cluster)
+
+    # Call the helper function to get node info
+    slurm_nodes_info = slurm_utils.slurm_node_info(
+        slurm_cluster_name=slurm_cluster)
+
+    if not slurm_nodes_info:
+        # Customize error message based on filters
+        err_msg = 'No matching GPU nodes found in the Slurm cluster'
+        filters_applied = []
+        if name_filter:
+            filters_applied.append(f'gpu_name={name_filter!r}')
+        if quantity_filter:
+            filters_applied.append(f'quantity>={quantity_filter}')
+        if region_filter:
+            filters_applied.append(f'cluster={region_filter!r}')
+        if filters_applied:
+            err_msg += f' with filters ({", ".join(filters_applied)})'
+        err_msg += '.'
+        logger.error(
+            err_msg)  # Log as error as it indicates no usable resources found
+        raise ValueError(err_msg)
+
+    # Aggregate results into the required format
+    qtys_map: Dict[str,
+                   Set[common.InstanceTypeInfo]] = collections.defaultdict(set)
+    total_capacity: Dict[str, int] = collections.defaultdict(int)
+    total_available: Dict[str, int] = collections.defaultdict(int)
+
+    for node_info in slurm_nodes_info:
+        gpu_type = node_info['gpu_type']
+        node_total_gpus = node_info['total_gpus']
+        node_free_gpus = node_info['free_gpus']
+        partition = node_info['partition']
+
+        # Apply name filter to the determined GPU type
+        regex_flags = 0 if case_sensitive else re.IGNORECASE
+        if name_filter and not re.match(
+                name_filter, gpu_type, flags=regex_flags):
+            continue
+
+        # Apply quantity filter (total GPUs on node must meet this)
+        if quantity_filter and node_total_gpus < quantity_filter:
+            continue
+
+        # Apply partition filter if specified
+        # TODO(zhwu): when a node is in multiple partitions, the partition
+        # mapping from node to partition does not work.
+        # if partition_filter and partition != partition_filter:
+        #     continue
+
+        # Create InstanceTypeInfo objects for various GPU counts
+        # Similar to Kubernetes, generate powers of 2 up to node_total_gpus
+        if node_total_gpus > 0:
+            count = 1
+            while count <= node_total_gpus:
+                instance_info = common.InstanceTypeInfo(
+                    instance_type=None,  # Slurm doesn't have instance types
+                    accelerator_name=gpu_type,
+                    accelerator_count=count,
+                    cpu_count=node_info['vcpu_count'],
+                    memory=node_info['memory_gb'],
+                    price=0.0,  # Slurm doesn't have price info
+                    region=partition,  # Use partition as region
+                    cloud='slurm',  # Specify cloud as 'slurm'
+                    device_memory=0.0,  # No GPU memory info from Slurm
+                    spot_price=0.0,  # Slurm doesn't have spot pricing
+                )
+                qtys_map[gpu_type].add(instance_info)
+                count *= 2
+
+            # Add the actual total if it's not already included
+            # (e.g., if node has 12 GPUs, include counts 1, 2, 4, 8, 12)
+            if count // 2 != node_total_gpus:
+                instance_info = common.InstanceTypeInfo(
+                    instance_type=None,
+                    accelerator_name=gpu_type,
+                    accelerator_count=node_total_gpus,
+                    cpu_count=node_info['vcpu_count'],
+                    memory=node_info['memory_gb'],
+                    price=0.0,
+                    region=partition,
+                    cloud='slurm',
+                    device_memory=0.0,
+                    spot_price=0.0,
+                )
+                qtys_map[gpu_type].add(instance_info)
+
+        # Map of GPU type -> total count across all matched nodes
+        total_capacity[gpu_type] += node_total_gpus
+
+        # Map of GPU type -> total *free* count across all matched nodes
+        total_available[gpu_type] += node_free_gpus
+
+    # Check if any GPUs were found after applying filters
+    if not total_capacity:
+        err_msg = 'No matching GPU nodes found in the Slurm cluster'
+        filters_applied = []
+        if name_filter:
+            filters_applied.append(f'gpu_name={name_filter!r}')
+        if quantity_filter:
+            filters_applied.append(f'quantity>={quantity_filter}')
+        if partition_filter:
+            filters_applied.append(f'partition={partition_filter!r}')
+        if filters_applied:
+            err_msg += f' with filters ({", ".join(filters_applied)})'
+        err_msg += '.'
+        logger.error(err_msg)
+        raise ValueError(err_msg)
+
+    # Convert sets of InstanceTypeInfo to sorted lists
+    final_qtys_map = {
+        gpu: sorted(list(instances), key=lambda x: x.accelerator_count)
+        for gpu, instances in qtys_map.items()
+    }
+
+    logger.debug(f'Aggregated Slurm GPU Info: '
+                 f'qtys={final_qtys_map}, '
+                 f'capacity={dict(total_capacity)}, '
+                 f'available={dict(total_available)}')
+
+    return final_qtys_map, dict(total_capacity), dict(total_available)
+
+
+def validate_region_zone(
+    region_name: Optional[str],
+    zone_name: Optional[str],
+) -> Tuple[Optional[str], Optional[str]]:
+    return (region_name, zone_name)