chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/util/test_action_scope.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator, final
+from typing import final
 
 import pytest
 

chia/_tests/util/test_async_pool.py

@@ -4,7 +4,7 @@ import asyncio
 import random
 import re
 from dataclasses import dataclass
-from typing import List, Optional, Tuple, Type
+from typing import Optional
 
 import anyio
 import pytest
@@ -110,7 +110,7 @@ async def test_worker_id_counts() -> None:
         worker_async_callable=worker,
         target_worker_count=1,
     ):
-        results: List[int] = []
+        results: list[int] = []
 
         with anyio.fail_after(adjusted_timeout(10)):
             for _ in expected_results:
@@ -194,7 +194,7 @@ async def test_simple_queue_example() -> None:
         for input in inputs:
             await work_queue.put(input)
 
-        results: List[int] = []
+        results: list[int] = []
 
         with anyio.fail_after(adjusted_timeout(10)):
             for _ in inputs:
@@ -228,7 +228,7 @@ async def test_simple_queue_example_using_queued() -> None:
         for job in jobs:
             await work_queue.put(job)
 
-        results: List[int] = []
+        results: list[int] = []
 
         with anyio.fail_after(adjusted_timeout(10)):
             for _ in expected_results:
@@ -266,7 +266,7 @@ async def test_queued_pre_cancel() -> None:
 
             await work_queue.put(job)
 
-        results: List[int] = []
+        results: list[int] = []
 
         with anyio.fail_after(adjusted_timeout(10)):
             for _ in expected_results:
@@ -304,7 +304,7 @@ async def test_queued_active_cancel() -> None:
         for job in jobs:
             await work_queue.put(job)
 
-        results: List[int] = []
+        results: list[int] = []
         with anyio.fail_after(adjusted_timeout(10)):
             for job in jobs:
                 await job.started.wait()
@@ -346,7 +346,7 @@ async def test_queued_raises() -> None:
         for job in jobs:
             await work_queue.put(job)
 
-        results: List[int] = []
+        results: list[int] = []
 
         with anyio.fail_after(adjusted_timeout(10)):
             for _ in expected_results:
@@ -355,7 +355,7 @@ async def test_queued_raises() -> None:
     raising_jobs = [job for job in jobs if job.input in raises]
     expected_exceptions = [(Exception, (job.input,)) for job in raising_jobs]
 
-    exceptions: List[Tuple[Type[BaseException], Tuple[int]]] = []
+    exceptions: list[tuple[type[BaseException], tuple[int]]] = []
     for job in raising_jobs:
         exception = job.exception
         assert isinstance(exception, BaseException)

chia/_tests/util/test_build_job_matrix.py

@@ -4,14 +4,13 @@ import json
 import pathlib
 import subprocess
 import sys
-from typing import Dict, List
 
 import chia._tests
 
 build_job_matrix_path = pathlib.Path(chia._tests.__file__).with_name("build-job-matrix.py")
 
 
