Add raw spec for local test and new bins

bittensor/_cli/commands/delegates.py

@@ -405,7 +405,7 @@ class MyDelegatesCommand:
     def run( cli ):
         '''Delegates stake to a chain delegate.'''
         config = cli.config.copy()
-        if config.all == True:
+        if config.get('all', d=None) == True:
             wallets = _get_coldkey_wallets_for_path( config.wallet.path )
         else:
             wallets = [bittensor.wallet( config = config )]
@@ -508,7 +508,7 @@ def add_args( parser: argparse.ArgumentParser ):
 
     @staticmethod   
     def check_config( config: 'bittensor.Config' ):
-        if not config.all and config.wallet.get('name') == bittensor.defaults.wallet.name and not config.no_prompt:
+        if not config.get( 'all', d=None ) and config.wallet.get('name') == bittensor.defaults.wallet.name and not config.no_prompt:
             wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name)
             config.wallet.name = str(wallet_name)
 

bittensor/_cli/commands/inspect.py

@@ -58,7 +58,7 @@ class InspectCommand:
     def run (cli):
         r""" Inspect a cold, hot pair.
         """
-        if cli.config.all == True:
+        if cli.config.get('all', d=False) == True:
             wallets = _get_coldkey_wallets_for_path( cli.config.wallet.path )
         else:
             wallets = [bittensor.wallet( config = cli.config )]
@@ -139,7 +139,7 @@ def run (cli):
 
     @staticmethod
     def check_config( config: 'bittensor.Config' ):
-        if not config.all and config.wallet.get('name') == bittensor.defaults.wallet.name and not config.no_prompt:
+        if not config.get( 'all', d=None ) and config.wallet.get('name') == bittensor.defaults.wallet.name and not config.no_prompt:
             wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name)
             config.wallet.name = str(wallet_name)
 

bittensor/_cli/commands/misc.py

@@ -27,7 +27,6 @@
 class HelpCommand:
     @staticmethod
     def run (cli):
-        cli.config.to_defaults()
         sys.argv = [sys.argv[0], '--help']
         # Run miner.
         if cli.config.model == 'core_server':

bittensor/_cli/commands/overview.py

@@ -41,7 +41,7 @@ def run( cli ):
         total_balance = bittensor.Balance(0)
 
         # We are printing for every coldkey.
-        if cli.config.all:
+        if cli.config.get( 'all', d=None ):
             cold_wallets = get_coldkey_wallets_for_path(cli.config.wallet.path)
             for cold_wallet in tqdm(cold_wallets, desc="Pulling balances"):
                 if cold_wallet.coldkeypub_file.exists_on_device() and not cold_wallet.coldkeypub_file.is_encrypted():
@@ -102,7 +102,7 @@ def run( cli ):
         grid = Table.grid(pad_edge=False)
 
         title: str = ""
-        if not cli.config.all:
+        if not cli.config.get( 'all', d=None ):
             title = ( "[bold white italic]Wallet - {}:{}".format(cli.config.wallet.name, wallet.coldkeypub.ss58_address) )
         else:
             title = ( "[bold whit italic]All Wallets:" )
@@ -333,10 +333,13 @@ def add_args( parser: argparse.ArgumentParser ):
 
     @staticmethod   
     def check_config( config: 'bittensor.Config' ):
-        if config.wallet.get('name') == bittensor.defaults.wallet.name  and not config.no_prompt and not config.all:
+        if config.wallet.get('name') == bittensor.defaults.wallet.name  and not config.no_prompt and not config.get( 'all', d=None ):
             wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name)
             config.wallet.name = str(wallet_name)
 
         if config.netuid != []:
-            config.netuid = [int(netuid) for netuid in config.netuid]
+            if not isinstance(config.netuid, list):
+                config.netuid = [int(config.netuid)]
+            else:
+                config.netuid = [int(netuid) for netuid in config.netuid]
 

bittensor/_cli/commands/unstake.py

@@ -32,12 +32,12 @@ def check_config( cls, config: 'bittensor.Config' ):
             wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name)
             config.wallet.name = str(wallet_name)
 
-        if not config.hotkey_ss58address and config.wallet.get('hotkey') == bittensor.defaults.wallet.hotkey and not config.no_prompt and not config.get('all_hotkeys') and not config.get('hotkeys'):
+        if not config.get('hotkey_ss58address') and config.wallet.get('hotkey') == bittensor.defaults.wallet.hotkey and not config.no_prompt and not config.get('all_hotkeys') and not config.get('hotkeys'):
             hotkey = Prompt.ask("Enter hotkey name", default = bittensor.defaults.wallet.hotkey)
             config.wallet.hotkey = str(hotkey)
 
         # Get amount.
