chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/core/data_layer/test_data_store.py

@@ -7,10 +7,11 @@ import random
 import re
 import statistics
 import time
+from collections.abc import Awaitable
 from dataclasses import dataclass
 from pathlib import Path
 from random import Random
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Tuple, cast
+from typing import Any, Callable, Optional, cast
 
 import aiohttp
 import aiosqlite
@@ -55,7 +56,7 @@ log = logging.getLogger(__name__)
 pytestmark = pytest.mark.data_layer
 
 
-table_columns: Dict[str, List[str]] = {
+table_columns: dict[str, list[str]] = {
     "node": ["hash", "node_type", "left", "right", "key", "value"],
     "root": ["tree_id", "generation", "node_hash", "status"],
 }
@@ -66,7 +67,7 @@ table_columns: Dict[str, List[str]] = {
 
 
 @pytest.mark.anyio
-async def test_valid_node_values_fixture_are_valid(data_store: DataStore, valid_node_values: Dict[str, Any]) -> None:
+async def test_valid_node_values_fixture_are_valid(data_store: DataStore, valid_node_values: dict[str, Any]) -> None:
     async with data_store.db_wrapper.writer() as writer:
         await writer.execute(
             """
@@ -80,7 +81,7 @@ async def test_valid_node_values_fixture_are_valid(data_store: DataStore, valid_
 @pytest.mark.parametrize(argnames=["table_name", "expected_columns"], argvalues=table_columns.items())
 @pytest.mark.anyio
 async def test_create_creates_tables_and_columns(
-    database_uri: str, table_name: str, expected_columns: List[str]
+    database_uri: str, table_name: str, expected_columns: list[str]
 ) -> None:
     # Never string-interpolate sql queries...  Except maybe in tests when it does not
     # allow you to parametrize the query.
@@ -101,7 +102,7 @@ async def test_create_creates_tables_and_columns(
 
 @pytest.mark.anyio
 async def test_create_tree_accepts_bytes32(raw_data_store: DataStore) -> None:
-    store_id = bytes32(b"\0" * 32)
+    store_id = bytes32.zeros
 
     await raw_data_store.create_tree(store_id=store_id)
 
@@ -298,7 +299,7 @@ async def test_get_ancestors(data_store: DataStore, store_id: bytes32) -> None:
 
 @pytest.mark.anyio
 async def test_get_ancestors_optimized(data_store: DataStore, store_id: bytes32) -> None:
-    ancestors: List[Tuple[int, bytes32, List[InternalNode]]] = []
+    ancestors: list[tuple[int, bytes32, list[InternalNode]]] = []
     random = Random()
     random.seed(100, version=2)
 
@@ -385,23 +386,23 @@ async def test_batch_update(
 ) -> None:
     total_operations = 1000 if use_optimized else 100
     num_ops_per_batch = total_operations // num_batches
-    saved_batches: List[List[Dict[str, Any]]] = []
-    saved_kv: List[List[TerminalNode]] = []
+    saved_batches: list[list[dict[str, Any]]] = []
+    saved_kv: list[list[TerminalNode]] = []
     db_uri = generate_in_memory_db_uri()
     async with DataStore.managed(database=db_uri, uri=True) as single_op_data_store:
         await single_op_data_store.create_tree(store_id, status=Status.COMMITTED)
         random = Random()
         random.seed(100, version=2)
 
-        batch: List[Dict[str, Any]] = []
-        keys_values: Dict[bytes, bytes] = {}
+        batch: list[dict[str, Any]] = []
+        keys_values: dict[bytes, bytes] = {}
         for operation in range(num_batches * num_ops_per_batch):
             [op_type] = random.choices(
                 ["insert", "upsert-insert", "upsert-update", "delete"],
                 [0.4, 0.2, 0.2, 0.2],
                 k=1,
             )
-            if op_type == "insert" or op_type == "upsert-insert" or len(keys_values) == 0:
+            if op_type in {"insert", "upsert-insert"} or len(keys_values) == 0:
                 if len(keys_values) == 0:
                     op_type = "insert"
                 key = operation.to_bytes(4, byteorder="big")
@@ -468,8 +469,8 @@ async def test_batch_update(
         assert {node.key: node.value for node in current_kv} == {
             node.key: node.value for node in saved_kv[batch_number]
         }
-        queue: List[bytes32] = [root.node_hash]
-        ancestors: Dict[bytes32, bytes32] = {}
+        queue: list[bytes32] = [root.node_hash]
+        ancestors: dict[bytes32, bytes32] = {}
         while len(queue) > 0:
             node_hash = queue.pop(0)
             expected_ancestors = []
@@ -722,7 +723,7 @@ async def test_autoinsert_balances_gaps(data_store: DataStore, store_id: bytes32
         if i == 0 or i > 10:
             insert_result = await data_store.autoinsert(key, value, store_id, status=Status.COMMITTED)
         else:
-            reference_node_hash = await data_store.get_terminal_node_for_seed(store_id, bytes32([0] * 32))
+            reference_node_hash = await data_store.get_terminal_node_for_seed(store_id, bytes32.zeros)
             insert_result = await data_store.insert(
                 key=key,
                 value=value,
@@ -1124,7 +1125,7 @@ async def test_kv_diff(data_store: DataStore, store_id: bytes32) -> None:
     random = Random()
     random.seed(100, version=2)
     insertions = 0
-    expected_diff: Set[DiffData] = set()
+    expected_diff: set[DiffData] = set()
     root_start = None
     for i in range(500):
         key = (i + 100).to_bytes(4, byteorder="big")
@@ -1175,7 +1176,7 @@ async def test_kv_diff_2(data_store: DataStore, store_id: bytes32) -> None:
         reference_node_hash=None,
         side=None,
     )
-    empty_hash = bytes32([0] * 32)
+    empty_hash = bytes32.zeros
     invalid_hash = bytes32([0] * 31 + [1])
     diff_1 = await data_store.get_kv_diff(store_id, empty_hash, insert_result.node_hash)
     assert diff_1 == {DiffData(OperationType.INSERT, b"000", b"000")}
@@ -1251,7 +1252,7 @@ async def test_subscribe_unsubscribe(data_store: DataStore, store_id: bytes32) -
 
     await data_store.unsubscribe(store_id)
     assert await data_store.get_subscriptions() == []
-    store_id2 = bytes32([0] * 32)
+    store_id2 = bytes32.zeros
 
     await data_store.subscribe(
         Subscription(
@@ -1422,7 +1423,7 @@ async def test_data_server_files(
     group_files_by_store: bool,
     tmp_path: Path,
 ) -> None:
-    roots: List[Root] = []
+    roots: list[Root] = []
     num_batches = 10
     num_ops_per_batch = 100
 
@@ -1432,11 +1433,11 @@ async def test_data_server_files(
         random = Random()
         random.seed(100, version=2)
 
-        keys: List[bytes] = []
+        keys: list[bytes] = []
         counter = 0
 
         for batch in range(num_batches):
-            changelist: List[Dict[str, Any]] = []
+            changelist: list[dict[str, Any]] = []
             for operation in range(num_ops_per_batch):
                 if random.randint(0, 4) > 0 or len(keys) == 0:
                     key = counter.to_bytes(4, byteorder="big")
@@ -1649,7 +1650,7 @@ async def test_benchmark_batch_insert_speed_multiple_batches(
 
 @pytest.mark.anyio
 async def test_delete_store_data(raw_data_store: DataStore) -> None:
-    store_id = bytes32(b"\0" * 32)
+    store_id = bytes32.zeros
     store_id_2 = bytes32(b"\0" * 31 + b"\1")
     await raw_data_store.create_tree(store_id=store_id, status=Status.COMMITTED)
     await raw_data_store.create_tree(store_id=store_id_2, status=Status.COMMITTED)
@@ -1864,7 +1865,7 @@ async def test_insert_from_delta_file(
     for generation in range(1, num_files + 2):
         root = await data_store.get_tree_root(store_id=store_id, generation=generation)
         await write_files_for_root(data_store, store_id, root, tmp_path_1, 0, False, group_files_by_store)
-        root_hashes.append(bytes32([0] * 32) if root.node_hash is None else root.node_hash)
+        root_hashes.append(bytes32.zeros if root.node_hash is None else root.node_hash)
     store_path = tmp_path_1.joinpath(f"{store_id}") if group_files_by_store else tmp_path_1
     with os.scandir(store_path) as entries:
         filenames = {entry.name for entry in entries}
@@ -2019,7 +2020,7 @@ async def test_insert_from_delta_file_correct_file_exists(
     for generation in range(1, num_files + 2):
         root = await data_store.get_tree_root(store_id=store_id, generation=generation)
         await write_files_for_root(data_store, store_id, root, tmp_path, 0, group_by_store=group_files_by_store)
-        root_hashes.append(bytes32([0] * 32) if root.node_hash is None else root.node_hash)
+        root_hashes.append(bytes32.zeros if root.node_hash is None else root.node_hash)
     store_path = tmp_path.joinpath(f"{store_id}") if group_files_by_store else tmp_path
     with os.scandir(store_path) as entries:
         filenames = {entry.name for entry in entries}
@@ -2156,7 +2157,7 @@ async def test_update_keys(data_store: DataStore, store_id: bytes32, use_upsert:
     num_values = 10
     new_keys = 10
     for value in range(num_values):
-        changelist: List[Dict[str, Any]] = []
+        changelist: list[dict[str, Any]] = []
         bytes_value = value.to_bytes(4, byteorder="big")
         if use_upsert:
             for key in range(num_keys):
@@ -2201,10 +2202,10 @@ async def test_migration_unknown_version(data_store: DataStore) -> None:
 
 async def _check_ancestors(
     data_store: DataStore, store_id: bytes32, root_hash: bytes32
-) -> Dict[bytes32, Optional[bytes32]]:
-    ancestors: Dict[bytes32, Optional[bytes32]] = {}
+) -> dict[bytes32, Optional[bytes32]]:
+    ancestors: dict[bytes32, Optional[bytes32]] = {}
     root_node: Node = await data_store.get_node(root_hash)
-    queue: List[Node] = [root_node]
+    queue: list[Node] = [root_node]
 
     while queue:
         node = queue.pop(0)
@@ -2231,7 +2232,7 @@ async def _check_ancestors(
 @pytest.mark.anyio
 async def test_build_ancestor_table(data_store: DataStore, store_id: bytes32) -> None:
     num_values = 1000
-    changelist: List[Dict[str, Any]] = []
+    changelist: list[dict[str, Any]] = []
     for value in range(num_values):
         value_bytes = value.to_bytes(4, byteorder="big")
         changelist.append({"action": "upsert", "key": value_bytes, "value": value_bytes})
@@ -2295,12 +2296,12 @@ async def test_sparse_ancestor_table(data_store: DataStore, store_id: bytes32) -
     assert previous_generation_count == 184
 
 
-async def get_all_nodes(data_store: DataStore, store_id: bytes32) -> List[Node]:
+async def get_all_nodes(data_store: DataStore, store_id: bytes32) -> list[Node]:
     root = await data_store.get_tree_root(store_id)
     assert root.node_hash is not None
     root_node = await data_store.get_node(root.node_hash)
-    nodes: List[Node] = []
-    queue: List[Node] = [root_node]
+    nodes: list[Node] = []
+    queue: list[Node] = [root_node]
 
     while len(queue) > 0:
         node = queue.pop(0)
@@ -2317,7 +2318,7 @@ async def get_all_nodes(data_store: DataStore, store_id: bytes32) -> List[Node]:
 @pytest.mark.anyio
 async def test_get_nodes(data_store: DataStore, store_id: bytes32) -> None:
     num_values = 50
-    changelist: List[Dict[str, Any]] = []
+    changelist: list[dict[str, Any]] = []
 
     for value in range(num_values):
         value_bytes = value.to_bytes(4, byteorder="big")
@@ -2332,7 +2333,7 @@ async def test_get_nodes(data_store: DataStore, store_id: bytes32) -> None:
     nodes = await data_store.get_nodes([node.hash for node in expected_nodes])
     assert nodes == expected_nodes
 
-    node_hash = bytes32([0] * 32)
+    node_hash = bytes32.zeros
     node_hash_2 = bytes32([0] * 31 + [1])
     with pytest.raises(Exception, match=f"^Nodes not found for hashes: {node_hash.hex()}, {node_hash_2.hex()}"):
         await data_store.get_nodes([node_hash, node_hash_2] + [node.hash for node in expected_nodes])
@@ -2349,11 +2350,11 @@ async def test_get_leaf_at_minimum_height(
 ) -> None:
     num_values = 1000
     value_offset = 1000000
-    all_min_leafs: Set[TerminalNode] = set()
+    all_min_leafs: set[TerminalNode] = set()
 
     if pre > 0:
         # This builds a complete binary tree, in order to test more than one batch in the queue before finding the leaf
-        changelist: List[Dict[str, Any]] = []
+        changelist: list[dict[str, Any]] = []
 
         for value in range(pre):
             value_bytes = (value * value).to_bytes(8, byteorder="big")
@@ -2375,12 +2376,12 @@ async def test_get_leaf_at_minimum_height(
         )
 
         if (value + 1) % batch_size == 0:
-            hash_to_parent: Dict[bytes32, InternalNode] = {}
+            hash_to_parent: dict[bytes32, InternalNode] = {}
             root = await data_store.get_tree_root(store_id)
             assert root.node_hash is not None
             min_leaf = await data_store.get_leaf_at_minimum_height(root.node_hash, hash_to_parent)
             all_nodes = await get_all_nodes(data_store, store_id)
-            heights: Dict[bytes32, int] = {}
+            heights: dict[bytes32, int] = {}
             heights[root.node_hash] = 0
             min_leaf_height = None
 

chia/_tests/core/data_layer/test_data_store_schema.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sqlite3
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -35,7 +35,7 @@ async def test_node_hash_must_be_32(
     data_store: DataStore,
     store_id: bytes32,
     length: int,
-    valid_node_values: Dict[str, Any],
+    valid_node_values: dict[str, Any],
 ) -> None:
     valid_node_values["hash"] = bytes([0] * length)
 
@@ -54,7 +54,7 @@ async def test_node_hash_must_be_32(
 async def test_node_hash_must_not_be_null(
     data_store: DataStore,
     store_id: bytes32,
-    valid_node_values: Dict[str, Any],
+    valid_node_values: dict[str, Any],
 ) -> None:
     valid_node_values["hash"] = None
 
@@ -74,7 +74,7 @@ async def test_node_type_must_be_valid(
     data_store: DataStore,
     node_type: NodeType,
     bad_node_type: int,
-    valid_node_values: Dict[str, Any],
+    valid_node_values: dict[str, Any],
 ) -> None:
     valid_node_values["node_type"] = bad_node_type
 
@@ -212,7 +212,7 @@ async def test_root_generation_must_not_be_less_than_zero(
 ) -> None:
     example = await add_01234567_example(data_store=data_store, store_id=store_id)
     values = {
-        "tree_id": bytes32([0] * 32),
+        "tree_id": bytes32.zeros,
         "generation": generation,
         "node_hash": example.terminal_nodes[0],
         "status": Status.PENDING,
@@ -233,7 +233,7 @@ async def test_root_generation_must_not_be_less_than_zero(
 async def test_root_generation_must_not_be_null(data_store: DataStore, store_id: bytes32) -> None:
     example = await add_01234567_example(data_store=data_store, store_id=store_id)
     values = {
-        "tree_id": bytes32([0] * 32),
+        "tree_id": bytes32.zeros,
         "generation": None,
         "node_hash": example.terminal_nodes[0],
         "status": Status.PENDING,
@@ -252,7 +252,7 @@ async def test_root_generation_must_not_be_null(data_store: DataStore, store_id:
 
 @pytest.mark.anyio
 async def test_root_node_hash_must_reference(data_store: DataStore) -> None:
-    values = {"tree_id": bytes32([0] * 32), "generation": 0, "node_hash": bytes32([0] * 32), "status": Status.PENDING}
+    values = {"tree_id": bytes32.zeros, "generation": 0, "node_hash": bytes32.zeros, "status": Status.PENDING}
 
     async with data_store.db_wrapper.writer() as writer:
         with pytest.raises(sqlite3.IntegrityError, match=r"^FOREIGN KEY constraint failed$"):
@@ -270,7 +270,7 @@ async def test_root_node_hash_must_reference(data_store: DataStore) -> None:
 async def test_root_status_must_be_valid(data_store: DataStore, store_id: bytes32, bad_status: int) -> None:
     example = await add_01234567_example(data_store=data_store, store_id=store_id)
     values = {
-        "tree_id": bytes32([0] * 32),
+        "tree_id": bytes32.zeros,
         "generation": 0,
         "node_hash": example.terminal_nodes[0],
         "status": bad_status,
@@ -290,7 +290,7 @@ async def test_root_status_must_be_valid(data_store: DataStore, store_id: bytes3
 @pytest.mark.anyio
 async def test_root_status_must_not_be_null(data_store: DataStore, store_id: bytes32) -> None:
     example = await add_01234567_example(data_store=data_store, store_id=store_id)
-    values = {"tree_id": bytes32([0] * 32), "generation": 0, "node_hash": example.terminal_nodes[0], "status": None}
+    values = {"tree_id": bytes32.zeros, "generation": 0, "node_hash": example.terminal_nodes[0], "status": None}
 
     async with data_store.db_wrapper.writer() as writer:
         with pytest.raises(sqlite3.IntegrityError, match=r"^NOT NULL constraint failed: root.status$"):
@@ -334,7 +334,7 @@ async def test_ancestors_ancestor_must_be_32(
                 INSERT INTO ancestors(hash, ancestor, tree_id, generation)
                 VALUES(:hash, :ancestor, :tree_id, :generation)
                 """,
-                {"hash": node_hash, "ancestor": bytes([0] * length), "tree_id": bytes32([0] * 32), "generation": 0},
+                {"hash": node_hash, "ancestor": bytes([0] * length), "tree_id": bytes32.zeros, "generation": 0},
             )
 
 
@@ -353,7 +353,7 @@ async def test_ancestors_store_id_must_be_32(
                 INSERT INTO ancestors(hash, ancestor, tree_id, generation)
                 VALUES(:hash, :ancestor, :tree_id, :generation)
                 """,
-                {"hash": node_hash, "ancestor": bytes32([0] * 32), "tree_id": bytes([0] * length), "generation": 0},
+                {"hash": node_hash, "ancestor": bytes32.zeros, "tree_id": bytes([0] * length), "generation": 0},
             )
 
 

chia/_tests/core/data_layer/util.py

@@ -6,8 +6,9 @@ import os
 import pathlib
 import shutil
 import subprocess
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import IO, TYPE_CHECKING, Any, Dict, Iterator, List, Literal, Optional, Union, overload
+from typing import IO, TYPE_CHECKING, Any, Literal, Optional, Union, overload
 
 from chia.data_layer.data_layer_util import InternalNode, Node, NodeType, Side, Status, TerminalNode
 from chia.data_layer.data_store import DataStore
@@ -15,7 +16,7 @@ from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 
 # from subprocess.pyi
-_FILE = Union[None, int, IO[Any]]
+_FILE = Union[int, IO[Any], None]
 
 
 if TYPE_CHECKING:
@@ -49,7 +50,7 @@ async def general_insert(
 @dataclass(frozen=True)
 class Example:
     expected: Node
-    terminal_nodes: List[bytes32]
+    terminal_nodes: list[bytes32]
 
 
 async def add_0123_example(data_store: DataStore, store_id: bytes32) -> Example:
@@ -121,7 +122,7 @@ class ChiaRoot:
 
     def run(
         self,
-        args: List[Union[str, os_PathLike_str]],
+        args: list[Union[str, os_PathLike_str]],
         *other_args: Any,
         check: bool = True,
         encoding: str = "utf-8",
@@ -141,13 +142,13 @@ class ChiaRoot:
         chia_executable = shutil.which("chia")
         if chia_executable is None:
             chia_executable = "chia"
-        modified_args: List[Union[str, os_PathLike_str]] = [
+        modified_args: list[Union[str, os_PathLike_str]] = [
             self.scripts_path.joinpath(chia_executable),
             "--root-path",
             self.path,
             *args,
         ]
-        processed_args: List[str] = [os.fspath(element) for element in modified_args]
+        processed_args: list[str] = [os.fspath(element) for element in modified_args]
         final_args = [processed_args, *other_args]
 
         kwargs["check"] = check
@@ -156,7 +157,7 @@ class ChiaRoot:
         kwargs["stderr"] = stderr
 
         try:
-            return subprocess.run(*final_args, **kwargs)
+            return subprocess.run(*final_args, **kwargs)  # noqa: PLW1510
         except OSError as e:
             raise Exception(f"failed to run:\n    {final_args}\n    {kwargs}") from e
 
@@ -191,20 +192,20 @@ def create_valid_node_values(
     node_type: Literal[NodeType.INTERNAL],
     left_hash: bytes32,
     right_hash: bytes32,
-) -> Dict[str, Any]: ...
+) -> dict[str, Any]: ...
 
 
 @overload
 def create_valid_node_values(
     node_type: Literal[NodeType.TERMINAL],
-) -> Dict[str, Any]: ...
+) -> dict[str, Any]: ...
 
 
 def create_valid_node_values(
     node_type: NodeType,
     left_hash: Optional[bytes32] = None,
     right_hash: Optional[bytes32] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     if node_type == NodeType.INTERNAL:
         assert left_hash is not None
         assert right_hash is not None

chia/_tests/core/farmer/test_farmer_api.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from asyncio import Task, create_task, gather, sleep
-from typing import Any, Coroutine, Optional, TypeVar
+from asyncio import Task, gather, sleep
+from collections.abc import Coroutine
+from typing import Any, Optional, TypeVar
 
 import pytest
 
@@ -19,13 +20,14 @@ from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.outbound_message import Message, NodeType
 from chia.util.hash import std_hash
 from chia.util.ints import uint8, uint32, uint64
+from chia.util.task_referencer import create_referenced_task
 
 T = TypeVar("T")
 
 
 async def begin_task(coro: Coroutine[Any, Any, T]) -> Task[T]:
     """Awaitable function that adds a coroutine to the event loop and sets it running."""
-    task = create_task(coro)
+    task = create_referenced_task(coro)
     await sleep(0)
 
     return task
@@ -38,7 +40,7 @@ async def test_farmer_ignores_concurrent_duplicate_signage_points(
     _, farmer_service, _ = farmer_one_harvester
     farmer_api: FarmerAPI = farmer_service._api
     farmer_server = farmer_service._server
-    incoming_queue, peer_id = await add_dummy_connection(farmer_server, self_hostname, 12312, NodeType.HARVESTER)
+    incoming_queue, _peer_id = await add_dummy_connection(farmer_server, self_hostname, 12312, NodeType.HARVESTER)
     # Consume the handshake
     response = (await incoming_queue.get()).type
     assert ProtocolMessageTypes(response).name == "harvester_handshake"

chia/_tests/core/full_node/full_sync/test_full_sync.py

@@ -1,15 +1,11 @@
-# flake8: noqa: F811, F401
 from __future__ import annotations
 
 import asyncio
-import dataclasses
 import logging
 import time
-from typing import List
 
 import pytest
 
-from chia._tests.conftest import ConsensusMode
 from chia._tests.core.node_height import node_height_between, node_height_exactly
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.full_node.full_node import FullNode
@@ -31,7 +27,7 @@ class TestFullSync:
     async def test_long_sync_from_zero(self, five_nodes, default_400_blocks, bt, self_hostname):
         # Must be larger than "sync_block_behind_threshold" in the config
         num_blocks = len(default_400_blocks)
-        blocks: List[FullBlock] = default_400_blocks
+        blocks: list[FullBlock] = default_400_blocks
         full_node_1, full_node_2, full_node_3, full_node_4, full_node_5 = five_nodes
         server_1 = full_node_1.full_node.server
         server_2 = full_node_2.full_node.server
@@ -117,7 +113,6 @@ class TestFullSync:
     async def test_sync_from_fork_point_and_weight_proof(
         self, three_nodes, default_1000_blocks, default_400_blocks, self_hostname
     ):
-        start = time.time()
         # Must be larger than "sync_block_behind_threshold" in the config
         num_blocks_initial = len(default_1000_blocks) - 50
         blocks_950 = default_1000_blocks[:num_blocks_initial]
@@ -345,7 +340,7 @@ class TestFullSync:
             assert peak1 is not None
 
             summary_heights = full_node_1.full_node.blockchain.get_ses_heights()
-            summaries: List[SubEpochSummary] = []
+            summaries: list[SubEpochSummary] = []
 
             # get ses list
             for sub_epoch_n, ses_height in enumerate(summary_heights):
@@ -395,7 +390,7 @@ class TestFullSync:
         await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), full_node_2.full_node.on_connect)
         await server_3.start_client(PeerInfo(self_hostname, server_1.get_port()), full_node_3.full_node.on_connect)
 
-        peers: List = [c for c in full_node_2.full_node.server.all_connections.values()]
+        peers: list = [c for c in full_node_2.full_node.server.all_connections.values()]
         request = full_node_protocol.RequestProofOfWeight(
             blocks_950[-1].height + 1, default_1000_blocks[-1].header_hash
         )
@@ -406,7 +401,7 @@ class TestFullSync:
         log.info(f"result was {res}")
         assert duration < 1
 
-        peers: List = [c for c in full_node_3.full_node.server.all_connections.values()]
+        peers: list = [c for c in full_node_3.full_node.server.all_connections.values()]
         request = full_node_protocol.RequestProofOfWeight(
             blocks_950[-1].height + 1, default_1000_blocks[-1].header_hash
         )
@@ -420,7 +415,7 @@ class TestFullSync:
     async def test_bad_peak_cache_invalidation(
         self, two_nodes, default_1000_blocks, blockchain_constants, consensus_mode
     ):
-        full_node_1, full_node_2, server_1, server_2, bt = two_nodes
+        full_node_1, _full_node_2, _server_1, _server_2, bt = two_nodes
 
         for block in default_1000_blocks[:-500]:
             await full_node_1.full_node.add_block(block)

chia/_tests/core/full_node/ram_db.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import contextlib
 import random
+from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import AsyncIterator, Tuple
 
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.constants import ConsensusConstants
@@ -15,7 +15,7 @@ from chia.util.db_wrapper import DBWrapper2
 @contextlib.asynccontextmanager
 async def create_ram_blockchain(
     consensus_constants: ConsensusConstants,
-) -> AsyncIterator[Tuple[DBWrapper2, Blockchain]]:
+) -> AsyncIterator[tuple[DBWrapper2, Blockchain]]:
     uri = f"file:db_{random.randint(0, 99999999)}?mode=memory&cache=shared"
     async with DBWrapper2.managed(database=uri, uri=True, reader_count=1, db_version=2) as db_wrapper:
         block_store = await BlockStore.create(db_wrapper)