skypilot-nightly 1.0.0.dev20250613__tar.gz → 1.0.0.dev20250614__tar.gz

{skypilot_nightly-1.0.0.dev20250613/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20250614}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250613
+Version: 1.0.0.dev20250614
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0
@@ -119,6 +119,7 @@ Requires-Dist: awscli>=1.27.10; extra == "nebius"
 Requires-Dist: botocore>=1.29.10; extra == "nebius"
 Requires-Dist: boto3>=1.26.1; extra == "nebius"
 Requires-Dist: colorama<0.4.5; extra == "nebius"
+Provides-Extra: hyperbolic
 Provides-Extra: all
 Requires-Dist: awscli>=1.27.10; extra == "all"
 Requires-Dist: botocore>=1.29.10; extra == "all"

{skypilot_nightly-1.0.0.dev20250613 → skypilot_nightly-1.0.0.dev20250614}/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 = '4dfa63417c4dc57a5a9fc52c9936a8dd52194d8e'
+_SKYPILOT_COMMIT_SHA = '660d2bde857362e597fa3c30252693fe4d8c3939'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250613'
+__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',

skypilot_nightly-1.0.0.dev20250614/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]"')

{skypilot_nightly-1.0.0.dev20250613 → skypilot_nightly-1.0.0.dev20250614}/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)

{skypilot_nightly-1.0.0.dev20250613 → skypilot_nightly-1.0.0.dev20250614}/sky/backends/backend_utils.py

@@ -939,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)
@@ -2508,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,

{skypilot_nightly-1.0.0.dev20250613 → skypilot_nightly-1.0.0.dev20250614}/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)]
 

skypilot_nightly-1.0.0.dev20250614/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())

skypilot_nightly-1.0.0.dev20250614/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')]

{skypilot_nightly-1.0.0.dev20250613 → skypilot_nightly-1.0.0.dev20250614}/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',
 ]

skypilot_nightly-1.0.0.dev20250614/sky/clouds/hyperbolic.py

