skypilot-nightly 1.0.0.dev20250905__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/check.py

@@ -14,6 +14,7 @@ from sky import global_user_state
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import cloudflare
+from sky.adaptors import coreweave
 from sky.clouds import cloud as sky_cloud
 from sky.skylet import constants
 from sky.utils import common_utils
@@ -33,7 +34,8 @@ def _get_workspace_allowed_clouds(workspace: str) -> List[str]:
     # clouds. Also validate names with get_cloud_tuple.
     config_allowed_cloud_names = skypilot_config.get_nested(
         ('allowed_clouds',),
-        [repr(c) for c in registry.CLOUD_REGISTRY.values()] + [cloudflare.NAME])
+        [repr(c) for c in registry.CLOUD_REGISTRY.values()] +
+        [cloudflare.NAME, coreweave.NAME])
     # filter out the clouds that are disabled in the workspace config
     workspace_disabled_clouds = []
     for cloud in config_allowed_cloud_names:
@@ -50,6 +52,32 @@ def _get_workspace_allowed_clouds(workspace: str) -> List[str]:
     return config_allowed_cloud_names
 
 
+def _get_workspace_cloud_capabilities(
+        workspace: str,
+        cloud: str) -> Optional[List[sky_cloud.CloudCapability]]:
+    """Get the capabilities for a cloud in a workspace.
+
+    Returns:
+        A list of capabilities for the cloud in the workspace.
+        None if the capabilities are not explicitly specified
+        in the workspace or global config.
+        Returned value of None does not mean the cloud is disabled.
+    """
+    cloud_config = skypilot_config.get_workspace_cloud(cloud,
+                                                       workspace=workspace)
+    cloud_capabilities = cloud_config.get('capabilities', None)
+    if not cloud_capabilities:
+        # get the capabilities from the global config
+        cloud_capabilities = skypilot_config.get_nested(
+            (cloud.lower(), 'capabilities'), default_value=None)
+    if cloud_capabilities:
+        return [
+            sky_cloud.CloudCapability(capability.lower())
+            for capability in cloud_capabilities
+        ]
+    return None
+
+
 def check_capabilities(
     quiet: bool = False,
     verbose: bool = False,
@@ -81,7 +109,7 @@ def check_capabilities(
 
     def get_all_clouds() -> Tuple[str, ...]:
         return tuple([repr(c) for c in registry.CLOUD_REGISTRY.values()] +
-                     [cloudflare.NAME])
+                     [cloudflare.NAME, coreweave.NAME])
 
     def _execute_check_logic_for_workspace(
         current_workspace_name: str,
@@ -121,9 +149,12 @@ def check_capabilities(
                 cloud_name: str
         ) -> Tuple[str, Union[sky_clouds.Cloud, ModuleType]]:
             # Validates cloud_name and returns a tuple of the cloud's name and
-            # the cloud object. Includes special handling for Cloudflare.
+            # the cloud object. Includes special handling for Cloudflare and
+            # CoreWeave.
             if cloud_name.lower().startswith('cloudflare'):
                 return cloudflare.NAME, cloudflare
+            elif cloud_name.lower().startswith('coreweave'):
+                return coreweave.NAME, coreweave
             else:
                 cloud_obj = registry.CLOUD_REGISTRY.from_str(cloud_name)
                 assert cloud_obj is not None, f'Cloud {cloud_name!r} not found'
@@ -147,12 +178,32 @@ def check_capabilities(
 
         # filter out the clouds that are disabled in the workspace config
         workspace_disabled_clouds = []
+        workspace_cloud_capabilities: Dict[
+            str, List[sky_cloud.CloudCapability]] = {}
         for cloud in config_allowed_cloud_names:
             cloud_config = skypilot_config.get_workspace_cloud(
                 cloud, workspace=current_workspace_name)
             cloud_disabled = cloud_config.get('disabled', False)
             if cloud_disabled:
                 workspace_disabled_clouds.append(cloud)
+            else:
+                specified_capabilities = _get_workspace_cloud_capabilities(
+                    current_workspace_name, cloud)
+                if specified_capabilities:
+                    # filter the capabilities to only the ones passed
+                    # in as argument to this function
+                    workspace_cloud_capabilities[cloud] = [
+                        enabled_capability
+                        for enabled_capability in specified_capabilities
+                        if enabled_capability in capabilities
+                    ]
+                    # mark capabilities that are not enabled
+                    # in the workspace config as disabled
+                    for capability in capabilities:
+                        if capability not in workspace_cloud_capabilities[
+                                cloud]:
+                            disabled_clouds.setdefault(cloud,
+                                                       []).append(capability)
 
         config_allowed_cloud_names = [
             c for c in config_allowed_cloud_names
@@ -172,7 +223,8 @@ def check_capabilities(
         for c in clouds_to_check:
             allowed = c[0] in config_allowed_cloud_names
             if allowed or check_explicit:
-                for capability in capabilities:
+                for capability in workspace_cloud_capabilities.get(
+                        c[0], capabilities):
                     combinations.append((c, capability, allowed))
 
         cloud2ctx2text: Dict[str, Dict[str, str]] = {}
@@ -219,23 +271,24 @@ def check_capabilities(
         # allowed_clouds in config.yaml, it will be disabled.
         all_enabled_clouds: Set[str] = set()
         for capability in capabilities:
-            # Cloudflare is not a real cloud in registry.CLOUD_REGISTRY, and
-            # should not be inserted into the DB (otherwise `sky launch` and
-            # other code would error out when it's trying to look it up in the
-            # registry).
+            # Cloudflare and CoreWeave are not real clouds in
+            # registry.CLOUD_REGISTRY, and should not be inserted into the DB
+            # (otherwise `sky launch` and other code would error out when it's
+            # trying to look it up in the registry).
             enabled_clouds_set = {
                 cloud for cloud, capabilities in enabled_clouds.items()
-                if capability in capabilities and
-                not cloud.startswith('Cloudflare')
+                if capability in capabilities and not cloud.startswith(
+                    'Cloudflare') and not cloud.startswith('CoreWeave')
             }
             disabled_clouds_set = {
                 cloud for cloud, capabilities in disabled_clouds.items()
-                if capability in capabilities and
-                not cloud.startswith('Cloudflare')
+                if capability in capabilities and not cloud.startswith(
+                    'Cloudflare') and not cloud.startswith('CoreWeave')
             }
             config_allowed_clouds_set = {
                 cloud for cloud in config_allowed_cloud_names
-                if not cloud.startswith('Cloudflare')
+                if not cloud.startswith('Cloudflare') and
+                not cloud.startswith('CoreWeave')
             }
             previously_enabled_clouds_set = {
                 repr(cloud)
@@ -430,6 +483,12 @@ def get_cloud_credential_file_mounts(
     if r2_is_enabled:
         r2_credential_mounts = cloudflare.get_credential_file_mounts()
         file_mounts.update(r2_credential_mounts)
+
+    # Similarly, handle CoreWeave storage credentials
+    coreweave_is_enabled, _ = coreweave.check_storage_credentials()
+    if coreweave_is_enabled:
+        coreweave_credential_mounts = coreweave.get_credential_file_mounts()
+        file_mounts.update(coreweave_credential_mounts)
     return file_mounts
 
 
@@ -494,7 +553,7 @@ def _print_checked_cloud(
         style_str = f'{colorama.Fore.GREEN}{colorama.Style.NORMAL}'
         status_msg = 'enabled'
         capability_string = f'[{", ".join(enabled_capabilities)}]'
-        if verbose and cloud is not cloudflare:
+        if verbose and cloud is not cloudflare and cloud is not coreweave:
             activated_account = cloud.get_active_user_identity_str()
         if isinstance(cloud_tuple[1], (sky_clouds.SSH, sky_clouds.Kubernetes)):
             detail_string = _format_context_details(cloud_tuple[1],
@@ -621,35 +680,6 @@ def _format_enabled_cloud(cloud_name: str,
     if cloud_name in [repr(sky_clouds.Kubernetes()), repr(sky_clouds.SSH())]:
         return (f'{title}' + _format_context_details(
             cloud_name, show_details=False, ctx2text=ctx2text))
-
-    if cloud_name == repr(sky_clouds.Kubernetes()):
-        # Get enabled contexts for Kubernetes
-        existing_contexts = sky_clouds.Kubernetes.existing_allowed_contexts()
-        if not existing_contexts:
-            return _green_color(cloud_and_capabilities)
-
-        # Check if allowed_contexts is explicitly set in config
-        allowed_contexts = skypilot_config.get_effective_region_config(
-            cloud='kubernetes',
-            region=None,
-            keys=('allowed_contexts',),
-            default_value=None)
-
-        # Format the context info with consistent styling
-        if allowed_contexts is not None:
-            contexts_formatted = []
-            for i, context in enumerate(existing_contexts):
-                symbol = (ux_utils.INDENT_LAST_SYMBOL
-                          if i == len(existing_contexts) -
-                          1 else ux_utils.INDENT_SYMBOL)
-                contexts_formatted.append(f'\n    {symbol}{context}')
-            context_info = f'  Allowed contexts:{"".join(contexts_formatted)}'
-        else:
-            context_info = f'  Active context: {existing_contexts[0]}'
-
-        return (f'{_green_color(cloud_and_capabilities)}\n'
-                f'  {colorama.Style.DIM}{context_info}'
-                f'{colorama.Style.RESET_ALL}')
     return _green_color(cloud_and_capabilities)