[v10] All TODOs resolved

MIGRATION.md

@@ -68,7 +68,7 @@
 13. ✅ Remove `Default is` and `Default to` in docstrings bc parameters enough.
 14. ✅ `camfairchild`: TODO, but we should have a grab_metadata if we don't already. Maybe don't decode, but can have a call that removes the Raw prefix, and another just doing grab_metadata_raw (no decoding). `get_commitment_metadata` added.
 15. ✅ Resolve an issue where a script using the SDK receives the `--config` or any other CLI parameters used in the SDK. Disable configuration processing. Use default values ​​instead.
-16. Find and process all `TODOs` across the entire code base. If in doubt, discuss each one with the team separately. SDK has 29 TODOs.
+16. ✅ Find and process all `TODOs` across the entire code base. If in doubt, discuss each one with the team separately. SDK has 29 TODOs.
 
 ## New features
 1. ✅ Unify extrinsic return values by introducing an ExtrinsicResponse class. Extrinsics currently return either a boolean or a tuple.
@@ -274,6 +274,11 @@ Added sub-package `bittensor.core.addons` to host optional extensions and experi
   - local env variable `BT_CHAIN_ENDPOINT` replaced with `BT_SUBTENSOR_CHAIN_ENDPOINT`.
 
 
+## Metagraph changes:
+- all methods with `mechid` parameter has reordered list of parameters.
+- async `_initialize_subtensor` method no longer kill the subtensor instance after use.
+
+
 ### Mechid related changes:
 In the next subtensor methods got updated the parameters order:
   - `bonds`

bittensor/core/async_subtensor.py

@@ -279,24 +279,7 @@ async def initialize(self):
             raise ConnectionError
 
     async def __aenter__(self):
