[CHIA-3633] August 2025 pass of Ruff linting rules (#19929)

* Enable Ruff `PLR1704` (`redefined-argument-from-local`)

* Enable Ruff `PLR5501` (`collapsible-else-if`)

* Enable Ruff `PLW2901` (`redefined-loop-name`)

* bad change

* Enable Ruff `RUF043` (`pytest-raises-ambiguous-pattern`)

* Enable Ruff `RUF046` (`unnecessary-cast-to-int`)

* Enable Ruff `RUF052` (`used-dummy-variable`)

* Remove unused ignore `UP006`

* One mis-signaled regex

* Comments by @altendky

* bad change, my bad

Author: Quexington

chia/_tests/blockchain/blockchain_test_utils.py

@@ -116,11 +116,10 @@ async def _validate_and_add_block(
         if err is not None:
             # Got an error
             raise AssertionError(err)
-    else:
-        # Here we will enforce checking of the exact error
-        if err != expected_error:
-            # Did not get the right error, or did not get an error
-            raise AssertionError(f"Expected {expected_error} but got {err}")
+    # Here we will enforce checking of the exact error
+    elif err != expected_error:
+        # Did not get the right error, or did not get an error
+        raise AssertionError(f"Expected {expected_error} but got {err}")
 
     if expected_result is not None and expected_result != result:
         raise AssertionError(f"Expected {expected_result} but got {result}")

chia/_tests/blockchain/test_augmented_chain.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
@@ -93,7 +94,7 @@ async def test_augmented_chain(default_10000_blocks: list[FullBlock]) -> None:
     with pytest.raises(KeyError):
         await abc.prev_block_hash([blocks[2].header_hash])
 
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await abc.lookup_block_generators(blocks[3].header_hash, {uint32(3)})
 
     block_records = []
@@ -105,11 +106,11 @@ async def test_augmented_chain(default_10000_blocks: list[FullBlock]) -> None:
 
     assert abc.height_to_block_record(uint32(1)) == block_records[1]
 
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await abc.lookup_block_generators(blocks[10].header_hash, {uint32(3), uint32(10)})
 
     # block 1 exists in the chain, but it doesn't have a generator
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await abc.lookup_block_generators(blocks[1].header_hash, {uint32(1)})
 
     expect_gen = blocks[2].transactions_generator

chia/_tests/blockchain/test_blockchain.py

@@ -4,6 +4,7 @@
 import copy
 import logging
 import random
+import re
 import time
 from collections.abc import AsyncIterator, Awaitable
 from contextlib import asynccontextmanager
@@ -4158,24 +4159,24 @@ async def test_lookup_block_generators(
     # make sure we don't cross the forks
     if clear_cache:
         b.clean_block_records()
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await b.lookup_block_generators(peak_1.prev_header_hash, {uint32(516)})
 
     if clear_cache:
         b.clean_block_records()
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await b.lookup_block_generators(peak_2.prev_header_hash, {uint32(503)})
 
     # make sure we fail when looking up a non-transaction block from the main
     # chain, regardless of which chain we start at
     if clear_cache:
         b.clean_block_records()
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await b.lookup_block_generators(peak_1.prev_header_hash, {uint32(8)})
 
     if clear_cache:
         b.clean_block_records()
-    with pytest.raises(ValueError, match="Err.GENERATOR_REF_HAS_NO_GENERATOR"):
+    with pytest.raises(ValueError, match=re.escape(Err.GENERATOR_REF_HAS_NO_GENERATOR.name)):
         await b.lookup_block_generators(peak_2.prev_header_hash, {uint32(8)})
 
     # if we try to look up generators starting from a disconnected block, we

chia/_tests/conftest.py

@@ -230,8 +230,8 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
 @pytest.fixture(scope="session", name="bt")
 async def block_tools_fixture(get_keychain, blockchain_constants, anyio_backend) -> BlockTools:
     # Note that this causes a lot of CPU and disk traffic - disk, DB, ports, process creation ...
-    _shared_block_tools = await create_block_tools_async(constants=blockchain_constants, keychain=get_keychain)
-    return _shared_block_tools
+    shared_block_tools = await create_block_tools_async(constants=blockchain_constants, keychain=get_keychain)
+    return shared_block_tools
 
 
 # if you have a system that has an unusual hostname for localhost and you want

chia/_tests/core/data_layer/test_data_rpc.py

@@ -2278,7 +2278,7 @@ async def test_unsubscribe_unknown(
     bare_data_layer_api: DataLayerRpcApi,
     seeded_random: random.Random,
 ) -> None:
-    with pytest.raises(RuntimeError, match="No subscription found for the given store_id."):
+    with pytest.raises(RuntimeError, match="No subscription found for the given store_id"):
         await bare_data_layer_api.unsubscribe(request={"id": bytes32.random(seeded_random).hex(), "retain": False})
 
 

chia/_tests/core/data_layer/test_data_store.py

@@ -594,7 +594,7 @@ async def test_ancestor_table_unique_inserts(data_store: DataStore, store_id: by
     hash_2 = bytes32.from_hexstr("924be8ff27e84cba17f5bc918097f8410fab9824713a4668a21c8e060a8cab40")
     await data_store._insert_ancestor_table(hash_1, hash_2, store_id, 2)
     await data_store._insert_ancestor_table(hash_1, hash_2, store_id, 2)
-    with pytest.raises(Exception, match="^Requested insertion of ancestor"):
+    with pytest.raises(Exception, match=r"^Requested insertion of ancestor"):
         await data_store._insert_ancestor_table(hash_1, hash_1, store_id, 2)
     await data_store._insert_ancestor_table(hash_1, hash_2, store_id, 2)
 
@@ -2385,11 +2385,10 @@ async def test_get_leaf_at_minimum_height(
                 if isinstance(node, InternalNode):
                     heights[node.left_hash] = heights[node.hash] + 1
                     heights[node.right_hash] = heights[node.hash] + 1
+                elif min_leaf_height is not None:
+                    min_leaf_height = min(min_leaf_height, heights[node.hash])
                 else:
-                    if min_leaf_height is not None:
-                        min_leaf_height = min(min_leaf_height, heights[node.hash])
-                    else:
-                        min_leaf_height = heights[node.hash]
+                    min_leaf_height = heights[node.hash]
 
             assert min_leaf_height is not None
             if pre > 0:

chia/_tests/core/full_node/stores/test_block_store.py

@@ -418,8 +418,8 @@ def generator(i: int) -> SerializedProgram:
         store = await BlockStore.create(db_wrapper, use_cache=use_cache)
 
         new_blocks = []
-        for i, block in enumerate(blocks):
-            block = block.replace(transactions_generator=generator(i))
+        for i, original_block in enumerate(blocks):
+            block = original_block.replace(transactions_generator=generator(i))
             block_record = header_block_to_sub_block_record(
                 DEFAULT_CONSTANTS, uint64(0), block, uint64(0), False, uint8(0), uint32(max(0, block.height - 1)), None
             )

chia/_tests/core/full_node/test_address_manager.py

@@ -560,7 +560,7 @@ async def check_retrieved_peers(self, wanted_peers: list[ExtendedPeerInfo], addr
     # use tmp_path pytest fixture to create a temporary directory
     async def test_serialization(self, tmp_path: Path):
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))
@@ -587,7 +587,7 @@ async def test_serialization(self, tmp_path: Path):
     @pytest.mark.anyio
     async def test_bad_ip_encoding(self, tmp_path: Path):
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))
@@ -725,7 +725,7 @@ async def old_serialize(address_manager: AddressManager, peers_file_path: Path)
 
         # create a file with the old serialization, then migrate to new serialization
         addrman = AddressManagerTest()
-        now = int(math.floor(time.time()))
+        now = math.floor(time.time())
         t_peer1 = TimestampedPeerInfo("250.7.1.1", uint16(8333), uint64(now - 10000))
         t_peer2 = TimestampedPeerInfo("1050:0000:0000:0000:0005:0600:300c:326b", uint16(9999), uint64(now - 20000))
         t_peer3 = TimestampedPeerInfo("250.7.3.3", uint16(9999), uint64(now - 30000))

chia/_tests/core/full_node/test_full_node.py

@@ -2678,16 +2678,15 @@ async def test_long_reorg_nodes(
             blocks = default_10000_blocks[: 1600 - chain_length]
             reorg_blocks = test_long_reorg_blocks_light[: 1600 - chain_length]
             reorg_height = 2000
-    else:
-        if fork_point == 1500:
-            blocks = default_10000_blocks[: 1900 - chain_length]
-            reorg_blocks = test_long_reorg_1500_blocks[: 1900 - chain_length]
-            reorg_height = 2300
-        else:  # pragma: no cover
-            pytest.skip("We rely on the light-blocks test for a 0 forkpoint")
-            blocks = default_10000_blocks[: 1100 - chain_length]
-            # reorg_blocks = test_long_reorg_blocks[: 1100 - chain_length]
-            reorg_height = 1600
+    elif fork_point == 1500:
+        blocks = default_10000_blocks[: 1900 - chain_length]
+        reorg_blocks = test_long_reorg_1500_blocks[: 1900 - chain_length]
+        reorg_height = 2300
+    else:  # pragma: no cover
+        pytest.skip("We rely on the light-blocks test for a 0 forkpoint")
+        blocks = default_10000_blocks[: 1100 - chain_length]
+        # reorg_blocks = test_long_reorg_blocks[: 1100 - chain_length]
+        reorg_height = 1600
 
     # this is a pre-requisite for a reorg to happen
     assert default_10000_blocks[reorg_height].weight > reorg_blocks[-1].weight
@@ -3163,15 +3162,14 @@ async def declare_pos_unfinished_block(
         challenge_chain_sp = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
     if block.reward_chain_block.reward_chain_sp_vdf is not None:
         reward_chain_sp = block.reward_chain_block.reward_chain_sp_vdf.output.get_hash()
+    elif len(block.finished_sub_slots) > 0:
+        reward_chain_sp = block.finished_sub_slots[-1].reward_chain.get_hash()
     else:
-        if len(block.finished_sub_slots) > 0:
-            reward_chain_sp = block.finished_sub_slots[-1].reward_chain.get_hash()
-        else:
-            curr = blockchain.block_record(block.prev_header_hash)
-            while not curr.first_in_sub_slot:
-                curr = blockchain.block_record(curr.prev_hash)
-            assert curr.finished_reward_slot_hashes is not None
-            reward_chain_sp = curr.finished_reward_slot_hashes[-1]
+        curr = blockchain.block_record(block.prev_header_hash)
+        while not curr.first_in_sub_slot:
+            curr = blockchain.block_record(curr.prev_hash)
+        assert curr.finished_reward_slot_hashes is not None
+        reward_chain_sp = curr.finished_reward_slot_hashes[-1]
     farmer_reward_address = block.foliage.foliage_block_data.farmer_reward_puzzle_hash
     pool_target = block.foliage.foliage_block_data.pool_target
     pool_target_signature = block.foliage.foliage_block_data.pool_signature

chia/_tests/core/mempool/test_mempool_fee_estimator.py

@@ -23,7 +23,6 @@ async def test_basics() -> None:
 
     cost = uint64(5000000)
     for i in range(300, 700):
-        i = uint32(i)
         items = []
         for _ in range(2, 100):
             fee = uint64(10000000)
@@ -50,7 +49,7 @@ async def test_basics() -> None:
             )
             items.append(mempool_item2)
 
-        fee_tracker.process_block(i, items)
+        fee_tracker.process_block(uint32(i), items)
 
     short, med, long = fee_tracker.estimate_fees()
 
@@ -72,7 +71,6 @@ async def test_fee_increase() -> None:
         estimator = SmartFeeEstimator(fee_tracker, uint64(test_constants.MAX_BLOCK_COST_CLVM))
         random = Random(x=1)
         for i in range(300, 700):
-            i = uint32(i)
             items = []
             for _ in range(20):
                 fee = uint64(0)
@@ -85,7 +83,7 @@ async def test_fee_increase() -> None:
                 )
                 items.append(mempool_item)
 
-            fee_tracker.process_block(i, items)
+            fee_tracker.process_block(uint32(i), items)
 
         short, med, long = fee_tracker.estimate_fees()
         mempool_info = mempool_manager.mempool.fee_estimator.get_mempool_info()