-def run(args: List[str]) -> str:
+def run(args: list[str]) -> str:
     completed_process = subprocess.run(
         [sys.executable, build_job_matrix_path, *args],
         check=True,
@@ -22,7 +21,7 @@ def run(args: List[str]) -> str:
 
 
 def test() -> None:
-    timeouts: Dict[int, Dict[str, int]] = {}
+    timeouts: dict[int, dict[str, int]] = {}
 
     multipliers = [1, 2, 3]
 

chia/_tests/util/test_condition_tools.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List, Tuple
-
 import pytest
 from chia_rs import G1Element
 from clvm.casts import int_to_bytes
@@ -29,8 +27,8 @@ TEST_COIN = Coin(H1, H2, uint64(123))
 
 def mk_agg_sig_conditions(
     opcode: ConditionOpcode,
-    agg_sig_data: List[Tuple[G1Element, bytes]],
-    agg_sig_unsafe_data: List[Tuple[G1Element, bytes]] = [],
+    agg_sig_data: list[tuple[G1Element, bytes]],
+    agg_sig_unsafe_data: list[tuple[G1Element, bytes]] = [],
 ) -> SpendBundleConditions:
     spend = SpendConditions(
         coin_id=TEST_COIN.name(),
@@ -53,7 +51,7 @@ def mk_agg_sig_conditions(
         agg_sig_puzzle_amount=agg_sig_data if opcode == ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT else [],
         flags=0,
     )
-    return SpendBundleConditions([spend], 0, 0, 0, None, None, agg_sig_unsafe_data, 0, 0, 0, False)
+    return SpendBundleConditions([spend], 0, 0, 0, None, None, agg_sig_unsafe_data, 0, 0, 0, False, 0, 0)
 
 
 @pytest.mark.parametrize(
@@ -100,7 +98,7 @@ def test_pkm_pairs_vs_for_conditions_dict(opcode: ConditionOpcode) -> None:
 
 class TestPkmPairs:
     def test_empty_list(self) -> None:
-        conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False)
+        conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, False, 0, 0)
         pks, msgs = pkm_pairs(conds, b"foobar")
         assert pks == []
         assert msgs == []

chia/_tests/util/test_config.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Set
+from typing import Any, Optional
 
 from chia._tests.util.misc import DataCase, Marks, datacases
 from chia.server.outbound_message import NodeType
@@ -13,9 +13,9 @@ from chia.util.ints import uint16
 @dataclass
 class GetUnresolvedPeerInfosCase(DataCase):
     description: str
-    service_config: Dict[str, Any]
+    service_config: dict[str, Any]
     requested_node_type: NodeType
-    expected_peer_infos: Set[UnresolvedPeerInfo]
+    expected_peer_infos: set[UnresolvedPeerInfo]
     marks: Marks = ()
 
     @property
@@ -154,9 +154,9 @@ def test_get_unresolved_peer_infos(case: GetUnresolvedPeerInfosCase) -> None:
 @dataclass
 class SetPeerInfoCase(DataCase):
     description: str
-    service_config: Dict[str, Any]
+    service_config: dict[str, Any]
     requested_node_type: NodeType
-    expected_service_config: Dict[str, Any]
+    expected_service_config: dict[str, Any]
     peer_host: Optional[str] = None
     peer_port: Optional[int] = None
     marks: Marks = ()

chia/_tests/util/test_dump_keyring.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import os
 import re
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Sequence
 
 from click.testing import CliRunner
 

chia/_tests/util/test_full_block_utils.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import random
-from typing import Generator, Iterator, List, Optional
+from collections.abc import Generator, Iterator
+from typing import Optional
 
 import pytest
 from chia_rs import G1Element, G2Element
@@ -23,15 +24,20 @@ from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
 from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
 from chia.types.full_block import FullBlock
 from chia.types.header_block import HeaderBlock
-from chia.util.full_block_utils import block_info_from_block, generator_from_block, header_block_from_block
+from chia.util.full_block_utils import (
+    block_info_from_block,
+    generator_from_block,
+    get_height_and_tx_status_from_block,
+    header_block_from_block,
+)
 from chia.util.generator_tools import get_block_header
 from chia.util.ints import uint8, uint32, uint64, uint128
 
-test_g2s: List[G2Element] = [rand_g2() for _ in range(10)]
-test_g1s: List[G1Element] = [rand_g1() for _ in range(10)]
-test_hashes: List[bytes32] = [rand_hash() for _ in range(100)]
-test_vdfs: List[VDFInfo] = [rand_vdf() for _ in range(100)]
-test_vdf_proofs: List[VDFProof] = [rand_vdf_proof() for _ in range(100)]
+test_g2s: list[G2Element] = [rand_g2() for _ in range(10)]
+test_g1s: list[G1Element] = [rand_g1() for _ in range(10)]
+test_hashes: list[bytes32] = [rand_hash() for _ in range(100)]
+test_vdfs: list[VDFInfo] = [rand_vdf() for _ in range(100)]
+test_vdf_proofs: list[VDFProof] = [rand_vdf_proof() for _ in range(100)]
 
 
 def g2() -> G2Element:
@@ -200,12 +206,12 @@ def get_end_of_sub_slot() -> Generator[EndOfSubSlotBundle, None, None]:
                     )
 
 
