skypilot-nightly 1.0.0.dev20250612__py3-none-any.whl → 1.0.0.dev20250614__py3-none-any.whl

sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = '88962061c851edfe5dfcfe12a1c3cf63a703dfd8'
+_SKYPILOT_COMMIT_SHA = '660d2bde857362e597fa3c30252693fe4d8c3939'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250612'
+__version__ = '1.0.0.dev20250614'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -144,6 +144,7 @@ Vast = clouds.Vast
 Vsphere = clouds.Vsphere
 Fluidstack = clouds.Fluidstack
 Nebius = clouds.Nebius
+Hyperbolic = clouds.Hyperbolic
 
 __all__ = [
     '__version__',
@@ -163,6 +164,7 @@ __all__ = [
     'Vsphere',
     'Fluidstack',
     'Nebius',
+    'Hyperbolic',
     'Optimizer',
     'OptimizeTarget',
     'backends',

sky/adaptors/hyperbolic.py

@@ -0,0 +1,8 @@
+"""Hyperbolic cloud adaptor."""
+
+from sky.adaptors import common
+
+hyperbolic = common.LazyImport(
+    'hyperbolic',
+    import_error_message='Failed to import dependencies for Hyperbolic. '
+    'Try running: pip install "skypilot[hyperbolic]"')

sky/adaptors/kubernetes.py

@@ -93,12 +93,13 @@ def _load_config(context: Optional[str] = None):
             context_name = '(current-context)' if context is None else context
             is_ssh_node_pool = False
             if context_name.startswith('ssh-'):
-                context_name = context_name.lstrip('ssh-')
+                context_name = common_utils.removeprefix(context_name, 'ssh-')
                 is_ssh_node_pool = True
             # Check if exception was due to no current-context
             if 'Expected key current-context' in str(e):
                 if is_ssh_node_pool:
-                    context_name = context_name.lstrip('ssh-')
+                    context_name = common_utils.removeprefix(
+                        context_name, 'ssh-')
                     err_str = ('Failed to load SSH Node Pool configuration for '
                                f'{context_name!r}.\n'
                                '    Run `sky ssh up --infra {context_name}` to '

sky/authentication.py

@@ -432,8 +432,8 @@ def setup_kubernetes_authentication(config: Dict[str, Any]) -> Dict[str, Any]:
         # Add message saying "Please check: ~/.sky/config.yaml" to the error
         # message.
         with ux_utils.print_exception_no_traceback():
-            raise ValueError(str(e) + ' Please check: ~/.sky/config.yaml.') \
-                from None
+            raise ValueError(str(e) +
+                             ' Please check: ~/.sky/config.yaml.') from None
     _, public_key_path = get_or_generate_keys()
 
     # Add the user's public key to the SkyPilot cluster.
@@ -567,3 +567,21 @@ def setup_fluidstack_authentication(config: Dict[str, Any]) -> Dict[str, Any]:
     client.get_or_add_ssh_key(public_key)
     config['auth']['ssh_public_key'] = public_key_path
     return configure_ssh_info(config)
+
+
+def setup_hyperbolic_authentication(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Sets up SSH authentication for Hyperbolic."""
+    _, public_key_path = get_or_generate_keys()
+    with open(public_key_path, 'r', encoding='utf-8') as f:
+        public_key = f.read().strip()
+
+    # TODO: adjust below to use public_keys instead of
+    # public_key once backwards-compatibility is no longer required
+    config['publicKey'] = public_key
+
+    # Set up auth section for Ray template
+    config.setdefault('auth', {})
+    config['auth']['ssh_user'] = 'ubuntu'
+    config['auth']['ssh_public_key'] = public_key_path
+
+    return configure_ssh_info(config)

sky/backends/backend_utils.py

@@ -126,7 +126,7 @@ _ENDPOINTS_RETRY_MESSAGE = ('If the cluster was recently started, '
                             'please retry after a while.')
 
 # If a cluster is less than LAUNCH_DOUBLE_CHECK_WINDOW seconds old, and we don't
-# see any instances in the cloud, the instances might be in the proccess of
+# see any instances in the cloud, the instances might be in the process of
 # being created. We will wait LAUNCH_DOUBLE_CHECK_DELAY seconds and then double
 # check to make sure there are still no instances. LAUNCH_DOUBLE_CHECK_DELAY
 # should be set longer than the delay between (sending the create instance
@@ -341,7 +341,13 @@ def path_size_megabytes(path: str) -> int:
                      f'{git_exclude_filter} --dry-run {path!r}')
     rsync_output = ''
     try:
-        rsync_output = str(subprocess.check_output(rsync_command, shell=True))
+        # rsync sometimes fails `--dry-run` for MacOS' rsync build, however this function is only used to display
+        # a warning message to the user if the size of a file/directory is too
+        # large, so we can safely ignore the error.
+        rsync_output = str(
+            subprocess.check_output(rsync_command,
+                                    shell=True,
+                                    stderr=subprocess.DEVNULL))
     except subprocess.CalledProcessError:
         logger.debug('Command failed, proceeding without estimating size: '
                      f'{rsync_command}')
@@ -933,6 +939,8 @@ def _add_auth_to_cluster_config(cloud: clouds.Cloud, tmp_yaml_path: str):
         config = auth.setup_vast_authentication(config)
     elif isinstance(cloud, clouds.Fluidstack):
         config = auth.setup_fluidstack_authentication(config)
+    elif isinstance(cloud, clouds.Hyperbolic):
+        config = auth.setup_hyperbolic_authentication(config)
     else:
         assert False, cloud
     common_utils.dump_yaml(tmp_yaml_path, config)
@@ -2502,7 +2510,7 @@ def is_controller_accessible(
           need_connection_check):
         # Check ssh connection if (1) controller is in INIT state, or (2) we failed to fetch the
         # status, both of which can happen when controller's status lock is held by another `sky jobs launch` or
-        # `sky serve up`. If we have controller's head_ip available and it is ssh-reachable,
+        # `sky serve up`. If we have controller's head_ip available and it is ssh-reachable,
         # we can allow access to the controller.
         ssh_credentials = ssh_credential_from_yaml(handle.cluster_yaml,
                                                    handle.docker_user,

sky/backends/cloud_vm_ray_backend.py

@@ -196,7 +196,8 @@ def _get_cluster_config_template(cloud):
         clouds.Vsphere: 'vsphere-ray.yml.j2',
         clouds.Vast: 'vast-ray.yml.j2',
         clouds.Fluidstack: 'fluidstack-ray.yml.j2',
-        clouds.Nebius: 'nebius-ray.yml.j2'
+        clouds.Nebius: 'nebius-ray.yml.j2',
+        clouds.Hyperbolic: 'hyperbolic-ray.yml.j2'
     }
     return cloud_to_template[type(cloud)]
 

sky/benchmark/benchmark_state.py

@@ -17,7 +17,6 @@ _BENCHMARK_BUCKET_NAME_KEY = 'bucket_name'
 _BENCHMARK_BUCKET_TYPE_KEY = 'bucket_type'
 
 _BENCHMARK_DB_PATH = os.path.expanduser('~/.sky/benchmark.db')
-os.makedirs(pathlib.Path(_BENCHMARK_DB_PATH).parents[0], exist_ok=True)
 
 
 class _BenchmarkSQLiteConn(threading.local):
@@ -80,6 +79,8 @@ def _init_db(func):
             return func(*args, **kwargs)
         with _benchmark_db_init_lock:
             if not _BENCHMARK_DB:
+                os.makedirs(pathlib.Path(_BENCHMARK_DB_PATH).parents[0],
+                            exist_ok=True)
                 _BENCHMARK_DB = _BenchmarkSQLiteConn()
         return func(*args, **kwargs)
 

sky/catalog/data_fetchers/fetch_aws.py

@@ -277,7 +277,7 @@ def _get_instance_types_df(region: str) -> Union[str, 'pd.DataFrame']:
             try:
                 return float(row['VCpuInfo']['DefaultVCpus'])
             except Exception as e:  # pylint: disable=broad-except
-                print('Error occured for row:', row)
+                print('Error occurred for row:', row)
                 print('Error:', e)
                 raise
 

sky/catalog/data_fetchers/fetch_hyperbolic.py

@@ -0,0 +1,136 @@
+"""Script to fetch Hyperbolic instance data and generate catalog."""
+import argparse
+import csv
+import json
+import os
+import sys
+from typing import Any, Dict
+
+import requests
+
+ENDPOINT = 'https://api.hyperbolic.xyz/v2/skypilot/catalog'
+API_KEY_PATH = os.path.expanduser('~/.hyperbolic/api_key')
+
+REQUIRED_FIELDS = [
+    'InstanceType', 'AcceleratorName', 'AcceleratorCount', 'vCPUs', 'MemoryGiB',
+    'StorageGiB', 'Price', 'Region', 'GpuInfo', 'SpotPrice'
+]
+
+
+class HyperbolicCatalogError(Exception):
+    """Base exception for Hyperbolic catalog errors."""
+    pass
+
+
+def get_api_key(api_key=None) -> str:
+    """Get API key from arg, env var, or file."""
+    if api_key:
+        return api_key
+    if api_key := os.environ.get('HYPERBOLIC_API_KEY'):
+        return api_key
+    try:
+        with open(API_KEY_PATH, 'r', encoding='utf-8') as f:
+            return f.read().strip()
+    except FileNotFoundError as exc:
+        raise HyperbolicCatalogError(
+            'No API key found. Please either:\n'
+            '1. Pass --api-key\n'
+            '2. Set HYPERBOLIC_API_KEY environment variable\n'
+            '3. Create ~/.hyperbolic/api_key file') from exc
+
+
+def get_output_path() -> str:
+    """Get output path for catalog file."""
+    current_dir = os.getcwd()
+    if os.path.basename(current_dir) == 'hyperbolic':
+        return 'vms.csv'
+    hyperbolic_dir = os.path.join(current_dir, 'hyperbolic')
+    os.makedirs(hyperbolic_dir, exist_ok=True)
+    return os.path.join(hyperbolic_dir, 'vms.csv')
+
+
+def validate_instance_data(instance: Dict[str, Any]) -> None:
+    """Validate instance data has all required fields."""
+    missing_fields = [
+        field for field in REQUIRED_FIELDS if field not in instance
+    ]
+    if missing_fields:
+        raise HyperbolicCatalogError(
+            f'Instance data missing required fields: {missing_fields}')
+
+
+def create_catalog(api_key=None) -> None:
+    """Generate Hyperbolic catalog CSV file."""
+    try:
+        response = requests.get(
+            ENDPOINT,
+            headers={'Authorization': f'Bearer {get_api_key(api_key)}'},
+            timeout=30)
+        response.raise_for_status()
+
+        try:
+            data = response.json()
+        except json.JSONDecodeError as e:
+            raise HyperbolicCatalogError(
+                f'Invalid JSON response from API: {response.text}') from e
+
+        if 'vms' not in data:
+            raise HyperbolicCatalogError(
+                f'Missing "vms" field in API response: {data}')
+
+        instances = data['vms']
+        if not isinstance(instances, list):
+            raise HyperbolicCatalogError(
+                f'Expected list of instances, got {type(instances)}')
+
+        if not instances:
+            raise HyperbolicCatalogError('No instances found in API response')
+
+        # Validate each instance
+        for instance in instances:
+            validate_instance_data(instance)
+
+    except requests.exceptions.RequestException as e:
+        raise HyperbolicCatalogError(
+            f'Failed to fetch instance data: {e}') from e
+
+    output_path = get_output_path()
+    try:
+        with open(output_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=REQUIRED_FIELDS)
+            writer.writeheader()
+
+            for instance in instances:
+                entry = instance.copy()
+                # Convert GpuInfo to string format
+                entry['GpuInfo'] = json.dumps(entry['GpuInfo'],
+                                              ensure_ascii=False).replace(
+                                                  '"', "'")  # pylint: disable=invalid-string-quote
+                writer.writerow(entry)
+    except (IOError, OSError) as e:
+        raise HyperbolicCatalogError(
+            f'Failed to write catalog file to {output_path}: {e}') from e
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description='Fetch Hyperbolic instance data')
+    parser.add_argument('--api-key', help='Hyperbolic API key')
+    args = parser.parse_args()
+
+    try:
+        create_catalog(args.api_key)
+        print(f'Hyperbolic Service Catalog saved to {get_output_path()}')
+        return 0
+    except HyperbolicCatalogError as e:
+        print(f'Error: {e}', file=sys.stderr)
+        return 1
+    except (requests.exceptions.RequestException, json.JSONDecodeError, IOError,
+            OSError) as e:
+        print(f'Unexpected error: {e}', file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

sky/catalog/data_fetchers/fetch_vast.py

@@ -2,7 +2,7 @@
 
 #
 # Due to the design of the sdk, pylint has a false
-# positive for the fnctions.
+# positive for the functions.
 #
 # pylint: disable=assignment-from-no-return
 import collections

sky/catalog/hyperbolic_catalog.py

@@ -0,0 +1,133 @@
+"""Hyperbolic Cloud service catalog.
+
+This module loads and queries the service catalog for Hyperbolic Cloud.
+"""
+from typing import Dict, List, Optional, Tuple, Union
+
+from sky.catalog import common
+from sky.clouds import cloud  # Import cloud here for Region
+from sky.utils import ux_utils
+
+# Initialize cloud variable at module level
+CLOUD = 'hyperbolic'
+
+_df = common.read_catalog('hyperbolic/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]]:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Hyperbolic Cloud does not support zones.')
+    return common.validate_region_zone_impl('hyperbolic', _df, region, zone)
+
+
+def get_hourly_cost(
+    instance_type: str,
+    use_spot: bool = False,
+    region: Optional[str] = None,
+    zone: Optional[str] = None,
+) -> float:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Hyperbolic Cloud does not support zones.')
+    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_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_vcpus_from_instance_type(instance_type: str) -> Optional[float]:
+    vcpus, _ = get_vcpus_mem_from_instance_type(instance_type)
+    return vcpus
+
+
+def get_memory_from_instance_type(instance_type: str) -> Optional[float]:
+    _, mem = get_vcpus_mem_from_instance_type(instance_type)
+    return mem
+
+
+def get_zone_shell_cmd() -> Optional[str]:
+    """Returns the shell command to obtain the zone."""
+    return None
+
+
+def get_default_instance_type(cpus: Optional[str] = None,
+                              memory: Optional[str] = None,
+                              disk_tier: Optional[str] = None) -> Optional[str]:
+    del disk_tier  # Unused
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+
+
+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]]:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Hyperbolic Cloud does not support zones.')
+    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 get_gen_version(instance_type: str) -> Optional[str]:
+    """Returns the generation version of the instance type."""
+    del instance_type  # Unused
+    # TODO: Implement generation version detection
+    return None
+
+
+def list_accelerators(
+    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 = True,
+) -> Dict[str, List[common.InstanceTypeInfo]]:
+    """Returns all instance types in Hyperbolic Cloud offering accelerators."""
+    del require_price  # Unused
+    return common.list_accelerators_impl('Hyperbolic', _df, gpus_only,
+                                         name_filter, region_filter,
+                                         quantity_filter, case_sensitive,
+                                         all_regions)
+
+
+def get_instance_type_from_catalog() -> dict:
+    # TODO: Implement this function
+    return {}
+
+
+def regions() -> List[cloud.Region]:
+    return [cloud.Region('default')]

sky/check.py

@@ -16,6 +16,7 @@ from sky import skypilot_config
 from sky.adaptors import cloudflare
 from sky.clouds import cloud as sky_cloud
 from sky.skylet import constants
+from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import rich_utils
 from sky.utils import subprocess_utils
@@ -561,7 +562,7 @@ def _format_context_details(cloud: Union[str, sky_clouds.Cloud],
             # TODO: This is a hack to remove the 'ssh-' prefix from the
             # context name. Once we have a separate kubeconfig for SSH,
             # this will not be required.
-            cleaned_context = context.lstrip('ssh-')
+            cleaned_context = common_utils.removeprefix(context, 'ssh-')
         else:
             cleaned_context = context
         symbol = (ux_utils.INDENT_LAST_SYMBOL if i == len(filtered_contexts) -

sky/cli.py

@@ -3613,7 +3613,7 @@ def show_gpus(
                 if not _filter_ctx(ctx):
                     continue
                 if is_ssh:
-                    display_ctx = ctx.lstrip('ssh-')
+                    display_ctx = common_utils.removeprefix(ctx, 'ssh-')
                 else:
                     display_ctx = ctx
                 num_filtered_contexts += 1

sky/client/cli.py

@@ -3613,7 +3613,7 @@ def show_gpus(
                 if not _filter_ctx(ctx):
                     continue
                 if is_ssh:
-                    display_ctx = ctx.lstrip('ssh-')
+                    display_ctx = common_utils.removeprefix(ctx, 'ssh-')
                 else:
                     display_ctx = ctx
                 num_filtered_contexts += 1

sky/clouds/__init__.py

@@ -19,6 +19,7 @@ from sky.clouds.cudo import Cudo
 from sky.clouds.do import DO
 from sky.clouds.fluidstack import Fluidstack
 from sky.clouds.gcp import GCP
+from sky.clouds.hyperbolic import Hyperbolic
 from sky.clouds.ibm import IBM
 from sky.clouds.kubernetes import Kubernetes
 from sky.clouds.lambda_cloud import Lambda
@@ -56,6 +57,7 @@ __all__ = [
     'StatusVersion',
     'Fluidstack',
     'Nebius',
+    'Hyperbolic',
     # Utility functions
     'cloud_in_iterable',
 ]

sky/clouds/cloud.py

@@ -631,7 +631,7 @@ class Cloud:
 
     def need_cleanup_after_preemption_or_failure(
             self, resources: 'resources_lib.Resources') -> bool:
-        """Whether a resource needs cleanup after preeemption or failure.
+        """Whether a resource needs cleanup after preemption or failure.
 
         In most cases, spot resources do not need cleanup after preemption,
         as long as the cluster can be relaunched with the same name and tag,

sky/clouds/gcp.py

@@ -1062,7 +1062,7 @@ class GCP(clouds.Cloud):
 
     def need_cleanup_after_preemption_or_failure(
             self, resources: 'resources.Resources') -> bool:
-        """Whether a resource needs cleanup after preeemption or failure."""
+        """Whether a resource needs cleanup after preemption or failure."""
         # Spot TPU VMs require manual cleanup after preemption.
         # "If your Cloud TPU is preempted,
         # you must delete it and create a new one ..."