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

chia/_tests/core/test_rpc_util.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import List
 
 import pytest
 
@@ -29,7 +28,7 @@ class TestRequestType(Streamable):
 @streamable
 @dataclass(frozen=True)
 class TestResponseObject(Streamable):
-    qat: List[str]
+    qat: list[str]
     sub: SubObject
 
 

chia/_tests/core/test_seeder.py

@@ -4,12 +4,19 @@ import time
 from dataclasses import dataclass
 from ipaddress import IPv4Address, IPv6Address
 from socket import AF_INET, AF_INET6, SOCK_STREAM
-from typing import Dict, List, Tuple, cast
+from typing import Optional, Union, cast
+from unittest.mock import AsyncMock
 
 import dns
 import pytest
+from dns.name import from_text
+from dns.rdataclass import IN
+from dns.rdatatype import AAAA as AAAA_TYPE
+from dns.rdatatype import A as A_TYPE
+from dns.rdtypes.IN.A import A
+from dns.rdtypes.IN.AAAA import AAAA
+from dns.rrset import RRset
 
-from chia._tests.util.time_out_assert import time_out_assert
 from chia.seeder.dns_server import DNSServer
 from chia.seeder.peer_record import PeerRecord, PeerReliability
 from chia.util.ints import uint32, uint64
@@ -17,7 +24,7 @@ from chia.util.ints import uint32, uint64
 timeout = 0.5
 
 
-def generate_test_combs() -> List[Tuple[bool, str, dns.rdatatype.RdataType]]:
+def generate_test_combs() -> list[tuple[bool, str, dns.rdatatype.RdataType]]:
     """
     Generates all the combinations of tests we want to run.
     """
@@ -60,7 +67,7 @@ class FakeDnsPacket:
 
 
 @pytest.fixture(scope="module")
-def database_peers() -> Dict[str, PeerReliability]:
+def database_peers() -> dict[str, PeerReliability]:
     """
     We override the values in the class with these dbs, to save time.
     """