-def get_finished_sub_slots() -> Generator[List[EndOfSubSlotBundle], None, None]:
+def get_finished_sub_slots() -> Generator[list[EndOfSubSlotBundle], None, None]:
     yield []
     yield [s for s in get_end_of_sub_slot()]
 
 
-def get_ref_list() -> Generator[List[uint32], None, None]:
+def get_ref_list() -> Generator[list[uint32], None, None]:
     yield []
     yield [uint32(1), uint32(2), uint32(3), uint32(4)]
     yield [uint32(256)]
@@ -244,7 +250,6 @@ def get_full_blocks() -> Iterator[FullBlock]:
 
 
 @pytest.mark.anyio
-@pytest.mark.skip("This test is expensive and has already convinced us the parser works")
 async def test_parser():
     # loop over every combination of Optionals being set and not set
     # along with random values for the FullBlock fields. Ensure
@@ -252,6 +257,9 @@ async def test_parser():
     # correctly
     for block in get_full_blocks():
         block_bytes = bytes(block)
+        height, is_tx_block = get_height_and_tx_status_from_block(block_bytes)
+        assert height == block.height
+        assert is_tx_block == (block.transactions_info is not None)
         gen = generator_from_block(block_bytes)
         assert gen == bytes(block.transactions_generator)
         bi = block_info_from_block(block_bytes)
@@ -266,6 +274,6 @@ async def test_parser():
 @pytest.mark.skip("This test is expensive and has already convinced us the parser works")
 async def test_header_block():
     for block in get_full_blocks():
-        hb: HeaderBlock = get_block_header(block, [], [])
+        hb: HeaderBlock = get_block_header(block)
         hb_bytes = header_block_from_block(memoryview(bytes(block)))
         assert HeaderBlock.from_bytes(hb_bytes) == hb

chia/_tests/util/test_limited_semaphore.py

@@ -6,6 +6,7 @@ from typing import Optional
 import pytest
 
 from chia.util.limited_semaphore import LimitedSemaphore, LimitedSemaphoreFullError
+from chia.util.task_referencer import create_referenced_task
 
 
 @pytest.mark.anyio
@@ -27,8 +28,8 @@ async def test_stuff() -> None:
     waiting_events = [asyncio.Event() for _ in range(waiting_limit)]
     failed_events = [asyncio.Event() for _ in range(beyond_limit)]
 
-    entered_tasks = [asyncio.create_task(acquire(entered_event=event)) for event in entered_events]
-    waiting_tasks = [asyncio.create_task(acquire(entered_event=event)) for event in waiting_events]
+    entered_tasks = [create_referenced_task(acquire(entered_event=event)) for event in entered_events]
+    waiting_tasks = [create_referenced_task(acquire(entered_event=event)) for event in waiting_events]
 
     await asyncio.gather(*(event.wait() for event in entered_events))
     assert all(event.is_set() for event in entered_events)
@@ -36,7 +37,7 @@ async def test_stuff() -> None:
 
     assert semaphore._available_count == 0
 
-    failure_tasks = [asyncio.create_task(acquire()) for _ in range(beyond_limit)]
+    failure_tasks = [create_referenced_task(acquire()) for _ in range(beyond_limit)]
 
     failure_results = await asyncio.gather(*failure_tasks, return_exceptions=True)
     assert [str(error) for error in failure_results] == [str(LimitedSemaphoreFullError())] * beyond_limit

chia/_tests/util/test_logging_filter.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 import time
-from re import split
 from time import sleep
 
 import pytest
@@ -27,7 +26,7 @@ def test_logging_filter(caplog: pytest.LogCaptureFixture) -> None:
             sleep(min(0.0, now - last_time))
             last_time = now
 
-    assert len(split("\n", caplog.text)) <= ((num_logs * sleep_secs) / log_interval_secs) + 1
+    assert len(caplog.text.split("\n")) <= ((num_logs * sleep_secs) / log_interval_secs) + 1
 
 
 def test_dont_filter_non_matches(caplog: pytest.LogCaptureFixture) -> None:
@@ -40,4 +39,4 @@ def test_dont_filter_non_matches(caplog: pytest.LogCaptureFixture) -> None:
         with caplog.at_level(logging.WARNING):
             log.warning(f"Don't Filter this log message {n}")
 
-    assert len(split("\n", caplog.text)) == num_log_statements
+    assert len(caplog.text.split("\n")) == num_log_statements

chia/_tests/util/test_misc.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import contextlib
-from typing import AsyncIterator, Iterator, List, Optional, Tuple, Type, TypeVar
+from collections.abc import AsyncIterator, Iterator
+from typing import Optional, TypeVar
 
 import aiohttp
 import anyio
@@ -89,7 +90,7 @@ def test_validate_directory_writable(tmp_path) -> None:
 
 def test_empty_lists() -> None:
     # An empty list should return an empty iterator and skip the loop's body.
-    empty: List[int] = []
+    empty: list[int] = []
     with pytest.raises(StopIteration):
         next(to_batches(empty, 1))
 
@@ -129,14 +130,14 @@ def test_invalid_input_type() -> None:
 
 
 @contextlib.contextmanager
-def sync_manager(y: List[str]) -> Iterator[None]:
+def sync_manager(y: list[str]) -> Iterator[None]:
     y.append("entered")
     yield
     y.append("exited")
 
 
 def test_split_manager_class_works() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitManager(manager=sync_manager(y=x), object=None)
     assert x == []
@@ -149,7 +150,7 @@ def test_split_manager_class_works() -> None:
 
 
 def test_split_manager_function_exits_if_needed() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     with split_manager(manager=sync_manager(y=x), object=None) as split:
         assert x == []
@@ -161,7 +162,7 @@ def test_split_manager_function_exits_if_needed() -> None:
 
 
 def test_split_manager_function_skips_if_not_needed() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     with split_manager(manager=sync_manager(y=x), object=None) as split:
         assert x == []
@@ -176,7 +177,7 @@ def test_split_manager_function_skips_if_not_needed() -> None:
 
 
 def test_split_manager_raises_on_second_entry() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitManager(manager=sync_manager(y=x), object=None)
     split.enter()
@@ -186,7 +187,7 @@ def test_split_manager_raises_on_second_entry() -> None:
 
 
 def test_split_manager_raises_on_second_entry_after_exiting() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitManager(manager=sync_manager(y=x), object=None)
     split.enter()
@@ -197,7 +198,7 @@ def test_split_manager_raises_on_second_entry_after_exiting() -> None:
 
 
 def test_split_manager_raises_on_second_exit() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitManager(manager=sync_manager(y=x), object=None)
     split.enter()
@@ -208,7 +209,7 @@ def test_split_manager_raises_on_second_exit() -> None:
 
 
 def test_split_manager_raises_on_exit_without_entry() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitManager(manager=sync_manager(y=x), object=None)
 
@@ -217,7 +218,7 @@ def test_split_manager_raises_on_exit_without_entry() -> None:
 
 
 @contextlib.asynccontextmanager
-async def async_manager(y: List[str]) -> AsyncIterator[None]:
+async def async_manager(y: list[str]) -> AsyncIterator[None]:
     y.append("entered")
     yield
     y.append("exited")
@@ -225,7 +226,7 @@ async def async_manager(y: List[str]) -> AsyncIterator[None]:
 
 @pytest.mark.anyio
 async def test_split_async_manager_class_works() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitAsyncManager(manager=async_manager(y=x), object=None)
     assert x == []
@@ -239,7 +240,7 @@ async def test_split_async_manager_class_works() -> None:
 
 @pytest.mark.anyio
 async def test_split_async_manager_function_exits_if_needed() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     async with split_async_manager(manager=async_manager(y=x), object=None) as split:
         assert x == []
@@ -252,7 +253,7 @@ async def test_split_async_manager_function_exits_if_needed() -> None:
 
 @pytest.mark.anyio
 async def test_split_async_manager_function_skips_if_not_needed() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     async with split_async_manager(manager=async_manager(y=x), object=None) as split:
         assert x == []
