RunPod: add CPU offer collection in gpuhunt (#225)

* runpod: add CPU offers to gpuhunt catalog

* runpod: gate CPU offers with runpod-cpu flag

* runpod: require cpu disk limit and strengthen cpu checks

- require diskLimitPerVcpu for CPU offers and set disk_size unconditionally
- add CPU integrity assertions for runpod catalog rows
- extend provider tests for CPU flag/spot/location invariants

---------

Co-authored-by: Andrey Cheptsov <andrey.cheptsov@github.com>

Author: peterschmidt85

src/gpuhunt/providers/runpod.py

@@ -68,6 +68,8 @@ def _fetch_offers(self) -> list[RawCatalogItem]:
 
         cluster_catalog_items = self._fetch_cluster_offers()
         catalog_items.extend(cluster_catalog_items)
+        cpu_catalog_items = self._fetch_cpu_offers()
+        catalog_items.extend(cpu_catalog_items)
         return catalog_items
 
     def _build_query_variables(self) -> list[dict]:
@@ -221,6 +223,89 @@ def _fetch_cluster_offers(self) -> list[RawCatalogItem]:
                 cluster_catalog_items.append(catalog_item)
         return cluster_catalog_items
 
+    def _fetch_cpu_offers(self) -> list[RawCatalogItem]:
+        response = _make_request({"query": cpu_data_centers_query, "variables": {}})
+        data_centers = [dc["id"] for dc in response["data"]["dataCenters"] if dc["listed"]]
+        if len(data_centers) == 0:
+            return []
+
+        cpu_flavors_by_data_center: dict[str, list[dict]] = {}
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            future_to_data_center = {
+                executor.submit(self._get_cpu_flavors, dc_id): dc_id for dc_id in data_centers
+            }
+            for future, dc_id in future_to_data_center.items():
+                try:
+                    cpu_flavors_by_data_center[dc_id] = future.result()
+                except RequestException as e:
+                    logger.exception("Failed to get cpuFlavors data for %s: %s", dc_id, e)
+
+        catalog_items = []
+        for dc_id in data_centers:
+            cpu_flavors = cpu_flavors_by_data_center.get(dc_id)
+            if cpu_flavors is None:
+                continue
+            catalog_items.extend(self._make_cpu_catalog_items(dc_id, cpu_flavors))
+        return catalog_items
+
+    def _get_cpu_flavors(self, data_center_id: str) -> list[dict]:
+        response = _make_request(
+            {"query": query_cpu_flavors, "variables": {"dataCenterId": data_center_id}}
+        )
+        return response["data"]["cpuFlavors"]
+
+    def _make_cpu_catalog_items(
+        self, data_center_id: str, cpu_flavors: list[dict]
+    ) -> list[RawCatalogItem]:
+        items: list[RawCatalogItem] = []
+        for flavor in cpu_flavors:
+            specifics = flavor.get("specifics") or {}
+            if specifics.get("stockStatus") is None:
+                continue
+            base_secure_price = specifics.get("securePrice")
+            if base_secure_price is None:
+                continue
+
+            min_vcpu = flavor.get("minVcpu")
+            max_vcpu = flavor.get("maxVcpu")
+            ram_multiplier = flavor.get("ramMultiplier")
+            disk_limit_per_vcpu = flavor.get("diskLimitPerVcpu")
+            if (
+                min_vcpu is None
+                or max_vcpu is None
+                or ram_multiplier is None
+                or disk_limit_per_vcpu is None
+            ):
+                continue
+            if min_vcpu <= 0 or max_vcpu <= 0 or min_vcpu > max_vcpu:
+                continue
+            if int(disk_limit_per_vcpu) <= 0:
+                continue
+
+            for vcpu in _cpu_size_ladder(int(min_vcpu), int(max_vcpu)):
+                # `ramMultiplier` maps vCPU to RAM in GB.
+                memory = int(vcpu * int(ram_multiplier))
+                disk_size = float(vcpu * int(disk_limit_per_vcpu))
+                scale = vcpu / min_vcpu
+                price = base_secure_price * scale
+                items.append(
+                    RawCatalogItem(
+                        instance_name=f"{flavor['id']}-{vcpu}-{memory}",
+                        location=data_center_id,
+                        price=price,
+                        cpu=vcpu,
+                        memory=memory,
+                        gpu_count=0,
+                        gpu_name=None,
+                        gpu_memory=None,
+                        spot=False,
+                        disk_size=disk_size,
+                        flags=["runpod-cpu"],
+                        provider_data={},
+                    )
+                )
+        return items
+
     def _get_gpu_vendor_and_name(
         self,
         gpu_id: str,
@@ -286,6 +371,45 @@ def _get_amd_gpu_name(name: str) -> Optional[str]:
     return None
 
 
+def _cpu_size_ladder(min_vcpu: int, max_vcpu: int) -> list[int]:
+    sizes = []
+    current = min_vcpu
+    while current <= max_vcpu:
+        sizes.append(current)
+        current *= 2
+    if sizes and sizes[-1] != max_vcpu:
+        sizes.append(max_vcpu)
+    return sorted(set(sizes))
+
+
+cpu_data_centers_query = """
+query CpuDataCenters {
+  dataCenters {
+    id
+    listed
+  }
+}
+"""
+
+query_cpu_flavors = """
+query CpuFlavors($dataCenterId: String!) {
+  cpuFlavors {
+    id
+    displayName
+    groupId
+    minVcpu
+    maxVcpu
+    ramMultiplier
+    diskLimitPerVcpu
+    specifics(input: { dataCenterId: $dataCenterId }) {
+      stockStatus
+      securePrice
+    }
+  }
+}
+"""
+
+
 gpu_types_query = """
 query GpuTypes {
   countryCodes

src/integrity_tests/test_runpod.py

@@ -58,3 +58,11 @@ def test_gpu_present(data_rows):
     refs = set(name for _, name in get_gpu_map().values())
     gpus = set(select_row(data_rows, "gpu_name"))
     assert len(refs & gpus) > 7
+
+
+def test_cpu_offers_integrity(data_rows):
+    cpu_rows = [row for row in data_rows if row["gpu_count"] == "0"]
+    assert len(cpu_rows) > 0
+    assert all("runpod-cpu" in row["flags"].split(",") for row in cpu_rows)
+    assert all(row["spot"] == "False" for row in cpu_rows)
+    assert all("-" in row["location"] for row in cpu_rows)

src/tests/providers/test_runpod.py

@@ -0,0 +1,209 @@
+import pytest
+from requests import RequestException
+
+from gpuhunt._internal.models import RawCatalogItem
+from gpuhunt.providers import runpod as runpod_module
+from gpuhunt.providers.runpod import RunpodProvider, _cpu_size_ladder
+
+
+def test_cpu_size_ladder():
+    assert _cpu_size_ladder(2, 32) == [2, 4, 8, 16, 32]
+    assert _cpu_size_ladder(3, 20) == [3, 6, 12, 20]
+
+
+def test_make_cpu_catalog_items():
+    provider = object.__new__(RunpodProvider)
+    cpu_flavors = [
+        {
+            "id": "cpu3g",
+            "minVcpu": 2,
+            "maxVcpu": 32,
+            "ramMultiplier": 4,
+            "diskLimitPerVcpu": 10,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": 0.08,
+                "slsPrice": 0.1,
+            },
+        }
+    ]
+
+    items = provider._make_cpu_catalog_items("AP-JP-1", cpu_flavors)
+
+    assert [item.instance_name for item in items] == [
+        "cpu3g-2-8",
+        "cpu3g-4-16",
+        "cpu3g-8-32",
+        "cpu3g-16-64",
+        "cpu3g-32-128",
+    ]
+    assert [item.cpu for item in items] == [2, 4, 8, 16, 32]
+    assert [item.memory for item in items] == [8, 16, 32, 64, 128]
+    assert [item.location for item in items] == ["AP-JP-1"] * 5
+    assert [item.spot for item in items] == [False] * 5
+    assert [item.gpu_count for item in items] == [0] * 5
+    assert [item.flags for item in items] == [["runpod-cpu"]] * 5
+    assert [item.disk_size for item in items] == [20.0, 40.0, 80.0, 160.0, 320.0]
+    assert items[0].price == pytest.approx(0.08)
+    assert items[-1].price == pytest.approx(1.28)
+    assert items[0].provider_data == {}
+    assert items[-1].provider_data == {}
+
+
+def test_make_cpu_catalog_items_skips_invalid_flavors():
+    provider = object.__new__(RunpodProvider)
+    cpu_flavors = [
+        {
+            "id": "cpu3c",
+            "minVcpu": 2,
+            "maxVcpu": 32,
+            "ramMultiplier": 2,
+            "diskLimitPerVcpu": 10,
+            "specifics": {
+                "stockStatus": None,
+                "securePrice": 0.06,
+                "slsPrice": 0.072,
+            },
+        },
+        {
+            "id": "cpu3m",
+            "minVcpu": 2,
+            "maxVcpu": 32,
+            "ramMultiplier": 8,
+            "diskLimitPerVcpu": 10,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": None,
+                "slsPrice": 0,
+            },
+        },
+        {
+            "id": "cpu5c",
+            "minVcpu": None,
+            "maxVcpu": 32,
+            "ramMultiplier": 2,
+            "diskLimitPerVcpu": 15,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": 0.07,
+                "slsPrice": 0.084,
+            },
+        },
+        {
+            "id": "cpu5m",
+            "minVcpu": 16,
+            "maxVcpu": 8,
+            "ramMultiplier": 8,
+            "diskLimitPerVcpu": 10,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": 0.13,
+                "slsPrice": 0,
+            },
+        },
+        {
+            "id": "cpu5g",
+            "minVcpu": 2,
+            "maxVcpu": 32,
+            "ramMultiplier": 4,
+            "diskLimitPerVcpu": None,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": 0.08,
+                "slsPrice": 0.1,
+            },
+        },
+        {
+            "id": "cpu5x",
+            "minVcpu": 2,
+            "maxVcpu": 32,
+            "ramMultiplier": 4,
+            "diskLimitPerVcpu": 0,
+            "specifics": {
+                "stockStatus": "High",
+                "securePrice": 0.08,
+                "slsPrice": 0.1,
+            },
+        },
+    ]
+
+    assert provider._make_cpu_catalog_items("AP-JP-1", cpu_flavors) == []
+
+
+def test_fetch_cpu_offers_handles_partial_datacenter_failures(monkeypatch):
+    provider = object.__new__(RunpodProvider)
+
+    def fake_make_request(payload):
+        assert payload["query"] == runpod_module.cpu_data_centers_query
+        return {
+            "data": {
+                "dataCenters": [
+                    {"id": "US-IL-1", "listed": True},
+                    {"id": "AP-JP-1", "listed": True},
+                    {"id": "DC-SKIP", "listed": False},
+                ]
+            }
+        }
+
+    def fake_get_cpu_flavors(dc_id: str):
+        if dc_id == "US-IL-1":
+            raise RequestException("boom")
+        return [
+            {
+                "id": "cpu3c",
+                "minVcpu": 2,
+                "maxVcpu": 32,
+                "ramMultiplier": 2,
+                "diskLimitPerVcpu": 10,
+                "specifics": {
+                    "stockStatus": "High",
+                    "securePrice": 0.06,
+                    "slsPrice": 0.072,
+                },
+            }
+        ]
+
+    monkeypatch.setattr(runpod_module, "_make_request", fake_make_request)
+    monkeypatch.setattr(provider, "_get_cpu_flavors", fake_get_cpu_flavors)
+
+    items = provider._fetch_cpu_offers()
+
+    assert len(items) == 5
+    assert {item.location for item in items} == {"AP-JP-1"}
+    assert all("-" in item.location for item in items)
+    assert all(item.spot is False for item in items)
+    assert {tuple(item.flags) for item in items} == {("runpod-cpu",)}
+    assert {item.disk_size for item in items} == {20.0, 40.0, 80.0, 160.0, 320.0}
+    assert {item.instance_name for item in items} == {
+        "cpu3c-2-4",
+        "cpu3c-4-8",
+        "cpu3c-8-16",
+        "cpu3c-16-32",
+        "cpu3c-32-64",
+    }
+
+
+def test_fetch_offers_appends_cpu_items(monkeypatch):
+    provider = object.__new__(RunpodProvider)
+    cpu_item = RawCatalogItem(
+        instance_name="cpu3g-2-8",
+        location="AP-JP-1",
+        price=0.08,
+        cpu=2,
+        memory=8,
+        gpu_count=0,
+        gpu_name=None,
+        gpu_memory=None,
+        spot=False,
+        disk_size=20.0,
+        flags=["runpod-cpu"],
+        provider_data={},
+    )
+
+    monkeypatch.setattr(provider, "_build_query_variables", lambda: [])
+    monkeypatch.setattr(provider, "_fetch_cluster_offers", lambda: [])
+    monkeypatch.setattr(provider, "_fetch_cpu_offers", lambda: [cpu_item])
+
+    offers = provider._fetch_offers()
+
+    assert offers == [cpu_item]