Merge pull request #2382 from opentensor/feat/roman/remove-prompt-from-sdk

Avoid using `prompt` in SDK

Author: ibraheem-abe

bittensor/core/config.py

@@ -97,18 +97,6 @@ def __init__(
             # this can fail if --no_version_checking has already been added.
             pass
 
-        try:
-            parser.add_argument(
-                "--no_prompt",
-                dest="no_prompt",
-                action="store_true",
-                help="Set ``true`` to stop cli from prompting the user.",
-                default=False,
-            )
-        except Exception:
-            # this can fail if --no_version_checking has already been added.
-            pass
-
         # Get args from argv if not passed in.
         if args is None:
             args = sys.argv[1:]

bittensor/core/extrinsics/commit_weights.py

@@ -20,7 +20,6 @@
 from typing import Optional, TYPE_CHECKING
 
 from retry import retry
-from rich.prompt import Confirm
 
 from bittensor.core.extrinsics.utils import submit_extrinsic
 from bittensor.utils import format_error_message
@@ -33,7 +32,7 @@
     from bittensor.core.subtensor import Subtensor
 
 
-# # Chain call for `commit_weights_extrinsic`
+# Chain call for `commit_weights_extrinsic`
 @ensure_connected
 def do_commit_weights(
     self: "Subtensor",
@@ -101,11 +100,10 @@ def commit_weights_extrinsic(
     commit_hash: str,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    prompt: bool = False,
 ) -> tuple[bool, str]:
     """
     Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
-    This function is a wrapper around the `do_commit_weights` method, handling user prompts and error messages.
+    This function is a wrapper around the `do_commit_weights` method.
 
     Args:
         subtensor (bittensor.core.subtensor.Subtensor): The subtensor instance used for blockchain interaction.
@@ -114,16 +112,12 @@ def commit_weights_extrinsic(
         commit_hash (str): The hash of the neuron's weights to be committed.
         wait_for_inclusion (bool): Waits for the transaction to be included in a block.
         wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-        prompt (bool): If ``True``, prompts for user confirmation before proceeding.
 
     Returns:
-        tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string
-        value describing the success or potential error.
+        tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string value describing the success or potential error.
 
     This function provides a user-friendly interface for committing weights to the Bittensor blockchain, ensuring proper error handling and user interaction when required.
     """
-    if prompt and not Confirm.ask(f"Would you like to commit weights?"):
-        return False, "User cancelled the operation."
 
     success, error_message = do_commit_weights(
         self=subtensor,
@@ -224,11 +218,10 @@ def reveal_weights_extrinsic(
     version_key: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    prompt: bool = False,
 ) -> tuple[bool, str]:
     """
     Reveals the weights for a specific subnet on the Bittensor blockchain using the provided wallet.
-    This function is a wrapper around the `_do_reveal_weights` method, handling user prompts and error messages.
+    This function is a wrapper around the `_do_reveal_weights` method.
 
     Args:
         subtensor (bittensor.core.subtensor.Subtensor): The subtensor instance used for blockchain interaction.
@@ -240,18 +233,13 @@ def reveal_weights_extrinsic(
         version_key (int): Version key for compatibility with the network.
         wait_for_inclusion (bool): Waits for the transaction to be included in a block.
         wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
-        prompt (bool): If ``True``, prompts for user confirmation before proceeding.
 
     Returns:
-        tuple[bool, str]: ``True`` if the weight revelation is successful, False otherwise. And `msg`, a string
-        value describing the success or potential error.
+        tuple[bool, str]: ``True`` if the weight revelation is successful, False otherwise. And `msg`, a string value describing the success or potential error.
 
     This function provides a user-friendly interface for revealing weights on the Bittensor blockchain, ensuring proper error handling and user interaction when required.
     """
 
-    if prompt and not Confirm.ask(f"Would you like to reveal weights?"):
-        return False, "User cancelled the operation."
-
     success, error_message = do_reveal_weights(
         self=subtensor,
         wallet=wallet,

bittensor/core/extrinsics/registration.py

@@ -20,7 +20,6 @@
 
 from bittensor_wallet.errors import KeyFileError
 from retry import retry
-from rich.prompt import Confirm
 
 from bittensor.utils import format_error_message
 from bittensor.utils.btlogging import logging
@@ -43,7 +42,7 @@ def _do_pow_register(
     self: "Subtensor",
     netuid: int,
     wallet: "Wallet",
-    pow_result: POWSolution,
+    pow_result: "POWSolution",
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
 ) -> tuple[bool, Optional[str]]:
@@ -53,14 +52,12 @@ def _do_pow_register(
         netuid (int): The subnet to register on.
         wallet (bittensor.wallet): The wallet to register.
         pow_result (POWSolution): The PoW result to register.
-        wait_for_inclusion (bool): If ``True``, waits for the extrinsic to be included in a block.
-            Default to `False`.
+        wait_for_inclusion (bool): If ``True``, waits for the extrinsic to be included in a block. Default to `False`.
         wait_for_finalization (bool): If ``True``, waits for the extrinsic to be finalized. Default to `True`.
 
     Returns:
         success (bool): ``True`` if the extrinsic was included in a block.
-        error (Optional[str]): ``None`` on success or not waiting for inclusion/finalization, otherwise the error
-            message.
+        error (Optional[str]): ``None`` on success or not waiting for inclusion/finalization, otherwise the error message.
     """
 
     @retry(delay=1, tries=3, backoff=2, max_delay=4)
@@ -108,7 +105,6 @@ def register_extrinsic(
     netuid: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
-    prompt: bool = False,
     max_allowed_attempts: int = 3,
     output_in_place: bool = True,
     cuda: bool = False,
@@ -126,7 +122,6 @@ def register_extrinsic(
         netuid (int): The ``netuid`` of the subnet to register on.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding.
         max_allowed_attempts (int): Maximum number of attempts to register the wallet.
         output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines. Defaults to `True`.
         cuda (bool): If ``true``, the wallet should be registered using CUDA device(s).
@@ -158,15 +153,9 @@ def register_extrinsic(
         )
         return True
 
-    if prompt:
-        if not Confirm.ask(
-            "Continue Registration?\n  hotkey:     [bold white]{}[/bold white]\n  coldkey:    [bold white]{}[/bold white]\n  network:    [bold white]{}[/bold white]".format(
-                wallet.hotkey.ss58_address,
-                wallet.coldkeypub.ss58_address,
-                subtensor.network,
-            )
-        ):
-            return False
+    logging.debug(
+        f"Registration hotkey: <blue>{wallet.hotkey.ss58_address}</blue>, <green>Public</green> coldkey: <blue>{wallet.coldkey.ss58_address}</blue> in the network: <blue>{subtensor.network}</blue>."
+    )
 
     if not torch:
         log_no_torch_error()
@@ -181,8 +170,6 @@ def register_extrinsic(
         # Solve latest POW.
         if cuda:
             if not torch.cuda.is_available():
-                if prompt:
-                    logging.info("CUDA is not available.")
                 return False
             pow_result: Optional[POWSolution] = create_pow(
                 subtensor,
@@ -349,7 +336,6 @@ def burned_register_extrinsic(
     netuid: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
-    prompt: bool = False,
 ) -> bool:
     """Registers the wallet to chain by recycling TAO.
 
@@ -359,7 +345,6 @@ def burned_register_extrinsic(
         netuid (int): The ``netuid`` of the subnet to register on.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding.
 
     Returns:
         success (bool): Flag is ``true`` if extrinsic was finalized or uncluded in the block. If we did not wait for finalization / inclusion, the response is ``true``.
@@ -386,7 +371,6 @@ def burned_register_extrinsic(
 
     old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
 
-    recycle_amount = subtensor.recycle(netuid=netuid)
     if not neuron.is_null:
         logging.info(":white_heavy_check_mark: <green>Already Registered</green>")
         logging.info(f"\t\tuid: <blue>{neuron.uid}</blue>")
@@ -395,12 +379,11 @@ def burned_register_extrinsic(
         logging.info(f"\t\tcoldkey: <blue>{neuron.coldkey}</blue>")
         return True
 
-    if prompt:
-        # Prompt user for confirmation.
-        if not Confirm.ask(f"Recycle {recycle_amount} to register on subnet:{netuid}?"):
-            return False
-
     logging.info(":satellite: <magenta>Recycling TAO for Registration...</magenta>")
+
+    recycle_amount = subtensor.recycle(netuid=netuid)
+    logging.info(f"Recycling {recycle_amount} to register on subnet:{netuid}")
+
     success, err_msg = _do_burned_register(
         self=subtensor,
         netuid=netuid,
@@ -410,7 +393,7 @@ def burned_register_extrinsic(
     )
 
     if not success:
-        logging.error(f":cross_mark: <red>Failed:</red> {err_msg}")
+        logging.error(f":cross_mark: <red>Failed error:</red> {err_msg}")
         time.sleep(0.5)
         return False
     # Successful registration, final check for neuron and pubkey

bittensor/core/extrinsics/root.py

@@ -5,7 +5,6 @@
 from bittensor_wallet.errors import KeyFileError
 from numpy.typing import NDArray
 from retry import retry
-from rich.prompt import Confirm
 
 from bittensor.core.settings import version_as_int
 from bittensor.utils import format_error_message, weight_utils
@@ -62,7 +61,6 @@ def root_register_extrinsic(
     wallet: "Wallet",
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = True,
-    prompt: bool = False,
 ) -> bool:
     """Registers the wallet to root network.
 
@@ -71,7 +69,6 @@ def root_register_extrinsic(
         wallet (bittensor_wallet.Wallet): Bittensor wallet object.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout. Default is ``False``.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout. Default is ``True``.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding. Default is ``False``.
 
     Returns:
         success (bool): Flag is ``true`` if extrinsic was finalized or uncluded in the block. If we did not wait for finalization / inclusion, the response is ``true``.
@@ -94,11 +91,6 @@ def root_register_extrinsic(
         )
         return True
 
-    if prompt:
-        # Prompt user for confirmation.
-        if not Confirm.ask("Register to root network?"):
-            return False
-
     logging.info(":satellite: <magenta>Registering to root network...</magenta>")
     success, err_msg = _do_root_register(
         wallet=wallet,
@@ -199,7 +191,6 @@ def set_root_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    prompt: bool = False,
 ) -> bool:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -211,7 +202,6 @@ def set_root_weights_extrinsic(
         version_key (int): The version key of the validator.  Default is ``0``.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout.  Default is ``False``.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout. Default is ``False``.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding. Default is ``False``.
 
     Returns:
         success (bool): Flag is ``true`` if extrinsic was finalized or uncluded in the block. If we did not wait for finalization / inclusion, the response is ``true``.
@@ -254,15 +244,6 @@ def set_root_weights_extrinsic(
         f"Raw Weights -> Normalized weights: <blue>{weights}</blue> -> <green>{formatted_weights}</green>"
     )
 
-    # Ask before moving on.
-    if prompt:
-        if not Confirm.ask(
-            "Do you want to set the following root weights?:\n[bold white]  weights: {}\n  uids: {}[/bold white ]?".format(
-                formatted_weights, netuids
-            )
-        ):
-            return False
-
     logging.info(
         f":satellite: <magenta>Setting root weights on</magenta> <blue>{subtensor.network}</blue> <magenta>...</magenta>"
     )

bittensor/core/extrinsics/serving.py

@@ -15,11 +15,9 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
-import json
 from typing import Optional, TYPE_CHECKING
 
 from retry import retry
-from rich.prompt import Confirm
 
 from bittensor.core.errors import MetadataError
 from bittensor.core.extrinsics.utils import submit_extrinsic
@@ -100,7 +98,6 @@ def serve_extrinsic(
     placeholder2: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization=True,
-    prompt: bool = False,
 ) -> bool:
     """Subscribes a Bittensor endpoint to the subtensor chain.
 
@@ -115,7 +112,6 @@ def serve_extrinsic(
         placeholder2 (int): A placeholder for future use.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding.
 
     Returns:
         success (bool): Flag is ``true`` if extrinsic was finalized or uncluded in the block. If we did not wait for finalization / inclusion, the response is ``true``.
@@ -159,15 +155,6 @@ def serve_extrinsic(
         )
         return True
 
-    if prompt:
-        output = params.copy()
-        output["coldkey"] = wallet.coldkeypub.ss58_address
-        output["hotkey"] = wallet.hotkey.ss58_address
-        if not Confirm.ask(
-            f"Do you want to serve axon:\n  [bold white]{json.dumps(output, indent=4, sort_keys=True)}[/bold white]"
-        ):
-            return False
-
     logging.debug(
         f"Serving axon with: AxonInfo({wallet.hotkey.ss58_address},{ip}:{port}) -> {subtensor.network}:{netuid}"
     )

bittensor/core/extrinsics/set_weights.py

@@ -21,7 +21,6 @@
 import numpy as np
 from numpy.typing import NDArray
 from retry import retry
-from rich.prompt import Confirm
 
 from bittensor.core.extrinsics.utils import submit_extrinsic
 from bittensor.core.settings import version_as_int
@@ -114,7 +113,6 @@ def set_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    prompt: bool = False,
 ) -> tuple[bool, str]:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -127,7 +125,6 @@ def set_weights_extrinsic(
         version_key (int): The version key of the validator.
         wait_for_inclusion (bool): If set, waits for the extrinsic to enter a block before returning ``true``, or returns ``false`` if the extrinsic fails to enter the block within the timeout.
         wait_for_finalization (bool): If set, waits for the extrinsic to be finalized on the chain before returning ``true``, or returns ``false`` if the extrinsic fails to be finalized within the timeout.
-        prompt (bool): If ``true``, the call waits for confirmation from the user before proceeding.
 
     Returns:
         tuple[bool, str]: A tuple containing a success flag and an optional response message.
@@ -149,17 +146,11 @@ def set_weights_extrinsic(
         uids, weights
     )
 
-    # Ask before moving on.
-    if prompt:
-        if not Confirm.ask(
-            f"Do you want to set weights:\n[bold white]  weights: {[float(v / 65535) for v in weight_vals]}\n"
-            f"uids: {weight_uids}[/bold white ]?"
-        ):
-            return False, "Prompt refused."
-
     logging.info(
         f":satellite: <magenta>Setting weights on </magenta><blue>{subtensor.network}<blue> <magenta>...</magenta>"
     )
+    logging.debug(f"Weights: {[float(v / 65535) for v in weight_vals]}")
+
     try:
         success, error_message = do_set_weights(
             self=subtensor,