Add latest crn version and compatible_available_gpus filters

Author: philogicae

src/aleph_client/commands/instance/__init__.py

@@ -374,7 +374,7 @@ async def create(
                 raise typer.Exit(1) from e
 
         echo("Fetching compute resource node's list...")
-        await fetch_crn_list(ipv6=False, stream_address=False)  # Precache complete unfiltered CRN list
+        await fetch_crn_list()  # Precache complete unfiltered CRN list
 
         if crn_url or crn_hash:
             try:
@@ -395,7 +395,11 @@ async def create(
 
         while not crn:
             crn_table = CRNTable(
-                only_reward_address=is_stream, only_qemu=is_qemu, only_confidentials=confidential, only_gpu=gpu
+                only_latest_crn_version=True,
+                only_reward_address=is_stream,
+                only_qemu=is_qemu,
+                only_confidentials=confidential,
+                only_gpu=gpu,
             )
             crn = await crn_table.run_async()
             if not crn:
@@ -761,7 +765,7 @@ async def _show_instances(messages: builtins.list[InstanceMessage]):
     table.add_column("Specifications", style="blue")
     table.add_column("Logs", style="blue", overflow="fold")
 
-    await fetch_crn_list()  # Precache CRN list
+    await fetch_crn_list()  # Precache complete unfiltered CRN list
     scheduler_responses = dict(await asyncio.gather(*[fetch_vm_info(message) for message in messages]))
     uninitialized_confidential_found = False
     for message in messages:

src/aleph_client/commands/instance/display.py

@@ -11,7 +11,10 @@
 from textual.widgets import DataTable, Footer, Label, ProgressBar
 from textual.widgets._data_table import RowKey
 
-from aleph_client.commands.instance.network import fetch_crn_list
+from aleph_client.commands.instance.network import (
+    fetch_crn_list,
+    fetch_latest_crn_version,
+)
 from aleph_client.commands.node import _format_score
 from aleph_client.models import CRNInfo
 
@@ -22,6 +25,7 @@ class CRNTable(App[CRNInfo]):
     table: DataTable
     tasks: set[asyncio.Task] = set()
     crns: dict[RowKey, CRNInfo] = {}
+    last_crn_version: str
     total_crns: int
     active_crns: int = 0
     filtered_crns: int = 0
@@ -50,12 +54,14 @@ class CRNTable(App[CRNInfo]):
 
     def __init__(
         self,
+        only_latest_crn_version: bool = False,
         only_reward_address: bool = False,
         only_qemu: bool = False,
         only_confidentials: bool = False,
         only_gpu: bool = False,
     ):
         super().__init__()
+        self.only_latest_crn_version = only_latest_crn_version
         self.only_reward_address = only_reward_address
         self.only_qemu = only_qemu
         self.only_confidentials = only_confidentials
@@ -94,8 +100,8 @@ async def on_mount(self):
         task.add_done_callback(self.tasks.discard)
 
     async def fetch_node_list(self):
-        crn_list: list[CRNInfo] = await fetch_crn_list(ipv6=False, stream_address=False)
-        self.crns: dict[RowKey, CRNInfo] = {RowKey(crn.hash): crn for crn in crn_list}
+        self.crns: dict[RowKey, CRNInfo] = {RowKey(crn.hash): crn for crn in await fetch_crn_list()}
+        self.last_crn_version = await fetch_latest_crn_version()
 
         # Initialize the progress bar
         self.total_crns = len(self.crns)
@@ -112,6 +118,10 @@ async def fetch_node_list(self):
 
     async def add_crn_info(self, crn: CRNInfo):
         self.active_crns += 1
+        # Skip CRNs with legacy version
+        if self.only_latest_crn_version and crn.version < self.last_crn_version:
+            logger.debug(f"Skipping CRN {crn.hash}, legacy version")
+            return
         # Skip CRNs without machine usage
         if not crn.machine_usage:
             logger.debug(f"Skipping CRN {crn.hash}, no machine usage")
@@ -133,11 +143,7 @@ async def add_crn_info(self, crn: CRNInfo):
             logger.debug(f"Skipping CRN {crn.hash}, no confidential support")
             return
         # Skip non-gpu CRNs if only-gpu is set
-        if (
-            self.only_gpu
-            and not crn.gpu_support
-            and not (crn.machine_usage.gpu and len(crn.machine_usage.gpu.available_devices) < 1)
-        ):
+        if self.only_gpu and not (crn.gpu_support and crn.compatible_available_gpus):
             logger.debug(f"Skipping CRN {crn.hash}, no GPU support or without GPU available")
             return
         self.filtered_crns += 1

src/aleph_client/commands/instance/network.py

@@ -32,8 +32,11 @@
 
 logger = logging.getLogger(__name__)
 
+latest_crn_version_link = "https://api.github.com/repos/aleph-im/aleph-vm/releases/latest"
+
 settings_link = (
-    f"{sanitize_url(settings.API_HOST)}/api/v0/aggregates/0xFba561a84A537fCaa567bb7A2257e7142701ae2A.json?keys=settings"
+    f"{sanitize_url(settings.API_HOST)}/api/v0/"
+    "aggregates/0xFba561a84A537fCaa567bb7A2257e7142701ae2A.json?keys=settings"
 )
 
 crn_list_link = (
@@ -83,33 +86,58 @@ async def call_program_crn_list() -> Optional[dict]:
     raise Exception(error)
 
 
+@async_lru_cache
+async def fetch_latest_crn_version() -> str:
+    """Fetch the latest crn version.
+
+    Returns:
+        str: Latest crn version as x.x.x.
+    """
+
+    async with ClientSession() as session:
+        try:
+            data = await fetch_json(session, latest_crn_version_link)
+            return data.get("tag_name")
+        except Exception as e:
+            logger.error(f"Error while fetching latest crn version: {e}")
+            raise Exit(code=1) from e
+
+
 @async_lru_cache
 async def fetch_crn_list(
-    ipv6: bool = True, stream_address: bool = True, confidential: Optional[bool] = None, gpu: Optional[bool] = None
+    latest_crn_version: bool = False,
+    ipv6: bool = False,
+    stream_address: bool = False,
+    confidential: bool = False,
+    gpu: bool = False,
 ) -> list[CRNInfo]:
-    """Fetch compute resource node list.
+    """Fetch compute resource node list, unfiltered by default.
 
     Args:
+        latest_crn_version (bool): Filter by latest crn version.
         ipv6 (bool): Filter invalid IPv6 configuration.
         stream_address (bool): Filter invalid payment receiver address.
-        confidential (Optional[bool]): Filter by confidential computing support.
-        gpu (Optional[bool]): Filter by GPU support.
+        confidential (bool): Filter by confidential computing support.
+        gpu (bool): Filter by GPU support.
     Returns:
         list[CRNInfo]: List of compute resource nodes.
     """
 
     data = await call_program_crn_list()
+    last_crn_version = await fetch_latest_crn_version()
     crns = []
     for crn in data.get("crns"):
+        if latest_crn_version and crn.get("version") >= last_crn_version:
+            continue
         if ipv6:
             ipv6_check = crn.get("ipv6_check")
             if not ipv6_check or not all(ipv6_check.values()):
                 continue
         if stream_address and not crn.get("payment_receiver_address"):
             continue
-        if confidential is not None and confidential != bool(crn.get("confidential_support")):
+        if confidential and not crn.get("confidential_support"):
             continue
-        if gpu is not None and gpu != bool(crn.get("gpu_support")):
+        if gpu and not (crn.get("gpu_support") and crn.get("compatible_available_gpus")):
             continue
         try:
             crns.append(CRNInfo.from_unsanitized_input(crn))

src/aleph_client/models.py

@@ -55,10 +55,12 @@ class MachineProperties(BaseModel):
 
 class GpuDevice(BaseModel):
     vendor: str
+    model: str
     device_name: str
     device_class: GpuDeviceClass
     pci_host: str
     device_id: str
+    compatible: bool
 
 
 class GPUProperties(BaseModel):

tests/unit/test_instance.py

@@ -63,10 +63,12 @@
 def dummy_gpu_device() -> GpuDevice:
     return GpuDevice(
         vendor="NVIDIA",
+        model="RTX 4090",
         device_name="RTX 4090",
         device_class=GpuDeviceClass.VGA_COMPATIBLE_CONTROLLER,
         pci_host="01:00.0",
         device_id="abcd:1234",
+        compatible=True,
     )
 
 
@@ -228,6 +230,10 @@ def create_mock_validate_ssh_pubkey_file():
     )
 
 
+def mock_fetch_latest_crn_version():
+    return AsyncMock(return_value="v420.69")
+
+
 def create_mock_fetch_crn_info():
     mock_machine_info = dummy_machine_info()
     return AsyncMock(
@@ -248,7 +254,7 @@ def create_mock_fetch_crn_info():
             confidential_computing=True,
             gpu_support=True,
             terms_and_conditions=FAKE_STORE_HASH,
-            compatible_available_gpus=[],
+            compatible_available_gpus=[dummy_gpu_device()],
         )
     )
 
@@ -456,6 +462,7 @@ async def test_create_instance(args, expected):
     @patch("aleph_client.commands.instance.get_balance", mock_get_balance)
     @patch("aleph_client.commands.instance.AlephHttpClient", mock_client_class)
     @patch("aleph_client.commands.instance.AuthenticatedAlephHttpClient", mock_auth_client_class)
+    @patch("aleph_client.commands.instance.network.fetch_latest_crn_version", mock_fetch_latest_crn_version())
     @patch("aleph_client.commands.instance.fetch_crn_info", mock_fetch_crn_info)
     @patch("aleph_client.commands.instance.validated_int_prompt", mock_validated_int_prompt)
     @patch("aleph_client.commands.instance.wait_for_processed_instance", mock_wait_for_processed_instance)
@@ -518,6 +525,7 @@ async def test_list_instances():
     )
 
     @patch("aleph_client.commands.instance._load_account", mock_load_account)
+    @patch("aleph_client.commands.instance.network.fetch_latest_crn_version", mock_fetch_latest_crn_version())
     @patch("aleph_client.commands.files.AlephHttpClient", mock_client_class)
     @patch("aleph_client.commands.instance.AlephHttpClient", mock_auth_client_class)
     @patch("aleph_client.commands.instance.filter_only_valid_messages", mock_instance_messages)