skypilot-nightly 1.0.0.dev20250502__py3-none-any.whl → 1.0.0.dev20251203__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/ssh_catalog.py

@@ -0,0 +1,167 @@
+"""SSH Catalog.
+
+This catalog inherits from the Kubernetes catalog as SSH cloud is a wrapper
+around Kubernetes that uses SSH-specific contexts.
+"""
+import typing
+from typing import Dict, List, Optional, Tuple
+
+from sky import sky_logging
+from sky.catalog import CloudFilter
+from sky.catalog import common
+from sky.catalog import kubernetes_catalog
+from sky.clouds import ssh
+
+logger = sky_logging.init_logger(__name__)
+
+if typing.TYPE_CHECKING:
+    import pandas as pd
+else:
+    from sky.adaptors import common as adaptors_common
+    pd = adaptors_common.LazyImport('pandas')
+
+_PULL_FREQUENCY_HOURS = 7
+
+# Reuse the Kubernetes images catalog for SSH cloud.
+# We keep pull_frequency_hours so we can remotely update the default image paths
+_image_df = common.read_catalog('kubernetes/images.csv',
+                                pull_frequency_hours=_PULL_FREQUENCY_HOURS)
+
+
+def get_image_id_from_tag(tag: str, region: Optional[str]) -> Optional[str]:
+    """Returns the image id from the tag.
+
+    Delegates to Kubernetes catalog implementation.
+    """
+    return kubernetes_catalog.get_image_id_from_tag(tag, region)
+
+
+def is_image_tag_valid(tag: str, region: Optional[str]) -> bool:
+    """Returns whether the image tag is valid.
+
+    Delegates to Kubernetes catalog implementation.
+    """
+    return kubernetes_catalog.is_image_tag_valid(tag, region)
+
+
+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 SSH-based Kubernetes clusters.
+
+    Delegates to the Kubernetes _list_accelerators function but restricts to
+    SSH contexts.
+    """
+    return _list_accelerators(gpus_only,
+                              name_filter,
+                              region_filter,
+                              quantity_filter,
+                              case_sensitive,
+                              all_regions,
+                              require_price,
+                              realtime=False)[0]
+
+
+def list_accelerators_realtime(
+    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
+) -> Tuple[Dict[str, List[common.InstanceTypeInfo]], Dict[str, int], Dict[str,
+                                                                          int]]:
+    """List accelerators in SSH Node Pools with real-time information.
+
+    Delegates to the Kubernetes _list_accelerators function but restricts to
+    SSH contexts.
+    """
+    return _list_accelerators(gpus_only,
+                              name_filter,
+                              region_filter,
+                              quantity_filter,
+                              case_sensitive,
+                              all_regions,
+                              require_price,
+                              realtime=True)
+
+
+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,
+    realtime: bool = False
+) -> Tuple[Dict[str, List[common.InstanceTypeInfo]], Dict[str, int], Dict[str,
+                                                                          int]]:
+    """List accelerators in SSH-based Kubernetes clusters.
+
+    This is a wrapper around the Kubernetes _list_accelerators function that
+    restricts the contexts to SSH-specific contexts only.
+
+    If region_filter is specified and it's not an SSH context, no results will
+    be returned.
+    """
+    # If a specific region is requested, ensure it's an SSH context
+    if region_filter is not None and not region_filter.startswith('ssh-'):
+        return {}, {}, {}
+
+    # Get SSH contexts
+    ssh_contexts = ssh.SSH.existing_allowed_contexts()
+
+    # If no contexts found, return empty results
+    if not ssh_contexts:
+        return {}, {}, {}
+
+    # If a region filter is specified and it's not a SSH context return empty
+    # results
+    if region_filter is not None and region_filter not in ssh_contexts:
+        return {}, {}, {}
+
+    # If region_filter is None, use the first context if all_regions is False
+    if region_filter is None and not all_regions and ssh_contexts:
+        # Use the first SSH context if no specific region requested
+        region_filter = ssh_contexts[0]
+
+    # Call the Kubernetes _list_accelerators with the appropriate region filter
+    if realtime:
+        return kubernetes_catalog.list_accelerators_realtime(
+            gpus_only, name_filter, region_filter, quantity_filter,
+            case_sensitive, all_regions, require_price)
+    else:
+        result = kubernetes_catalog.list_accelerators(
+            gpus_only, name_filter, region_filter, quantity_filter,
+            case_sensitive, all_regions, require_price)
+        return result, {}, {}
+
+
+def validate_region_zone(
+        region_name: Optional[str],
+        zone_name: Optional[str],
+        clouds: CloudFilter = None) -> Tuple[Optional[str], Optional[str]]:
+    """Validates the region and zone for SSH cloud.
+
+    Delegates to the Kubernetes catalog implementation but ensures
+    the region is a valid SSH context.
+    """
+    # Delegate to Kubernetes implementation
+    region, zone = kubernetes_catalog.validate_region_zone(
+        region_name, zone_name, clouds)
+
+    # Get SSH contexts
+    ssh_contexts = ssh.SSH.existing_allowed_contexts()
+
+    # If a region is specified, ensure it's in the list of SSH contexts
+    if region is not None and region not in ssh_contexts:
+        return None, None
+
+    return region, zone

sky/{clouds/service_catalog → catalog}/vast_catalog.py

@@ -7,7 +7,7 @@ query instance types and pricing information for Vast.ai.
 import typing
 from typing import Dict, List, Optional, Tuple, Union
 
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
@@ -48,11 +48,14 @@ def get_vcpus_mem_from_instance_type(
 
 def get_default_instance_type(cpus: Optional[str] = None,
                               memory: Optional[str] = None,
-                              disk_tier: Optional[str] = None) -> Optional[str]:
+                              disk_tier: Optional[str] = None,
+                              region: Optional[str] = None,
+                              zone: Optional[str] = None) -> Optional[str]:
     del disk_tier
     # NOTE: After expanding catalog to multiple entries, you may
     # want to specify a default instance type or family.
-    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory, region,
+                                                      zone)
 
 
 def get_accelerators_from_instance_type(

sky/{clouds/service_catalog → catalog}/vsphere_catalog.py

@@ -5,7 +5,7 @@ import typing
 from typing import Dict, List, Optional, Tuple, Union
 
 from sky.adaptors import common as adaptors_common
-from sky.clouds.service_catalog import common
+from sky.catalog import common
 
 if typing.TYPE_CHECKING:
     import pandas as pd
@@ -72,6 +72,8 @@ 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  # unused
     if cpus is None and memory is None:
@@ -81,7 +83,8 @@ def get_default_instance_type(
     else:
         memory_gb_or_ratio = memory
     return common.get_instance_type_for_cpus_mem_impl(_get_df(), cpus,
-                                                      memory_gb_or_ratio)
+                                                      memory_gb_or_ratio,
+                                                      region, zone)
 
 
 def get_accelerators_from_instance_type(