-        logging.info(
-            f"[magenta]Connecting to Substrate:[/magenta] [blue]{self}[/blue][magenta]...[/magenta]"
-        )
-        try:
-            await self.substrate.initialize()
-            return self
-        except TimeoutError:
-            logging.error(
-                f"[red]Error[/red]: Timeout occurred connecting to substrate."
-                f" Verify your chain and network settings: {self}"
-            )
-            raise ConnectionError
-        except (ConnectionRefusedError, ssl.SSLError) as error:
-            logging.error(
-                f"[red]Error[/red]: Connection refused when connecting to substrate. "
-                f"Verify your chain and network settings: {self}. Error: {error}"
-            )
-            raise ConnectionError
+        return await self.initialize()
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.substrate.close()
@@ -3908,12 +3891,12 @@ async def metagraph(
         decentralized architecture, particularly in relation to neuron interconnectivity and consensus processes.
         """
         metagraph = AsyncMetagraph(
-            network=self.chain_endpoint,
             netuid=netuid,
+            mechid=mechid,
+            network=self.chain_endpoint,
             lite=lite,
             sync=False,
             subtensor=self,
-            mechid=mechid,
         )
         await metagraph.sync(block=block, lite=lite, subtensor=self)
 
@@ -4379,7 +4362,6 @@ async def weights(
         """
         storage_index = get_mechid_storage_index(netuid, mechid)
         block_hash = await self.determine_block_hash(block, block_hash, reuse_block)
-        # TODO look into seeing if we can speed this up with storage query
         w_map_encoded = await self.substrate.query_map(
             module="SubtensorModule",
             storage_function="Weights",
@@ -5647,7 +5629,7 @@ async def _blocks_weight_limit() -> bool:
                 and await _blocks_weight_limit()
             ):
                 logging.debug(
-                    f"Committing weights for subnet [blue]{netuid}[/blue]. "
+                    f"Committing weights {weights} for subnet [blue]{netuid}[/blue]. "
                     f"Attempt [blue]{retries + 1}[blue] of [green]{max_retries}[/green]."
                 )
                 try:

bittensor/core/metagraph.py

@@ -526,11 +526,11 @@ def addresses(self) -> list[str]:
     def __init__(
         self,
         netuid: int,
+        mechid: int = 0,
         network: str = settings.DEFAULT_NETWORK,
         lite: bool = True,
         sync: bool = True,
         subtensor: Optional[Union["AsyncSubtensor", "Subtensor"]] = None,
-        mechid: int = 0,
     ):
         """
         Initializes a new instance of the metagraph object, setting up the basic structure and parameters based on the
@@ -671,7 +671,6 @@ def _create_tensor(data, dtype) -> Tensor:
 
                 self.stake = self._create_tensor(neuron_stakes, dtype=np.float32)
         """
-        # TODO: Check and test the creation of tensor
         return (
             torch.nn.Parameter(torch.tensor(data, dtype=dtype), requires_grad=False)
             if use_torch()
@@ -706,7 +705,6 @@ def _process_weights_or_bonds(self, data, attribute: str) -> Tensor:
                     data_array.append(np.zeros(len(self.neurons), dtype=np.float32))
             else:
                 uids, values = zip(*item)
-                # TODO: Validate and test the conversion of uids and values to tensor
                 if attribute == "weights":
                     data_array.append(
                         convert_weight_uids_and_vals_to_tensor(
@@ -1033,11 +1031,11 @@ class TorchMetagraph(MetagraphMixin, BaseClass):
     def __init__(
         self,
         netuid: int,
+        mechid: int = 0,
         network: str = settings.DEFAULT_NETWORK,
         lite: bool = True,
         sync: bool = True,
         subtensor: Optional[Union["AsyncSubtensor", "Subtensor"]] = None,
-        mechid: int = 0,
     ):
         """
         Initializes a new instance of the metagraph object, setting up the basic structure and parameters based on the
@@ -1199,11 +1197,11 @@ class NonTorchMetagraph(MetagraphMixin):
     def __init__(
         self,
         netuid: int,
+        mechid: int = 0,
         network: str = settings.DEFAULT_NETWORK,
         lite: bool = True,
         sync: bool = True,
         subtensor: Optional[Union["AsyncSubtensor", "Subtensor"]] = None,
-        mechid: int = 0,
     ):
         """
         Initializes a new instance of the metagraph object, setting up the basic structure and parameters based on the
@@ -1227,7 +1225,7 @@ def __init__(
 
                 metagraph = Metagraph(netuid=123, network="finney", lite=True, sync=True)
         """
-        MetagraphMixin.__init__(self, netuid, network, lite, sync, subtensor, mechid)
+        MetagraphMixin.__init__(self, netuid, mechid, network, lite, sync, subtensor)
 
         self.netuid = netuid
         self.network, self.chain_endpoint = determine_chain_endpoint_and_network(
@@ -1330,19 +1328,29 @@ def load_from_path(self, dir_path: str) -> "MetagraphMixin":
 
 class AsyncMetagraph(NumpyOrTorch):
     """
-    TODO docstring. Advise user to use `async_metagraph` factory fn if they want to sync at init
+    Asynchronous version of the Metagraph class for non-blocking synchronization  with the Bittensor network state.
+
+    This class allows developers to fetch and update metagraph data using async  operations, enabling concurrent
+    execution in event-driven environments.
+
+    Note:
+        Prefer using the factory function `async_metagraph()` for initialization,  which handles async synchronization
+        automatically.
+
+    Example:
+        metagraph = await async_metagraph(netuid=1, network="finney")
     """
 
     def __init__(
         self,
         netuid: int,
+        mechid: int = 0,
         network: str = settings.DEFAULT_NETWORK,
         lite: bool = True,
         sync: bool = True,
         subtensor: Optional["AsyncSubtensor"] = None,
-        mechid: int = 0,
     ):
-        super().__init__(netuid, network, lite, sync, subtensor, mechid)
+        super().__init__(netuid, mechid, network, lite, sync, subtensor)
 
     async def __aenter__(self):
         if self.should_sync:
@@ -1467,8 +1475,9 @@ async def _initialize_subtensor(
             # Lazy import due to circular import (subtensor -> metagraph, metagraph -> subtensor)
             from bittensor.core.async_subtensor import AsyncSubtensor
 
-            async with AsyncSubtensor(network=self.chain_endpoint) as subtensor:
-                self.subtensor = subtensor
+            self.subtensor = AsyncSubtensor(network=self.chain_endpoint)
+            await self.subtensor.initialize()
+            self.subtensor = subtensor
         return subtensor
 
     async def _assign_neurons(
@@ -1518,7 +1527,6 @@ async def _set_weights_and_bonds(self, subtensor: "AsyncSubtensor", block: int):
 
                 self._set_weights_and_bonds(subtensor=subtensor)
         """
-        # TODO: Check and test the computation of weights and bonds
         if self.netuid == 0:
             self.weights = await self._process_root_weights(
                 [neuron.weights for neuron in self.neurons],
@@ -1568,7 +1576,6 @@ async def _process_root_weights(
                     data_array.append(np.zeros(n_subnets, dtype=np.float32))
             else:
                 uids, values = zip(*item)
-                # TODO: Validate and test the conversion of uids and values to tensor
                 data_array.append(
                     convert_root_weight_uids_and_vals_to_tensor(
                         n_subnets, list(uids), list(values), subnets
@@ -1656,16 +1663,28 @@ async def _apply_extra_info(self, block: int):
 
 
 class Metagraph(NumpyOrTorch):
+    """
+    Synchronous implementation of the Metagraph, representing the current state of a Bittensor subnet.
+
+    The Metagraph encapsulates neuron attributes such as stake, trust, incentive,  weights, and connectivity, and
+    provides methods to synchronize these values directly from the blockchain via a Subtensor instance.
+
+    Example:
+        from bittensor.core.subtensor import Subtensor
+        subtensor = Subtensor(network="finney")
+        metagraph = Metagraph(netuid=1, network="finney", sync=True, subtensor=subtensor)
+    """
+
     def __init__(
         self,
         netuid: int,
+        mechid: int = 0,
         network: str = settings.DEFAULT_NETWORK,
         lite: bool = True,
         sync: bool = True,
         subtensor: Optional["Subtensor"] = None,
-        mechid: int = 0,
     ):
-        super().__init__(netuid, network, lite, sync, subtensor, mechid)
+        super().__init__(netuid, mechid, network, lite, sync, subtensor)
         if self.should_sync:
             self.sync()
 
@@ -1877,7 +1896,6 @@ def _process_root_weights(
                     data_array.append(np.zeros(n_subnets, dtype=np.float32))
             else:
                 uids, values = zip(*item)
-                # TODO: Validate and test the conversion of uids and values to tensor
                 data_array.append(
                     convert_root_weight_uids_and_vals_to_tensor(
                         n_subnets, list(uids), list(values), subnets
@@ -1966,6 +1984,7 @@ def _apply_extra_info(self, block: int):
 
 async def async_metagraph(
     netuid: int,
+    mechid: int = 0,
     network: str = settings.DEFAULT_NETWORK,
     lite: bool = True,
     sync: bool = True,
@@ -1975,7 +1994,12 @@ async def async_metagraph(
     Factory function to create an instantiated AsyncMetagraph, mainly for the ability to use sync at instantiation.
     """
     metagraph_ = AsyncMetagraph(
-        netuid=netuid, network=network, lite=lite, sync=sync, subtensor=subtensor
+        netuid=netuid,
+        mechid=mechid,
+        network=network,
+        lite=lite,
+        sync=sync,
+        subtensor=subtensor,
     )
     if sync:
         await metagraph_.sync()

bittensor/core/subtensor.py

@@ -1693,11 +1693,11 @@ def get_mechanism_count(
     def get_metagraph_info(
         self,
         netuid: int,
+        mechid: int = 0,
         selected_indices: Optional[
             Union[list[SelectiveMetagraphIndex], list[int]]
         ] = None,
         block: Optional[int] = None,
-        mechid: int = 0,
     ) -> Optional[MetagraphInfo]:
         """
         Retrieves full or partial metagraph information for the specified subnet mechanism (netuid, mechid).
@@ -2868,12 +2868,12 @@ def metagraph(
         decentralized architecture, particularly in relation to neuron interconnectivity and consensus processes.
         """
         metagraph = Metagraph(
-            network=self.chain_endpoint,
             netuid=netuid,
+            mechid=mechid,
+            network=self.chain_endpoint,
             lite=lite,
             sync=False,
             subtensor=self,
-            mechid=mechid,
         )
         metagraph.sync(block=block, lite=lite, subtensor=self)
 
@@ -4428,7 +4428,7 @@ def _blocks_weight_limit() -> bool:
                 and _blocks_weight_limit()
             ):
                 logging.debug(
-                    f"Committing weights for subnet [blue]{netuid}[/blue]. "
+                    f"Committing weights {weights} for subnet [blue]{netuid}[/blue]. "
                     f"Attempt [blue]{retries + 1}[blue] of [green]{max_retries}[/green]."
                 )
                 try:

bittensor/core/types.py

@@ -58,7 +58,7 @@ def _check_and_log_network_settings(self):
                 "This increases decentralization and resilience of the network."
             )
 
-    @staticmethod  # TODO can this be a class method?
+    @staticmethod
     def config() -> "Config":
         """
         Creates and returns a Bittensor configuration object.
@@ -72,7 +72,7 @@ def config() -> "Config":
         return Config(parser)
 
     @staticmethod
-    def setup_config(network: Optional[str], config: "Config"):
+    def setup_config(network: Optional[str], config: "Config") -> tuple[str, str]:
         """
         Sets up and returns the configuration for the Subtensor network and endpoint.
 

bittensor/extras/dev_framework/subnet.py

@@ -47,16 +47,21 @@ def __init__(
         self.wait_for_finalization = wait_for_finalization
 
         self._netuid: Optional[int] = None
+        self._owner: Optional[Wallet] = None
         self._calls: list[CALL_RECORD] = []
 
     @property
-    def calls(self):
+    def calls(self) -> list[CALL_RECORD]:
         return self._calls
 
     @property
-    def netuid(self):
+    def netuid(self) -> int:
         return self._netuid
 
+    @property
+    def owner(self) -> Wallet:
+        return self._owner
+
     def execute_steps(self, steps: list[Union[STEPS, tuple]]):
         """Executes a multiple steps synchronously."""
         for step in steps:
@@ -214,6 +219,7 @@ def _register_subnet(
         else:
             self._netuid = self.s.subnets.get_total_subnets() - 1
         if response.success:
+            self._owner = owner_wallet
             logging.console.info(f"Subnet [blue]{self._netuid}[/blue] was registered.")
         self._add_call_record(REGISTER_SUBNET.__name__, response)
         return response
@@ -243,6 +249,7 @@ async def _async_register_subnet(
         else:
             self._netuid = self.s.subnets.get_total_subnets() - 1
         if response.success:
+            self._owner = owner_wallet
             logging.console.info(f"Subnet [blue]{self._netuid}[/blue] was registered.")
         self._add_call_record(REGISTER_SUBNET.__name__, response)
         return response

bittensor/utils/mock/subtensor_mock.py

@@ -976,7 +976,6 @@ def neuron_for_uid_lite(
 
         neuron_info = self._neuron_subnet_exists(uid, netuid, block)
         if neuron_info is None:
-            # TODO Why does this return None here but a null neuron earlier?
             return None
 
         else:

tests/e2e_tests/test_hotkeys.py

@@ -5,7 +5,6 @@
     RegistrationNotPermittedOnRootSubnet,
     SubnetNotExists,
     InvalidChild,
-    TooManyChildren,
     ProportionOverflow,
     DuplicateChild,
     TxRateLimitExceeded,
@@ -227,7 +226,7 @@ def test_children(subtensor, alice_wallet, bob_wallet, dave_wallet):
         )
 
     with pytest.raises(DuplicateChild):
-        subtensor.set_children(
+        subtensor.wallets.set_children(
             wallet=alice_wallet,
             hotkey_ss58=alice_wallet.hotkey.ss58_address,
             netuid=dave_sn.netuid,
@@ -532,7 +531,7 @@ async def test_children_async(async_subtensor, alice_wallet, bob_wallet, dave_wa
             raise_error=True,
         )
 
-    with pytest.raises(TooManyChildren):
+    with pytest.raises(DuplicateChild):
         await async_subtensor.extrinsics.set_children(
             wallet=alice_wallet,
             hotkey_ss58=alice_wallet.hotkey.ss58_address,