bittensor-cli 9.0.0rc4__py3-none-any.whl → 9.0.2__py3-none-any.whl

bittensor_cli/src/commands/sudo.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Union, Optional
 
 import typer
 from bittensor_wallet import Wallet
-from bittensor_wallet.errors import KeyFileError
 from rich import box
 from rich.table import Column, Table
 from rich.prompt import Confirm
@@ -17,6 +16,10 @@ from bittensor_cli.src.bittensor.utils import (
     print_error,
     print_verbose,
     normalize_hyperparameters,
+    unlock_key,
+    blocks_to_duration,
+    float_to_u64,
+    float_to_u16,
 )
 
 if TYPE_CHECKING:
@@ -69,12 +72,76 @@ def allowed_value(
     return True, value
 
 
+def search_metadata(
+    param_name: str, value: Union[str, bool, float, list[float]], netuid: int, metadata
+) -> tuple[bool, Optional[dict]]:
+    """
+    Searches the substrate metadata AdminUtils pallet for a given parameter name. Crafts a response dict to be used
+        as call parameters for setting this hyperparameter.
+
+    Args:
+        param_name: the name of the hyperparameter
+        value: the value to set the hyperparameter
+        netuid: the specified netuid
+        metadata: the subtensor.substrate.metadata
+
+    Returns:
+        (success, dict of call params)
+
+    """
+
+    def string_to_bool(val) -> bool:
+        try:
+            return {"true": True, "1": True, "0": False, "false": False}[val.lower()]
+        except KeyError:
+            return ValueError
+
+    def type_converter_with_retry(type_, val, arg_name):
+        try:
+            if val is None:
+                val = input(
+                    f"Enter a value for field '{arg_name}' with type '{arg_type_output[type_]}': "
+                )
+            return arg_types[type_](val)
+        except ValueError:
+            return type_converter_with_retry(type_, None, arg_name)
+
+    arg_types = {"bool": string_to_bool, "u16": float_to_u16, "u64": float_to_u64}
+    arg_type_output = {"bool": "bool", "u16": "float", "u64": "float"}
+
+    call_crafter = {"netuid": netuid}
+
+    for pallet in metadata.pallets:
+        if pallet.name == "AdminUtils":
+            for call in pallet.calls:
+                if call.name == param_name:
+                    if "netuid" not in [x.name for x in call.args]:
+                        return False, None
+                    call_args = [
+                        arg for arg in call.args if arg.value["name"] != "netuid"
+                    ]
+                    if len(call_args) == 1:
+                        arg = call_args[0].value
+                        call_crafter[arg["name"]] = type_converter_with_retry(
+                            arg["typeName"], value, arg["name"]
+                        )
+                    else:
+                        for arg_ in call_args:
+                            arg = arg_.value
+                            call_crafter[arg["name"]] = type_converter_with_retry(
+                                arg["typeName"], None, arg["name"]
+                            )
+                    return True, call_crafter
+    else:
+        return False, None
+
+
 async def set_hyperparameter_extrinsic(
     subtensor: "SubtensorInterface",
     wallet: "Wallet",
     netuid: int,
     parameter: str,
-    value: Union[str, bool, float, list[float]],
+    value: Optional[Union[str, bool, float, list[float]]],
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
 ) -> bool:
@@ -106,68 +173,90 @@ async def set_hyperparameter_extrinsic(
         )
         return False
 
-    try:
-        wallet.unlock_coldkey()
-    except KeyFileError:
-        err_console.print("Error decrypting coldkey (possibly incorrect password)")
+    if not unlock_key(wallet).success:
         return False
 
-    extrinsic = HYPERPARAMS.get(parameter)
-    if extrinsic is None:
-        err_console.print(":cross_mark: [red]Invalid hyperparameter specified.[/red]")
-        return False
+    arbitrary_extrinsic = False
 
+    extrinsic, sudo_ = HYPERPARAMS.get(parameter, ("", False))
+    if not extrinsic:
+        arbitrary_extrinsic, call_params = search_metadata(
+            parameter, value, netuid, subtensor.substrate.metadata
+        )
+        extrinsic = parameter
+        if not arbitrary_extrinsic:
+            err_console.print(
+                ":cross_mark: [red]Invalid hyperparameter specified.[/red]"
+            )
+            return False
+
+    substrate = subtensor.substrate
+    msg_value = value if not arbitrary_extrinsic else call_params
     with console.status(
-        f":satellite: Setting hyperparameter [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{parameter}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] to [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{value}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] on subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] ...",
+        f":satellite: Setting hyperparameter [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{parameter}"
+        f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] to [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{msg_value}"
+        f"[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] on subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
+        f"{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] ...",
         spinner="earth",
     ):
-        substrate = subtensor.substrate
-        extrinsic_params = await substrate.get_metadata_call_function(
-            "AdminUtils", extrinsic
-        )
-        call_params: dict[str, Union[str, bool, float]] = {"netuid": netuid}
-
-        # if input value is a list, iterate through the list and assign values
-        if isinstance(value, list):
-            # Ensure that there are enough values for all non-netuid parameters
-            non_netuid_fields = [
-                param["name"]
-                for param in extrinsic_params["fields"]
-                if "netuid" not in param["name"]
-            ]
-
-            if len(value) < len(non_netuid_fields):
-                raise ValueError(
-                    "Not enough values provided in the list for all parameters"
-                )
-
-            call_params.update(
-                {str(name): val for name, val in zip(non_netuid_fields, value)}
+        if not arbitrary_extrinsic:
+            extrinsic_params = await substrate.get_metadata_call_function(
+                "AdminUtils", extrinsic
             )
+            call_params = {"netuid": netuid}
+
+            # if input value is a list, iterate through the list and assign values
+            if isinstance(value, list):
+                # Ensure that there are enough values for all non-netuid parameters
+                non_netuid_fields = [
+                    param["name"]
+                    for param in extrinsic_params["fields"]
+                    if "netuid" not in param["name"]
+                ]
+
+                if len(value) < len(non_netuid_fields):
+                    raise ValueError(
+                        "Not enough values provided in the list for all parameters"
+                    )
 
-        else:
-            value_argument = extrinsic_params["fields"][
-                len(extrinsic_params["fields"]) - 1
-            ]
-            call_params[str(value_argument["name"])] = value
+                call_params.update(
+                    {str(name): val for name, val in zip(non_netuid_fields, value)}
+                )
+
+            else:
+                value_argument = extrinsic_params["fields"][
+                    len(extrinsic_params["fields"]) - 1
+                ]
+                call_params[str(value_argument["name"])] = value
 
         # create extrinsic call
-        call = await substrate.compose_call(
+        call_ = await substrate.compose_call(
             call_module="AdminUtils",
             call_function=extrinsic,
             call_params=call_params,
         )
+        if sudo_:
+            call = await substrate.compose_call(
+                call_module="Sudo", call_function="sudo", call_params={"call": call_}
+            )
+        else:
+            call = call_
         success, err_msg = await subtensor.sign_and_send_extrinsic(
             call, wallet, wait_for_inclusion, wait_for_finalization
         )
         if not success:
             err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
             await asyncio.sleep(0.5)
-
+        elif arbitrary_extrinsic:
+            console.print(
+                f":white_heavy_check_mark: "
+                f"[dark_sea_green3]Hyperparameter {parameter} values changed to {call_params}[/dark_sea_green3]"
+            )
         # Successful registration, final check for membership
         else:
             console.print(
-                f":white_heavy_check_mark: [dark_sea_green3]Hyperparameter {parameter} changed to {value}[/dark_sea_green3]"
+                f":white_heavy_check_mark: "
+                f"[dark_sea_green3]Hyperparameter {parameter} changed to {value}[/dark_sea_green3]"
             )
             return True
 
@@ -266,14 +355,22 @@ def format_call_data(call_data: dict) -> str:
     call_info = call_details[0]
     call_function, call_args = next(iter(call_info.items()))
 
-    # Extract the argument, handling tuple values
-    formatted_args = ", ".join(
-        str(arg[0]) if isinstance(arg, tuple) else str(arg)
-        for arg in call_args.values()
-    )
+    # Format arguments, handle nested/large payloads
+    formatted_args = []
+    for arg_name, arg_value in call_args.items():
+        if isinstance(arg_value, (tuple, list, dict)):
+            # For large nested, show abbreviated version
+            content_str = str(arg_value)
+            if len(content_str) > 20:
+                formatted_args.append(f"{arg_name}: ... [{len(content_str)}] ...")
+            else:
+                formatted_args.append(f"{arg_name}: {arg_value}")
+        else:
+            formatted_args.append(f"{arg_name}: {arg_value}")
 
     # Format the final output string
-    return f"{call_function}({formatted_args})"
+    args_str = ", ".join(formatted_args)
+    return f"{module}.{call_function}({args_str})"
 
 
 def _validate_proposal_hash(proposal_hash: str) -> bool:
@@ -458,28 +555,33 @@ async def sudo_set_hyperparameter(
     subtensor: "SubtensorInterface",
     netuid: int,
     param_name: str,
-    param_value: str,
+    param_value: Optional[str],
 ):
     """Set subnet hyperparameters."""
 
     normalized_value: Union[str, bool]
     if param_name in [
-        "network_registration_allowed",
+        "registration_allowed",
         "network_pow_registration_allowed",
         "commit_reveal_weights_enabled",
         "liquid_alpha_enabled",
     ]:
         normalized_value = param_value.lower() in ["true", "1"]
+    elif param_value in ("True", "False"):
+        normalized_value = {
+            "True": True,
+            "False": False,
+        }[param_value]
     else:
         normalized_value = param_value
 
     is_allowed_value, value = allowed_value(param_name, normalized_value)
     if not is_allowed_value:
         err_console.print(
-            f"Hyperparameter {param_name} value is not within bounds. Value is {normalized_value} but must be {value}"
+            f"Hyperparameter [dark_orange]{param_name}[/dark_orange] value is not within bounds. "
+            f"Value is {normalized_value} but must be {value}"
         )
         return
-
     success = await set_hyperparameter_extrinsic(
         subtensor, wallet, netuid, param_name, value
     )
@@ -572,24 +674,30 @@ async def get_senate(subtensor: "SubtensorInterface"):
     return console.print(table)
 
 
-async def proposals(subtensor: "SubtensorInterface"):
+async def proposals(subtensor: "SubtensorInterface", verbose: bool):
     console.print(
         ":satellite: Syncing with chain: [white]{}[/white] ...".format(
             subtensor.network
         )
     )
-    print_verbose("Fetching senate members & proposals")
     block_hash = await subtensor.substrate.get_chain_head()
-    senate_members, all_proposals = await asyncio.gather(
+    senate_members, all_proposals, current_block = await asyncio.gather(
         _get_senate_members(subtensor, block_hash),
         _get_proposals(subtensor, block_hash),
+        subtensor.substrate.get_block_number(block_hash),
     )
 
-    print_verbose("Fetching member information from Chain")
     registered_delegate_info: dict[
         str, DelegatesDetails
     ] = await subtensor.get_delegate_identities()
 
+    title = (
+        f"[bold #4196D6]Bittensor Governance Proposals[/bold #4196D6]\n"
+        f"[steel_blue3]Current Block:[/steel_blue3] {current_block}\t"
+        f"[steel_blue3]Network:[/steel_blue3] {subtensor.network}\n\n"
+        f"[steel_blue3]Active Proposals:[/steel_blue3] {len(all_proposals)}\t"
+        f"[steel_blue3]Senate Size:[/steel_blue3] {len(senate_members)}\n"
+    )
     table = Table(
         Column(
             "[white]HASH",
@@ -604,8 +712,8 @@ async def proposals(subtensor: "SubtensorInterface"):
             style="rgb(50,163,219)",
         ),
         Column("[white]END", style="bright_cyan"),
-        Column("[white]CALLDATA", style="dark_sea_green"),
-        title=f"\n[dark_orange]Proposals\t\t\nActive Proposals: {len(all_proposals)}\t\tSenate Size: {len(senate_members)}\nNetwork: {subtensor.network}",
+        Column("[white]CALLDATA", style="dark_sea_green", width=30),
+        title=title,
         show_footer=True,
         box=box.SIMPLE_HEAVY,
         pad_edge=False,
@@ -613,16 +721,36 @@ async def proposals(subtensor: "SubtensorInterface"):
         border_style="bright_black",
     )
     for hash_, (call_data, vote_data) in all_proposals.items():
+        blocks_remaining = vote_data.end - current_block
+        if blocks_remaining > 0:
+            duration_str = blocks_to_duration(blocks_remaining)
+            vote_end_cell = f"{vote_data.end} [dim](in {duration_str})[/dim]"
+        else:
+            vote_end_cell = f"{vote_data.end} [red](expired)[/red]"
+
+        ayes_threshold = (
+            (len(vote_data.ayes) / vote_data.threshold * 100)
+            if vote_data.threshold > 0
+            else 0
+        )
+        nays_threshold = (
+            (len(vote_data.nays) / vote_data.threshold * 100)
+            if vote_data.threshold > 0
+            else 0
+        )
         table.add_row(
-            hash_,
+            hash_ if verbose else f"{hash_[:4]}...{hash_[-4:]}",
             str(vote_data.threshold),
-            str(len(vote_data.ayes)),
-            str(len(vote_data.nays)),
+            f"{len(vote_data.ayes)} ({ayes_threshold:.2f}%)",
+            f"{len(vote_data.nays)} ({nays_threshold:.2f}%)",
             display_votes(vote_data, registered_delegate_info),
-            str(vote_data.end),
+            vote_end_cell,
             format_call_data(call_data),
         )
-    return console.print(table)
+    console.print(table)
+    console.print(
+        "\n[dim]* Both Ayes and Nays percentages are calculated relative to the proposal's threshold.[/dim]"
+    )
 
 
 async def senate_vote(
@@ -653,10 +781,7 @@ async def senate_vote(
         return False
 
     # Unlock the wallet.
-    try:
-        wallet.unlock_hotkey()
-        wallet.unlock_coldkey()
-    except KeyFileError:
+    if not unlock_key(wallet, "hot").success and unlock_key(wallet, "cold").success:
         return False
 
     console.print(f"Fetching proposals in [dark_orange]network: {subtensor.network}")
@@ -732,10 +857,7 @@ async def set_take(
         f"Setting take on [{COLOR_PALETTE['GENERAL']['LINKS']}]network: {subtensor.network}"
     )
 
-    try:
-        wallet.unlock_hotkey()
-        wallet.unlock_coldkey()
-    except KeyFileError:
+    if not unlock_key(wallet, "hot").success and unlock_key(wallet, "cold").success:
         return False
 
     result_ = await _do_set_take()