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

chia/_tests/pools/test_pool_wallet.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, List, Optional, cast
+from typing import Any, Optional, cast
 from unittest.mock import MagicMock
 
 import pytest
@@ -20,10 +20,14 @@ class MockStandardWallet:
     async def get_new_puzzlehash(self) -> bytes32:
         return self.canned_puzzlehash
 
+    async def get_puzzle_hash(self, new: bool) -> bytes32:
+        return self.canned_puzzlehash
+
 
 @dataclass
 class MockWalletStateManager:
     root_path: Optional[Path] = None
+    config: dict[str, Any] = field(default_factory=dict)
 
 
 @dataclass
@@ -56,7 +60,7 @@ async def test_update_pool_config_new_config(monkeypatch: Any) -> None:
     Test that PoolWallet can create a new pool config
     """
 
-    updated_configs: List[MockPoolWalletConfig] = []
+    updated_configs: list[MockPoolWalletConfig] = []
     payout_instructions_ph = rand_hash()
     launcher_id: bytes32 = rand_hash()
     p2_singleton_puzzle_hash: bytes32 = rand_hash()
@@ -75,14 +79,14 @@ async def test_update_pool_config_new_config(monkeypatch: Any) -> None:
     )
 
     # No config data
-    def mock_load_pool_config(root_path: Path) -> List[MockPoolWalletConfig]:
+    def mock_load_pool_config(root_path: Path) -> list[MockPoolWalletConfig]:
         return []
 
     monkeypatch.setattr("chia.pools.pool_wallet.load_pool_config", mock_load_pool_config)
 
     # Mock pool_config.update_pool_config to capture the updated configs
     async def mock_pool_config_update_pool_config(
-        root_path: Path, pool_config_list: List[MockPoolWalletConfig]
+        root_path: Path, pool_config_list: list[MockPoolWalletConfig]
     ) -> None:
         nonlocal updated_configs
         updated_configs = pool_config_list
@@ -121,7 +125,7 @@ async def test_update_pool_config_existing_payout_instructions(monkeypatch: Any)
     Test that PoolWallet will retain existing payout_instructions when updating the pool config.
     """
 
-    updated_configs: List[MockPoolWalletConfig] = []
+    updated_configs: list[MockPoolWalletConfig] = []
     payout_instructions_ph = rand_hash()
     launcher_id: bytes32 = rand_hash()
     p2_singleton_puzzle_hash: bytes32 = rand_hash()
@@ -157,7 +161,7 @@ async def test_update_pool_config_existing_payout_instructions(monkeypatch: Any)
     )
 
     # No config data
-    def mock_load_pool_config(root_path: Path) -> List[MockPoolWalletConfig]:
+    def mock_load_pool_config(root_path: Path) -> list[MockPoolWalletConfig]:
         nonlocal existing_config
         return [existing_config]
 
@@ -165,7 +169,7 @@ async def test_update_pool_config_existing_payout_instructions(monkeypatch: Any)
 
     # Mock pool_config.update_pool_config to capture the updated configs
     async def mock_pool_config_update_pool_config(
-        root_path: Path, pool_config_list: List[MockPoolWalletConfig]
+        root_path: Path, pool_config_list: list[MockPoolWalletConfig]
     ) -> None:
         nonlocal updated_configs
         updated_configs = pool_config_list

chia/_tests/pools/test_wallet_pool_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional
+from typing import Optional
 
 import pytest
 from clvm_tools import binutils
