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

chia/util/keychain.py

@@ -1,18 +1,22 @@
+# Package: utils
+
 from __future__ import annotations
 
 import sys
 import unicodedata
+from collections.abc import Iterator
 from dataclasses import dataclass
 from hashlib import pbkdf2_hmac
 from pathlib import Path
-from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, Union, overload
+from typing import Any, Literal, Optional, Union, overload
 
 import importlib_resources
 from bitstring import BitArray  # pyright: reportMissingImports=false
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey  # pyright: reportMissingImports=false
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
 from typing_extensions import final
 
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.bech32m import bech32_decode, convertbits
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.errors import (
@@ -26,7 +30,6 @@ from chia.util.errors import (
 )
 from chia.util.file_keyring import Key
 from chia.util.hash import std_hash
-from chia.util.ints import uint32
 from chia.util.keyring_wrapper import KeyringWrapper
 from chia.util.streamable import Streamable, streamable
 
@@ -38,10 +41,10 @@ MIN_PASSPHRASE_LEN = 8
 
 
 def supports_os_passphrase_storage() -> bool:
-    return sys.platform in ["darwin", "win32", "cygwin"]
+    return sys.platform in {"darwin", "win32", "cygwin"}
 
 
-def passphrase_requirements() -> Dict[str, Any]:
+def passphrase_requirements() -> dict[str, Any]:
     """
     Returns a dictionary specifying current passphrase requirements
     """
@@ -68,7 +71,7 @@ def generate_mnemonic() -> str:
 
 
 def bytes_to_mnemonic(mnemonic_bytes: bytes) -> str:
-    if len(mnemonic_bytes) not in [16, 20, 24, 28, 32]:
+    if len(mnemonic_bytes) not in {16, 20, 24, 28, 32}:
         raise ValueError(
             f"Data length should be one of the following: [16, 20, 24, 28, 32], but it is {len(mnemonic_bytes)}."
         )
@@ -93,8 +96,8 @@ def bytes_to_mnemonic(mnemonic_bytes: bytes) -> str:
 
 
 def check_mnemonic_validity(mnemonic_str: str) -> bool:
-    mnemonic: List[str] = mnemonic_str.split(" ")
-    return len(mnemonic) in [12, 15, 18, 21, 24]
+    mnemonic: list[str] = mnemonic_str.split(" ")
+    return len(mnemonic) in {12, 15, 18, 21, 24}
 
 
 def mnemonic_from_short_words(mnemonic_str: str) -> str:
@@ -103,12 +106,12 @@ def mnemonic_from_short_words(mnemonic_str: str) -> str:
     practice to only store the first 4 letters of each word in many offline storage solutions, also support looking
     up words by the first 4 characters
     """
-    mnemonic: List[str] = mnemonic_str.split(" ")
-    if len(mnemonic) not in [12, 15, 18, 21, 24]:
+    mnemonic: list[str] = mnemonic_str.split(" ")
+    if len(mnemonic) not in {12, 15, 18, 21, 24}:
         raise ValueError("Invalid mnemonic length")
 
     four_char_dict = {word[:4]: word for word in bip39_word_list().splitlines()}
-    full_words: List[str] = []
+    full_words: list[str] = []
     for word in mnemonic:
         full_word = four_char_dict.get(word[:4])
         if full_word is None:
@@ -120,7 +123,7 @@ def mnemonic_from_short_words(mnemonic_str: str) -> str:
 
 def bytes_from_mnemonic(mnemonic_str: str) -> bytes:
     full_mnemonic_str = mnemonic_from_short_words(mnemonic_str)
-    mnemonic: List[str] = full_mnemonic_str.split(" ")
+    mnemonic: list[str] = full_mnemonic_str.split(" ")
 
     word_list = {word: i for i, word in enumerate(bip39_word_list().splitlines())}
     bit_array = BitArray()
@@ -185,7 +188,7 @@ def get_private_key_user(user: str, index: int) -> str:
 @streamable
 @dataclass(frozen=True)
 class KeyDataSecrets(Streamable):
-    mnemonic: List[str]
+    mnemonic: list[str]
     entropy: bytes
     private_key: PrivateKey
 
@@ -259,7 +262,7 @@ class KeyData(Streamable):
         return cls.from_mnemonic(generate_mnemonic(), label)
 
     @property
-    def mnemonic(self) -> List[str]:
+    def mnemonic(self) -> list[str]:
         if self.secrets is None:
             raise KeychainSecretsMissing()
         return self.secrets.mnemonic
@@ -434,7 +437,7 @@ class Keychain:
                 pass
         return None
 
-    def get_first_private_key(self) -> Optional[Tuple[PrivateKey, bytes]]:
+    def get_first_private_key(self) -> Optional[tuple[PrivateKey, bytes]]:
         """
         Returns the first key in the keychain that has one of the passed in passphrases.
         """
@@ -442,7 +445,7 @@ class Keychain:
             return key_data.private_key, key_data.entropy
         return None
 
-    def get_private_key_by_fingerprint(self, fingerprint: int) -> Optional[Tuple[PrivateKey, bytes]]:
+    def get_private_key_by_fingerprint(self, fingerprint: int) -> Optional[tuple[PrivateKey, bytes]]:
         """
         Return first private key which have the given public key fingerprint.
         """
@@ -451,12 +454,12 @@ class Keychain:
                 return key_data.private_key, key_data.entropy
         return None
 
-    def get_all_private_keys(self) -> List[Tuple[PrivateKey, bytes]]:
+    def get_all_private_keys(self) -> list[tuple[PrivateKey, bytes]]:
         """
         Returns all private keys which can be retrieved, with the given passphrases.
         A tuple of key, and entropy bytes (i.e. mnemonic) is returned for each key.
         """
-        all_keys: List[Tuple[PrivateKey, bytes]] = []
+        all_keys: list[tuple[PrivateKey, bytes]] = []
         for key_data in self._iterate_through_key_datas(skip_public_only=True):
             all_keys.append((key_data.private_key, key_data.entropy))
         return all_keys
@@ -470,21 +473,21 @@ class Keychain:
                 return key_data
         raise KeychainFingerprintNotFound(fingerprint)
 
-    def get_keys(self, include_secrets: bool = False) -> List[KeyData]:
+    def get_keys(self, include_secrets: bool = False) -> list[KeyData]:
         """
         Returns the KeyData of all keys which can be retrieved.
         """
-        all_keys: List[KeyData] = []
+        all_keys: list[KeyData] = []
         for key_data in self._iterate_through_key_datas(include_secrets=include_secrets, skip_public_only=False):
             all_keys.append(key_data)
 
         return all_keys
 
-    def get_all_public_keys(self) -> List[G1Element]:
+    def get_all_public_keys(self) -> list[G1Element]:
         """
         Returns all public keys.
         """
-        all_keys: List[G1Element] = []
+        all_keys: list[G1Element] = []
         for key_data in self._iterate_through_key_datas(skip_public_only=False):
             all_keys.append(key_data.public_key)
 
@@ -521,13 +524,13 @@ class Keychain:
                 pass
         return removed
 
-    def delete_keys(self, keys_to_delete: List[Tuple[PrivateKey, bytes]]) -> None:
+    def delete_keys(self, keys_to_delete: list[tuple[PrivateKey, bytes]]) -> None:
         """
         Deletes all keys in the list.
         """
         remaining_fingerprints = {x[0].get_g1().get_fingerprint() for x in keys_to_delete}
         remaining_removals = len(remaining_fingerprints)
-        while len(remaining_fingerprints):
+        while len(remaining_fingerprints) > 0:
             key_to_delete = remaining_fingerprints.pop()
             if self.delete_key_by_fingerprint(key_to_delete) > 0:
                 remaining_removals -= 1

chia/util/keyring_wrapper.py

@@ -1,15 +1,22 @@
+# Package: utils
+
 from __future__ import annotations
 
+import sys
+import time
+from getpass import getpass
 from pathlib import Path
 from sys import platform
-from typing import ClassVar, Optional, Tuple, Union, overload
+from typing import ClassVar, Optional, Union, overload
 
+import colorama
 from keyring.backends.macOS import Keyring as MacKeyring
 from keyring.backends.Windows import WinVaultKeyring as WinKeyring
 from keyring.errors import KeyringError, PasswordDeleteError
 from typing_extensions import Literal
 
 from chia.util.default_root import DEFAULT_KEYS_ROOT_PATH
+from chia.util.errors import KeychainMaxUnlockAttempts
 from chia.util.file_keyring import FileKeyring
 
 # We want to protect the keyring, even if a user-specified master passphrase isn't provided
@@ -52,6 +59,62 @@ def warn_if_macos_errSecInteractionNotAllowed(error: KeyringError) -> bool:
     return False
 
 
+DEFAULT_PASSPHRASE_PROMPT = (
+    colorama.Fore.YELLOW + colorama.Style.BRIGHT + "(Unlock Keyring)" + colorama.Style.RESET_ALL + " Passphrase: "
+)
+FAILED_ATTEMPT_DELAY = 0.5
+MAX_RETRIES = 3
+
+
+def prompt_for_passphrase(prompt: str) -> str:
+    if sys.platform == "win32" or sys.platform == "cygwin":
+        print(prompt, end="", flush=True)
+        prompt = ""
+    return getpass(prompt)
+
+
+def obtain_current_passphrase(prompt: str = DEFAULT_PASSPHRASE_PROMPT, use_passphrase_cache: bool = False) -> str:
+    from chia.util.keyring_wrapper import KeyringWrapper
+
+    """
+    Obtains the master passphrase for the keyring, optionally using the cached
+    value (if previously set). If the passphrase isn't already cached, the user is
+    prompted interactively to enter their passphrase a max of MAX_RETRIES times
+    before failing.
+    """
+
+    if use_passphrase_cache:
+        passphrase, validated = KeyringWrapper.get_shared_instance().get_cached_master_passphrase()
+        if passphrase:
+            # If the cached passphrase was previously validated, we assume it's... valid
+            if validated:
+                return passphrase
+
+            # Cached passphrase needs to be validated
+            if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
+                return passphrase
+            else:
+                # Cached passphrase is bad, clear the cache
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(None)
+
+    # Prompt interactively with up to MAX_RETRIES attempts
+    for i in range(MAX_RETRIES):
+        colorama.init()
+
+        passphrase = prompt_for_passphrase(prompt)
+
+        if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
+            # If using the passphrase cache, and the user inputted a passphrase, update the cache
+            if use_passphrase_cache:
+                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
+            return passphrase
+
+        time.sleep(FAILED_ATTEMPT_DELAY)
+        print("Incorrect passphrase\n")
+    raise KeychainMaxUnlockAttempts()
+
+
 class KeyringWrapper:
     """
     KeyringWrapper provides an abstraction that the Keychain class can use
@@ -141,7 +204,7 @@ class KeyringWrapper:
 
     # Master passphrase support
 
-    def get_cached_master_passphrase(self) -> Tuple[Optional[str], bool]:
+    def get_cached_master_passphrase(self) -> tuple[Optional[str], bool]:
         """
         Returns a tuple including the currently cached passphrase and a bool
         indicating whether the passphrase has been previously validated.
@@ -228,7 +291,6 @@ class KeyringWrapper:
             except KeyringError as e:
                 if not warn_if_macos_errSecInteractionNotAllowed(e):
                     raise
-        return None
 
     def remove_master_passphrase_from_credential_store(self) -> None:
         passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
@@ -247,7 +309,6 @@ class KeyringWrapper:
             except KeyringError as e:
                 if not warn_if_macos_errSecInteractionNotAllowed(e):
                     raise
-        return None
 
     def get_master_passphrase_from_credential_store(self) -> Optional[str]:
         passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()

chia/util/limited_semaphore.py

@@ -1,9 +1,11 @@
+# Package: utils
+
 from __future__ import annotations
 
 import asyncio
 import contextlib
+from collections.abc import AsyncIterator
 from dataclasses import dataclass
-from typing import AsyncIterator
 
 from typing_extensions import final
 

chia/util/lock.py

@@ -1,9 +1,11 @@
+# Package: utils
+
 from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
 from types import TracebackType
-from typing import Optional, Type
+from typing import Optional
 
 from filelock import BaseFileLock, FileLock, Timeout
 from typing_extensions import final
@@ -31,7 +33,7 @@ class Lockfile:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> None:

chia/util/log_exceptions.py

@@ -1,9 +1,12 @@
+# Package: utils
+
 from __future__ import annotations
 
 import logging
 import traceback
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator, Tuple, Type, Union
+from typing import Union
 
 
 @contextmanager
@@ -14,7 +17,7 @@ def log_exceptions(
     message: str = "Caught exception",
     level: int = logging.ERROR,
     show_traceback: bool = True,
-    exceptions_to_process: Union[Type[BaseException], Tuple[Type[BaseException], ...]] = Exception,
+    exceptions_to_process: Union[type[BaseException], tuple[type[BaseException], ...]] = Exception,
 ) -> Iterator[None]:
     try:
         yield

chia/util/logging.py

@@ -1,9 +1,11 @@
+# Package: utils
+
 from __future__ import annotations
 
 import logging
 import re
 import time
-from typing import Pattern
+from re import Pattern
 
 
 class TimedDuplicateFilter(logging.Filter):

chia/util/lru_cache.py

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

chia/util/math.py

@@ -1,14 +1,14 @@
-from __future__ import annotations
+# Package: utils
 
-from typing import List
+from __future__ import annotations
 
 
 def clamp(n: int, smallest: int, largest: int) -> int:
     return max(smallest, min(n, largest))
 
 
-def make_monotonically_decreasing(seq: List[float]) -> List[float]:
-    out: List[float] = []
+def make_monotonically_decreasing(seq: list[float]) -> list[float]:
+    out: list[float] = []
     if len(seq) > 0:
         min = seq[0]
         for n in seq:

chia/util/network.py

@@ -5,51 +5,19 @@ import ipaddress
 import logging
 import socket
 import ssl
+from collections.abc import Iterable
 from dataclasses import dataclass
-from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network, ip_address
-from typing import Any, Dict, Iterable, List, Literal, Optional, Tuple, Union
+from ipaddress import IPv4Network, IPv6Network, ip_address
+from typing import Any, Literal, Optional, Union
 
 from aiohttp import web
 from aiohttp.log import web_logger
 from typing_extensions import final
 
-from chia.server.outbound_message import NodeType
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.ints import uint16
-
-
-@dataclass(frozen=True)
-class IPAddress:
-    _inner: Union[IPv4Address, IPv6Address]
-
-    @classmethod
-    def create(cls, ip: str) -> IPAddress:
-        return cls(ip_address(ip))
-
-    def __int__(self) -> int:
-        return int(self._inner)
-
-    def __str__(self) -> str:
-        return str(self._inner)
-
-    def __repr__(self) -> str:
-        return repr(self._inner)
-
-    @property
-    def packed(self) -> bytes:
-        return self._inner.packed
-
-    @property
-    def is_private(self) -> bool:
-        return self._inner.is_private
-
-    @property
-    def is_v4(self) -> bool:
-        return self._inner.version == 4
-
-    @property
-    def is_v6(self) -> bool:
-        return self._inner.version == 6
+from chia.util.ip_address import IPAddress
+from chia.util.task_referencer import create_referenced_task
 
 
 @final
@@ -130,7 +98,7 @@ class WebServer:
         await self.runner.cleanup()
 
     def close(self) -> None:
-        self._close_task = asyncio.create_task(self._close())
+        self._close_task = create_referenced_task(self._close())
 
     async def await_closed(self) -> None:
         if self._close_task is None:
@@ -146,7 +114,7 @@ def is_in_network(peer_host: str, networks: Iterable[Union[IPv4Network, IPv6Netw
         return False
 
 
-def is_trusted_cidr(peer_host: str, trusted_cidrs: List[str]) -> bool:
+def is_trusted_cidr(peer_host: str, trusted_cidrs: list[str]) -> bool:
     try:
         ip_obj = ipaddress.ip_address(peer_host)
     except ValueError:
@@ -161,41 +129,15 @@ def is_trusted_cidr(peer_host: str, trusted_cidrs: List[str]) -> bool:
 
 
 def is_localhost(peer_host: str) -> bool:
-    return peer_host in ["127.0.0.1", "localhost", "::1", "0:0:0:0:0:0:0:1"]
+    return peer_host in {"127.0.0.1", "localhost", "::1", "0:0:0:0:0:0:0:1"}
 
 
 def is_trusted_peer(
-    host: str, node_id: bytes32, trusted_peers: Dict[str, Any], trusted_cidrs: List[str], testing: bool = False
+    host: str, node_id: bytes32, trusted_peers: dict[str, Any], trusted_cidrs: list[str], testing: bool = False
 ) -> bool:
-    return not testing and is_localhost(host) or node_id.hex() in trusted_peers or is_trusted_cidr(host, trusted_cidrs)
-
-
-def class_for_type(type: NodeType) -> Any:
-    if type is NodeType.FULL_NODE:
-        from chia.full_node.full_node_api import FullNodeAPI
-
-        return FullNodeAPI
-    elif type is NodeType.WALLET:
-        from chia.wallet.wallet_node_api import WalletNodeAPI
-
-        return WalletNodeAPI
-    elif type is NodeType.INTRODUCER:
-        from chia.introducer.introducer_api import IntroducerAPI
-
-        return IntroducerAPI
-    elif type is NodeType.TIMELORD:
-        from chia.timelord.timelord_api import TimelordAPI
-
-        return TimelordAPI
-    elif type is NodeType.FARMER:
-        from chia.farmer.farmer_api import FarmerAPI
-
-        return FarmerAPI
-    elif type is NodeType.HARVESTER:
-        from chia.harvester.harvester_api import HarvesterAPI
-
-        return HarvesterAPI
-    raise ValueError("No class for type")
+    return (
+        (not testing and is_localhost(host)) or node_id.hex() in trusted_peers or is_trusted_cidr(host, trusted_cidrs)
+    )
 
 
 async def resolve(host: str, *, prefer_ipv6: bool = False) -> IPAddress:
@@ -203,8 +145,8 @@ async def resolve(host: str, *, prefer_ipv6: bool = False) -> IPAddress:
         return IPAddress.create(host)
     except ValueError:
         pass
-    addrset: List[
-        Tuple[socket.AddressFamily, socket.SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]
+    addrset: list[
+        tuple[socket.AddressFamily, socket.SocketKind, int, str, Union[tuple[str, int], tuple[str, int, int, int]]]
     ] = await asyncio.get_event_loop().getaddrinfo(host, None)
     # The list returned by getaddrinfo is never empty, an exception is thrown or data is returned.
     ips_v4 = []
@@ -224,7 +166,7 @@ async def resolve(host: str, *, prefer_ipv6: bool = False) -> IPAddress:
         raise ValueError(f"failed to resolve {host} into an IP address")
 
 
-def select_port(prefer_ipv6: bool, addresses: List[Any]) -> uint16:
+def select_port(prefer_ipv6: bool, addresses: list[Any]) -> uint16:
     selected_port: uint16
     for address_string, port, *_ in addresses:
         address = ip_address(address_string)

chia/util/paginator.py

@@ -1,8 +1,10 @@
+# Package: utils
+
 from __future__ import annotations
 
 import dataclasses
+from collections.abc import Sequence
 from math import ceil
-from typing import Sequence
 
 
 class InvalidPageSizeLimit(Exception):

chia/util/path.py

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

chia/util/permissions.py

@@ -1,11 +1,12 @@
+# Package: utils
+
 from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Tuple
 
 
-def verify_file_permissions(path: Path, mask: int) -> Tuple[bool, int]:
+def verify_file_permissions(path: Path, mask: int) -> tuple[bool, int]:
     """
     Check that the file's permissions are properly restricted, as compared to the
     permission mask

chia/util/prev_transaction_block.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Tuple
-
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.util.ints import uint128
@@ -11,7 +9,7 @@ def get_prev_transaction_block(
     curr: BlockRecord,
     blocks: BlockRecordsProtocol,
     total_iters_sp: uint128,
-) -> Tuple[bool, BlockRecord]:
+) -> tuple[bool, BlockRecord]:
     prev_transaction_block = curr
     while not curr.is_transaction_block:
         curr = blocks.block_record(curr.prev_hash)