-        if not config.hotkey_ss58address and not config.get('amount') and not config.get('unstake_all') and not config.get('max_stake'):
+        if not config.get('hotkey_ss58address') and not config.get('amount') and not config.get('unstake_all') and not config.get('max_stake'):
             hotkeys: str = ''
             if config.get('all_hotkeys'):
                 hotkeys = "all hotkeys"

bittensor/_cli/commands/wallets.py

@@ -48,7 +48,7 @@ def check_config( config: 'bittensor.Config' ):
             wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name)
             config.wallet.name = str(wallet_name)
 
-        if config.mnemonic == None and config.seed == None and config.json == None:
+        if config.mnemonic == None and config.get( 'seed', d=None ) == None and config.get( 'json', d=None ) == None:
             prompt_answer = Prompt.ask("Enter mnemonic, seed, or json file location")
             if prompt_answer.startswith("0x"):
                 config.seed = prompt_answer
@@ -57,7 +57,7 @@ def check_config( config: 'bittensor.Config' ):
             else:
                 config.json = prompt_answer
 
-        if config.json and config.json_password == None:
+        if config.get( 'json', d=None ) and config.get( 'json_password', d=None ) == None:
             config.json_password = Prompt.ask("Enter json backup password", password=True)
 
     @staticmethod
@@ -213,7 +213,7 @@ def check_config( config: 'bittensor.Config' ):
             hotkey = Prompt.ask("Enter hotkey name", default = bittensor.defaults.wallet.hotkey)
             config.wallet.hotkey = str(hotkey)
 
-        if config.mnemonic == None and config.seed == None and config.json == None:
+        if config.mnemonic == None and config.get( 'seed', d=None ) == None and config.get( 'json', d=None ) == None:
             prompt_answer = Prompt.ask("Enter mnemonic, seed, or json file location")
             if prompt_answer.startswith("0x"):
                 config.seed = prompt_answer
@@ -222,7 +222,7 @@ def check_config( config: 'bittensor.Config' ):
             else:
                 config.json = prompt_answer
 
-        if config.json and config.json_password == None:
+        if config.get( 'json', d=None ) and config.get( 'json_password', d=None ) == None:
             config.json_password = Prompt.ask("Enter json backup password", password=True)
 
     @staticmethod

bittensor/_cli/naka_cli_impl.py

@@ -617,7 +617,7 @@ def overview(self):
         total_balance = bittensor.Balance(0)
 
         # We are printing for every coldkey.
-        if self.config.all:
+        if self.config.get('all', d=None):
             cold_wallets = CLI._get_coldkey_wallets_for_path(self.config.wallet.path)
             for cold_wallet in tqdm(cold_wallets, desc="Pulling balances"):
                 if cold_wallet.coldkeypub_file.exists_on_device() and not cold_wallet.coldkeypub_file.is_encrypted():
@@ -728,7 +728,7 @@ def overview(self):
 
         total_neurons = len(neurons)                
         table = Table(show_footer=False, width=self.config.get('width', None), pad_edge=False, box=None)
-        if not self.config.all:
+        if not self.config.get('all', d=None):
             table.title = ( "[white]Wallet - {}:{}".format(self.config.wallet.name, wallet.coldkeypub.ss58_address) )
         else:
             table.title = ( "[white]All Wallets:" )

bittensor/_subtensor/__init__.py

@@ -37,7 +37,7 @@ class subtensor:
     """Factory Class for both bittensor.Subtensor and Mock_Subtensor Classes
 
     The Subtensor class handles interactions with the substrate subtensor chain.
-    By default, the Subtensor class connects to the Nakamoto which serves as the main bittensor network.
+    By default, the Subtensor class connects to the Finney which serves as the main bittensor network.
 
     """
 

bittensor/_subtensor/chain_data.py

@@ -296,8 +296,8 @@ def _neuron_dict_to_namespace(neuron_dict) -> 'NeuronInfo':
             return NeuronInfo._null_neuron()
         else:
             neuron = NeuronInfo( **neuron_dict )
-            neuron.stake = Balance.from_rao(neuron.total_stake)
             neuron.stake_dict = { hk: Balance.from_rao(stake) for hk, stake in neuron.stake.items() }
+            neuron.stake = Balance.from_rao(neuron.total_stake)
             neuron.total_stake = neuron.stake
             neuron.rank = neuron.rank / U16_MAX
             neuron.trust = neuron.trust / U16_MAX

bittensor/_subtensor/extrinsics/staking.py