@@ -98,7 +105,7 @@ async def make_dns_query(
     return await dns.asyncquery.udp(q=dns_message, where=target_address, timeout=d_timeout, port=port)
 
 
-def get_addresses(num_subnets: int = 10) -> Tuple[List[IPv4Address], List[IPv6Address]]:
+def get_addresses(num_subnets: int = 10) -> tuple[list[IPv4Address], list[IPv6Address]]:
     ipv4 = []
     ipv6 = []
     # generate 2500 ipv4 and 2500 ipv6 peers, it's just a string so who cares
@@ -110,7 +117,7 @@ def get_addresses(num_subnets: int = 10) -> Tuple[List[IPv4Address], List[IPv6Ad
 
 
 def assert_standard_results(
-    std_query_answer: List[dns.rrset.RRset], request_type: dns.rdatatype.RdataType, num_ns: int
+    std_query_answer: list[dns.rrset.RRset], request_type: dns.rdatatype.RdataType, num_ns: int
 ) -> None:
     if request_type == dns.rdatatype.A:
         assert len(std_query_answer) == 1  # only 1 kind of answer
@@ -164,7 +171,7 @@ async def test_error_conditions(
     no_peers_response = await make_dns_query(use_tcp, target_address, port, no_peers)
     assert no_peers_response.rcode() == dns.rcode.NOERROR
 
-    if request_type == dns.rdatatype.A or request_type == dns.rdatatype.AAAA:
+    if request_type in {dns.rdatatype.A, dns.rdatatype.AAAA}:
         assert len(no_peers_response.answer) == 0  # no response, as expected
     elif request_type == dns.rdatatype.ANY:  # ns + soa
         assert len(no_peers_response.answer) == 2
@@ -216,7 +223,7 @@ async def test_error_conditions(
             r = await dns.asyncquery.tcp(q=no_peers, where=target_address, timeout=timeout, sock=socket)
             assert r.answer == no_peers_response.answer
             # send 120, as the first 2 bytes / the length of the packet, so that the server expects more.
-            await socket.sendall(int(120).to_bytes(2, byteorder="big"), int(time.time() + timeout))
+            await socket.sendall((120).to_bytes(2, byteorder="big"), int(time.time() + timeout))
             await socket.close()
             with pytest.raises(EOFError):
                 await dns.asyncquery.receive_tcp(tcp_socket, timeout)
@@ -273,12 +280,11 @@ async def test_dns_queries(
             await make_dns_query(use_tcp, target_address, port, e_query)
 
 
-@pytest.mark.skip(reason="Flaky test with fixes in progress")
 @pytest.mark.anyio
 @pytest.mark.parametrize("use_tcp, target_address, request_type", all_test_combinations)
 async def test_db_processing(
     seeder_service: DNSServer,
-    database_peers: Dict[str, PeerReliability],
+    database_peers: dict[str, PeerReliability],
     use_tcp: bool,
     target_address: str,
     request_type: dns.rdatatype.RdataType,
@@ -298,11 +304,117 @@ async def test_db_processing(
     # Write these new peers to db.
     await crawl_store.load_reliable_peers_to_db()
 
-    # wait for the new db to be read.
-    await time_out_assert(30, lambda: seeder_service.reliable_peers_v4 != [])
+    # Force a DB reload and ensure it loaded the peers
+    await seeder_service.refresh_reliable_peers()
+    assert seeder_service.reliable_peers_v4 != []
 
     # now we check that the db peers are being used.
     query = dns.message.make_query(domain, request_type, use_edns=True)  # we need to generate a new request id.
     std_query_response = await make_dns_query(use_tcp, target_address, port, query)
     assert std_query_response.rcode() == dns.rcode.NOERROR
     assert_standard_results(std_query_response.answer, request_type, num_ns)
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "use_tcp, target_address, request_type",
+    [
+        [False, "127.0.0.1", dns.rdatatype.A],
+        [False, "127.0.0.1", dns.rdatatype.AAAA],
+        [True, "127.0.0.1", dns.rdatatype.A],
+        [True, "127.0.0.1", dns.rdatatype.AAAA],
+        [False, "::1", dns.rdatatype.A],
+        [False, "::1", dns.rdatatype.AAAA],
+        [True, "::1", dns.rdatatype.A],
+        [True, "::1", dns.rdatatype.AAAA],
+    ],
+)
+async def test_static_peers(
+    seeder_service: DNSServer,
+    database_peers: dict[str, PeerReliability],
+    use_tcp: bool,
+    target_address: str,
+    request_type: dns.rdatatype.RdataType,
+) -> None:
+    port = get_dns_port(seeder_service, False, target_address)
+    domain = seeder_service.domain  # default is: seeder.example.com
+
+    seeder_service.config["static_peers"] = ["1.2.3.4", "2001:0DB8::5"]
+    await seeder_service.refresh_reliable_peers()
+
+    query = dns.message.make_query(domain, request_type, use_edns=True)  # we need to generate a new request id.
+    std_query_response = await make_dns_query(False, target_address, port, query, d_timeout=10)
+    assert std_query_response.rcode() == dns.rcode.NOERROR
+    assert len(std_query_response.answer) == 1  # only 1 kind of answer
+    answer = std_query_response.answer[0]
+    assert answer.rdtype == request_type
+    assert len(answer) == 1
+    expected = "2001:db8::5" if request_type == dns.rdatatype.AAAA else "1.2.3.4"
+    assert answer[0].to_text() == expected
+
+
+def get_mock_resolver() -> AsyncMock:
+    # Mock IPv4 response
+    mock_rrset_a = RRset(from_text("node.example.com."), IN, A_TYPE)
+    mock_rrset_a.add(A(IN, A_TYPE, "1.2.3.4"))  # type: ignore
+
+    # Mock IPv6 response
+    mock_rrset_aaaa = RRset(from_text("node.example.com."), IN, AAAA_TYPE)
+    mock_rrset_aaaa.add(AAAA(IN, AAAA_TYPE, "2001:db8::5"))  # type: ignore
+
+    # Create a mock Resolver
+    mock_resolver = AsyncMock()
+
+    # Adjust mock_resolve to accept all arguments
+    async def mock_resolve(
+        qname: Union[dns.name.Name, str],
+        rdtype: Union[dns.rdatatype.RdataType, str] = dns.rdatatype.A,
+        lifetime: Optional[float] = None,
+    ) -> RRset:
+        if rdtype == "A":
+            return mock_rrset_a
+        elif rdtype == "AAAA":
+            return mock_rrset_aaaa
+        raise Exception(f"Unexpected query type: {rdtype}")
+
+    mock_resolver.resolve.side_effect = mock_resolve
+    return mock_resolver
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "use_tcp, target_address, request_type",
+    [
+        [False, "127.0.0.1", dns.rdatatype.A],
+        [False, "127.0.0.1", dns.rdatatype.AAAA],
+        [True, "127.0.0.1", dns.rdatatype.A],
+        [True, "127.0.0.1", dns.rdatatype.AAAA],
+        [False, "::1", dns.rdatatype.A],
+        [False, "::1", dns.rdatatype.AAAA],
+        [True, "::1", dns.rdatatype.A],
+        [True, "::1", dns.rdatatype.AAAA],
+    ],
+)
+async def test_static_peers_with_hostnames(
+    seeder_service: DNSServer,
+    database_peers: dict[str, PeerReliability],
+    use_tcp: bool,
+    target_address: str,
+    request_type: dns.rdatatype.RdataType,
+) -> None:
+    port = get_dns_port(seeder_service, False, target_address)
+    domain = seeder_service.domain  # default is: seeder.example.com
+
+    seeder_service.resolver = get_mock_resolver()
+    seeder_service.config["static_peers"] = ["node.example.com"]
+    await seeder_service.refresh_reliable_peers()
+
+    query = dns.message.make_query(domain, request_type, use_edns=True)  # we need to generate a new request id.
+    std_query_response = await make_dns_query(False, target_address, port, query, d_timeout=10)
+    assert std_query_response.rcode() == dns.rcode.NOERROR
+    assert len(std_query_response.answer) == 1  # only 1 kind of answer
+    answer = std_query_response.answer[0]
+    assert answer.rdtype == request_type
+    assert len(answer) == 1
+    expected = "2001:db8::5" if request_type == dns.rdatatype.AAAA else "1.2.3.4"
+    assert answer[0].to_text() == expected

chia/_tests/core/util/test_block_cache.py

@@ -26,7 +26,7 @@ def BR(height: int, header_hash: bytes32, prev_hash: bytes32) -> BlockRecord:
 @pytest.mark.anyio
 async def test_block_cache(seeded_random: random.Random) -> None:
     a = BlockCache({})
-    prev = bytes32([0] * 32)
+    prev = bytes32.zeros
     hashes = [bytes32.random(seeded_random) for _ in range(10)]
     for i, hh in enumerate(hashes):
         a.add_block(BR(i + 1, hh, prev))
@@ -36,9 +36,9 @@ async def test_block_cache(seeded_random: random.Random) -> None:
         if i == 0:
             continue
         assert await a.prev_block_hash([hh]) == [hashes[i - 1]]
-        assert a.try_block_record(hh) == BR(i + 1, hashes[i], hashes[i - 1])
-        assert a.block_record(hh) == BR(i + 1, hashes[i], hashes[i - 1])
-        assert a.height_to_hash(uint32(i + 1)) == hashes[i]
-        assert a.height_to_block_record(uint32(i + 1)) == BR(i + 1, hashes[i], hashes[i - 1])
+        assert a.try_block_record(hh) == BR(i + 1, hh, hashes[i - 1])
+        assert a.block_record(hh) == BR(i + 1, hh, hashes[i - 1])
+        assert a.height_to_hash(uint32(i + 1)) == hh
+        assert a.height_to_block_record(uint32(i + 1)) == BR(i + 1, hh, hashes[i - 1])
         assert a.contains_block(hh)
         assert a.contains_height(uint32(i + 1))

chia/_tests/core/util/test_cached_bls.py

@@ -4,10 +4,10 @@ from chia_rs import AugSchemeMPL, BLSCache
 
 from chia.util.hash import std_hash
 
-LOCAL_CACHE = BLSCache(50000)
+LOCAL_CACHE = BLSCache(50_000)
 
 
-def test_cached_bls():
+def test_cached_bls() -> None:
     n_keys = 10
     seed = b"a" * 31
     sks = [AugSchemeMPL.key_gen(seed + bytes([i])) for i in range(n_keys)]
@@ -42,7 +42,7 @@ def test_cached_bls():
     assert local_cache.aggregate_verify(pks, msgs, agg_sig)
 
 
-def test_cached_bls_repeat_pk():
+def test_cached_bls_repeat_pk() -> None:
     n_keys = 400
     seed = b"a" * 32
     sks = [AugSchemeMPL.key_gen(seed) for i in range(n_keys)] + [AugSchemeMPL.key_gen(std_hash(seed))]

chia/_tests/core/util/test_config.py

@@ -10,7 +10,7 @@ from multiprocessing import Pool, Queue, TimeoutError
 from pathlib import Path
 from threading import Thread
 from time import sleep
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pytest
 import yaml
@@ -37,7 +37,7 @@ from chia.util.timing import adjusted_timeout
 
 def write_config(
     root_path: Path,
-    config: Dict,
+    config: dict,
     atomic_write: bool,
     do_sleep: bool,
     iterations: int,
@@ -74,7 +74,7 @@ def write_config(
 
 
 def read_and_compare_config(
-    root_path: Path, default_config: Dict, do_sleep: bool, iterations: int, error_queue: Optional[Queue] = None
+    root_path: Path, default_config: dict, do_sleep: bool, iterations: int, error_queue: Optional[Queue] = None
 ):
     """
     Wait for a random amount of time, read the config and compare with the
@@ -99,7 +99,7 @@ def read_and_compare_config(
         raise
 
 
-async def create_reader_and_writer_tasks(root_path: Path, default_config: Dict):
+async def create_reader_and_writer_tasks(root_path: Path, default_config: dict):
     """
     Spin-off reader and writer threads and wait for completion
     """
@@ -135,7 +135,7 @@ async def create_reader_and_writer_tasks(root_path: Path, default_config: Dict):
         raise error_queue.get()
 
 
-def run_reader_and_writer_tasks(root_path: Path, default_config: Dict):
+def run_reader_and_writer_tasks(root_path: Path, default_config: dict):
     """
     Subprocess entry point. This function spins-off threads to perform read/write tasks
     concurrently, possibly leading to synchronization issues accessing config data.
@@ -144,12 +144,12 @@ def run_reader_and_writer_tasks(root_path: Path, default_config: Dict):
 
 
 @pytest.fixture(scope="function")
-def default_config_dict() -> Dict:
+def default_config_dict() -> dict:
     """
     Returns a dictionary containing the default config.yaml contents
     """
     content: str = initial_config_file("config.yaml")
-    config: Dict = yaml.safe_load(content)
+    config: dict = yaml.safe_load(content)
     return config
 
 
@@ -208,7 +208,7 @@ class TestConfig:
         """
         root_path: Path = root_path_populated_with_config
         # When: loading a newly created config
-        config: Dict = load_config(root_path=root_path, filename="config.yaml")
+        config: dict = load_config(root_path=root_path, filename="config.yaml")
         assert config is not None
         # Expect: config values should match the defaults (from a small sampling)
         assert config["daemon_port"] == default_config_dict["daemon_port"] == 55400
@@ -242,7 +242,7 @@ class TestConfig:
         calling load_config().
         """
         root_path: Path = root_path_populated_with_config
-        config: Dict = copy.deepcopy(default_config_dict)
+        config: dict = copy.deepcopy(default_config_dict)
         # When: modifying the config
         config["harvester"]["farmer_peers"][0]["host"] = "oldmacdonald.eie.io"
         # Sanity check that we didn't modify the default config
@@ -255,7 +255,7 @@ class TestConfig:
             save_config(root_path=root_path, filename="config.yaml", config_data=config)
 
         # Expect: modifications should be preserved in the config read from disk
-        loaded: Dict = load_config(root_path=root_path, filename="config.yaml")
+        loaded: dict = load_config(root_path=root_path, filename="config.yaml")
         assert loaded["harvester"]["farmer_peers"][0]["host"] == "oldmacdonald.eie.io"
 
     def test_multiple_writers(self, root_path_populated_with_config, default_config_dict):
@@ -310,7 +310,7 @@ class TestConfig:
             await asyncio.gather(*all_tasks)
 
     @pytest.mark.parametrize("prefix", [None])
-    def test_selected_network_address_prefix_default_config(self, config_with_address_prefix: Dict[str, Any]) -> None:
+    def test_selected_network_address_prefix_default_config(self, config_with_address_prefix: dict[str, Any]) -> None:
         """
         Temp config.yaml created using a default config. address_prefix is defaulted to "xch"
         """
@@ -319,7 +319,7 @@ class TestConfig:
         assert prefix == "xch"
 
     @pytest.mark.parametrize("prefix", ["txch"])
-    def test_selected_network_address_prefix_testnet_config(self, config_with_address_prefix: Dict[str, Any]) -> None:
+    def test_selected_network_address_prefix_testnet_config(self, config_with_address_prefix: dict[str, Any]) -> None:
         """
         Temp config.yaml created using a modified config. address_prefix is set to "txch"
         """
@@ -327,7 +327,7 @@ class TestConfig:
         prefix = selected_network_address_prefix(config)
         assert prefix == "txch"
 
-    def test_selected_network_address_prefix_config_dict(self, default_config_dict: Dict[str, Any]) -> None:
+    def test_selected_network_address_prefix_config_dict(self, default_config_dict: dict[str, Any]) -> None:
         """
         Modified config dictionary has address_prefix set to "customxch"
         """

chia/_tests/core/util/test_files.py

@@ -336,7 +336,7 @@ class TestWriteFile:
         Write a file to a location and use the default permissions.
         """
 
-        if sys.platform in ["win32", "cygwin"]:
+        if sys.platform in {"win32", "cygwin"}:
             pytest.skip("Setting UNIX file permissions doesn't apply to Windows")
 
         dest_path: Path = tmp_path / "test_write_file/test_write_file.txt"
@@ -355,7 +355,7 @@ class TestWriteFile:
         Write a file to a location and use custom permissions.
         """
 
-        if sys.platform in ["win32", "cygwin"]:
+        if sys.platform in {"win32", "cygwin"}:
             pytest.skip("Setting UNIX file permissions doesn't apply to Windows")
 
         dest_path: Path = tmp_path / "test_write_file/test_write_file.txt"

chia/_tests/core/util/test_jsonify.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.ints import uint32
 from chia.util.streamable import Streamable, recurse_jsonify, streamable
 
 
-def dict_with_types(d: Dict[str, Any]) -> Dict[str, Any]:
+def dict_with_types(d: dict[str, Any]) -> dict[str, Any]:
     return {k: (v, type(v)) for k, v in d.items()}
 
 
@@ -46,7 +46,7 @@ def test_primitives() -> None:
         "set optional",
         "foobar",
         b"\0\1",
-        bytes32([0] * 32),
+        bytes32.zeros,
         False,
     )
 
@@ -64,7 +64,7 @@ def test_list() -> None:
     @streamable
     @dataclass(frozen=True)
     class ListTest(Streamable):
-        d: List[str]
+        d: list[str]
 
     t = ListTest(["foo", "bar"])
 
@@ -75,7 +75,7 @@ def test_tuple() -> None:
     @streamable
     @dataclass(frozen=True)
     class TupleTest(Streamable):
-        d: Tuple[str, uint32, str]
+        d: tuple[str, uint32, str]
 
     t = TupleTest(("foo", uint32(123), "bar"))
 
@@ -85,14 +85,14 @@ def test_tuple() -> None:
 @streamable
 @dataclass(frozen=True)
 class NestedWithTupleInner(Streamable):
-    a: Tuple[str, uint32, str]
+    a: tuple[str, uint32, str]
     b: bytes
 
 
 @streamable
 @dataclass(frozen=True)
 class NestedWithTupleOuter(Streamable):
-    a: Tuple[NestedWithTupleInner, uint32, str]
+    a: tuple[NestedWithTupleInner, uint32, str]
 
 
 def test_nested_with_tuple() -> None:
@@ -113,7 +113,7 @@ class NestedWithListInner(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NestedWithListOuter(Streamable):
-    a: List[NestedWithListInner]
+    a: list[NestedWithListInner]
 
 
 def test_nested_with_list() -> None:
@@ -125,7 +125,7 @@ def test_nested_with_list() -> None:
 @streamable
 @dataclass(frozen=True)
 class TestNestedInner(Streamable):
-    a: Tuple[str, uint32, str]
+    a: tuple[str, uint32, str]
     b: bytes
 
 

chia/_tests/core/util/test_keychain.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import random
 from dataclasses import dataclass, replace
-from typing import Callable, List, Optional, Tuple
+from typing import Callable, Optional
 
 import importlib_resources
 import pytest
@@ -180,7 +180,11 @@ class TestKeychain:
 
         # All added keys should still be valid with their label
         assert all(
-            key_data in [key_data_0, key_data_1, key_data_2] for key_data in keychain.get_keys(include_secrets=True)
+            # This must be compared to a tuple because the `.mnemonic` property is a list which makes the
+            # class unhashable. We should eventually add support in streamable for varadic tuples and maybe remove
+            # support for the mutable `list`.
+            key_data in (key_data_0, key_data_1, key_data_2)  # noqa: PLR6201
+            for key_data in keychain.get_keys(include_secrets=True)
         )
 
     def test_bip39_eip2333_test_vector(self, empty_temp_file_keyring: TempKeyring):
@@ -318,7 +322,7 @@ def test_key_data_without_secrets(key_info: KeyInfo) -> None:
         ((_24keyinfo.mnemonic.split(), _24keyinfo.entropy, KeyDataSecrets.generate().private_key), "private_key"),
     ],
 )
-def test_key_data_secrets_post_init(input_data: Tuple[List[str], bytes, PrivateKey], data_type: str) -> None:
+def test_key_data_secrets_post_init(input_data: tuple[list[str], bytes, PrivateKey], data_type: str) -> None:
     with pytest.raises(KeychainKeyDataMismatch, match=data_type):
         KeyDataSecrets(*input_data)
 
@@ -339,7 +343,7 @@ def test_key_data_secrets_post_init(input_data: Tuple[List[str], bytes, PrivateK
     ],
 )
 def test_key_data_post_init(
-    input_data: Tuple[uint32, G1Element, Optional[str], Optional[KeyDataSecrets]], data_type: str
+    input_data: tuple[uint32, G1Element, Optional[str], Optional[KeyDataSecrets]], data_type: str
 ) -> None:
     with pytest.raises(KeychainKeyDataMismatch, match=data_type):
         KeyData(*input_data)
@@ -427,7 +431,11 @@ async def test_set_label(get_temp_keyring: Keychain) -> None:
     keychain.set_label(fingerprint=key_data_1.fingerprint, label=key_data_1.label)
     assert key_data_0 == keychain.get_key(fingerprint=key_data_0.fingerprint, include_secrets=True)
     # All added keys should still be valid with their label
-    assert all(key_data in [key_data_0, key_data_1] for key_data in keychain.get_keys(include_secrets=True))
+
+    # This must be compared to a tuple because the `.mnemonic` property is a list which makes the
+    # class unhashable. We should eventually add support in streamable for varadic tuples and maybe remove
+    # support for the mutable `list`.
+    assert all(key_data in (key_data_0, key_data_1) for key_data in keychain.get_keys(include_secrets=True))  # noqa: PLR6201
 
 
 @pytest.mark.parametrize(

chia/_tests/core/util/test_keyring_wrapper.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
 import logging
-from typing import Type
 
 import pytest
 
 from chia.simulator.keyring import TempKeyring
 from chia.util.errors import KeychainFingerprintNotFound, KeychainLabelError, KeychainLabelExists, KeychainLabelInvalid
 from chia.util.file_keyring import Key
-from chia.util.keyring_wrapper import DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE, KeyringWrapper
+from chia.util.keyring_wrapper import (
+    DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE,
+    KeyringWrapper,
+    obtain_current_passphrase,
+)
 
 log = logging.getLogger(__name__)
 
@@ -260,8 +263,6 @@ class TestKeyringWrapper:
         assert KeyringWrapper.get_shared_instance().keyring.get_key("some service", "some user") is None
 
         # Check that metadata is properly deleted
-        from chia.cmds.passphrase_funcs import obtain_current_passphrase
-
         passphrase = obtain_current_passphrase(use_passphrase_cache=True)
         assert KeyringWrapper.get_shared_instance().keyring.cached_file_content.get_decrypted_data_dict(passphrase) == {
             "keys": {},
@@ -457,7 +458,7 @@ class TestKeyringWrapper:
         ],
     )
     def test_set_label_failures(
-        self, label: str, exception: Type[KeychainLabelError], message: str, empty_temp_file_keyring: TempKeyring
+        self, label: str, exception: type[KeychainLabelError], message: str, empty_temp_file_keyring: TempKeyring
     ) -> None:
         keyring_wrapper = KeyringWrapper.get_shared_instance()
         keyring_wrapper.keyring.set_label(1, "one")

chia/_tests/core/util/test_log_exceptions.py

@@ -4,7 +4,7 @@ import contextlib
 import dataclasses
 import logging
 import re
-from typing import Tuple, Type, Union
+from typing import Union
 
 import pytest
 
@@ -21,8 +21,8 @@ def logger_fixture() -> logging.Logger:
 
 @dataclasses.dataclass
 class ErrorCase:
-    type_to_raise: Type[BaseException]
-    type_to_catch: Union[Type[BaseException], Tuple[Type[BaseException], ...]]
+    type_to_raise: type[BaseException]
+    type_to_catch: Union[type[BaseException], tuple[type[BaseException], ...]]
     should_match: bool