Merge pull request #2831 from opentensor/feat/roman/ruff-version

Bumping ruff version

Author: basfroman

bittensor/core/async_subtensor.py

@@ -3005,7 +3005,7 @@ async def wait_for_block(self, block: Optional[int] = None):
 
         async def handler(block_data: dict):
             logging.debug(
-                f'reached block {block_data["header"]["number"]}. Waiting for block {target_block}'
+                f"reached block {block_data['header']['number']}. Waiting for block {target_block}"
             )
             if block_data["header"]["number"] >= target_block:
                 return True

bittensor/core/axon.py

@@ -504,9 +504,9 @@ def verify_custom(synapse: MyCustomSynapse):
             )
 
         param_class = first_param.annotation
-        assert issubclass(
-            param_class, Synapse
-        ), "The first argument of forward_fn must inherit from bittensor.Synapse"
+        assert issubclass(param_class, Synapse), (
+            "The first argument of forward_fn must inherit from bittensor.Synapse"
+        )
         request_name = param_class.__name__
 
         async def endpoint(*args, **kwargs):
@@ -580,19 +580,19 @@ async def endpoint(*args, **kwargs):
             blacklist_sig = Signature(
                 expected_params, return_annotation=Tuple[bool, str]
             )
-            assert (
-                signature(blacklist_fn) == blacklist_sig
-            ), f"The blacklist_fn function must have the signature: blacklist( synapse: {request_name} ) -> tuple[bool, str]"
+            assert signature(blacklist_fn) == blacklist_sig, (
+                f"The blacklist_fn function must have the signature: blacklist( synapse: {request_name} ) -> tuple[bool, str]"
+            )
         if priority_fn:
             priority_sig = Signature(expected_params, return_annotation=float)
-            assert (
-                signature(priority_fn) == priority_sig
-            ), f"The priority_fn function must have the signature: priority( synapse: {request_name} ) -> float"
+            assert signature(priority_fn) == priority_sig, (
+                f"The priority_fn function must have the signature: priority( synapse: {request_name} ) -> float"
+            )
         if verify_fn:
             verify_sig = Signature(expected_params, return_annotation=None)
-            assert (
-                signature(verify_fn) == verify_sig
-            ), f"The verify_fn function must have the signature: verify( synapse: {request_name} ) -> None"
+            assert signature(verify_fn) == verify_sig, (
+                f"The verify_fn function must have the signature: verify( synapse: {request_name} ) -> None"
+            )
 
         # Store functions in appropriate attribute dictionaries
         self.forward_class_types[request_name] = param_class
@@ -747,9 +747,9 @@ def check_config(cls, config: "Config"):
         Raises:
             AssertionError: If the axon or external ports are not in range [1024, 65535]
         """
-        assert (
-            1024 < config.axon.port < 65535
-        ), "Axon port must be in range [1024, 65535]"
+        assert 1024 < config.axon.port < 65535, (
+            "Axon port must be in range [1024, 65535]"
+        )
 
         assert config.axon.external_port is None or (
             1024 < config.axon.external_port < 65535

bittensor/core/extrinsics/asyncex/staking.py

@@ -127,7 +127,7 @@ async def add_stake_extrinsic(
             logging.info(
                 f":satellite: [magenta]Safe Staking to:[/magenta] "
                 f"[blue]netuid: [green]{netuid}[/green], amount: [green]{staking_balance}[/green], "
-                f"tolerance percentage: [green]{rate_tolerance*100}%[/green], "
+                f"tolerance percentage: [green]{rate_tolerance * 100}%[/green], "
                 f"price limit: [green]{rate_with_tolerance}[/green], "
                 f"original price: [green]{base_rate}[/green], "
                 f"with partial stake: [green]{allow_partial_stake}[/green] "

bittensor/core/extrinsics/asyncex/unstaking.py

@@ -106,7 +106,7 @@ async def unstake_extrinsic(
             logging.info(
                 f":satellite: [magenta]Safe Unstaking from:[/magenta] "
                 f"netuid: [green]{netuid}[/green], amount: [green]{unstaking_balance}[/green], "
-                f"tolerance percentage: [green]{rate_tolerance*100}%[/green], "
+                f"tolerance percentage: [green]{rate_tolerance * 100}%[/green], "
                 f"price limit: [green]{rate_with_tolerance}[/green], "
                 f"original price: [green]{base_rate}[/green], "
                 f"with partial unstake: [green]{allow_partial_stake}[/green] "

bittensor/core/extrinsics/staking.py

@@ -115,7 +115,7 @@ def add_stake_extrinsic(
             logging.info(
                 f":satellite: [magenta]Safe Staking to:[/magenta] "
                 f"[blue]netuid: [green]{netuid}[/green], amount: [green]{staking_balance}[/green], "
-                f"tolerance percentage: [green]{rate_tolerance*100}%[/green], "
+                f"tolerance percentage: [green]{rate_tolerance * 100}%[/green], "
                 f"price limit: [green]{rate_with_tolerance}[/green], "
                 f"original price: [green]{base_rate}[/green], "
                 f"with partial stake: [green]{allow_partial_stake}[/green] "

bittensor/core/extrinsics/unstaking.py

@@ -103,7 +103,7 @@ def unstake_extrinsic(
             logging.info(
                 f":satellite: [magenta]Safe Unstaking from:[/magenta] "
                 f"netuid: [green]{netuid}[/green], amount: [green]{unstaking_balance}[/green], "
-                f"tolerance percentage: [green]{rate_tolerance*100}%[/green], "
+                f"tolerance percentage: [green]{rate_tolerance * 100}%[/green], "
                 f"price limit: [green]{rate_with_tolerance}[/green], "
                 f"original price: [green]{base_rate}[/green], "
                 f"with partial unstake: [green]{allow_partial_stake}[/green] "

bittensor/core/subtensor.py

@@ -2467,7 +2467,7 @@ def wait_for_block(self, block: Optional[int] = None):
 
         def handler(block_data: dict):
             logging.debug(
-                f'reached block {block_data["header"]["number"]}. Waiting for block {target_block}'
+                f"reached block {block_data['header']['number']}. Waiting for block {target_block}"
             )
             if block_data["header"]["number"] >= target_block:
                 return True

bittensor/core/threadpool.py

@@ -219,7 +219,7 @@ def submit(self, fn: Callable, *args, **kwargs) -> _base.Future:
                 raise RuntimeError("cannot schedule new futures after shutdown")
             if _shutdown:
                 raise RuntimeError(
-                    "cannot schedule new futures after " "interpreter shutdown"
+                    "cannot schedule new futures after interpreter shutdown"
                 )
 
             priority = kwargs.get("priority", random.randint(0, 1000000))
@@ -269,7 +269,7 @@ def weakref_cb(_, q=self._work_queue):
     def _initializer_failed(self):
         with self._shutdown_lock:
             self._broken = (
-                "A thread initializer failed, the thread pool " "is not usable anymore"
+                "A thread initializer failed, the thread pool is not usable anymore"
             )
             # Drain work queue and mark pending futures failed
             while True:

pyproject.toml

@@ -56,7 +56,7 @@ dev = [
     "types-retry==0.9.9.4",
     "freezegun==1.5.0",
     "httpx==0.27.0",
-    "ruff==0.4.7",
+    "ruff==0.11.5",
     "aioresponses==0.7.6",
     "factory-boy==3.3.0",
     "types-requests",

tests/e2e_tests/test_axon.py

@@ -34,12 +34,12 @@ async def test_axon(subtensor, templates, alice_wallet):
     # Validate current metagraph stats
     old_axon = metagraph.axons[0]
     assert len(metagraph.axons) == 1, f"Expected 1 axon, but got {len(metagraph.axons)}"
-    assert (
-        old_axon.hotkey == alice_wallet.hotkey.ss58_address
-    ), "Hotkey mismatch for the axon"
-    assert (
-        old_axon.coldkey == alice_wallet.coldkey.ss58_address
-    ), "Coldkey mismatch for the axon"
+    assert old_axon.hotkey == alice_wallet.hotkey.ss58_address, (
+        "Hotkey mismatch for the axon"
+    )
+    assert old_axon.coldkey == alice_wallet.coldkey.ss58_address, (
+        "Coldkey mismatch for the axon"
+    )
     assert old_axon.ip == "0.0.0.0", f"Expected IP 0.0.0.0, but got {old_axon.ip}"
     assert old_axon.port == 0, f"Expected port 0, but got {old_axon.port}"
     assert old_axon.ip_type == 0, f"Expected IP type 0, but got {old_axon.ip_type}"
@@ -54,30 +54,30 @@ async def test_axon(subtensor, templates, alice_wallet):
         external_ip = networking.get_external_ip()
 
     # Assert updated attributes
-    assert (
-        len(metagraph.axons) == 1
-    ), f"Expected 1 axon, but got {len(metagraph.axons)} after mining"
+    assert len(metagraph.axons) == 1, (
+        f"Expected 1 axon, but got {len(metagraph.axons)} after mining"
+    )
 
-    assert (
-        len(metagraph.neurons) == 1
-    ), f"Expected 1 neuron, but got {len(metagraph.neurons)}"
+    assert len(metagraph.neurons) == 1, (
+        f"Expected 1 neuron, but got {len(metagraph.neurons)}"
+    )
 
-    assert (
-        updated_axon.ip == external_ip
-    ), f"Expected IP {external_ip}, but got {updated_axon.ip}"
+    assert updated_axon.ip == external_ip, (
+        f"Expected IP {external_ip}, but got {updated_axon.ip}"
+    )
 
-    assert (
-        updated_axon.ip_type == networking.ip_version(external_ip)
-    ), f"Expected IP type {networking.ip_version(external_ip)}, but got {updated_axon.ip_type}"
+    assert updated_axon.ip_type == networking.ip_version(external_ip), (
+        f"Expected IP type {networking.ip_version(external_ip)}, but got {updated_axon.ip_type}"
+    )
 
     assert updated_axon.port == 8091, f"Expected port 8091, but got {updated_axon.port}"
 
-    assert (
-        updated_axon.hotkey == alice_wallet.hotkey.ss58_address
-    ), "Hotkey mismatch after mining"
+    assert updated_axon.hotkey == alice_wallet.hotkey.ss58_address, (
+        "Hotkey mismatch after mining"
+    )
 
-    assert (
-        updated_axon.coldkey == alice_wallet.coldkey.ss58_address
-    ), "Coldkey mismatch after mining"
+    assert updated_axon.coldkey == alice_wallet.coldkey.ss58_address, (
+        "Coldkey mismatch after mining"
+    )
 
     print("✅ Passed test_axon")