Merge branch 'staging' into feat/roman/subtensor-api

Author: basfroman

README.md

@@ -239,18 +239,18 @@ pytest tests/unit_tests
 - are executed very quickly
 - require docker installed in OS
 
-Ho to use:
+How to use:
 ```bash
 pytest tests/e2e_tests
 ```
 
-#### TUsing `legacy runner`:
+#### Using `legacy runner`:
 - Will start compilation of the collected code in your subtensor repository
 - you must provide the `LOCALNET_SH_PATH` variable in the local environment with the path to the file `/scripts/localnet.sh` in the cloned repository within your OS
 - you can use the `BUILD_BINARY=0` variable, this will skip the copy step for each test.
 - you can use the `USE_DOCKER=0` variable, this will run tests using the "legacy runner", even if docker is installed in your OS
 
-#### Ho to use:
+#### How to use:
 Regular e2e tests run
 ```bash
 LOCALNET_SH_PATH=/path/to/your/localnet.sh pytest tests/e2e_tests

tests/e2e_tests/test_commit_reveal_v3.py

@@ -129,6 +129,7 @@ async def test_commit_and_reveal_weights_cr3(local_chain, subtensor, alice_walle
         wait_for_inclusion=True,
         wait_for_finalization=True,
         block_time=BLOCK_TIME,
+        period=16,
     )
 
     # Assert committing was a success

tests/e2e_tests/test_staking.py

@@ -5,7 +5,7 @@
 from tests.helpers.helpers import ApproxBalance
 from tests.e2e_tests.utils.e2e_test_utils import wait_to_start_call
 
-logging.enable_info()
+logging.enable_debug()
 
 
 def test_single_operation(subtensor, alice_wallet, bob_wallet):
@@ -162,11 +162,11 @@ def test_single_operation(subtensor, alice_wallet, bob_wallet):
         ),
     }
 
+    # unstale all to check in later
     success = subtensor.unstake(
         wallet=alice_wallet,
         hotkey_ss58=bob_wallet.hotkey.ss58_address,
         netuid=alice_subnet_netuid,
-        amount=stake_bob,
         wait_for_inclusion=True,
         wait_for_finalization=True,
         period=16,
@@ -180,6 +180,7 @@ def test_single_operation(subtensor, alice_wallet, bob_wallet):
         netuid=alice_subnet_netuid,
     )
 
+    # all balances have been unstaked
     assert stake == Balance(0).set_unit(alice_subnet_netuid)
 
 

tests/unit_tests/extrinsics/test_registration.py

@@ -80,40 +80,37 @@ def test_register_extrinsic_without_pow(
     mocker,
 ):
     # Arrange
-    with (
-        mocker.patch.object(
-            mock_subtensor, "subnet_exists", return_value=subnet_exists
-        ),
-        mocker.patch.object(
-            mock_subtensor,
-            "get_neuron_for_pubkey_and_subnet",
-            return_value=mocker.MagicMock(is_null=neuron_is_null),
-        ),
-        mocker.patch("torch.cuda.is_available", return_value=cuda_available),
-        mocker.patch(
-            "bittensor.utils.registration.pow._get_block_with_retry",
-            return_value=(0, 0, "00ff11ee"),
-        ),
-    ):
-        # Act
-        result = registration.register_extrinsic(
-            subtensor=mock_subtensor,
-            wallet=mock_wallet,
-            netuid=123,
-            wait_for_inclusion=True,
-            wait_for_finalization=True,
-            max_allowed_attempts=3,
-            output_in_place=True,
-            cuda=True,
-            dev_id=0,
-            tpb=256,
-            num_processes=None,
-            update_interval=None,
-            log_verbose=False,
-        )
+    mocker.patch.object(mock_subtensor, "subnet_exists", return_value=subnet_exists)
+    mocker.patch.object(
+        mock_subtensor,
+        "get_neuron_for_pubkey_and_subnet",
+        return_value=mocker.MagicMock(is_null=neuron_is_null),
+    )
+    mocker.patch("torch.cuda.is_available", return_value=cuda_available)
+    mocker.patch(
+        "bittensor.utils.registration.pow._get_block_with_retry",
+        return_value=(0, 0, "00ff11ee"),
+    )
 
-        # Assert
-        assert result == expected_result, f"Test failed for test_id: {test_id}"
+    # Act
+    result = registration.register_extrinsic(
+        subtensor=mock_subtensor,
+        wallet=mock_wallet,
+        netuid=123,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        max_allowed_attempts=3,
+        output_in_place=True,
+        cuda=True,
+        dev_id=0,
+        tpb=256,
+        num_processes=None,
+        update_interval=None,
+        log_verbose=False,
+    )
+
+    # Assert
+    assert result == expected_result, f"Test failed for test_id: {test_id}"
 
 
 @pytest.mark.parametrize(
@@ -141,48 +138,47 @@ def test_register_extrinsic_with_pow(
     mocker,
 ):
     # Arrange
-    with (
-        mocker.patch(
-            "bittensor.utils.registration.pow._solve_for_difficulty_fast",
-            return_value=mock_pow_solution if pow_success else None,
-        ),
-        mocker.patch(
-            "bittensor.utils.registration.pow._solve_for_difficulty_fast_cuda",
-            return_value=mock_pow_solution if pow_success else None,
-        ),
-        mocker.patch(
-            "bittensor.core.extrinsics.registration._do_pow_register",
-            return_value=(registration_success, "HotKeyAlreadyRegisteredInSubNet"),
-        ),
-        mocker.patch("torch.cuda.is_available", return_value=cuda),
-    ):
-        # Act
-        if pow_success:
-            mock_pow_solution.is_stale.return_value = pow_stale
-
-        if not pow_success and hotkey_registered:
-            mock_subtensor.is_hotkey_registered = mocker.MagicMock(
-                return_value=hotkey_registered
-            )
-
-        result = registration.register_extrinsic(
-            subtensor=mock_subtensor,
-            wallet=mock_wallet,
-            netuid=123,
-            wait_for_inclusion=True,
-            wait_for_finalization=True,
-            max_allowed_attempts=3,
-            output_in_place=True,
-            cuda=cuda,
-            dev_id=0,
-            tpb=256,
-            num_processes=None,
-            update_interval=None,
-            log_verbose=False,
+    mocker.patch(
+        "bittensor.utils.registration.pow._solve_for_difficulty_fast",
+        return_value=mock_pow_solution if pow_success else None,
+    )
+    mocker.patch(
+        "bittensor.utils.registration.pow._solve_for_difficulty_fast_cuda",
+        return_value=mock_pow_solution if pow_success else None,
+    )
+    mocker.patch(
+        "bittensor.core.extrinsics.registration._do_pow_register",
+        return_value=(registration_success, "HotKeyAlreadyRegisteredInSubNet"),
+    )
+    mocker.patch("torch.cuda.is_available", return_value=cuda)
+
+    # Act
+    if pow_success:
+        mock_pow_solution.is_stale.return_value = pow_stale
+
+    if not pow_success and hotkey_registered:
+        mock_subtensor.is_hotkey_registered = mocker.MagicMock(
+            return_value=hotkey_registered
         )
 
-        # Assert
-        assert result == expected_result, f"Test failed for test_id: {test_id}."
+    result = registration.register_extrinsic(
+        subtensor=mock_subtensor,
+        wallet=mock_wallet,
+        netuid=123,
+        wait_for_inclusion=True,
+        wait_for_finalization=True,
+        max_allowed_attempts=3,
+        output_in_place=True,
+        cuda=cuda,
+        dev_id=0,
+        tpb=256,
+        num_processes=None,
+        update_interval=None,
+        log_verbose=False,
+    )
+
+    # Assert
+    assert result == expected_result, f"Test failed for test_id: {test_id}."
 
 
 @pytest.mark.parametrize(
@@ -209,29 +205,26 @@ def test_burned_register_extrinsic(
     mocker,
 ):
     # Arrange
-    with (
-        mocker.patch.object(
-            mock_subtensor, "subnet_exists", return_value=subnet_exists
-        ),
-        mocker.patch.object(
-            mock_subtensor,
-            "get_neuron_for_pubkey_and_subnet",
-            return_value=mocker.MagicMock(is_null=neuron_is_null),
-        ),
-        mocker.patch(
-            "bittensor.core.extrinsics.registration._do_burned_register",
-            return_value=(recycle_success, "Mock error message"),
-        ),
-        mocker.patch.object(
-            mock_subtensor, "is_hotkey_registered", return_value=is_registered
-        ),
-    ):
-        # Act
-        result = registration.burned_register_extrinsic(
-            subtensor=mock_subtensor, wallet=mock_wallet, netuid=123
-        )
-        # Assert
-        assert result == expected_result, f"Test failed for test_id: {test_id}"
+    mocker.patch.object(mock_subtensor, "subnet_exists", return_value=subnet_exists)
+    mocker.patch.object(
+        mock_subtensor,
+        "get_neuron_for_pubkey_and_subnet",
+        return_value=mocker.MagicMock(is_null=neuron_is_null),
+    )
+    mocker.patch(
+        "bittensor.core.extrinsics.registration._do_burned_register",
+        return_value=(recycle_success, "Mock error message"),
+    )
+    mocker.patch.object(
+        mock_subtensor, "is_hotkey_registered", return_value=is_registered
+    )
+
+    # Act
+    result = registration.burned_register_extrinsic(
+        subtensor=mock_subtensor, wallet=mock_wallet, netuid=123
+    )
+    # Assert
+    assert result == expected_result, f"Test failed for test_id: {test_id}"
 
 
 def test_set_subnet_identity_extrinsic_is_success(mock_subtensor, mock_wallet, mocker):

tests/unit_tests/test_dendrite.py

@@ -305,7 +305,7 @@ async def test_dendrite__call__success_response(
     )
     mock_aio_response.post(
         f"http://127.0.0.1:666/SynapseDummy",
-        body=expected_synapse.json(),
+        body=expected_synapse.model_dump_json(),
     )
     synapse = await setup_dendrite.call(axon_info, synapse=input_synapse)
 

tests/unit_tests/test_metagraph.py

@@ -129,10 +129,10 @@ def mock_subtensor(mocker):
 @pytest.fixture
 def metagraph_instance(mocker):
     metagraph = Metagraph(netuid=1337, sync=False)
-    metagraph._assign_neurons = mocker.AsyncMock()
-    metagraph._set_metagraph_attributes = mocker.AsyncMock()
-    metagraph._set_weights_and_bonds = mocker.AsyncMock()
-    metagraph._get_all_stakes_from_chain = mocker.AsyncMock()
+    metagraph._assign_neurons = mocker.Mock()
+    metagraph._set_metagraph_attributes = mocker.Mock()
+    metagraph._set_weights_and_bonds = mocker.Mock()
+    metagraph._get_all_stakes_from_chain = mocker.Mock()
     return metagraph
 
 

tests/unit_tests/test_subtensor.py

@@ -2258,7 +2258,6 @@ def test_networks_during_connection(mock_substrate, mocker):
         sub.chain_endpoint = settings.NETWORK_MAP.get(network)
 
 
-@pytest.mark.asyncio
 def test_get_stake_for_coldkey_and_hotkey(subtensor, mocker):
     netuids = [1, 2, 3]
     stake_info_dict = {