@@ -69,7 +69,7 @@ def add_stake_extrinsic(
         hotkey_ss58 = wallet.hotkey.ss58_address 
 
     # Flag to indicate if we are using the wallet's own hotkey.
-    own_hotkey: bool = (wallet.hotkey.ss58_address == hotkey_ss58)
+    own_hotkey: bool
 
     with bittensor.__console__.status(":satellite: Syncing with chain: [white]{}[/white] ...".format(subtensor.network)):
         old_balance = subtensor.get_balance( wallet.coldkeypub.ss58_address )

bittensor/_subtensor/subtensor_impl.py

@@ -408,107 +408,107 @@ def make_substrate_call_with_retry():
 
     """ Returns network Rho hyper parameter """
     def rho (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor( "Rho", block, [netuid] ).value
 
     """ Returns network Kappa hyper parameter """
     def kappa (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return U16_NORMALIZED_FLOAT( self.query_subtensor( "Kappa", block, [netuid] ).value )
 
     """ Returns network Difficulty hyper parameter """
     def difficulty (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor( "Difficulty", block, [netuid] ).value
 
     """ Returns network Burn hyper parameter """
     def burn (self, netuid: int, block: Optional[int] = None ) -> Optional[bittensor.Balance]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return bittensor.Balance.from_rao( self.query_subtensor( "Burn", block, [netuid] ).value )
 
     """ Returns network ImmunityPeriod hyper parameter """
     def immunity_period (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ImmunityPeriod", block, [netuid] ).value
 
     """ Returns network ValidatorBatchSize hyper parameter """
     def validator_batch_size (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ValidatorBatchSize", block, [netuid] ).value
 
     """ Returns network ValidatorPruneLen hyper parameter """
     def validator_prune_len (self, netuid: int, block: Optional[int] = None ) -> int:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ValidatorPruneLen", block, [netuid] ).value
 
     """ Returns network ValidatorLogitsDivergence hyper parameter """
     def validator_logits_divergence (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return U16_NORMALIZED_FLOAT(self.query_subtensor("ValidatorLogitsDivergence", block, [netuid]).value)
 
     """ Returns network ValidatorSequenceLength hyper parameter """
     def validator_sequence_length (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ValidatorSequenceLength", block, [netuid] ).value
 
     """ Returns network ValidatorEpochsPerReset hyper parameter """
     def validator_epochs_per_reset (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ValidatorEpochsPerReset", block, [netuid] ).value
 
     """ Returns network ValidatorEpochLen hyper parameter """
     def validator_epoch_length (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("ValidatorEpochLen", block, [netuid] ).value
 
     """ Returns network ValidatorEpochLen hyper parameter """
     def validator_exclude_quantile (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return U16_NORMALIZED_FLOAT( self.query_subtensor("ValidatorExcludeQuantile", block, [netuid] ).value )
 
     """ Returns network MaxAllowedValidators hyper parameter """
     def max_allowed_validators(self, netuid: int, block: Optional[int] = None) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor( 'MaxAllowedValidators', block, [netuid] ).value
 
     """ Returns network MinAllowedWeights hyper parameter """
     def min_allowed_weights (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor("MinAllowedWeights", block, [netuid] ).value
 
     """ Returns network MaxWeightsLimit hyper parameter """
     def max_weight_limit (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return U16_NORMALIZED_FLOAT( self.query_subtensor('MaxWeightsLimit', block, [netuid] ).value )
 
     """ Returns network ScalingLawPower hyper parameter """
     def scaling_law_power (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('ScalingLawPower', block, [netuid] ).value / 100.
 
     """ Returns network SynergyScalingLawPower hyper parameter """
     def synergy_scaling_law_power (self, netuid: int, block: Optional[int] = None ) -> Optional[float]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('SynergyScalingLawPower', block, [netuid] ).value / 100.
 
     """ Returns network SubnetworkN hyper parameter """
     def subnetwork_n (self, netuid: int, block: Optional[int] = None ) -> int:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('SubnetworkN', block, [netuid] ).value
 
     """ Returns network MaxAllowedUids hyper parameter """
     def max_n (self, netuid: int, block: Optional[int] = None ) -> Optional[int]:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('MaxAllowedUids', block, [netuid] ).value
 
     """ Returns network BlocksSinceLastStep hyper parameter """
     def blocks_since_epoch (self, netuid: int, block: Optional[int] = None) -> int:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('BlocksSinceLastStep', block, [netuid] ).value
 
     """ Returns network Tempo hyper parameter """
     def tempo (self, netuid: int, block: Optional[int] = None) -> int:
-        if not self.subnet_exists( netuid ): return None
+        if not self.subnet_exists( netuid, block ): return None
         return self.query_subtensor('Tempo', block, [netuid] ).value
 
     ##########################