diff --git a/bittensor/__init__.py b/bittensor/__init__.py index c351954f20..71dc689c4d 100644 --- a/bittensor/__init__.py +++ b/bittensor/__init__.py @@ -186,18 +186,13 @@ def debug(on: bool = True): "type": "u16", }, ], - "type": "Vec" + "type": "Vec", } } }, "SubnetRegistrationRuntimeApi": { - "methods": { - "get_network_registration_cost": { - "params": [], - "type": "u64" - } - } - } + "methods": {"get_network_registration_cost": {"params": [], "type": "u64"}} + }, }, } diff --git a/bittensor/extrinsics/set_weights.py b/bittensor/extrinsics/set_weights.py index 22d1577c13..bd5b623bd9 100644 --- a/bittensor/extrinsics/set_weights.py +++ b/bittensor/extrinsics/set_weights.py @@ -97,10 +97,11 @@ def set_weights_extrinsic( wait_for_finalization=wait_for_finalization, wait_for_inclusion=wait_for_inclusion, ) - if success == True: - if not wait_for_finalization and not wait_for_inclusion: - return True + if not wait_for_finalization and not wait_for_inclusion: + return True + + if success == True: bittensor.__console__.print( ":white_heavy_check_mark: [green]Finalized[/green]" ) diff --git a/bittensor/subtensor.py b/bittensor/subtensor.py index 7cea452da6..e41856cbf8 100644 --- a/bittensor/subtensor.py +++ b/bittensor/subtensor.py @@ -16,7 +16,6 @@ # 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 time import os import copy import torch @@ -30,7 +29,6 @@ from substrateinterface.base import QueryMapResult, SubstrateInterface from scalecodec.base import RuntimeConfiguration from scalecodec.type_registry import load_type_registry_preset -from websocket import WebSocketTimeoutException # Local imports. from .chain_data import ( @@ -390,43 +388,35 @@ def _do_set_weights( wait_for_inclusion: bool = False, wait_for_finalization: bool = True, ) -> Tuple[bool, Optional[str]]: # (success, error_message) - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="set_weights", - call_params={ - "dests": uids, - "weights": vals, - "netuid": netuid, - "version_key": version_key, - }, - ) - # Period dictates how long the extrinsic will stay as part of waiting pool - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.hotkey, era={"period": 100} - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True, None - - response.process_events() - if response.is_success: - return True, None - else: - return False, response.error_message - - except TimeoutError: - return False, "Substrate set_weights call timeout." + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="set_weights", + call_params={ + "dests": uids, + "weights": vals, + "netuid": netuid, + "version_key": version_key, + }, + ) + # Period dictates how long the extrinsic will stay as part of waiting pool + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.hotkey, era={"period": 100} + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True, None - except Exception as e: - return False, str(e) + response.process_events() + if response.is_success: + return True, None + else: + return False, response.error_message ###################### #### Registration #### @@ -534,44 +524,40 @@ def _do_pow_register( 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. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - # create extrinsic call - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="register", - call_params={ - "netuid": netuid, - "block_number": pow_result.block_number, - "nonce": pow_result.nonce, - "work": [int(byte_) for byte_ in pow_result.seal], - "hotkey": wallet.hotkey.ss58_address, - "coldkey": wallet.coldkeypub.ss58_address, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.hotkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) + with self.substrate as substrate: + # create extrinsic call + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="register", + call_params={ + "netuid": netuid, + "block_number": pow_result.block_number, + "nonce": pow_result.nonce, + "work": [int(byte_) for byte_ in pow_result.seal], + "hotkey": wallet.hotkey.ss58_address, + "coldkey": wallet.coldkeypub.ss58_address, + }, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.hotkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True, None + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True, None - # process if registration successful, try again if pow is still valid - response.process_events() - if not response.is_success: - return False, response.error_message - # Successful registration - else: - return True, None - except TimeoutError: - return False, "Substrate register call timeout." + # process if registration successful, try again if pow is still valid + response.process_events() + if not response.is_success: + return False, response.error_message + # Successful registration + else: + return True, None def _do_burned_register( self, @@ -580,40 +566,33 @@ def _do_burned_register( wait_for_inclusion: bool = False, wait_for_finalization: bool = True, ) -> Tuple[bool, Optional[str]]: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - # create extrinsic call - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="burned_register", - call_params={ - "netuid": netuid, - "hotkey": wallet.hotkey.ss58_address, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) + with self.substrate as substrate: + # create extrinsic call + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="burned_register", + call_params={"netuid": netuid, "hotkey": wallet.hotkey.ss58_address}, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True - # process if registration successful, try again if pow is still valid - response.process_events() - if not response.is_success: - return False, response.error_message - # Successful registration - else: - return True, None - except (TimeoutError, WebSocketTimeoutException): - return False, "Substrate burn register call timeout." + # process if registration successful, try again if pow is still valid + response.process_events() + if not response.is_success: + return False, response.error_message + # Successful registration + else: + return True, None ################## #### Transfer #### @@ -646,34 +625,24 @@ def get_transfer_fee( elif isinstance(value, int): transfer_balance = Balance.from_rao(value) - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="Balances", - call_function="transfer", - call_params={"dest": dest, "value": transfer_balance.rao}, - ) + with self.substrate as substrate: + call = substrate.compose_call( + call_module="Balances", + call_function="transfer", + call_params={"dest": dest, "value": transfer_balance.rao}, + ) - try: - payment_info = substrate.get_payment_info( - call=call, keypair=wallet.coldkeypub - ) - except Exception as e: - bittensor.__console__.print( - ":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n {}[/bold white]".format( - e - ) - ) - payment_info = {"partialFee": 2e-7} # assume 0.02 Tao - - except TimeoutError: - payment_info = {"partialFee": 2e-7} - bittensor.__console__.print( - ":hourglass: [yellow]Timeout fetching transfer fee[/yellow]. \nDefaulting to:[bold white] {}[/bold white]".format( - payment_info["partialFee"] + try: + payment_info = substrate.get_payment_info( + call=call, keypair=wallet.coldkeypub ) - ) + except Exception as e: + bittensor.__console__.print( + ":cross_mark: [red]Failed to get payment info[/red]:[bold white]\n {}[/bold white]".format( + e + ) + ) + payment_info = {"partialFee": 2e7} # assume 0.02 Tao fee = Balance.from_rao(payment_info["partialFee"]) return fee @@ -699,35 +668,31 @@ def _do_transfer( (On success and if wait_for_ finalization/inclusion is True) error (:obj:`str`): Error message if transfer failed. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="Balances", - call_function="transfer", - call_params={"dest": dest, "value": transfer_balance.rao}, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True, None, None - - # Otherwise continue with finalization. - response.process_events() - if response.is_success: - block_hash = response.block_hash - return True, block_hash, None - else: - return False, None, response.error_message - except TimeoutError: - return False, None, "Substrate transfer call timeout." + with self.substrate as substrate: + call = substrate.compose_call( + call_module="Balances", + call_function="transfer", + call_params={"dest": dest, "value": transfer_balance.rao}, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True, None, None + + # Otherwise continue with finalization. + response.process_events() + if response.is_success: + block_hash = response.block_hash + return True, block_hash, None + else: + return False, None, response.error_message def get_existential_deposit(self, block: Optional[int] = None) -> Optional[Balance]: """Returns the existential deposit for the chain.""" @@ -827,32 +792,28 @@ def _do_serve_axon( wait_for_inclusion: bool = False, wait_for_finalization: bool = True, ) -> Tuple[bool, Optional[str]]: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="serve_axon", - call_params=call_params, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.hotkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - if wait_for_inclusion or wait_for_finalization: - response.process_events() - if response.is_success: - return True, None - else: - return False, response.error_message - else: - return True, None - except TimeoutError: - return False, "Substrate serve axon call timeout." + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="serve_axon", + call_params=call_params, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.hotkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + if wait_for_inclusion or wait_for_finalization: + response.process_events() + if response.is_success: + return True, None + else: + return False, response.error_message + else: + return True, None def serve_prometheus( self, @@ -889,32 +850,28 @@ def _do_serve_prometheus( success (:obj:`bool`): True if serve prometheus was successful. error (:obj:`Optional[str]`): Error message if serve prometheus failed, None otherwise. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="serve_prometheus", - call_params=call_params, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.hotkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - if wait_for_inclusion or wait_for_finalization: - response.process_events() - if response.is_success: - return True, None - else: - return False, response.error_message - else: - return True, None - except TimeoutError: - return False, "Substrate serve prometheus call timeout." + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="serve_prometheus", + call_params=call_params, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.hotkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + if wait_for_inclusion or wait_for_finalization: + response.process_events() + if response.is_success: + return True, None + else: + return False, response.error_message + else: + return True, None def _do_associate_ips( self, @@ -938,37 +895,31 @@ def _do_associate_ips( success (:obj:`bool`): True if associate IPs was successful. error (:obj:`Optional[str]`): Error message if associate IPs failed, None otherwise. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="associate_ips", - call_params={ - "ip_info_list": [ - ip_info.encode() for ip_info in ip_info_list - ], - "netuid": netuid, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.hotkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - if wait_for_inclusion or wait_for_finalization: - response.process_events() - if response.is_success: - return True, None - else: - return False, response.error_message - else: - return True, None - except TimeoutError: - return False, "Substrate associate ips call timeout." + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="associate_ips", + call_params={ + "ip_info_list": [ip_info.encode() for ip_info in ip_info_list], + "netuid": netuid, + }, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.hotkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + if wait_for_inclusion or wait_for_finalization: + response.process_events() + if response.is_success: + return True, None + else: + return False, response.error_message + else: + return True, None ################# #### Staking #### @@ -1033,38 +984,29 @@ def _do_stake( Raises: StakeError: If the extrinsic failed. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="add_stake", - call_params={ - "hotkey": hotkey_ss58, - "amount_staked": amount.rao, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True - - response.process_events() - if response.is_success: - return True - else: - raise StakeError(response.error_message) - except TimeoutError: - bittensor.__console__.print( - ":hourglass: [yellow]Timeout add stake call.[/yellow]" + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="add_stake", + call_params={"hotkey": hotkey_ss58, "amount_staked": amount.rao}, ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True + + response.process_events() + if response.is_success: + return True + else: + raise StakeError(response.error_message) ################### #### Unstaking #### @@ -1129,38 +1071,29 @@ def _do_unstake( Raises: StakeError: If the extrinsic failed. """ - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="remove_stake", - call_params={ - "hotkey": hotkey_ss58, - "amount_unstaked": amount.rao, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True - - response.process_events() - if response.is_success: - return True - else: - raise StakeError(response.error_message) - except TimeoutError: - bittensor.__console__.print( - ":hourglass: [yellow]Timeout remove stake call.[/yellow]" + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="remove_stake", + call_params={"hotkey": hotkey_ss58, "amount_unstaked": amount.rao}, ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True + + response.process_events() + if response.is_success: + return True + else: + raise StakeError(response.error_message) ################ #### Senate #### @@ -1288,37 +1221,33 @@ def _do_root_register( wait_for_inclusion: bool = False, wait_for_finalization: bool = True, ) -> Tuple[bool, Optional[str]]: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - # create extrinsic call - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="root_register", - call_params={"hotkey": wallet.hotkey.ss58_address}, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) + with self.substrate as substrate: + # create extrinsic call + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="root_register", + call_params={"hotkey": wallet.hotkey.ss58_address}, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True - # process if registration successful, try again if pow is still valid - response.process_events() - if not response.is_success: - return False, response.error_message - # Successful registration - else: - return True, None - except TimeoutError: - return False, "Substrate root register call timeout." + # process if registration successful, try again if pow is still valid + response.process_events() + if not response.is_success: + return False, response.error_message + # Successful registration + else: + return True, None def root_set_weights( self, @@ -2459,37 +2388,28 @@ def _do_delegation( wait_for_inclusion: bool = True, wait_for_finalization: bool = False, ) -> bool: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="add_stake", - call_params={ - "hotkey": delegate_ss58, - "amount_staked": amount.rao, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True - response.process_events() - if response.is_success: - return True - else: - raise StakeError(response.error_message) - except TimeoutError: - bittensor.__console__.print( - ":hourglass: [yellow]Timeout delegate call.[/yellow]" + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="add_stake", + call_params={"hotkey": delegate_ss58, "amount_staked": amount.rao}, ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True + response.process_events() + if response.is_success: + return True + else: + raise StakeError(response.error_message) def _do_undelegation( self, @@ -2499,37 +2419,28 @@ def _do_undelegation( wait_for_inclusion: bool = True, wait_for_finalization: bool = False, ) -> bool: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="remove_stake", - call_params={ - "hotkey": delegate_ss58, - "amount_unstaked": amount.rao, - }, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True - response.process_events() - if response.is_success: - return True - else: - raise StakeError(response.error_message) - except TimeoutError: - bittensor.__console__.print( - ":hourglass: [yellow]Timeout undelegate call.[/yellow]" + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="remove_stake", + call_params={"hotkey": delegate_ss58, "amount_unstaked": amount.rao}, + ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey ) + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True + response.process_events() + if response.is_success: + return True + else: + raise StakeError(response.error_message) def _do_nominate( self, @@ -2537,34 +2448,28 @@ def _do_nominate( wait_for_inclusion: bool = True, wait_for_finalization: bool = False, ) -> bool: - try: - with bittensor.timeout(20): - with self.substrate as substrate: - call = substrate.compose_call( - call_module="SubtensorModule", - call_function="become_delegate", - call_params={"hotkey": wallet.hotkey.ss58_address}, - ) - extrinsic = substrate.create_signed_extrinsic( - call=call, keypair=wallet.coldkey - ) # sign with coldkey - response = substrate.submit_extrinsic( - extrinsic, - wait_for_inclusion=wait_for_inclusion, - wait_for_finalization=wait_for_finalization, - ) - # We only wait here if we expect finalization. - if not wait_for_finalization and not wait_for_inclusion: - return True - response.process_events() - if response.is_success: - return True - else: - raise NominationError(response.error_message) - except TimeoutError: - bittensor.__console__.print( - ":hourglass: [yellow]Timeout nominate call.[/yellow]" + with self.substrate as substrate: + call = substrate.compose_call( + call_module="SubtensorModule", + call_function="become_delegate", + call_params={"hotkey": wallet.hotkey.ss58_address}, ) + extrinsic = substrate.create_signed_extrinsic( + call=call, keypair=wallet.coldkey + ) # sign with coldkey + response = substrate.submit_extrinsic( + extrinsic, + wait_for_inclusion=wait_for_inclusion, + wait_for_finalization=wait_for_finalization, + ) + # We only wait here if we expect finalization. + if not wait_for_finalization and not wait_for_inclusion: + return True + response.process_events() + if response.is_success: + return True + else: + raise NominationError(response.error_message) ################ #### Legacy #### diff --git a/bittensor/utils/__init__.py b/bittensor/utils/__init__.py index e14ac20728..65f45ad32f 100644 --- a/bittensor/utils/__init__.py +++ b/bittensor/utils/__init__.py @@ -26,7 +26,6 @@ from .wallet_utils import * from .registration import create_pow as create_pow, __reregister_wallet as reregister -from .timeout import timeout RAOPERTAO = 1e9 U16_MAX = 65535 diff --git a/bittensor/utils/networking.py b/bittensor/utils/networking.py index f9a70eb1f3..d8e1b79e9f 100644 --- a/bittensor/utils/networking.py +++ b/bittensor/utils/networking.py @@ -26,9 +26,6 @@ import requests from loguru import logger -from retry import retry - -from .timeout import timeout def int_to_ip(int_val: int) -> str: @@ -91,7 +88,6 @@ class ExternalIPNotFound(Exception): """Raised if we cannot attain your external ip from CURL/URLLIB/IPIFY/AWS""" -@retry(delay=2, tries=3, backoff=2, max_delay=4, exceptions=(TimeoutError, Exception)) def get_external_ip() -> str: r"""Checks CURL/URLLIB/IPIFY/AWS for your external ip. Returns: @@ -104,66 +100,56 @@ def get_external_ip() -> str: """ # --- Try AWS try: - with timeout(10): - external_ip = requests.get("https://checkip.amazonaws.com").text.strip() - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception) as e: + external_ip = requests.get("https://checkip.amazonaws.com").text.strip() + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass # --- Try ipconfig. try: - with timeout(10): - process = os.popen("curl -s ifconfig.me") - external_ip = process.readline() - process.close() - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception): + process = os.popen("curl -s ifconfig.me") + external_ip = process.readline() + process.close() + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass # --- Try ipinfo. try: - with timeout(10): - process = os.popen("curl -s https://ipinfo.io") - external_ip = json.loads(process.read())["ip"] - process.close() - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception): + process = os.popen("curl -s https://ipinfo.io") + external_ip = json.loads(process.read())["ip"] + process.close() + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass # --- Try myip.dnsomatic try: - with timeout(10): - process = os.popen("curl -s myip.dnsomatic.com") - external_ip = process.readline() - process.close() - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception): + process = os.popen("curl -s myip.dnsomatic.com") + external_ip = process.readline() + process.close() + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass # --- Try urllib ipv6 try: - with timeout(10): - external_ip = ( - urllib.request.urlopen("https://ident.me").read().decode("utf8") - ) - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception): + external_ip = urllib.request.urlopen("https://ident.me").read().decode("utf8") + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass # --- Try Wikipedia try: - with timeout(10): - external_ip = requests.get("https://www.wikipedia.org").headers[ - "X-Client-IP" - ] - assert isinstance(ip_to_int(external_ip), int) - return str(external_ip) - except (TimeoutError, Exception): + external_ip = requests.get("https://www.wikipedia.org").headers["X-Client-IP"] + assert isinstance(ip_to_int(external_ip), int) + return str(external_ip) + except Exception: pass raise ExternalIPNotFound diff --git a/bittensor/utils/timeout.py b/bittensor/utils/timeout.py deleted file mode 100644 index c3cd2ca46d..0000000000 --- a/bittensor/utils/timeout.py +++ /dev/null @@ -1,18 +0,0 @@ -import threading -import _thread -import time -from contextlib import contextmanager - - -@contextmanager -def timeout(timeout): - timer = threading.Timer(timeout, _thread.interrupt_main) - timer.start() - - try: - yield - except KeyboardInterrupt as e: - print(f"timeout exception {e} after {timeout} seconds") - raise TimeoutError - finally: - timer.cancel()