@@ -268,7 +269,7 @@ async def test_split_async_manager_function_skips_if_not_needed() -> None:
 
 @pytest.mark.anyio
 async def test_split_async_manager_raises_on_second_entry() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitAsyncManager(manager=async_manager(y=x), object=None)
     await split.enter()
@@ -279,7 +280,7 @@ async def test_split_async_manager_raises_on_second_entry() -> None:
 
 @pytest.mark.anyio
 async def test_split_async_manager_raises_on_second_entry_after_exiting() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitAsyncManager(manager=async_manager(y=x), object=None)
     await split.enter()
@@ -291,7 +292,7 @@ async def test_split_async_manager_raises_on_second_entry_after_exiting() -> Non
 
 @pytest.mark.anyio
 async def test_split_async_manager_raises_on_second_exit() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitAsyncManager(manager=async_manager(y=x), object=None)
     await split.enter()
@@ -303,7 +304,7 @@ async def test_split_async_manager_raises_on_second_exit() -> None:
 
 @pytest.mark.anyio
 async def test_split_async_manager_raises_on_exit_without_entry() -> None:
-    x: List[str] = []
+    x: list[str] = []
 
     split = SplitAsyncManager(manager=async_manager(y=x), object=None)
 
@@ -365,7 +366,7 @@ async def test_valued_event_wait_blocks_when_not_set() -> None:
 
 @pytest.mark.anyio
 async def test_valued_event_multiple_waits_all_get_values() -> None:
-    results: List[int] = []
+    results: list[int] = []
     valued_event = ValuedEvent[int]()
     value = 37
     task_count = 10
@@ -430,15 +431,15 @@ async def test_recording_web_server_specified_response(
         (42, uint64, False),
         (uint64(42), uint64, True),
         ("42", int, False),
-        ([4, 2], List[int], True),
-        ([4, "2"], List[int], False),
-        ((4, 2), Tuple[int, int], True),
-        ((4, "2"), Tuple[int, int], False),
-        ((4, 2), Tuple[int, ...], True),
-        ((4, "2"), Tuple[int, ...], False),
-        ([(4, Program.to([2]))], List[Tuple[int, Program]], True),
-        ([(4, "2")], Tuple[int, str], False),
+        ([4, 2], list[int], True),
+        ([4, "2"], list[int], False),
+        ((4, 2), tuple[int, int], True),
+        ((4, "2"), tuple[int, int], False),
+        ((4, 2), tuple[int, ...], True),
+        ((4, "2"), tuple[int, ...], False),
+        ([(4, Program.to([2]))], list[tuple[int, Program]], True),
+        ([(4, "2")], tuple[int, str], False),
     ],
 )
-def test_satisfies_hint(obj: T, type_hint: Type[T], expected_result: bool) -> None:
+def test_satisfies_hint(obj: T, type_hint: type[T], expected_result: bool) -> None:
     assert satisfies_hint(obj, type_hint) == expected_result

chia/_tests/util/test_network.py

@@ -3,42 +3,43 @@ from __future__ import annotations
 import os
 import sys
 from ipaddress import IPv4Address, IPv6Address
-from typing import Type, Union
+from typing import Union
 
 import pytest
 
