fix(sudo): show single numbered hyperparameter table in interactive sudo set

Interactive `btcli sudo set` printed the full hyperparameter values table
and then a second picker table repeating names and descriptions. The values
table now carries the selection numbers itself, with settable registry
params absent from the chain response (e.g. alpha_values) appended so
nothing previously selectable is lost.

Author: wouterharinghuizen

bittensor_cli/cli.py

@@ -42,7 +42,6 @@
     COLORS,
     HYPERPARAMS,
     HYPERPARAMS_METADATA,
-    RootSudoOnly,
     WalletOptions,
 )
 from bittensor_cli.src.bittensor import utils
@@ -7304,12 +7303,17 @@ def sudo_set(
         self.verbosity_handler(quiet, verbose, json_output, prompt, decline)
         proxy = self.is_valid_proxy_name_or_ss58(proxy, False)
 
+        param_names: list[str] = []
         if not param_name or not param_value:
-            hyperparams = self._run_command(
-                sudo.get_hyperparameters(self.initialize_chain(network), netuid),
+            success, param_names = self._run_command(
+                sudo.get_hyperparameters(
+                    self.initialize_chain(network),
+                    netuid,
+                    numbered=not param_name,
+                ),
                 exit_early=False,
-            )
-            if not hyperparams:
+            ) or (False, [])
+            if not success:
                 # Ensure we don't leave the websocket connection hanging.
                 if self.subtensor:
                     try:
@@ -7328,49 +7332,13 @@ def sudo_set(
                     "Param name not supplied with `--no-prompt` flag. Cannot continue"
                 )
                 return False
-            hyperparam_list = sorted(HYPERPARAMS.keys())
-            console.print("Available hyperparameters:\n")
-
-            # Create a table to show hyperparameters with descriptions
-            param_table = Table(
-                Column("[white]#", style="dim", width=4),
-                Column("[white]HYPERPARAMETER", style=COLORS.SU.HYPERPARAMETER),
-                Column("[white]OWNER SETTABLE", style="bright_cyan", width=18),
-                Column("[white]DESCRIPTION", style="dim", overflow="fold"),
-                box=box.SIMPLE,
-                show_edge=False,
-                pad_edge=False,
-            )
-
-            for idx, param in enumerate(hyperparam_list, start=1):
-                metadata = HYPERPARAMS_METADATA.get(param, {})
-                description = metadata.get("description", "No description available.")
-
-                # Check ownership from HYPERPARAMS
-                _, root_sudo = HYPERPARAMS.get(param, ("", RootSudoOnly.FALSE))
-                if root_sudo == RootSudoOnly.TRUE:
-                    owner_settable_str = "[red]No (Root Only)[/red]"
-                elif root_sudo == RootSudoOnly.COMPLICATED:
-                    owner_settable_str = "[yellow]COMPLICATED[/yellow]"
-                else:
-                    owner_settable_str = "[green]Yes[/green]"
-
-                param_table.add_row(
-                    str(idx),
-                    f"[bold]{param}[/bold]",
-                    owner_settable_str,
-                    description,
-                )
-
-            console.print(param_table)
             console.print()
-
             choice = IntPrompt.ask(
                 "Enter the [bold]number[/bold] of the hyperparameter",
-                choices=[str(i) for i in range(1, len(hyperparam_list) + 1)],
+                choices=[str(i) for i in range(1, len(param_names) + 1)],
                 show_choices=False,
             )
-            param_name = hyperparam_list[choice - 1]
+            param_name = param_names[choice - 1]
 
             # Show additional info for selected parameter
             metadata = HYPERPARAMS_METADATA.get(param_name, {})
@@ -7561,11 +7529,12 @@ def sudo_get(
         [green]$[/green] btcli sudo get --netuid 1
         """
         self.verbosity_handler(quiet, verbose, json_output, False)
-        return self._run_command(
+        success, _ = self._run_command(
             sudo.get_hyperparameters(
                 self.initialize_chain(network), netuid, json_output
             )
-        )
+        ) or (False, [])
+        return success
 
     def sudo_senate(
         self,

bittensor_cli/src/commands/sudo.py

@@ -1143,8 +1143,16 @@ async def get_hyperparameters(
     netuid: int,
     json_output: bool = False,
     show_descriptions: bool = True,
-) -> bool:
-    """View hyperparameters of a subnetwork."""
+    numbered: bool = False,
+) -> tuple[bool, list[str]]:
+    """View hyperparameters of a subnetwork.
+
+    When `numbered` is True, each row is prefixed with a selection number and
+    settable hyperparameters not reported by the chain (e.g. alpha_values) are
+    appended, so callers can prompt the user to pick a row from this table.
+
+    Returns (success, hyperparameter names in display order).
+    """
     print_verbose("Fetching hyperparameters")
     try:
         if not await subtensor.subnet_exists(netuid):
@@ -1153,7 +1161,7 @@ async def get_hyperparameters(
                 json_console.print_json(data={"error": error_msg})
             else:
                 print_error(error_msg)
-            return False
+            return False, []
         subnet, subnet_info = await asyncio.gather(
             subtensor.get_subnet_hyperparameters(netuid), subtensor.subnet(netuid)
         )
@@ -1163,19 +1171,22 @@ async def get_hyperparameters(
                 json_console.print_json(data={"error": error_msg})
             else:
                 print_error(error_msg)
-            return False
+            return False, []
     except Exception as e:
         if json_output:
             json_console.print_json(data={"error": str(e)})
         else:
             raise
-        return False
+        return False, []
 
     # Determine if we should show extended info (descriptions, ownership)
     show_extended = show_descriptions and not json_output
+    numbered = numbered and show_extended
 
     if show_extended:
+        columns = [Column("[white]#", style="dim")] if numbered else []
         table = Table(
+            *columns,
             Column("[white]HYPERPARAMETER", style=COLOR_PALETTE.SU.HYPERPARAMETER),
             Column("[white]VALUE", style=COLOR_PALETTE.SU.VALUE),
             Column("[white]NORMALIZED", style=COLOR_PALETTE.SU.NORMAL),
@@ -1209,10 +1220,19 @@ async def get_hyperparameters(
             show_edge=True,
         )
     dict_out = []
+    param_names = []
 
     normalized_values = normalize_hyperparameters(subnet, json_output=json_output)
     sorted_values = sorted(normalized_values, key=lambda x: x[0])
+    if numbered:
+        # Keep settable hyperparameters absent from the chain response (e.g.
+        # alpha_values) selectable from this single table.
+        displayed = {param for param, _, _ in sorted_values}
+        sorted_values += [
+            (param, "-", "-") for param in sorted(set(HYPERPARAMS) - displayed)
+        ]
     for param, value, norm_value in sorted_values:
+        param_names.append(param)
         if not json_output:
             if show_extended:
                 # Get metadata for this hyperparameter
@@ -1236,13 +1256,16 @@ async def get_hyperparameters(
                 else:
                     description_with_link = description
 
-                table.add_row(
+                row = [
                     "  " + param,
                     value,
                     norm_value,
                     owner_settable_str,
                     description_with_link,
-                )
+                ]
+                if numbered:
+                    row.insert(0, str(len(param_names)))
+                table.add_row(*row)
             else:
                 table.add_row("  " + param, value, norm_value)
         else:
@@ -1272,7 +1295,7 @@ async def get_hyperparameters(
         json_str = json.dumps(dict_out, ensure_ascii=True)
         sys.stdout.write(json_str + "\n")
         sys.stdout.flush()
-        return True
+        return True, param_names
     else:
         console.print(table)
         if show_extended:
@@ -1295,7 +1318,7 @@ async def get_hyperparameters(
             console.print(
                 "[dim]📚 For detailed documentation, visit: [link]https://docs.bittensor.com[/link]"
             )
-    return True
+    return True, param_names
 
 
 async def get_senate(

tests/unit_tests/test_sudo_get_hyperparameters.py

@@ -0,0 +1,74 @@
+"""
+Unit tests for sudo.get_hyperparameters.
+
+Covers the (success, hyperparameter names) return contract and the `numbered`
+selection mode used by the interactive `btcli sudo set` flow, which renders a
+single table instead of a separate picker table.
+"""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+from bittensor_cli.src import HYPERPARAMS
+from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
+from bittensor_cli.src.commands.sudo import get_hyperparameters
+
+CHAIN_PARAMS = {"immunity_period": 65535, "kappa": 32767, "tempo": 360}
+
+
+def _prepare_subtensor(mock_subtensor) -> MagicMock:
+    subnet_info = MagicMock()
+    subnet_info.subnet_name = "test_subnet"
+    mock_subtensor.get_subnet_hyperparameters = AsyncMock(
+        return_value=SubnetHyperparameters(hyperparameters=dict(CHAIN_PARAMS))
+    )
+    mock_subtensor.subnet = AsyncMock(return_value=subnet_info)
+    return mock_subtensor
+
+
+@pytest.mark.asyncio
+async def test_returns_chain_params_in_display_order(mock_subtensor):
+    subtensor = _prepare_subtensor(mock_subtensor)
+
+    success, param_names = await get_hyperparameters(subtensor, netuid=18)
+
+    assert success is True
+    assert param_names == sorted(CHAIN_PARAMS)
+
+
+@pytest.mark.asyncio
+async def test_numbered_appends_registry_only_params(mock_subtensor):
+    subtensor = _prepare_subtensor(mock_subtensor)
+
+    success, param_names = await get_hyperparameters(
+        subtensor, netuid=18, numbered=True
+    )
+
+    registry_only = sorted(set(HYPERPARAMS) - set(CHAIN_PARAMS))
+    assert success is True
+    assert param_names == sorted(CHAIN_PARAMS) + registry_only
+    assert "alpha_values" in param_names
+    assert len(param_names) == len(set(param_names))
+
+
+@pytest.mark.asyncio
+async def test_numbered_has_no_effect_on_json_output(mock_subtensor, capsys):
+    subtensor = _prepare_subtensor(mock_subtensor)
+
+    success, param_names = await get_hyperparameters(
+        subtensor, netuid=18, json_output=True, numbered=True
+    )
+
+    assert success is True
+    assert param_names == sorted(CHAIN_PARAMS)
+    assert "alpha_values" not in capsys.readouterr().out
+
+
+@pytest.mark.asyncio
+async def test_nonexistent_subnet_returns_failure(mock_subtensor):
+    mock_subtensor.subnet_exists = AsyncMock(return_value=False)
+
+    success, param_names = await get_hyperparameters(mock_subtensor, netuid=999)
+
+    assert success is False
+    assert param_names == []