@@ -36,7 +36,7 @@ def make_child_solution(
     return sol
 
 
-async def assert_db_spends(store: WalletPoolStore, wallet_id: int, spends: List[CoinSpend]) -> None:
+async def assert_db_spends(store: WalletPoolStore, wallet_id: int, spends: list[CoinSpend]) -> None:
     db_spends = await store.get_spends_for_wallet(wallet_id)
     assert len(db_spends) == len(spends)
     for spend, (_, db_spend) in zip(spends, db_spends):
@@ -46,7 +46,7 @@ async def assert_db_spends(store: WalletPoolStore, wallet_id: int, spends: List[
 @dataclass
 class DummySpends:
     seeded_random: random.Random
-    spends_per_wallet: Dict[int, List[CoinSpend]] = field(default_factory=dict)
+    spends_per_wallet: dict[int, list[CoinSpend]] = field(default_factory=dict)
 
     def generate(self, wallet_id: int, count: int) -> None:
         current = self.spends_per_wallet.setdefault(wallet_id, [])

chia/_tests/process_junit.py

@@ -7,30 +7,30 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from pathlib import Path
 from statistics import StatisticsError, mean, stdev
-from typing import Any, Dict, List, Optional, TextIO, Tuple, Type, final
+from typing import Any, Optional, TextIO, final
 
 import click
 import lxml.etree
 
-from chia._tests.util.misc import BenchmarkData, DataTypeProtocol, TestId
-from chia._tests.util.time_out_assert import TimeOutAssertData
+from chia._tests.util.misc import BenchmarkData, TestId
+from chia._tests.util.time_out_assert import DataTypeProtocol, TimeOutAssertData
 
-supported_data_types: List[Type[DataTypeProtocol]] = [TimeOutAssertData, BenchmarkData]
-supported_data_types_by_tag: Dict[str, Type[DataTypeProtocol]] = {cls.tag: cls for cls in supported_data_types}
+supported_data_types: list[type[DataTypeProtocol]] = [TimeOutAssertData, BenchmarkData]
+supported_data_types_by_tag: dict[str, type[DataTypeProtocol]] = {cls.tag: cls for cls in supported_data_types}
 
 
 @final
 @dataclass(frozen=True, order=True)
 class Result:
     file_path: Path
-    test_path: Tuple[str, ...]
-    ids: Tuple[str, ...]
+    test_path: tuple[str, ...]
+    ids: tuple[str, ...]
     label: str
     line: int = field(compare=False)
-    durations: Tuple[float, ...] = field(compare=False)
+    durations: tuple[float, ...] = field(compare=False)
     limit: float = field(compare=False)
 
-    def marshal(self) -> Dict[str, Any]:
+    def marshal(self) -> dict[str, Any]:
         return {
             "file_path": self.file_path.as_posix(),
             "test_path": self.test_path,
@@ -133,7 +133,7 @@ def main(
     tree = lxml.etree.parse(xml_file)
     root = tree.getroot()
 
-    cases_by_test_id: defaultdict[TestId, List[lxml.etree.Element]] = defaultdict(list)
+    cases_by_test_id: defaultdict[TestId, list[lxml.etree.Element]] = defaultdict(list)
     for suite in root.findall("testsuite"):
         for case in suite.findall("testcase"):
             if case.find("skipped") is not None:
@@ -145,7 +145,7 @@ def main(
             )
             cases_by_test_id[test_id].append(case)
 
-    data_by_event_id: defaultdict[EventId, List[DataTypeProtocol]] = defaultdict(list)
+    data_by_event_id: defaultdict[EventId, list[DataTypeProtocol]] = defaultdict(list)
     for test_id, cases in cases_by_test_id.items():
         for case in cases:
             for property in case.findall(f"properties/property[@name='{tag}']"):
@@ -154,7 +154,7 @@ def main(
                 event_id = EventId(test_id=test_id, tag=tag, line=data.line, path=data.path, label=data.label)
                 data_by_event_id[event_id].append(data)
 
-    results: List[Result] = []
+    results: list[Result] = []
     for event_id, datas in data_by_event_id.items():
         [limit] = {data.limit for data in datas}
         results.append(
@@ -196,7 +196,7 @@ def output_benchmark(
     output: TextIO,
     percent_margin: int,
     randomoji: bool,
-    results: List[Result],
+    results: list[Result],
 ) -> None:
     if not markdown:
         for result in sorted(results):
@@ -206,7 +206,7 @@ def output_benchmark(
     else:
         output.write("# Benchmark Metrics\n\n")
 
-        output.write("| Test | 🍿 | Mean | Max | 3σ | Limit | Percent |\n")
+        output.write("| Test | 🍿 | Mean | Max | 3σ | Limit | Percent |\n")  # noqa: RUF001
         output.write("| --- | --- | --- | --- | --- | --- | --- |\n")
         for result in sorted(results):
             link_url = result.link(prefix=link_prefix, line_separator=link_line_separator)
@@ -273,7 +273,7 @@ def output_time_out_assert(
     output: TextIO,
     percent_margin: int,
     randomoji: bool,
-    results: List[Result],
+    results: list[Result],
 ) -> None:
     if not markdown:
         for result in sorted(results):
@@ -283,7 +283,7 @@ def output_time_out_assert(
     else:
         output.write("# Time Out Assert Metrics\n\n")
 
-        output.write("| Test | 🍿 | Mean | Max | 3σ | Limit | Percent |\n")
+        output.write("| Test | 🍿 | Mean | Max | 3σ | Limit | Percent |\n")  # noqa: RUF001
         output.write("| --- | --- | --- | --- | --- | --- | --- |\n")
         for result in sorted(results):
             link_url = result.link(prefix=link_prefix, line_separator=link_line_separator)
@@ -345,5 +345,4 @@ def output_time_out_assert(
 
 
 if __name__ == "__main__":
-    # pylint: disable = no-value-for-parameter
     main()

chia/_tests/rpc/test_rpc_client.py

@@ -1,21 +1,38 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator, Awaitable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, Optional
+from typing import Any, Callable, Optional
 
 import pytest
 
 from chia._tests.util.misc import Marks, RecordingWebServer, datacases
 from chia.rpc.rpc_client import ResponseFailureError, RpcClient
+from chia.rpc.rpc_server import RpcServer
+from chia.server.outbound_message import NodeType
 from chia.util.ints import uint16
 
+non_fetch_client_methods = {
+    RpcClient.create,
+    RpcClient.create_as_context,
+    RpcClient.fetch,
+    RpcClient.close,
+    RpcClient.await_closed,
+}
+
+client_fetch_methods = [
+    attribute
+    for name, attribute in vars(RpcClient).items()
+    if callable(attribute) and attribute not in non_fetch_client_methods and not name.startswith("__")
+]
+
 
 @dataclass
 class InvalidCreateCase:
     id: str
     root_path: Optional[Path] = None
-    net_config: Optional[Dict[str, Any]] = None
+    net_config: Optional[dict[str, Any]] = None
     marks: Marks = ()
 
 
@@ -79,3 +96,43 @@ async def test_failure_exception(
         await rpc_client.fetch(path="/table", request_json={"response": expected_response})
 
     assert exception_info.value.response == expected_response
+
+
+def test_client_standard_endpoints_match_server() -> None:
+    # NOTE: this test assumes that the client method names should match the server
+    #       route names
+    client_method_names = {method.__name__ for method in client_fetch_methods}
+    server_route_names = {method.lstrip("/") for method in RpcServer._routes.keys()}
+    assert client_method_names == server_route_names
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("client_method", client_fetch_methods)
+async def test_client_fetch_methods(
+    client_method: Callable[..., Awaitable[object]],
+    rpc_client: RpcClient,
+    recording_web_server: RecordingWebServer,
+) -> None:
+    # NOTE: this test assumes that the client method names should match the server
+    #       route names
+
+    parameters: dict[Callable[..., Awaitable[object]], dict[str, object]] = {
+        RpcClient.open_connection: {"host": "", "port": 0},
+        RpcClient.close_connection: {"node_id": b""},
+        RpcClient.get_connections: {"node_type": NodeType.FULL_NODE},
+        RpcClient.set_log_level: {"level": "DEBUG"},
+    }
+
+    try:
+        await client_method(rpc_client, **parameters.get(client_method, {}))
+    except Exception as exception:
+        if client_method is RpcClient.get_connections and isinstance(exception, KeyError):
+            pass
+        else:  # pragma: no cover
+            # this case will fail the test so not normally executed
+            raise
+
+    [request] = recording_web_server.requests
+    assert request.content_type == "application/json"
+    assert request.method == "POST"
+    assert request.path == f"/{client_method.__name__}"

chia/_tests/rpc/test_rpc_server.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import logging
+import ssl
+import sys
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+import aiohttp
+import pytest
+
+from chia.rpc.rpc_server import Endpoint, EndpointResult, RpcServer, RpcServiceProtocol
+from chia.ssl.create_ssl import create_all_ssl
+from chia.util.config import load_config
+from chia.util.ints import uint16
+from chia.util.ws_message import WsRpcMessage
+
+root_logger = logging.getLogger()
+
+if sys.version_info >= (3, 11):  # pragma: no cover
+    name_to_number_level_map = logging.getLevelNamesMapping()
+else:
+    name_to_number_level_map = logging._nameToLevel
+
+number_to_name_level_map = {number: name for name, number in name_to_number_level_map.items()}
+
+# just picking one for which a config is present
+service_name = "full_node"
+
+
+@dataclasses.dataclass
+class TestRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("TestRpcApi", None)
+
+    # unused as of the initial writing of these tests
+    service: RpcServiceProtocol
+    service_name: str = service_name
+
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+        # just here to satisfy the complete protocol
+        return []  # pragma: no cover
+
+    def get_routes(self) -> dict[str, Endpoint]:
+        return {
+            "/log": self.log,
+        }
+
+    async def log(self, request: dict[str, Any]) -> EndpointResult:
+        message = request["message"]
+
+        level = name_to_number_level_map[request["level"]]
+
+        root_logger.log(level=level, msg=message)
+
+        return {}
+
+
+@dataclasses.dataclass
+class Client:
+    session: aiohttp.ClientSession
+    ssl_context: ssl.SSLContext
+    url: str
+
+    @classmethod
+    @contextlib.asynccontextmanager
+    async def managed(cls, ssl_context: ssl.SSLContext, url: str) -> AsyncIterator[Client]:
+        async with aiohttp.ClientSession() as session:
+            yield cls(session=session, ssl_context=ssl_context, url=url)
+
+    async def request(self, endpoint: str, json: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        if json is None:
+            json = {}
+
+        async with self.session.post(
+            self.url.rstrip("/") + "/" + endpoint.lstrip("/"),
+            json=json,
+            ssl=self.ssl_context,
+        ) as response:
+            response.raise_for_status()
+            json = await response.json()
+
+        assert json is not None
+        assert json["success"], json
+
+        return json
+
+    async def log(self, level: str, message: str) -> None:
+        await self.request("log", json={"message": message, "level": level})
+
+
+@pytest.fixture(name="server")
+async def server_fixture(
+    root_path_populated_with_config: Path,
+    self_hostname: str,
+) -> AsyncIterator[RpcServer[TestRpcApi]]:
+    config = load_config(root_path=root_path_populated_with_config, filename="config.yaml")
+    service_config = config[service_name]
+
+    create_all_ssl(root_path=root_path_populated_with_config)
+    rpc_server = RpcServer.create(
+        # the test rpc api doesn't presently need a real service for these tests
+        rpc_api=TestRpcApi(service=None),  # type: ignore[arg-type]
+        service_name="test_rpc_server",
+        stop_cb=lambda: None,
+        root_path=root_path_populated_with_config,
+        net_config=config,
+        service_config=service_config,
+        prefer_ipv6=False,
+    )
+
+    try:
+        await rpc_server.start(
+            self_hostname=self_hostname,
+            rpc_port=uint16(0),
+            max_request_body_size=2**16,
+        )
+
+        yield rpc_server
+    finally:
+        rpc_server.close()
+        await rpc_server.await_closed()
+
+
+@pytest.fixture(name="client")
+async def client_fixture(
+    server: RpcServer[TestRpcApi],
+) -> AsyncIterator[Client]:
+    assert server.webserver is not None
+    async with Client.managed(ssl_context=server.ssl_client_context, url=server.webserver.url()) as client:
+        yield client
+
+
+@pytest.mark.anyio
+async def test_get_log_level(
+    client: Client,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    level = "WARNING"
+    root_logger.setLevel(level)
+    result = await client.request("get_log_level")
+    assert result["level"] == number_to_name_level_map[root_logger.level]
+
+
+@pytest.mark.anyio
+async def test_set_log_level(
+    client: Client,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    message = "just a maybe unique probably message"
+
+    level = "WARNING"
+    await client.request("set_log_level", json={"level": level})
+    assert number_to_name_level_map[root_logger.level] == level
+
+    caplog.clear()
+    await client.log(message=message, level="WARNING")
+    assert caplog.messages == [message]
+
+    caplog.clear()
+    await client.log(message=message, level="INFO")
+    assert caplog.messages == []
+
+
+@pytest.mark.anyio
+async def test_reset_log_level(
+    client: Client,
+    server: RpcServer[TestRpcApi],
+) -> None:
+    configured_level = server.service_config["logging"]["log_level"]
+    temporary_level = "INFO"
+    assert configured_level != temporary_level
+
+    root_logger.setLevel(temporary_level)
+    assert number_to_name_level_map[root_logger.level] == temporary_level
+
+    await client.request("reset_log_level")
+    assert number_to_name_level_map[root_logger.level] == configured_level

chia/_tests/simulation/test_simulation.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import importlib.metadata
 import json
-from typing import AsyncIterator, List, Tuple
+from collections.abc import AsyncIterator
 
 import aiohttp
 import pytest
@@ -186,7 +186,7 @@ class TestSimulation:
     @pytest.mark.anyio
     async def test_simulator_auto_farm_and_get_coins(
         self,
-        two_wallet_nodes: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+        two_wallet_nodes: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
         self_hostname: str,
     ) -> None:
         num_blocks = 2
@@ -194,7 +194,7 @@ class TestSimulation:
         full_node_api = full_nodes[0]
         server_1 = full_node_api.full_node.server
         wallet_node, server_2 = wallets[0]
-        wallet_node_2, server_3 = wallets[1]
+        wallet_node_2, _server_3 = wallets[1]
         wallet = wallet_node.wallet_state_manager.main_wallet
         ph = await wallet.get_new_puzzlehash()
         wallet_node.config["trusted_peers"] = {}
@@ -313,7 +313,7 @@ class TestSimulation:
             peak = full_node_api.full_node.blockchain.get_peak()
             assert isinstance(peak, BlockRecord)
             start_time = peak.timestamp
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32([0] * 32)))
+            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.zeros))
             peak = full_node_api.full_node.blockchain.get_peak()
             assert isinstance(peak, BlockRecord)
             end_time = peak.timestamp
@@ -485,7 +485,7 @@ class TestSimulation:
     async def test_create_coins_with_invalid_amounts_raises(
         self,
         self_hostname: str,
-        amounts: List[uint64],
+        amounts: list[uint64],
         simulator_and_wallet: OldSimulatorsAndWallets,
     ) -> None:
         [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet

chia/_tests/simulation/test_simulator.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List, Tuple
-
 import pytest
 
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
@@ -21,7 +19,7 @@ from chia.wallet.wallet_node import WalletNode
 async def test_simulation_farm_blocks_to_puzzlehash(
     count: int,
     guarantee_transaction_blocks: bool,
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     [[full_node_api], _, _] = simulator_and_wallet
 
@@ -41,7 +39,7 @@ async def test_simulation_farm_blocks_to_puzzlehash(
 @pytest.mark.parametrize(argnames="count", argvalues=[0, 1, 2, 5, 10])
 async def test_simulation_farm_blocks_to_wallet(
     count: int,
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
 
@@ -79,7 +77,7 @@ async def test_simulation_farm_blocks_to_wallet(
 async def test_simulation_farm_rewards_to_wallet(
     amount: int,
     coin_count: int,
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
 
@@ -107,7 +105,7 @@ async def test_simulation_farm_rewards_to_wallet(
 
 @pytest.mark.anyio
 async def test_wait_transaction_records_entered_mempool(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     repeats = 50
     tx_amount = 1
@@ -143,7 +141,7 @@ async def test_wait_transaction_records_entered_mempool(
 
 @pytest.mark.anyio
 async def test_process_transaction_records(
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     repeats = 50
     tx_amount = 1
@@ -187,7 +185,7 @@ async def test_process_transaction_records(
     ],
 )
 async def test_create_coins_with_amounts(
-    self_hostname: str, amounts: List[uint64], simulator_and_wallet: OldSimulatorsAndWallets
+    self_hostname: str, amounts: list[uint64], simulator_and_wallet: OldSimulatorsAndWallets
 ) -> None:
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
     await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
@@ -213,8 +211,8 @@ async def test_create_coins_with_amounts(
     ids=lambda amounts: ", ".join(str(amount) for amount in amounts),
 )
 async def test_create_coins_with_invalid_amounts_raises(
-    amounts: List[int],
-    simulator_and_wallet: Tuple[List[FullNodeSimulator], List[Tuple[WalletNode, ChiaServer]], BlockTools],
+    amounts: list[int],
+    simulator_and_wallet: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
 ) -> None:
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
 

chia/_tests/simulation/test_start_simulator.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import Any, AsyncGenerator, Dict, Tuple
+from typing import Any
 
 import pytest
 
@@ -28,15 +29,15 @@ class TestStartSimulator:
     @pytest.fixture(scope="function")
     async def get_chia_simulator(
         self, tmp_path: Path, empty_keyring: Keychain
-    ) -> AsyncGenerator[Tuple[FullNodeSimulator, Path, Dict[str, Any], str, int, Keychain], None]:
+    ) -> AsyncGenerator[tuple[FullNodeSimulator, Path, dict[str, Any], str, int, Keychain], None]:
         async for simulator_args in get_full_chia_simulator(chia_root=tmp_path, keychain=empty_keyring):
             yield simulator_args
 
     @pytest.mark.anyio
     async def test_start_simulator(
-        self, get_chia_simulator: Tuple[FullNodeSimulator, Path, Dict[str, Any], str, int, Keychain]
+        self, get_chia_simulator: tuple[FullNodeSimulator, Path, dict[str, Any], str, int, Keychain]
     ) -> None:
-        simulator, root_path, config, mnemonic, fingerprint, keychain = get_chia_simulator
+        simulator, root_path, config, _mnemonic, fingerprint, keychain = get_chia_simulator
         ph_1: bytes32 = get_puzzle_hash_from_key(keychain=keychain, fingerprint=fingerprint, key_id=1)
         ph_2: bytes32 = get_puzzle_hash_from_key(keychain=keychain, fingerprint=fingerprint, key_id=2)
         dummy_hash: bytes32 = std_hash(b"test")