@@ -0,0 +1,276 @@
+"""Hyperbolic Cloud provider implementation
+for SkyPilot.
+"""
+import os
+import typing
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from sky import catalog
+from sky import clouds
+from sky.utils import registry
+from sky.utils import resources_utils
+from sky.utils.resources_utils import DiskTier
+
+if typing.TYPE_CHECKING:
+    from sky import resources as resources_lib
+
+
+@registry.CLOUD_REGISTRY.register
+class Hyperbolic(clouds.Cloud):
+    """Hyperbolic Cloud Provider."""
+
+    _REPR = 'Hyperbolic'
+    name = 'hyperbolic'
+    _MAX_CLUSTER_NAME_LEN_LIMIT = 120
+    API_KEY_PATH = os.path.expanduser('~/.hyperbolic/api_key')
+
+    _CLOUD_UNSUPPORTED_FEATURES = {
+        clouds.CloudImplementationFeatures.STOP: ('Stopping not supported.'),
+        clouds.CloudImplementationFeatures.MULTI_NODE:
+            ('Multi-node not supported.'),
+        clouds.CloudImplementationFeatures.CUSTOM_DISK_TIER:
+            ('Custom disk tiers not supported.'),
+        clouds.CloudImplementationFeatures.STORAGE_MOUNTING:
+            ('Storage mounting not supported.'),
+        clouds.CloudImplementationFeatures.HIGH_AVAILABILITY_CONTROLLERS:
+            ('High availability controllers not supported.'),
+        clouds.CloudImplementationFeatures.SPOT_INSTANCE:
+            ('Spot instances not supported.'),
+        clouds.CloudImplementationFeatures.CLONE_DISK_FROM_CLUSTER:
+            ('Disk cloning not supported.'),
+        clouds.CloudImplementationFeatures.DOCKER_IMAGE:
+            ('Docker images not supported.'),
+        clouds.CloudImplementationFeatures.OPEN_PORTS:
+            ('Opening ports not supported.'),
+        clouds.CloudImplementationFeatures.IMAGE_ID:
+            ('Custom image IDs not supported.'),
+        clouds.CloudImplementationFeatures.CUSTOM_NETWORK_TIER:
+            ('Custom network tiers not supported.'),
+        clouds.CloudImplementationFeatures.HOST_CONTROLLERS:
+            ('Host controllers not supported.'),
+        clouds.CloudImplementationFeatures.AUTO_TERMINATE:
+            ('Auto-termination not supported.'),
+        clouds.CloudImplementationFeatures.AUTOSTOP:
+            ('Auto-stop not supported.'),
+        clouds.CloudImplementationFeatures.AUTODOWN:
+            ('Auto-down not supported.'),
+    }
+
+    PROVISIONER_VERSION = clouds.ProvisionerVersion.SKYPILOT
+    STATUS_VERSION = clouds.StatusVersion.SKYPILOT
+    OPEN_PORTS_VERSION = clouds.OpenPortsVersion.LAUNCH_ONLY
+
+    @classmethod
+    def _unsupported_features_for_resources(
+        cls, resources: 'resources_lib.Resources'
+    ) -> Dict[clouds.CloudImplementationFeatures, str]:
+        del resources
+        return cls._CLOUD_UNSUPPORTED_FEATURES
+
+    @classmethod
+    def _max_cluster_name_length(cls) -> Optional[int]:
+        return cls._MAX_CLUSTER_NAME_LEN_LIMIT
+
+    def instance_type_exists(self, instance_type: str) -> bool:
+        return catalog.instance_type_exists(instance_type, 'hyperbolic')
+
+    @classmethod
+    def regions_with_offering(cls, instance_type: str,
+                              accelerators: Optional[Dict[str, int]],
+                              use_spot: bool, region: Optional[str],
+                              zone: Optional[str]) -> List[clouds.Region]:
+        assert zone is None, 'Hyperbolic does not support zones.'
+        del accelerators, zone  # unused
+
+        regions = catalog.get_region_zones_for_instance_type(
+            instance_type, use_spot, 'hyperbolic')
+        if region is not None:
+            regions = [r for r in regions if r.name == region]
+        return regions
+
+    @classmethod
+    def get_vcpus_mem_from_instance_type(
+            cls, instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+        return catalog.get_vcpus_mem_from_instance_type(instance_type,
+                                                        clouds='hyperbolic')
+
+    def instance_type_to_hourly_cost(self,
+                                     instance_type: str,
+                                     use_spot: bool,
+                                     region: Optional[str] = None,
+                                     zone: Optional[str] = None) -> float:
+        return catalog.get_hourly_cost(instance_type,
+                                       use_spot=use_spot,
+                                       region=region,
+                                       zone=zone,
+                                       clouds='hyperbolic')
+
+    @classmethod
+    def get_default_instance_type(
+            cls,
+            cpus: Optional[str] = None,
+            memory: Optional[str] = None,
+            disk_tier: Optional[DiskTier] = None) -> Optional[str]:
+        return catalog.get_default_instance_type(cpus=cpus,
+                                                 memory=memory,
+                                                 disk_tier=disk_tier,
+                                                 clouds='hyperbolic')
+
+    @classmethod
+    def get_accelerators_from_instance_type(
+            cls, instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+        return catalog.get_accelerators_from_instance_type(instance_type,
+                                                           clouds='hyperbolic')
+
+    @classmethod
+    def _check_credentials(cls) -> Tuple[bool, Optional[str]]:
+        if os.path.exists(cls.API_KEY_PATH):
+            return True, None
+        return False, f'API key not found at {cls.API_KEY_PATH}'
+
+    @classmethod
+    def _check_compute_credentials(cls) -> Tuple[bool, Optional[str]]:
+        return cls._check_credentials()
+
+    @classmethod
+    def get_credential_file_mounts(cls) -> Dict[str, str]:
+        if os.path.exists(cls.API_KEY_PATH):
+            return {cls.API_KEY_PATH: '~/.hyperbolic/api_key'}
+        return {}
+
+    def __repr__(self):
+        return self._REPR
+
+    def _get_feasible_launchable_resources(
+        self, resources: 'resources_lib.Resources'
+    ) -> 'resources_utils.FeasibleResources':
+        # Check if the instance type exists in the catalog
+        if resources.instance_type is not None:
+            if catalog.instance_type_exists(resources.instance_type,
+                                            'hyperbolic'):
+                # Remove accelerators for launchable resources
+                resources_launch = resources.copy(accelerators=None)
+                return resources_utils.FeasibleResources([resources_launch], [],
+                                                         None)
+            else:
+                raise ValueError(
+                    f'Invalid instance type: {resources.instance_type}')
+
+        # If accelerators are specified
+        accelerators = resources.accelerators
+        if accelerators is not None:
+            assert len(accelerators) == 1, resources
+            acc, acc_count = list(accelerators.items())[0]
+            (instance_list,
+             fuzzy_candidate_list) = catalog.get_instance_type_for_accelerator(
+                 acc,
+                 acc_count,
+                 use_spot=resources.use_spot,
+                 cpus=resources.cpus,
+                 memory=resources.memory,
+                 region=resources.region,
+                 zone=resources.zone,
+                 clouds='hyperbolic')
+            if instance_list is None:
+                return resources_utils.FeasibleResources([],
+                                                         fuzzy_candidate_list,
+                                                         None)
+
+            def _make(instance_list):
+                resource_list = []
+                for instance_type in instance_list:
+                    r = resources.copy(
+                        cloud=self,
+                        instance_type=instance_type,
+                        accelerators=None,
+                        cpus=None,
+                        memory=None,
+                    )
+                    resource_list.append(r)
+                return resource_list
+
+            return resources_utils.FeasibleResources(_make(instance_list),
+                                                     fuzzy_candidate_list, None)
+
+        # If nothing is specified, return a default instance type
+        default_instance_type = self.get_default_instance_type(
+            cpus=resources.cpus,
+            memory=resources.memory,
+            disk_tier=resources.disk_tier)
+        if default_instance_type is None:
+            return resources_utils.FeasibleResources([], [], None)
+        else:
+            r = resources.copy(
+                cloud=self,
+                instance_type=default_instance_type,
+                accelerators=None,
+                cpus=None,
+                memory=None,
+            )
+            return resources_utils.FeasibleResources([r], [], None)
+
+    def validate_region_zone(
+            self, region: Optional[str],
+            zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+        if zone is not None:
+            raise ValueError('Hyperbolic does not support zones.')
+        return catalog.validate_region_zone(region, zone, 'hyperbolic')
+
+    @classmethod
+    def regions(cls) -> List[clouds.Region]:
+        """Returns the list of regions in Hyperbolic's catalog."""
+        return catalog.regions('hyperbolic')
+
+    @classmethod
+    def zones_provision_loop(cls,
+                             *,
+                             region: str,
+                             num_nodes: int,
+                             instance_type: str,
+                             accelerators: Optional[Dict[str, int]] = None,
+                             use_spot: bool = False):
+        yield None
+
+    @classmethod
+    def get_zone_shell_cmd(cls) -> Optional[str]:
+        return None
+
+    def get_egress_cost(self, num_gigabytes: float):
+        return 0.0
+
+    def accelerators_to_hourly_cost(self, accelerators: Dict[str, int],
+                                    use_spot: bool, region: Optional[str],
+                                    zone: Optional[str]) -> float:
+        return 0.0
+
+    def make_deploy_resources_variables(
+            self,
+            resources: 'resources_lib.Resources',
+            cluster_name: resources_utils.ClusterName,
+            region: 'clouds.Region',
+            zones: Optional[List['clouds.Zone']],
+            num_nodes: int,
+            dryrun: bool = False) -> Dict[str, Any]:
+        """Returns a dict of variables for the deployment template."""
+        del dryrun, region, cluster_name  # unused
+        assert zones is None, ('Hyperbolic does not support zones', zones)
+
+        resources = resources.assert_launchable()
+        # resources.accelerators is cleared but .instance_type encodes the info.
+        acc_dict = self.get_accelerators_from_instance_type(
+            resources.instance_type)
+        custom_resources = resources_utils.make_ray_custom_resources_str(
+            acc_dict)
+
+        return {
+            'instance_type': resources.instance_type,
+            'custom_resources': custom_resources,
+            'num_nodes': 1,  # Hyperbolic only supports single-node clusters
+        }
+
+    def cluster_name_in_hint(self, cluster_name_on_cloud: Optional[str],
+                             cluster_name: str) -> bool:
+        """Check if a node's name matches the cluster name pattern."""
+        if cluster_name_on_cloud is None:
+            return False
+        return cluster_name_on_cloud.startswith(cluster_name)