-from chia.util.network import IPAddress, resolve
+from chia.util.ip_address import IPAddress
+from chia.util.network import resolve
 
 
-class TestNetwork:
-    @pytest.mark.anyio
-    async def test_resolve4(self):
-        # Run these tests forcing IPv4 resolution
-        prefer_ipv6 = False
-        assert await resolve("127.0.0.1", prefer_ipv6=prefer_ipv6) == IPAddress.create("127.0.0.1")
-        assert await resolve("10.11.12.13", prefer_ipv6=prefer_ipv6) == IPAddress.create("10.11.12.13")
-        assert await resolve("localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("127.0.0.1")
-        assert await resolve("example.net", prefer_ipv6=prefer_ipv6) == IPAddress.create("93.184.215.14")
+@pytest.mark.anyio
+async def test_resolve4() -> None:
+    # Run these tests forcing IPv4 resolution
+    prefer_ipv6 = False
+    assert await resolve("127.0.0.1", prefer_ipv6=prefer_ipv6) == IPAddress.create("127.0.0.1")
+    assert await resolve("10.11.12.13", prefer_ipv6=prefer_ipv6) == IPAddress.create("10.11.12.13")
+    assert await resolve("localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("127.0.0.1")
+    example = await resolve("example.net", prefer_ipv6=prefer_ipv6)
+    assert example.is_v4
+    assert not example.is_private
 
-    @pytest.mark.anyio
-    @pytest.mark.skipif(
-        condition=("GITHUB_ACTIONS" in os.environ) and (sys.platform in {"darwin", "win32"}),
-        reason="macOS and Windows runners in GitHub Actions do not seem to support IPv6",
-    )
-    async def test_resolve6(self):
-        # Run these tests forcing IPv6 resolution
-        prefer_ipv6 = True
-        assert await resolve("::1", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
-        assert await resolve("2000:1000::1234:abcd", prefer_ipv6=prefer_ipv6) == IPAddress.create(
-            "2000:1000::1234:abcd"
-        )
-        # ip6-localhost is not always available, and localhost is IPv4 only
-        # on some systems.  Just test neither here.
-        # assert await resolve("ip6-localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
-        # assert await resolve("localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
-        assert await resolve("example.net", prefer_ipv6=prefer_ipv6) == IPAddress.create(
-            "2606:2800:21f:cb07:6820:80da:af6b:8b2c"
-        )
+
+@pytest.mark.anyio
+@pytest.mark.skipif(
+    condition=("GITHUB_ACTIONS" in os.environ) and (sys.platform in {"darwin", "win32"}),
+    reason="macOS and Windows runners in GitHub Actions do not seem to support IPv6",
+)
+async def test_resolve6() -> None:
+    # Run these tests forcing IPv6 resolution
+    prefer_ipv6 = True
+    assert await resolve("::1", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
+    assert await resolve("2000:1000::1234:abcd", prefer_ipv6=prefer_ipv6) == IPAddress.create("2000:1000::1234:abcd")
+    # ip6-localhost is not always available, and localhost is IPv4 only
+    # on some systems.  Just test neither here.
+    # assert await resolve("ip6-localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
+    # assert await resolve("localhost", prefer_ipv6=prefer_ipv6) == IPAddress.create("::1")
+    example = await resolve("example.net", prefer_ipv6=prefer_ipv6)
+    assert example.is_v6
+    assert not example.is_private
 
 
 @pytest.mark.parametrize(
@@ -51,7 +52,7 @@ class TestNetwork:
         ("93.184.216.34", IPv4Address),
     ],
 )
-def test_ip_address(address_string: str, expected_inner: Type[Union[IPv4Address, IPv6Address]]) -> None:
+def test_ip_address(address_string: str, expected_inner: type[Union[IPv4Address, IPv6Address]]) -> None:
     inner = expected_inner(address_string)
     ip = IPAddress.create(address_string)
     # Helpers

chia/_tests/util/test_network_protocol_files.py

@@ -1,16 +1,16 @@
+# ruff: noqa: F405
 # this file is generated by build_network_protocol_files.py
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple
 
 from chia._tests.util.build_network_protocol_files import get_network_protocol_filename
 from chia._tests.util.network_protocol_data import *  # noqa: F403
 from chia._tests.util.protocol_messages_json import *  # noqa: F403
 
 
-def parse_blob(input_bytes: bytes) -> Tuple[bytes, bytes]:
+def parse_blob(input_bytes: bytes) -> tuple[bytes, bytes]:
     size_bytes = input_bytes[:4]
     input_bytes = input_bytes[4:]
     size = int.from_bytes(size_bytes, "big")
@@ -20,7 +20,6 @@ def parse_blob(input_bytes: bytes) -> Tuple[bytes, bytes]:
 
 
 def test_protocol_bytes() -> None:
-
     filename: Path = get_network_protocol_filename()
     assert filename.exists()
     with open(filename, "rb") as f:

chia/_tests/util/test_network_protocol_json.py

@@ -1,3 +1,4 @@
+# ruff: noqa: F405
 # this file is generated by build_network_protocol_files.py
 
 from __future__ import annotations