chia/util/priority_mutex.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import asyncio
@@ -5,8 +7,9 @@ import collections
 import contextlib
 import dataclasses
 import logging
+from collections.abc import AsyncIterator
 from enum import IntEnum
-from typing import AsyncIterator, Dict, Generic, Optional, Type, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from typing_extensions import final
 
@@ -45,11 +48,11 @@ class PriorityMutex(Generic[_T_Priority]):
     ```
     """
 
-    _deques: Dict[_T_Priority, collections.deque[_Element]]
+    _deques: dict[_T_Priority, collections.deque[_Element]]
     _active: Optional[_Element] = None
 
     @classmethod
-    def create(cls, priority_type: Type[_T_Priority]) -> PriorityMutex[_T_Priority]:
+    def create(cls, priority_type: type[_T_Priority]) -> PriorityMutex[_T_Priority]:
         return cls(
             _deques={priority: collections.deque() for priority in sorted(priority_type)},
         )

chia/util/profiler.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import asyncio
@@ -5,9 +7,10 @@ import cProfile
 import logging
 import pathlib
 import tracemalloc
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from datetime import datetime
-from typing import AsyncIterator, Optional
+from typing import Optional
 
 from chia.util.path import path_from_root
 
@@ -132,7 +135,7 @@ if __name__ == "__main__":
             output_file += f"-{last}"
 
         print(f"generating call tree for slot(s) [{first}, {last}]")
-        check_call(["gprof2dot", "-f", "pstats", "-o", output_file + ".dot"] + files)
+        check_call(["gprof2dot", "-f", "pstats", "-o", output_file + ".dot", *files])
         with open(output_file + ".png", "w+") as f:
             check_call(["dot", "-T", "png", output_file + ".dot"], stdout=f)
         print(f"output written to: {output_file}.png")
@@ -140,7 +143,7 @@ if __name__ == "__main__":
     if len(sys.argv) == 2:
         # this analyzes the CPU usage at all slots saved to the profiler directory
         analyze_cpu_usage(profile_dir)
-    elif len(sys.argv) in [3, 4]:
+    elif len(sys.argv) in {3, 4}:
         # the additional arguments are interpreted as either one slot, or a
         # slot range (first and last) to analyze
         first = int(sys.argv[2])
@@ -174,7 +177,7 @@ async def mem_profile_task(root_path: pathlib.Path, service: str, log: logging.L
             await asyncio.sleep(60)
             snapshot = tracemalloc.take_snapshot()
             snapshot.dump(str(profile_dir / f"heap-{counter:05d}.profile"))
-            log.info(f"Heap usage: {tracemalloc.get_traced_memory()[0]/1000000:0.3f} MB profile {counter:05d}")
+            log.info(f"Heap usage: {tracemalloc.get_traced_memory()[0] / 1000000:0.3f} MB profile {counter:05d}")
             counter += 1
     finally:
         tracemalloc.stop()

chia/util/recursive_replace.py

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

chia/util/safe_cancel_task.py

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