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

chia/util/beta_metrics.py

@@ -6,12 +6,13 @@ import platform
 import socket
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import psutil
 
 from chia.util.config import load_config
 from chia.util.cpu import available_logical_cores
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger("beta")
 
@@ -43,7 +44,7 @@ def log_memory_metrics() -> None:
     log.debug(f"MEMORY - virtual memory: {psutil.virtual_memory()}, swap: {psutil.swap_memory()}")
 
 
-def log_disk_metrics(root_path: Path, plot_dirs: List[str]) -> None:
+def log_disk_metrics(root_path: Path, plot_dirs: list[str]) -> None:
     # TODO, Could this spam the logs too much for large farms? Maybe don't log usage of plot dirs and
     #       set perdisk=False rather for psutil.disk_io_counters? Lets try it with the default interval of 15s for now.
     log.debug(f"DISK partitions: {psutil.disk_partitions()}")
@@ -57,7 +58,7 @@ def log_disk_metrics(root_path: Path, plot_dirs: List[str]) -> None:
     log.debug(f"DISK - io counters: {psutil.disk_io_counters(perdisk=True)}")
 
 
-def log_port_states(config: Dict[str, Any]) -> None:
+def log_port_states(config: dict[str, Any]) -> None:
     selected_network = config["selected_network"]
     full_node_port = config["network_overrides"]["config"][selected_network]["default_full_node_port"]
     test_socket_ipv4 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -84,7 +85,7 @@ class BetaMetricsLogger:
         if self.task is not None:
             raise RuntimeError("Already started")
         self.stop_task = False
-        self.task = asyncio.create_task(self.run())
+        self.task = create_referenced_task(self.run())
 
     async def stop_logging(self) -> None:
         log.debug("stop_logging")

chia/util/block_cache.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.consensus.block_record import BlockRecord
 from chia.types.blockchain_format.sized_bytes import bytes32
@@ -14,12 +14,12 @@ class BlockCache:
 
         _protocol_check: ClassVar[BlockRecordsProtocol] = cast("BlockCache", None)
 
-    _block_records: Dict[bytes32, BlockRecord]
-    _height_to_hash: Dict[uint32, bytes32]
+    _block_records: dict[bytes32, BlockRecord]
+    _height_to_hash: dict[uint32, bytes32]
 
     def __init__(
         self,
-        blocks: Dict[bytes32, BlockRecord],
+        blocks: dict[bytes32, BlockRecord],
     ):
         self._block_records = blocks
         self._height_to_hash = {block.height: hh for hh, block in blocks.items()}
@@ -52,5 +52,5 @@ class BlockCache:
     def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
         return self._block_records.get(header_hash)
 
-    async def prev_block_hash(self, header_hashes: List[bytes32]) -> List[bytes32]:
+    async def prev_block_hash(self, header_hashes: list[bytes32]) -> list[bytes32]:
         return [self._block_records[h].prev_hash for h in header_hashes]

chia/util/byte_types.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 

chia/util/check_fork_next_block.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Awaitable, Callable, List
+from collections.abc import Awaitable
+from typing import Callable
 
 from chia.consensus.blockchain_interface import BlockchainInterface
 from chia.server.ws_connection import WSChiaConnection
@@ -10,7 +11,7 @@ from chia.util.ints import uint32
 async def check_fork_next_block(
     blockchain: BlockchainInterface,
     fork_point_height: uint32,
-    peers_with_peak: List[WSChiaConnection],
+    peers_with_peak: list[WSChiaConnection],
     check_block_future: Callable[[WSChiaConnection, uint32, BlockchainInterface], Awaitable[bool]],
 ) -> uint32:
     our_peak_height = blockchain.get_peak_height()

chia/util/chia_logging.py

@@ -4,20 +4,19 @@ import logging
 import os
 from logging.handlers import SysLogHandler
 from pathlib import Path
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
 import colorlog
 from concurrent_log_handler import ConcurrentRotatingFileHandler
 
 from chia import __version__
 from chia.util.chia_version import chia_short_version
