skypilot-nightly 1.0.0.dev20250715__tar.gz → 1.0.0.dev20250717__tar.gz

{skypilot_nightly-1.0.0.dev20250715/sky/setup_files → skypilot_nightly-1.0.0.dev20250717}/MANIFEST.in

@@ -17,3 +17,4 @@ include sky/utils/kubernetes/*
 include sky/server/html/*
 recursive-include sky/dashboard/out *
 include sky/users/*.conf
+include sky/utils/*.sh

{skypilot_nightly-1.0.0.dev20250715/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20250717}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250715
+Version: 1.0.0.dev20250717
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0
@@ -54,6 +54,8 @@ Requires-Dist: sqlalchemy_adapter
 Requires-Dist: prometheus_client>=0.8.0
 Requires-Dist: passlib
 Requires-Dist: pyjwt
+Requires-Dist: gitpython
+Requires-Dist: types-paramiko
 Provides-Extra: aws
 Requires-Dist: awscli>=1.27.10; extra == "aws"
 Requires-Dist: botocore>=1.29.10; extra == "aws"
@@ -118,7 +120,7 @@ Requires-Dist: vastai-sdk>=0.1.12; extra == "vast"
 Provides-Extra: vsphere
 Requires-Dist: pyvmomi==8.0.1.0.2; extra == "vsphere"
 Provides-Extra: nebius
-Requires-Dist: nebius>=0.2.0; extra == "nebius"
+Requires-Dist: nebius>=0.2.37; extra == "nebius"
 Requires-Dist: awscli>=1.27.10; extra == "nebius"
 Requires-Dist: botocore>=1.29.10; extra == "nebius"
 Requires-Dist: boto3>=1.26.1; extra == "nebius"
@@ -174,7 +176,7 @@ Requires-Dist: azure-core>=1.24.0; extra == "all"
 Requires-Dist: azure-common; extra == "all"
 Requires-Dist: vastai-sdk>=0.1.12; extra == "all"
 Requires-Dist: pyvmomi==8.0.1.0.2; extra == "all"
-Requires-Dist: nebius>=0.2.0; extra == "all"
+Requires-Dist: nebius>=0.2.37; extra == "all"
 Requires-Dist: awscli>=1.27.10; extra == "all"
 Requires-Dist: botocore>=1.29.10; extra == "all"
 Requires-Dist: boto3>=1.26.1; extra == "all"

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/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 = 'a8f4afecf9eb1cc4eca7ccc205498a2f6ed1fe38'
+_SKYPILOT_COMMIT_SHA = '5ed1775c386bbd0cc4b9d1c80fc0d2d91b352870'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250715'
+__version__ = '1.0.0.dev20250717'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 
@@ -88,6 +88,7 @@ from sky.admin_policy import UserRequest
 from sky.catalog import list_accelerators
 from sky.client.sdk import api_cancel
 from sky.client.sdk import api_info
+from sky.client.sdk import api_login
 from sky.client.sdk import api_server_logs
 from sky.client.sdk import api_start
 from sky.client.sdk import api_status
@@ -206,6 +207,7 @@ __all__ = [
     'api_status',
     'api_cancel',
     'api_info',
+    'api_login',
     'api_start',
     'api_stop',
     'api_server_logs',

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/adaptors/nebius.py

@@ -89,6 +89,12 @@ def iam():
     return iam_v1
 
 
+def billing():
+    # pylint: disable=import-outside-toplevel
+    from nebius.api.nebius.billing import v1alpha1 as billing_v1alpha1
+    return billing_v1alpha1
+
+
 def nebius_common():
     # pylint: disable=import-outside-toplevel
     from nebius.api.nebius.common import v1 as common_v1

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/backends/backend.py

@@ -1,6 +1,6 @@
 """Sky backend interface."""
 import typing
-from typing import Dict, Generic, Optional, Tuple
+from typing import Any, Dict, Generic, Optional, Tuple, Union
 
 from sky.usage import usage_lib
 from sky.utils import cluster_utils
@@ -90,8 +90,10 @@ class Backend(Generic[_ResourceHandleType]):
 
     @timeline.event
     @usage_lib.messages.usage.update_runtime('sync_workdir')
-    def sync_workdir(self, handle: _ResourceHandleType, workdir: Path) -> None:
-        return self._sync_workdir(handle, workdir)
+    def sync_workdir(self, handle: _ResourceHandleType,
+                     workdir: Union[Path, Dict[str, Any]],
+                     envs_and_secrets: Dict[str, str]) -> None:
+        return self._sync_workdir(handle, workdir, envs_and_secrets)
 
     @timeline.event
     @usage_lib.messages.usage.update_runtime('sync_file_mounts')
@@ -165,7 +167,9 @@ class Backend(Generic[_ResourceHandleType]):
     ) -> Tuple[Optional[_ResourceHandleType], bool]:
         raise NotImplementedError
 
-    def _sync_workdir(self, handle: _ResourceHandleType, workdir: Path) -> None:
+    def _sync_workdir(self, handle: _ResourceHandleType,
+                      workdir: Union[Path, Dict[str, Any]],
+                      envs_and_secrets: Dict[str, str]) -> None:
         raise NotImplementedError
 
     def _sync_file_mounts(

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/backends/cloud_vm_ray_backend.py

@@ -3240,10 +3240,59 @@ class CloudVmRayBackend(backends.Backend['CloudVmRayResourceHandle']):
             common_utils.remove_file_if_exists(lock_path)
 
     def _sync_workdir(self, handle: CloudVmRayResourceHandle,
-                      workdir: Path) -> None:
+                      workdir: Union[Path, Dict[str, Any]],
+                      envs_and_secrets: Dict[str, str]) -> None:
         # Even though provision() takes care of it, there may be cases where
         # this function is called in isolation, without calling provision(),
         # e.g., in CLI.  So we should rerun rsync_up.
+        if isinstance(workdir, dict):
+            self._sync_git_workdir(handle, envs_and_secrets)
+        else:
+            self._sync_path_workdir(handle, workdir)
+
+    def _sync_git_workdir(self, handle: CloudVmRayResourceHandle,
+                          envs_and_secrets: Dict[str, str]) -> None:
+        style = colorama.Style
+        ip_list = handle.external_ips()
+        assert ip_list is not None, 'external_ips is not cached in handle'
+
+        log_path = os.path.join(self.log_dir, 'workdir_sync.log')
+
+        # TODO(zhwu): refactor this with backend_utils.parallel_cmd_with_rsync
+        runners = handle.get_command_runners()
+
+        def _sync_git_workdir_node(
+                runner: command_runner.CommandRunner) -> None:
+            # Type assertion to help mypy understand the type
+            assert hasattr(
+                runner, 'git_clone'
+            ), f'CommandRunner should have git_clone method, ' \
+                f'got {type(runner)}'
+            runner.git_clone(
+                target_dir=SKY_REMOTE_WORKDIR,
+                log_path=log_path,
+                stream_logs=False,
+                max_retry=3,
+                envs_and_secrets=envs_and_secrets,
+            )
+
+        num_nodes = handle.launched_nodes
+        plural = 's' if num_nodes > 1 else ''
+        logger.info(
+            f'  {style.DIM}Syncing workdir (to {num_nodes} node{plural}): '
+            f'{SKY_REMOTE_WORKDIR}{style.RESET_ALL}')
+        os.makedirs(os.path.expanduser(self.log_dir), exist_ok=True)
+        os.system(f'touch {log_path}')
+        num_threads = subprocess_utils.get_parallel_threads(
+            str(handle.launched_resources.cloud))
+        with rich_utils.safe_status(
+                ux_utils.spinner_message('Syncing workdir', log_path)):
+            subprocess_utils.run_in_parallel(_sync_git_workdir_node, runners,
+                                             num_threads)
+        logger.info(ux_utils.finishing_message('Synced workdir.', log_path))
+
+    def _sync_path_workdir(self, handle: CloudVmRayResourceHandle,
+                           workdir: Path) -> None:
         fore = colorama.Fore
         style = colorama.Style
         ip_list = handle.external_ips()

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/backends/docker_utils.py

@@ -168,7 +168,7 @@ def build_dockerimage(task: task_mod.Task,
                                         build_dir=temp_dir)
 
     dst = os.path.join(temp_dir, SKY_DOCKER_WORKDIR)
-    if task.workdir is not None:
+    if task.workdir is not None and isinstance(task.workdir, str):
         # Copy workdir contents to tempdir
         shutil.copytree(os.path.expanduser(task.workdir), dst)
     else:

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/backends/local_docker_backend.py

@@ -178,7 +178,8 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
         return handle, False
 
     def _sync_workdir(self, handle: LocalDockerResourceHandle,
-                      workdir: Path) -> None:
+                      workdir: Union[Path, Dict[str, Any]],
+                      envs_and_secrets: Dict[str, str]) -> None:
         """Workdir is sync'd by adding to the docker image.
 
         This happens in the execute step.

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/catalog/common.py

@@ -13,6 +13,7 @@ from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.clouds import cloud as cloud_lib
 from sky.skylet import constants
+from sky.utils import annotations
 from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import rich_utils
@@ -125,17 +126,21 @@ class LazyDataFrame:
 
     We don't need to load the catalog for every SkyPilot call, and this class
     allows us to load the catalog only when needed.
+
+    Use update_if_stale_func to pass in a function that decides whether to
+    update the catalog on disk, updates it if needed, and returns
+    a bool indicating whether the update was done.
     """
 
-    def __init__(self, filename: str, update_func: Callable[[], None]):
+    def __init__(self, filename: str, update_if_stale_func: Callable[[], bool]):
         self._filename = filename
         self._df: Optional['pd.DataFrame'] = None
-        self._update_func = update_func
+        self._update_if_stale_func = update_if_stale_func
 
+    @annotations.lru_cache(scope='request')
     def _load_df(self) -> 'pd.DataFrame':
-        if self._df is None:
+        if self._update_if_stale_func() or self._df is None:
             try:
-                self._update_func()
                 self._df = pd.read_csv(self._filename)
             except Exception as e:  # pylint: disable=broad-except
                 # As users can manually modify the catalog, read_csv can fail.
@@ -193,55 +198,60 @@ def read_catalog(filename: str,
         return last_update + pull_frequency_hours * 3600 < time.time()
 
     def _update_catalog():
+        # Fast path: Exit early to avoid lock contention.
+        if not _need_update():
+            return False
+
         # Atomic check, to avoid conflicts with other processes.
         with filelock.FileLock(meta_path + '.lock'):
-            if _need_update():
-                url = f'{constants.HOSTED_CATALOG_DIR_URL}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
-                url_fallback = f'{constants.HOSTED_CATALOG_DIR_URL_S3_MIRROR}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
-                headers = {'User-Agent': 'SkyPilot/0.7'}
-                update_frequency_str = ''
-                if pull_frequency_hours is not None:
-                    update_frequency_str = (
-                        f' (every {pull_frequency_hours} hours)')
-                with rich_utils.safe_status(
-                        ux_utils.spinner_message(
-                            f'Updating {cloud} catalog: {filename}') +
-                        f'{update_frequency_str}'):
-                    try:
-                        r = requests.get(url=url, headers=headers)
-                        if r.status_code == 429:
-                            # fallback to s3 mirror, github introduced rate
-                            # limit after 2025-05, see
-                            # https://github.com/skypilot-org/skypilot/issues/5438
-                            # for more details
-                            r = requests.get(url=url_fallback, headers=headers)
-                        r.raise_for_status()
-                    except requests.exceptions.RequestException as e:
-                        error_str = (f'Failed to fetch {cloud} catalog '
-                                     f'{filename}. ')
-                        if os.path.exists(catalog_path):
-                            logger.warning(
-                                f'{error_str}Using cached catalog files.')
-                            # Update catalog file modification time.
-                            os.utime(catalog_path, None)  # Sets to current time
-                        else:
-                            logger.error(
-                                f'{error_str}Please check your internet '
-                                'connection.')
-                            with ux_utils.print_exception_no_traceback():
-                                raise e
+            # Double check after acquiring the lock.
+            if not _need_update():
+                return False
+
+            url = f'{constants.HOSTED_CATALOG_DIR_URL}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
+            url_fallback = f'{constants.HOSTED_CATALOG_DIR_URL_S3_MIRROR}/{constants.CATALOG_SCHEMA_VERSION}/{filename}'  # pylint: disable=line-too-long
+            headers = {'User-Agent': 'SkyPilot/0.7'}
+            update_frequency_str = ''
+            if pull_frequency_hours is not None:
+                update_frequency_str = (
+                    f' (every {pull_frequency_hours} hours)')
+            with rich_utils.safe_status(
+                    ux_utils.spinner_message(
+                        f'Updating {cloud} catalog: {filename}') +
+                    f'{update_frequency_str}'):
+                try:
+                    r = requests.get(url=url, headers=headers)
+                    if r.status_code == 429:
+                        # fallback to s3 mirror, github introduced rate
+                        # limit after 2025-05, see
+                        # https://github.com/skypilot-org/skypilot/issues/5438
+                        # for more details
+                        r = requests.get(url=url_fallback, headers=headers)
+                    r.raise_for_status()
+                except requests.exceptions.RequestException as e:
+                    error_str = (f'Failed to fetch {cloud} catalog '
+                                 f'{filename}. ')
+                    if os.path.exists(catalog_path):
+                        logger.warning(
+                            f'{error_str}Using cached catalog files.')
+                        # Update catalog file modification time.
+                        os.utime(catalog_path, None)  # Sets to current time
                     else:
-                        # Download successful, save the catalog to a local file.
-                        os.makedirs(os.path.dirname(catalog_path),
-                                    exist_ok=True)
-                        with open(catalog_path, 'w', encoding='utf-8') as f:
-                            f.write(r.text)
-                        with open(meta_path + '.md5', 'w',
-                                  encoding='utf-8') as f:
-                            f.write(hashlib.md5(r.text.encode()).hexdigest())
-                logger.debug(f'Updated {cloud} catalog {filename}.')
-
-    return LazyDataFrame(catalog_path, update_func=_update_catalog)
+                        logger.error(f'{error_str}Please check your internet '
+                                     'connection.')
+                        with ux_utils.print_exception_no_traceback():
+                            raise e
+                else:
+                    # Download successful, save the catalog to a local file.
+                    os.makedirs(os.path.dirname(catalog_path), exist_ok=True)
+                    with open(catalog_path, 'w', encoding='utf-8') as f:
+                        f.write(r.text)
+                    with open(meta_path + '.md5', 'w', encoding='utf-8') as f:
+                        f.write(hashlib.md5(r.text.encode()).hexdigest())
+            logger.debug(f'Updated {cloud} catalog {filename}.')
+        return True
+
+    return LazyDataFrame(catalog_path, update_if_stale_func=_update_catalog)
 
 
 def _get_instance_type(

{skypilot_nightly-1.0.0.dev20250715 → skypilot_nightly-1.0.0.dev20250717}/sky/catalog/data_fetchers/fetch_gcp.py

@@ -198,6 +198,7 @@ SERIES_TO_DESCRIPTION = {
     'n1': 'N1 Predefined Instance',
     'n2': 'N2 Instance',
     'n2d': 'N2D AMD Instance',
+    'n4': 'N4 Instance',
     't2a': 'T2A Arm Instance',
     't2d': 'T2D AMD Instance',
 }

skypilot_nightly-1.0.0.dev20250717/sky/catalog/data_fetchers/fetch_nebius.py

@@ -0,0 +1,308 @@
+"""A script that queries Nebius API to get instance types and pricing info.
+
+This script takes about 1 minute to finish.
+"""
+import csv
+from dataclasses import dataclass
+import decimal
+import json
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+from sky.adaptors import nebius
+from sky.adaptors.nebius import billing
+from sky.adaptors.nebius import compute
+from sky.adaptors.nebius import iam
+from sky.adaptors.nebius import nebius_common
+
+logger = logging.getLogger(__name__)
+
+TIMEOUT = 10
+PARENT_ID_TEMPLATE = 'project-{}public-images'
+ACCELERATOR_MANUFACTURER = 'NVIDIA'
+
+
+@dataclass
+class PresetInfo:
+    """Represents information about a specific compute preset,
+    including its pricing.
+
+    Attributes:
+        region (str): The geographical region where the preset is available.
+        fullname (str): The full name of the preset, a combination of platform
+        and preset name.
+        name (str): The name of the preset.
+        platform_name (str): The name of the platform the preset belongs to.
+        gpu (int): The number of GPUs in the preset.
+        vcpu (int): The number of virtual CPUs in the preset.
+        memory_gib (int): The amount of memory in GiB in the preset.
+        accelerator_manufacturer (str | None): The manufacturer of the
+        accelerator (e.g., "NVIDIA"), or None if no accelerator.
+        accelerator_name (str | None): The name of the accelerator
+        (e.g., "H100"), or None if no accelerator.
+        price_hourly (decimal.Decimal): The hourly price of the preset.
+    """
+
+    region: str
+    fullname: str
+    name: str
+    platform_name: str
+    gpu: int
+    vcpu: int
+    memory_gib: int
+    accelerator_manufacturer: Optional[str]
+    accelerator_name: Optional[str]
+    price_hourly: decimal.Decimal
+
+
+def _format_decimal(value: decimal.Decimal) -> str:
+    """Formats a decimal value to a string with at least two decimal places,
+    removing trailing zeros and ensuring a two-digit decimal part.
+
+    Args:
+        value (decimal.Decimal): The decimal value to format.
+
+    Returns:
+        str: The formatted string representation of the decimal.
+    """
+    formatted_value = f'{value:f}'.rstrip('0').rstrip('.')
+    integer_part, decimal_part = formatted_value.split(
+        '.') if '.' in formatted_value else (formatted_value, '')
+    if len(decimal_part) < 2:
+        decimal_part += '0' * (2 - len(decimal_part))
+
+    return f'{integer_part}.{decimal_part}'
+
+
+def _estimate_platforms(platforms: List[Any], parent_id: str,
+                        region: str) -> List[PresetInfo]:
+    """Collects specifications for all presets on the given platforms to form a
+    batch price request. It then sends the request and processes the responses
+    to create a list of PresetInfo objects.
+
+    Args:
+        platforms (List[Platform]): A List of compute platforms to estimate
+        prices for.
+        parent_id (str): The parent ID used for resource metadata
+        in the estimate request.
+        region (str): The region associated with the platforms.
+
+    Returns:
+        List[PresetInfo]: A list of PresetInfo objects containing details and
+        estimated prices for each preset.
+    """
+
+    calculator_service = billing().CalculatorServiceClient(nebius.sdk())
+    futures = []
+
+    for platform in platforms:
+        platform_name = platform.metadata.name
+
+        for preset in platform.spec.presets:
+            # Form the specification for the price request
+            estimate_spec = billing().ResourceSpec(
+                compute_instance_spec=compute().CreateInstanceRequest(
+                    metadata=nebius_common().ResourceMetadata(
+                        parent_id=parent_id,),
+                    spec=compute().InstanceSpec(
+                        resources=compute().ResourcesSpec(
+                            platform=platform_name,
+                            preset=preset.name,
+                        )),
+                ))
+
+            price_request = billing().EstimateBatchRequest(
+                resource_specs=[estimate_spec])
+            # Start future for each preset
+            futures.append((
+                platform,
+                preset,
+                calculator_service.estimate_batch(price_request,
+                                                  timeout=TIMEOUT),
+            ))
+
+    # wait all futures to complete and collect results
+    result = []
+    for platform, preset, future in futures:
+        platform_name = platform.metadata.name
+        result.append(
+            PresetInfo(
+                region=region,
+                fullname=f'{platform_name}_{preset.name}',
+                name=preset.name,
+                platform_name=platform_name,
+                gpu=preset.resources.gpu_count or 0,
+                vcpu=preset.resources.vcpu_count,
+                memory_gib=preset.resources.memory_gibibytes,
+                accelerator_manufacturer=ACCELERATOR_MANUFACTURER
+                if platform_name.startswith('gpu-') else '',
+                accelerator_name=platform_name.split('-')[1].upper()
+                if platform_name.startswith('gpu-') else '',
+                price_hourly=decimal.Decimal(
+                    future.wait().hourly_cost.general.total.cost),
+            ))
+
+    return result
+
+
+def _write_preset_prices(presets: List[PresetInfo], output_file: str) -> None:
+    """Writes the provided preset information to a CSV file.
+
+    Args:
+        presets (List[PresetInfo]): A list of PresetInfo objects to write.
+        output_file (str): The path to the output CSV file.
+    """
+    # Set up the CSV writer to output to stdout
+    with open(output_file, 'w', encoding='utf-8') as out:
+        header = [
+            'InstanceType',
+            'AcceleratorName',
+            'AcceleratorCount',
+            'vCPUs',
+            'MemoryGiB',
+            'Price',
+            'Region',
+            'GpuInfo',
+            'SpotPrice',
+        ]
+        writer = csv.DictWriter(out, fieldnames=header)
+        writer.writeheader()
+
+        for preset in sorted(presets,
+                             key=lambda x:
+                             (bool(x.gpu), x.region, x.platform_name, x.vcpu)):
+            gpu_info = ''
+            if preset.gpu > 0:
+                gpu_info_dict = {
+                    'Gpus': [{
+                        'Name': preset.accelerator_name,
+                        'Manufacturer': preset.accelerator_manufacturer,
+                        'Count': preset.gpu,
+                        'MemoryInfo': {
+                            'SizeInMiB': preset.memory_gib * 1024 // preset.gpu
+                        },
+                    }],
+                    'TotalGpuMemoryInMiB': preset.memory_gib * 1024,
+                }
+                gpu_info = json.dumps(gpu_info_dict).replace('"', '\'')
+
+            writer.writerow({
+                'InstanceType': preset.fullname,
+                'AcceleratorName': preset.accelerator_name,
+                'AcceleratorCount': preset.gpu,
+                'vCPUs': preset.vcpu,
+                'MemoryGiB': preset.memory_gib,
+                'Price': _format_decimal(preset.price_hourly),
+                'Region': preset.region,
+                'GpuInfo': gpu_info,
+                'SpotPrice': '',
+            })
+
+
+def _fetch_platforms_for_project(project_id: str) -> List[Any]:
+    """Fetches all available compute platforms for a given project.
+
+    Args:
+        project_id (str): The ID of the project to fetch platforms from.
+
+    Returns:
+        List[ComputePlatform]: A list of ComputePlatform objects available
+        in the project.
+    """
+    platform_service = compute().PlatformServiceClient(nebius.sdk())
+
+    platform_request = compute().ListPlatformsRequest(page_size=999,
+                                                      parent_id=project_id)
+    platform_response = platform_service.list(platform_request,
+                                              timeout=TIMEOUT).wait()
+
+    return platform_response.items
+
+
+def _get_regions_map() -> Dict[str, str]:
+    """Maps region codes to their full names by iterating through tenants and
+     projects.
+
+    Returns:
+        dict[str, str]: A dictionary where keys are region codes (e.g., "e00")
+                        and values are full region names (e.g., "eu-north1").
+    """
+    result = {}
+    response = iam().TenantServiceClient(nebius.sdk()).list(
+        iam().ListTenantsRequest(), timeout=TIMEOUT).wait()
+
+    for tenant in response.items:
+        projects = (iam().ProjectServiceClient(nebius.sdk()).list(
+            iam().ListProjectsRequest(parent_id=tenant.metadata.id),
+            timeout=TIMEOUT).wait())
+
+        for project in projects.items:
+            match = re.match(r'^project-([a-z0-9]{3})', project.metadata.id)
+            if match is None:
+                logger.error('Could not parse project id %s',
+                             project.metadata.id)
+                continue
+            result[match.group(1)] = project.status.region
+
+    return result
+
+
+def _get_all_platform_prices() -> List[PresetInfo]:
+    """Orchestrates fetching specifications and prices for all platforms across
+     all regions.
+
+    This function first retrieves a map of region codes to full names, then
+    iterates through each region, fetches available platforms for
+    the corresponding project ID, and finally estimates prices for all presets
+    on those platforms.
+
+    Returns:
+        List[PresetInfo]: A consolidated list of PresetInfo objects for all
+                        platforms and presets across all regions.
+    """
+
+    # Get regions codes to names
+    regions_map = _get_regions_map()
+
+    presets = []
+
+    for region_code in sorted(regions_map.keys()):
+        project_id = PARENT_ID_TEMPLATE.format(region_code)
+        region = regions_map[region_code]
+        logger.info('Processing region: %s (project: %s)...', region,
+                    project_id)
+
+        platforms = _fetch_platforms_for_project(project_id)
+        if not platforms:
+            logger.warning('No platforms found in region %s', region)
+            continue
+
+        presets.extend(
+            _estimate_platforms(platforms=platforms,
+                                parent_id=project_id,
+                                region=region))
+
+    return presets
+
+
+def main() -> None:
+    """Main function to fetch and write Nebius platform prices to a CSV file.
+
+    It initializes the SDK, fetches all platform prices, and then writes them
+    to the specified CSV file.
+    """
+
+    output_file = 'nebius/vms.csv'
+
+    # Fetch presets and estimate
+    presets = _get_all_platform_prices()
+
+    # Write CSV
+    _write_preset_prices(presets, output_file)
+
+    logger.info('Done!')
+
+
+if __name__ == '__main__':
+    main()