-from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.path import path_from_root
 
 default_log_level = "WARNING"
 
 
-def get_beta_logging_config() -> Dict[str, Any]:
+def get_beta_logging_config() -> dict[str, Any]:
     return {
         "log_filename": f"{chia_short_version()}/chia-blockchain/beta.log",
         "log_level": "DEBUG",
@@ -29,7 +28,7 @@ def get_beta_logging_config() -> Dict[str, Any]:
 
 
 def get_file_log_handler(
-    formatter: logging.Formatter, root_path: Path, logging_config: Dict[str, object]
+    formatter: logging.Formatter, root_path: Path, logging_config: dict[str, object]
 ) -> ConcurrentRotatingFileHandler:
     log_path = path_from_root(root_path, str(logging_config.get("log_filename", "log/debug.log")))
     log_path.parent.mkdir(parents=True, exist_ok=True)
@@ -45,25 +44,35 @@ def get_file_log_handler(
 
 def initialize_logging(
     service_name: str,
-    logging_config: Dict[str, Any],
+    logging_config: dict[str, Any],
     root_path: Path,
     beta_root_path: Optional[Path] = None,
 ) -> None:
+    log_backcompat = logging_config.get("log_backcompat", False)
     log_level = logging_config.get("log_level", default_log_level)
     file_name_length = 33 - len(service_name)
     log_date_format = "%Y-%m-%dT%H:%M:%S"
     file_log_formatter = logging.Formatter(
-        fmt=f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
-        f"%(levelname)-8s %(message)s",
+        fmt=(
+            f"%(asctime)s.%(msecs)03d {service_name} %(name)-{file_name_length}s: %(levelname)-8s %(message)s"
+            if log_backcompat
+            else f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
+            f"%(levelname)-8s %(message)s"
+        ),
         datefmt=log_date_format,
     )
-    handlers: List[logging.Handler] = []
+    handlers: list[logging.Handler] = []
     if logging_config["log_stdout"]:
         stdout_handler = colorlog.StreamHandler()
         stdout_handler.setFormatter(
             colorlog.ColoredFormatter(
-                f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
-                f"%(log_color)s%(levelname)-8s%(reset)s %(message)s",
+                (
+                    f"%(asctime)s.%(msecs)03d {service_name} %(name)-{file_name_length}s: "
+                    f"%(log_color)s%(levelname)-8s%(reset)s %(message)s"
+                    if log_backcompat
+                    else f"%(asctime)s.%(msecs)03d {__version__} {service_name} %(name)-{file_name_length}s: "
+                    f"%(log_color)s%(levelname)-8s%(reset)s %(message)s"
+                ),
                 datefmt=log_date_format,
                 reset=True,
             )
@@ -83,31 +92,42 @@ def initialize_logging(
         handlers.append(get_file_log_handler(file_log_formatter, beta_root_path, get_beta_logging_config()))
 
     root_logger = logging.getLogger()
-    log_level_exceptions = {}
     for handler in handlers:
+        root_logger.addHandler(handler)
+
+    set_log_level(log_level=log_level, service_name=service_name)
+
+
+def set_log_level(log_level: str, service_name: str) -> list[str]:
+    root_logger = logging.getLogger()
+    log_level_exceptions = {}
+
+    for handler in root_logger.handlers:
         try:
             handler.setLevel(log_level)
         except Exception as e:
             handler.setLevel(default_log_level)
             log_level_exceptions[handler] = e
-        root_logger.addHandler(handler)
 
-    for handler, exception in log_level_exceptions.items():
-        root_logger.error(
-            f"Handler {handler}: Invalid log level '{log_level}' found in {service_name} config. "
-            f"Defaulting to: {default_log_level}. Error: {exception}"
-        )
+    error_strings = [
+        f"Handler {handler}: Invalid log level '{log_level}' for {service_name}. "
+        f"Defaulting to: {default_log_level}. Error: {exception}"
+        for handler, exception in log_level_exceptions.items()
+    ]
+    for error_string in error_strings:
+        root_logger.error(error_string)
 
     # Adjust the root logger to the smallest used log level since its default level is WARNING which would overwrite
     # the potentially smaller log levels of specific handlers.
-    root_logger.setLevel(min(handler.level for handler in handlers))
+    root_logger.setLevel(min(handler.level for handler in root_logger.handlers))
 
     if root_logger.level <= logging.DEBUG:
         logging.getLogger("aiosqlite").setLevel(logging.INFO)  # Too much logging on debug level
 
+    return error_strings
+
 
-def initialize_service_logging(service_name: str, config: Dict[str, Any]) -> None:
-    logging_root_path = DEFAULT_ROOT_PATH
+def initialize_service_logging(service_name: str, config: dict[str, Any], root_path: Path) -> None:
     if service_name == "daemon":
         # TODO: Maybe introduce a separate `daemon` section in the config instead of having `daemon_port`, `logging`
         #  and the daemon related stuff as top level entries.
@@ -119,6 +139,6 @@ def initialize_service_logging(service_name: str, config: Dict[str, Any]) -> Non
     initialize_logging(
         service_name=service_name,
         logging_config=logging_config,
-        root_path=logging_root_path,
+        root_path=root_path,
         beta_root_path=beta_config_path,
     )

chia/util/collection.py

@@ -1,11 +1,11 @@
-from __future__ import annotations
+# Package: utils
 
-from typing import List, Set
+from __future__ import annotations
 
 # Utility Functions for Collections & Sequences
 
 
-def find_duplicates(array: List[int]) -> Set[int]:
+def find_duplicates(array: list[int]) -> set[int]:
     seen = set()
     duplicates = set()
 

chia/util/condition_tools.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import lru_cache
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 from chia_rs import G1Element
 from clvm.casts import int_from_bytes, int_to_bytes
@@ -33,7 +33,7 @@ def parse_sexp_to_condition(sexp: Program) -> ConditionWithArgs:
     # since the ConditionWithArgs only has atoms as the args, we can't parse
     # hints and memos with this function. We just exit the loop if we encounter
     # a pair instead of an atom
-    vars: List[bytes] = []
+    vars: list[bytes] = []
     for arg in Program(first[1]).as_iter():
         a = arg.atom
         if a is None:
@@ -47,7 +47,7 @@ def parse_sexp_to_condition(sexp: Program) -> ConditionWithArgs:
     return ConditionWithArgs(ConditionOpcode(op), vars)
 
 
-def parse_sexp_to_conditions(sexp: Program) -> List[ConditionWithArgs]:
+def parse_sexp_to_conditions(sexp: Program) -> list[ConditionWithArgs]:
     """
     Takes a ChiaLisp sexp (list) and returns the list of ConditionWithArgss
     Raises an ConsensusError if it fails.
@@ -56,8 +56,8 @@ def parse_sexp_to_conditions(sexp: Program) -> List[ConditionWithArgs]:
 
 
 @lru_cache
-def agg_sig_additional_data(agg_sig_data: bytes) -> Dict[ConditionOpcode, bytes]:
-    ret: Dict[ConditionOpcode, bytes] = {}
+def agg_sig_additional_data(agg_sig_data: bytes) -> dict[ConditionOpcode, bytes]:
+    ret: dict[ConditionOpcode, bytes] = {}
     for code in [
         ConditionOpcode.AGG_SIG_PARENT,
         ConditionOpcode.AGG_SIG_PUZZLE,
@@ -76,7 +76,7 @@ def make_aggsig_final_message(
     opcode: ConditionOpcode,
     msg: bytes,
     spend_conditions: Union[Coin, SpendConditions],
-    agg_sig_additional_data: Dict[ConditionOpcode, bytes],
+    agg_sig_additional_data: dict[ConditionOpcode, bytes],
 ) -> bytes:
     if isinstance(spend_conditions, Coin):
         coin = spend_conditions
@@ -85,7 +85,7 @@ def make_aggsig_final_message(
     else:
         raise ValueError(f"Expected Coin or Spend, got {type(spend_conditions)}")  # pragma: no cover
 
-    COIN_TO_ADDENDUM_F_LOOKUP: Dict[ConditionOpcode, Callable[[Coin], bytes]] = {
+    COIN_TO_ADDENDUM_F_LOOKUP: dict[ConditionOpcode, Callable[[Coin], bytes]] = {
         ConditionOpcode.AGG_SIG_PARENT: lambda coin: coin.parent_coin_info,
         ConditionOpcode.AGG_SIG_PUZZLE: lambda coin: coin.puzzle_hash,
         ConditionOpcode.AGG_SIG_AMOUNT: lambda coin: int_to_bytes(coin.amount),
@@ -98,8 +98,8 @@ def make_aggsig_final_message(
     return msg + addendum + agg_sig_additional_data[opcode]
 
 
-def pkm_pairs(conditions: SpendBundleConditions, additional_data: bytes) -> Tuple[List[G1Element], List[bytes]]:
-    ret: Tuple[List[G1Element], List[bytes]] = ([], [])
+def pkm_pairs(conditions: SpendBundleConditions, additional_data: bytes) -> tuple[list[G1Element], list[bytes]]:
+    ret: tuple[list[G1Element], list[bytes]] = ([], [])
 
     data = agg_sig_additional_data(additional_data)
 
@@ -137,11 +137,11 @@ def validate_cwa(cwa: ConditionWithArgs) -> None:
 
 
 def pkm_pairs_for_conditions_dict(
-    conditions_dict: Dict[ConditionOpcode, List[ConditionWithArgs]],
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]],
     coin: Coin,
     additional_data: bytes,
-) -> List[Tuple[G1Element, bytes]]:
-    ret: List[Tuple[G1Element, bytes]] = []
+) -> list[tuple[G1Element, bytes]]:
+    ret: list[tuple[G1Element, bytes]] = []
 
     data = agg_sig_additional_data(additional_data)
 
@@ -169,9 +169,9 @@ def pkm_pairs_for_conditions_dict(
 
 
 def created_outputs_for_conditions_dict(
-    conditions_dict: Dict[ConditionOpcode, List[ConditionWithArgs]],
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]],
     input_coin_name: bytes32,
-) -> List[Coin]:
+) -> list[Coin]:
     output_coins = []
     for cvp in conditions_dict.get(ConditionOpcode.CREATE_COIN, []):
         puzzle_hash, amount_bin = cvp.vars[0], cvp.vars[1]
@@ -183,8 +183,8 @@ def created_outputs_for_conditions_dict(
 
 def conditions_dict_for_solution(
     puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
-) -> Dict[ConditionOpcode, List[ConditionWithArgs]]:
-    conditions_dict: Dict[ConditionOpcode, List[ConditionWithArgs]] = {}
+) -> dict[ConditionOpcode, list[ConditionWithArgs]]:
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {}
     for cvp in conditions_for_solution(puzzle_reveal, solution, max_cost):
         conditions_dict.setdefault(cvp.opcode, list()).append(cvp)
     return conditions_dict
@@ -192,10 +192,10 @@ def conditions_dict_for_solution(
 
 def conditions_for_solution(
     puzzle_reveal: Union[Program, SerializedProgram], solution: Union[Program, SerializedProgram], max_cost: int
-) -> List[ConditionWithArgs]:
+) -> list[ConditionWithArgs]:
     # get the standard script for a puzzle hash and feed in the solution
     try:
-        cost, r = puzzle_reveal.run_with_cost(max_cost, solution)
+        _cost, r = puzzle_reveal.run_with_cost(max_cost, solution)
         return parse_sexp_to_conditions(r)
     except Program.EvalError as e:
         raise ConsensusError(Err.SEXP_ERROR, [str(e)]) from e

chia/util/config.py

@@ -10,8 +10,9 @@ import sys
 import tempfile
 import time
 import traceback
+from collections.abc import Iterator
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Union, cast
+from typing import Any, Callable, Optional, Union, cast
 
 import importlib_resources
 import yaml
@@ -30,7 +31,7 @@ def initial_config_file(filename: Union[str, Path]) -> str:
     return contents
 
 
-def create_default_chia_config(root_path: Path, filenames: List[str] = ["config.yaml"]) -> None:
+def create_default_chia_config(root_path: Path, filenames: list[str] = ["config.yaml"]) -> None:
     for filename in filenames:
         default_config_file_data: str = initial_config_file(filename)
         path: Path = config_path_for_filename(root_path, filename)
@@ -66,7 +67,7 @@ def lock_and_load_config(
     root_path: Path,
     filename: Union[str, Path],
     fill_missing_services: bool = False,
-) -> Iterator[Dict[str, Any]]:
+) -> Iterator[dict[str, Any]]:
     with lock_config(root_path=root_path, filename=filename):
         config = _load_config_maybe_locked(
             root_path=root_path,
@@ -96,7 +97,7 @@ def load_config(
     sub_config: Optional[str] = None,
     exit_on_error: bool = True,
     fill_missing_services: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     return _load_config_maybe_locked(
         root_path=root_path,
         filename=filename,
@@ -114,7 +115,7 @@ def _load_config_maybe_locked(
     exit_on_error: bool = True,
     acquire_lock: bool = True,
     fill_missing_services: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     # This must be called under an acquired config lock, or acquire_lock should be True
 
     path = config_path_for_filename(root_path, filename)
@@ -130,7 +131,7 @@ def _load_config_maybe_locked(
     for i in range(10):
         try:
             # at least we intend it to be this type
-            r: Dict[str, Any]
+            r: dict[str, Any]
             with contextlib.ExitStack() as exit_stack:
                 if acquire_lock:
                     exit_stack.enter_context(lock_config(root_path, filename))
@@ -143,7 +144,7 @@ def _load_config_maybe_locked(
             if fill_missing_services:
                 r.update(load_defaults_for_missing_services(config=r, config_name=path.name))
             if sub_config is not None:
-                r = cast(Dict[str, Any], r.get(sub_config))
+                r = cast(dict[str, Any], r.get(sub_config))
             return r
         except Exception as e:
             tb = traceback.format_exc()
@@ -157,7 +158,7 @@ def load_config_cli(
     filename: str,
     sub_config: Optional[str] = None,
     fill_missing_services: bool = False,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Loads configuration from the specified filename, in the config directory,
     and then overrides any properties using the passed in command line arguments.
@@ -182,7 +183,7 @@ def load_config_cli(
     return unflatten_properties(flattened_props)
 
 
-def flatten_properties(config: Dict[str, Any]) -> Dict[str, Any]:
+def flatten_properties(config: dict[str, Any]) -> dict[str, Any]:
     properties = {}
     for key, value in config.items():
         if type(value) is dict:
@@ -193,8 +194,8 @@ def flatten_properties(config: Dict[str, Any]) -> Dict[str, Any]:
     return properties
 
 
-def unflatten_properties(config: Dict[str, Any]) -> Dict[str, Any]:
-    properties: Dict[str, Any] = {}
+def unflatten_properties(config: dict[str, Any]) -> dict[str, Any]:
+    properties: dict[str, Any] = {}
     for key, value in config.items():
         if "." in key:
             add_property(properties, key, value)
@@ -203,7 +204,7 @@ def unflatten_properties(config: Dict[str, Any]) -> Dict[str, Any]:
     return properties
 
 
-def add_property(d: Dict[str, Any], partial_key: str, value: Any) -> None:
+def add_property(d: dict[str, Any], partial_key: str, value: Any) -> None:
     if "." not in partial_key:  # root of dict
         d[partial_key] = value
     else:
@@ -220,15 +221,15 @@ def str2bool(v: Union[str, bool]) -> bool:
     # Source from https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
     if isinstance(v, bool):
         return v
-    if v.lower() in ("yes", "true", "True", "t", "y", "1"):
+    if v.lower() in {"yes", "true", "True", "t", "y", "1"}:
         return True
-    elif v.lower() in ("no", "false", "False", "f", "n", "0"):
+    elif v.lower() in {"no", "false", "False", "f", "n", "0"}:
         return False
     else:
         raise argparse.ArgumentTypeError("Boolean value expected.")
 
 
-def traverse_dict(d: Dict[str, Any], key_path: str) -> Any:
+def traverse_dict(d: dict[str, Any], key_path: str) -> Any:
     """
     Traverse nested dictionaries to find the element pointed-to by key_path.
     Key path components are separated by a ':' e.g.
@@ -256,7 +257,7 @@ def traverse_dict(d: Dict[str, Any], key_path: str) -> Any:
 
 method_strings = Literal["default", "python_default", "fork", "forkserver", "spawn"]
 method_values = Optional[Literal["fork", "forkserver", "spawn"]]
-start_methods: Dict[method_strings, method_values] = {
+start_methods: dict[method_strings, method_values] = {
     "default": None,
     "python_default": None,
     "fork": "fork",
@@ -266,7 +267,7 @@ start_methods: Dict[method_strings, method_values] = {
 
 
 def process_config_start_method(
-    config: Dict[str, Any],
+    config: dict[str, Any],
     log: logging.Logger,
 ) -> method_values:
     from_config: object = config.get("multiprocessing_start_method")
@@ -290,7 +291,7 @@ def process_config_start_method(
     return processed_method
 
 
-def override_config(config: Dict[str, Any], config_overrides: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+def override_config(config: dict[str, Any], config_overrides: Optional[dict[str, Any]]) -> dict[str, Any]:
     new_config = copy.deepcopy(config)
     if config_overrides is None:
         return new_config
@@ -299,13 +300,13 @@ def override_config(config: Dict[str, Any], config_overrides: Optional[Dict[str,
     return new_config
 
 
-def selected_network_address_prefix(config: Dict[str, Any]) -> str:
+def selected_network_address_prefix(config: dict[str, Any]) -> str:
     # we intend this to be a str at least
     address_prefix: str = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"]
     return address_prefix
 
 
-def load_defaults_for_missing_services(config: Dict[str, Any], config_name: str) -> Dict[str, Any]:
+def load_defaults_for_missing_services(config: dict[str, Any], config_name: str) -> dict[str, Any]:
     services = ["data_layer"]
     missing_services = [service for service in services if service not in config]
     defaulted = {}
@@ -331,16 +332,16 @@ def load_defaults_for_missing_services(config: Dict[str, Any], config_name: str)
     return defaulted
 
 
-PEER_INFO_MAPPING: Dict[NodeType, str] = {
+PEER_INFO_MAPPING: dict[NodeType, str] = {
     NodeType.FULL_NODE: "full_node_peer",
     NodeType.FARMER: "farmer_peer",
 }
 
 
-def get_unresolved_peer_infos(service_config: Dict[str, Any], peer_type: NodeType) -> Set[UnresolvedPeerInfo]:
+def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeType) -> set[UnresolvedPeerInfo]:
     peer_info_key = PEER_INFO_MAPPING[peer_type]
-    peer_infos: List[Dict[str, Any]] = service_config.get(f"{peer_info_key}s", [])
-    peer_info: Optional[Dict[str, Any]] = service_config.get(peer_info_key)
+    peer_infos: list[dict[str, Any]] = service_config.get(f"{peer_info_key}s", [])
+    peer_info: Optional[dict[str, Any]] = service_config.get(peer_info_key)
     if peer_info is not None:
         peer_infos.append(peer_info)
 
@@ -348,7 +349,7 @@ def get_unresolved_peer_infos(service_config: Dict[str, Any], peer_type: NodeTyp
 
 
 def set_peer_info(
-    service_config: Dict[str, Any],
+    service_config: dict[str, Any],
     peer_type: NodeType,
     peer_host: Optional[str] = None,
     peer_port: Optional[int] = None,

chia/util/cpu.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import os

chia/util/db_synchronous.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 

chia/util/db_version.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import sqlite3

chia/util/db_wrapper.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import asyncio
@@ -6,10 +8,11 @@ import functools
 import secrets
 import sqlite3
 import sys
+from collections.abc import AsyncIterator, Iterable
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, Iterable, List, Optional, TextIO, Tuple, Type, Union
+from typing import Any, Optional, TextIO, Union
 
 import aiosqlite
 import anyio
@@ -29,8 +32,8 @@ class DBWrapperError(Exception):
 
 
 class ForeignKeyError(DBWrapperError):
-    def __init__(self, violations: Iterable[Union[aiosqlite.Row, Tuple[str, object, str, object]]]) -> None:
-        self.violations: List[Dict[str, object]] = []
+    def __init__(self, violations: Iterable[Union[aiosqlite.Row, tuple[str, object, str, object]]]) -> None:
+        self.violations: list[dict[str, object]] = []
 
         for violation in violations:
             if isinstance(violation, tuple):
@@ -71,7 +74,8 @@ async def _create_connection(
     log_file: Optional[TextIO] = None,
     name: Optional[str] = None,
 ) -> aiosqlite.Connection:
-    connection = await aiosqlite.connect(database=database, uri=uri)
+    # To avoid https://github.com/python/cpython/issues/118172
+    connection = await aiosqlite.connect(database=database, uri=uri, cached_statements=0)
 
     if log_file is not None:
         await connection.set_trace_callback(functools.partial(sql_trace_callback, file=log_file, name=name))
@@ -111,8 +115,7 @@ def get_host_parameter_limit() -> int:
     if sys.version_info >= (3, 11):
         connection = sqlite3.connect(":memory:")
 
-        # sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER exists in 3.11, pylint
-        limit_number = sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER  # pylint: disable=E1101
+        limit_number = sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER
         host_parameter_limit = connection.getlimit(limit_number)
     else:
         # guessing based on defaults, seems you can't query
@@ -136,7 +139,7 @@ class DBWrapper2:
     _lock: asyncio.Lock = field(default_factory=asyncio.Lock)
     _read_connections: asyncio.Queue[aiosqlite.Connection] = field(default_factory=asyncio.Queue)
     _num_read_connections: int = 0
-    _in_use: Dict[asyncio.Task[object], aiosqlite.Connection] = field(default_factory=dict)
+    _in_use: dict[asyncio.Task[object], aiosqlite.Connection] = field(default_factory=dict)
     _current_writer: Optional[asyncio.Task[object]] = None
     _savepoint_name: int = 0
 
@@ -160,7 +163,7 @@ class DBWrapper2:
         journal_mode: str = "WAL",
         synchronous: Optional[str] = None,
         foreign_keys: Optional[bool] = None,
-        row_factory: Optional[Type[aiosqlite.Row]] = None,
+        row_factory: Optional[type[aiosqlite.Row]] = None,
     ) -> AsyncIterator[DBWrapper2]:
         if foreign_keys is None:
             foreign_keys = False
@@ -217,7 +220,7 @@ class DBWrapper2:
         journal_mode: str = "WAL",
         synchronous: Optional[str] = None,
         foreign_keys: bool = False,
-        row_factory: Optional[Type[aiosqlite.Row]] = None,
+        row_factory: Optional[type[aiosqlite.Row]] = None,
     ) -> DBWrapper2:
         # WARNING: please use .managed() instead
         if log_path is None:
@@ -270,7 +273,7 @@ class DBWrapper2:
         await self._write_connection.execute(f"SAVEPOINT {name}")
         try:
             yield
-        except:  # noqa E722
+        except:
             await self._write_connection.execute(f"ROLLBACK TO {name}")
             raise
         finally: