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

chia/util/service_groups.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from typing import Dict, Generator, Iterable, KeysView
+from collections.abc import Generator, Iterable, KeysView
 
-SERVICES_FOR_GROUP: Dict[str, list[str]] = {
+SERVICES_FOR_GROUP: dict[str, list[str]] = {
     "all": [
         "chia_harvester",
         "chia_timelord_launcher",

chia/util/setproctitle.py

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

chia/util/significant_bits.py

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

chia/util/ssl_check.py

@@ -5,7 +5,7 @@ import stat
 import sys
 from logging import Logger
 from pathlib import Path
-from typing import List, Optional, Set, Tuple
+from typing import Optional
 
 from chia.util.config import load_config, traverse_dict
 from chia.util.permissions import octal_mode_string, verify_file_permissions
@@ -60,15 +60,15 @@ KEY_CONFIG_KEY_PATHS = [
 
 
 # Set to keep track of which files we've already warned about
-warned_ssl_files: Set[Path] = set()
+warned_ssl_files: set[Path] = set()
 
 
-def get_all_ssl_file_paths(root_path: Path) -> Tuple[List[Path], List[Path]]:
+def get_all_ssl_file_paths(root_path: Path) -> tuple[list[Path], list[Path]]:
     """Lookup config values and append to a list of files whose permissions we need to check"""
     from chia.ssl.create_ssl import get_mozilla_ca_crt
 
-    all_certs: List[Path] = []
-    all_keys: List[Path] = []
+    all_certs: list[Path] = []
+    all_keys: list[Path] = []
 
     try:
         config = load_config(root_path, "config.yaml", exit_on_error=False, fill_missing_services=True)
@@ -99,16 +99,16 @@ def get_ssl_perm_warning(path: Path, actual_mode: int, expected_mode: int) -> st
 
 
 def verify_ssl_certs_and_keys(
-    cert_paths: List[Path], key_paths: List[Path], log: Optional[Logger] = None
-) -> List[Tuple[Path, int, int]]:
+    cert_paths: list[Path], key_paths: list[Path], log: Optional[Logger] = None
+) -> list[tuple[Path, int, int]]:
     """Check that file permissions are properly set for the provided SSL cert and key files"""
     if sys.platform == "win32" or sys.platform == "cygwin":
         # TODO: ACLs for SSL certs/keys on Windows
         return []
 
-    invalid_files_and_modes: List[Tuple[Path, int, int]] = []
+    invalid_files_and_modes: list[tuple[Path, int, int]] = []
 
-    def verify_paths(paths: List[Path], restrict_mask: int, expected_permissions: int) -> None:
+    def verify_paths(paths: list[Path], restrict_mask: int, expected_permissions: int) -> None:
         nonlocal invalid_files_and_modes
         for path in paths:
             try:
@@ -157,7 +157,7 @@ def check_ssl(root_path: Path) -> None:
         print("\n".join(lines), file=sys.stderr)
 
 
-def check_and_fix_permissions_for_ssl_file(file: Path, mask: int, updated_mode: int) -> Tuple[bool, bool]:
+def check_and_fix_permissions_for_ssl_file(file: Path, mask: int, updated_mode: int) -> tuple[bool, bool]:
     """Check file permissions and attempt to fix them if found to be too open"""
     if sys.platform == "win32" or sys.platform == "cygwin":
         # TODO: ACLs for SSL certs/keys on Windows
@@ -168,7 +168,7 @@ def check_and_fix_permissions_for_ssl_file(file: Path, mask: int, updated_mode:
 
     # Check that the file permissions are not too permissive
     try:
-        (good_perms, mode) = verify_file_permissions(file, mask)
+        (good_perms, _mode) = verify_file_permissions(file, mask)
         if not good_perms:
             valid = False
             print(

chia/util/streamable.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import dataclasses
@@ -5,30 +7,16 @@ import io
 import os
 import pprint
 import traceback
+from collections.abc import Collection
 from enum import Enum
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    BinaryIO,
-    Callable,
-    ClassVar,
-    Collection,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    get_type_hints,
-)
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, ClassVar, Optional, TypeVar, Union, get_type_hints
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint32, uint64
 from typing_extensions import Literal, get_args, get_origin
 
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.hash import std_hash
-from chia.util.ints import uint16, uint32, uint64
 
 if TYPE_CHECKING:
     from _typeshed import DataclassInstance
@@ -45,7 +33,7 @@ class UnsupportedType(StreamableError):
 
 
 class DefinitionError(StreamableError):
-    def __init__(self, message: str, cls: Type[object]):
+    def __init__(self, message: str, cls: type[object]):
         super().__init__(
             f"{message} Correct usage is:\n\n"
             f"@streamable\n@dataclass(frozen=True)\nclass {cls.__name__}(Streamable):\n    ..."
@@ -53,7 +41,7 @@ class DefinitionError(StreamableError):
 
 
 class ParameterMissingError(StreamableError):
-    def __init__(self, cls: type, missing: List[str]):
+    def __init__(self, cls: type, missing: list[str]):
         super().__init__(
             f"{len(missing)} field{'s' if len(missing) != 1 else ''} missing for {cls.__name__}: {', '.join(missing)}"
         )
@@ -91,7 +79,7 @@ ConvertFunctionType = Callable[[object], object]
 @dataclasses.dataclass(frozen=True)
 class Field:
     name: str
-    type: Type[object]
+    type: type[object]
     has_default: bool
     stream_function: StreamFunctionType
     parse_function: ParseFunctionType
@@ -99,10 +87,10 @@ class Field:
     post_init_function: ConvertFunctionType
 
 
-StreamableFields = Tuple[Field, ...]
+StreamableFields = tuple[Field, ...]
 
 
-def create_fields(cls: Type[DataclassInstance]) -> StreamableFields:
+def create_fields(cls: type[DataclassInstance]) -> StreamableFields:
     hints = get_type_hints(cls)
     fields = []
     for field in dataclasses.fields(cls):
@@ -124,7 +112,7 @@ def create_fields(cls: Type[DataclassInstance]) -> StreamableFields:
 
 
 def is_type_List(f_type: object) -> bool:
-    return get_origin(f_type) == list or f_type == list
+    return get_origin(f_type) is list or f_type is list
 
 
 def is_type_SpecificOptional(f_type: object) -> bool:
@@ -135,7 +123,7 @@ def is_type_SpecificOptional(f_type: object) -> bool:
 
 
 def is_type_Tuple(f_type: object) -> bool:
-    return get_origin(f_type) == tuple or f_type == tuple
+    return get_origin(f_type) is tuple or f_type is tuple
 
 
 def convert_optional(convert_func: ConvertFunctionType, item: Any) -> Any:
@@ -144,7 +132,7 @@ def convert_optional(convert_func: ConvertFunctionType, item: Any) -> Any:
     return convert_func(item)
 
 
-def convert_tuple(convert_funcs: List[ConvertFunctionType], items: Collection[Any]) -> Tuple[Any, ...]:
+def convert_tuple(convert_funcs: list[ConvertFunctionType], items: Collection[Any]) -> tuple[Any, ...]:
     if not isinstance(items, (list, tuple)):
         raise InvalidTypeError(tuple, type(items))
     if len(items) != len(convert_funcs):
@@ -152,7 +140,7 @@ def convert_tuple(convert_funcs: List[ConvertFunctionType], items: Collection[An
     return tuple(convert_func(item) for convert_func, item in zip(convert_funcs, items))
 
 
-def convert_list(convert_func: ConvertFunctionType, items: List[Any]) -> List[Any]:
+def convert_list(convert_func: ConvertFunctionType, items: list[Any]) -> list[Any]:
     if not isinstance(items, list):
         raise InvalidTypeError(list, type(items))
     return [convert_func(item) for item in items]
@@ -167,7 +155,7 @@ def convert_hex_string(item: str) -> bytes:
         raise ConversionError(item, bytes, e) from e
 
 
-def convert_byte_type(f_type: Type[Any], item: Any) -> Any:
+def convert_byte_type(f_type: type[Any], item: Any) -> Any:
     if isinstance(item, f_type):
         return item
     if not isinstance(item, bytes):
@@ -178,7 +166,7 @@ def convert_byte_type(f_type: Type[Any], item: Any) -> Any:
         raise ConversionError(item, f_type, e) from e
 
 
-def convert_primitive(f_type: Type[Any], item: Any) -> Any:
+def convert_primitive(f_type: type[Any], item: Any) -> Any:
     if isinstance(item, f_type):
         return item
     try:
@@ -187,7 +175,7 @@ def convert_primitive(f_type: Type[Any], item: Any) -> Any:
         raise ConversionError(item, f_type, e) from e
 
 
-def streamable_from_dict(klass: Type[_T_Streamable], item: Any) -> _T_Streamable:
+def streamable_from_dict(klass: type[_T_Streamable], item: Any) -> _T_Streamable:
     """
     Converts a dictionary based on a dataclass, into an instance of that dataclass.
     Recursively goes through lists, optionals, and dictionaries.
@@ -208,7 +196,7 @@ def streamable_from_dict(klass: Type[_T_Streamable], item: Any) -> _T_Streamable
 
 
 def function_to_convert_one_item(
-    f_type: Type[Any], json_parser: Optional[Callable[[object], Streamable]] = None
+    f_type: type[Any], json_parser: Optional[Callable[[object], Streamable]] = None
 ) -> ConvertFunctionType:
     if is_type_SpecificOptional(f_type):
         convert_inner_func = function_to_convert_one_item(get_args(f_type)[0], json_parser)
@@ -228,7 +216,7 @@ def function_to_convert_one_item(
     elif hasattr(f_type, "from_json_dict"):
         if json_parser is None:
             json_parser = f_type.from_json_dict
-        return lambda item: json_parser(item)
+        return json_parser
     elif issubclass(f_type, bytes):
         # Type is bytes, data is a hex string or bytes
         return lambda item: convert_byte_type(f_type, item)
@@ -237,7 +225,7 @@ def function_to_convert_one_item(
         return lambda item: convert_primitive(f_type, item)
 
 
-def post_init_process_item(f_type: Type[Any], item: Any) -> object:
+def post_init_process_item(f_type: type[Any], item: Any) -> object:
     if not isinstance(item, f_type):
         try:
             item = f_type(item)
@@ -255,7 +243,7 @@ def post_init_process_item(f_type: Type[Any], item: Any) -> object:
     return item
 
 
-def function_to_post_init_process_one_item(f_type: Type[object]) -> ConvertFunctionType:
+def function_to_post_init_process_one_item(f_type: type[object]) -> ConvertFunctionType:
     if is_type_SpecificOptional(f_type):
         process_inner_func = function_to_post_init_process_one_item(get_args(f_type)[0])
         return lambda item: convert_optional(process_inner_func, item)
@@ -309,7 +297,7 @@ def recurse_jsonify(
     elif d is None or type(d) is str:
         return d
     elif hasattr(d, "to_json_dict"):
-        ret: Union[List[Any], Dict[str, Any], str, None, int] = d.to_json_dict()
+        ret: Union[list[Any], dict[str, Any], str, int, None] = d.to_json_dict()
         return ret
     raise UnsupportedType(f"failed to jsonify {d} (type: {type(d)})")
 
@@ -346,7 +334,7 @@ def parse_optional(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> Option
         raise ValueError("Optional must be 0 or 1")
 
 
-def parse_rust(f: BinaryIO, f_type: Type[Any]) -> Any:
+def parse_rust(f: BinaryIO, f_type: type[Any]) -> Any:
     assert isinstance(f, io.BytesIO)
     buf = f.getbuffer()
     ret, advance = f_type.parse_rust(buf[f.tell() :])
@@ -361,8 +349,8 @@ def parse_bytes(f: BinaryIO) -> bytes:
     return bytes_read
 
 
-def parse_list(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> List[object]:
-    full_list: List[object] = []
+def parse_list(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> list[object]:
+    full_list: list[object] = []
     # wjb assert inner_type != get_args(List)[0]
     list_size = parse_uint32(f)
     for list_index in range(list_size):
@@ -370,8 +358,8 @@ def parse_list(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> List[objec
     return full_list
 
 
-def parse_tuple(f: BinaryIO, list_parse_inner_type_f: List[ParseFunctionType]) -> Tuple[object, ...]:
-    full_list: List[object] = []
+def parse_tuple(f: BinaryIO, list_parse_inner_type_f: list[ParseFunctionType]) -> tuple[object, ...]:
+    full_list: list[object] = []
     for parse_f in list_parse_inner_type_f:
         full_list.append(parse_f(f))
     return tuple(full_list)
@@ -384,12 +372,12 @@ def parse_str(f: BinaryIO) -> str:
     return bytes.decode(str_read_bytes, "utf-8")
 
 
-def function_to_parse_one_item(f_type: Type[Any]) -> ParseFunctionType:
+def function_to_parse_one_item(f_type: type[Any]) -> ParseFunctionType:
     """
     This function returns a function taking one argument `f: BinaryIO` that parses
     and returns a value of the given type.
     """
-    inner_type: Type[Any]
+    inner_type: type[Any]
     if f_type is bool:
         return parse_bool
     if is_type_SpecificOptional(f_type):
@@ -401,7 +389,7 @@ def function_to_parse_one_item(f_type: Type[Any]) -> ParseFunctionType:
     if hasattr(f_type, "parse"):
         # Ignoring for now as the proper solution isn't obvious
         return f_type.parse  # type: ignore[no-any-return]
-    if f_type == bytes:
+    if f_type is bytes:
         return parse_bytes
     if is_type_List(f_type):
         inner_type = get_args(f_type)[0]
@@ -435,7 +423,7 @@ def stream_list(stream_inner_type_func: StreamFunctionType, item: Any, f: Binary
         stream_inner_type_func(element, f)
 
 
-def stream_tuple(stream_inner_type_funcs: List[StreamFunctionType], item: Any, f: BinaryIO) -> None:
+def stream_tuple(stream_inner_type_funcs: list[StreamFunctionType], item: Any, f: BinaryIO) -> None:
     assert len(stream_inner_type_funcs) == len(item)
     for i in range(len(item)):
         stream_inner_type_funcs[i](item[i], f)
@@ -459,13 +447,13 @@ def stream_byte_convertible(item: object, f: BinaryIO) -> None:
     f.write(getattr(item, "__bytes__")())
 
 
-def function_to_stream_one_item(f_type: Type[Any]) -> StreamFunctionType:
-    inner_type: Type[Any]
+def function_to_stream_one_item(f_type: type[Any]) -> StreamFunctionType:
+    inner_type: type[Any]
     if is_type_SpecificOptional(f_type):
         inner_type = get_args(f_type)[0]
         stream_inner_type_func = function_to_stream_one_item(inner_type)
         return lambda item, f: stream_optional(stream_inner_type_func, item, f)
-    elif f_type == bytes:
+    elif f_type is bytes:
         return stream_bytes
     elif hasattr(f_type, "stream"):
         return stream_streamable
@@ -489,7 +477,7 @@ def function_to_stream_one_item(f_type: Type[Any]) -> StreamFunctionType:
         raise UnsupportedType(f"can't stream {f_type}")
 
 
-def streamable(cls: Type[_T_Streamable]) -> Type[_T_Streamable]:
+def streamable(cls: type[_T_Streamable]) -> type[_T_Streamable]:
     """
     This decorator forces correct streamable protocol syntax/usage and populates the caches for types hints and
     (de)serialization methods for all members of the class. The correct usage is:
@@ -528,7 +516,7 @@ def streamable(cls: Type[_T_Streamable]) -> Type[_T_Streamable]:
 class Streamable:
     """
     This class defines a simple serialization format, and adds methods to parse from/to bytes and json. It also
-    validates and parses all fields at construction in ´__post_init__` to make sure all fields have the correct type
+    validates and parses all fields at construction in `__post_init__` to make sure all fields have the correct type
     and can be streamed/parsed properly.
 
     The available primitives are:
@@ -542,8 +530,8 @@ class Streamable:
 
     An item is one of:
     * primitive
-    * Tuple[item1, .. itemx]
-    * List[item1, .. itemx]
+    * tuple[item1, .. itemx]
+    * list[item1, .. itemx]
     * Optional[item]
     * Custom item
 
@@ -587,7 +575,7 @@ class Streamable:
             raise
 
     @classmethod
-    def parse(cls: Type[_T_Streamable], f: BinaryIO) -> _T_Streamable:
+    def parse(cls: type[_T_Streamable], f: BinaryIO) -> _T_Streamable:
         # Create the object without calling __init__() to avoid unnecessary post-init checks in strictdataclass
         obj: _T_Streamable = object.__new__(cls)
         for field in cls._streamable_fields:
@@ -602,7 +590,7 @@ class Streamable:
         return std_hash(bytes(self), skip_bytes_conversion=True)
 
     @classmethod
-    def from_bytes(cls: Type[_T_Streamable], blob: bytes) -> _T_Streamable:
+    def from_bytes(cls: type[_T_Streamable], blob: bytes) -> _T_Streamable:
         f = io.BytesIO(blob)
         parsed = cls.parse(f)
         assert f.read() == b""
@@ -624,12 +612,12 @@ class Streamable:
     def __repr__(self: Any) -> str:
         return pp.pformat(recurse_jsonify(self))
 
-    def to_json_dict(self) -> Dict[str, Any]:
-        ret: Dict[str, Any] = recurse_jsonify(self)
+    def to_json_dict(self) -> dict[str, Any]:
+        ret: dict[str, Any] = recurse_jsonify(self)
         return ret
 
     @classmethod
-    def from_json_dict(cls: Type[_T_Streamable], json_dict: Dict[str, Any]) -> _T_Streamable:
+    def from_json_dict(cls: type[_T_Streamable], json_dict: dict[str, Any]) -> _T_Streamable:
         return streamable_from_dict(cls, json_dict)
 
 

chia/util/task_referencer.py

@@ -0,0 +1,59 @@
+# TODO: this should not exist, it is a bad task group that doesn't require
+#       any responsibility of the requestor.
+
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import logging
+import typing
+
+T = typing.TypeVar("T")
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass(frozen=True)
+class _TaskInfo:
+    task: asyncio.Task[object]
+    # retained for potential debugging use
+    known_unreferenced: bool
+
+    def __str__(self) -> str:
+        return self.task.get_name()
+
+
+@dataclasses.dataclass
+class _TaskReferencer:
+    """Holds strong references to tasks until they are done.  This compensates for
+    asyncio holding only weak references.  This should be replaced by patterns using
+    task groups such as from anyio.
+    """
+
+    tasks: dict[asyncio.Task[object], _TaskInfo] = dataclasses.field(default_factory=dict)
+
+    def create_task(
+        self,
+        coroutine: typing.Coroutine[object, object, T],
+        *,
+        name: typing.Optional[str] = None,
+        known_unreferenced: bool = False,
+    ) -> asyncio.Task[T]:
+        task = asyncio.create_task(coro=coroutine, name=name)  # noqa: TID251
+        task.add_done_callback(self._task_done)
+
+        self.tasks[task] = _TaskInfo(task=task, known_unreferenced=known_unreferenced)
+
+        return task
+
+    def _task_done(self, task: asyncio.Task[object]) -> None:
+        # TODO: consider collecting results and logging errors
+        try:
+            del self.tasks[task]
+        except KeyError:
+            logger.warning("Task not found in task referencer: %s", task)
+
+
+_global_task_referencer = _TaskReferencer()
+
+create_referenced_task = _global_task_referencer.create_task

chia/util/task_timing.py

@@ -1,3 +1,5 @@
+# Package: utils
+
 from __future__ import annotations
 
 import asyncio
@@ -6,8 +8,9 @@ import inspect
 import os
 import sys
 import time
+from collections.abc import Iterator
 from types import FrameType
-from typing import Any, Dict, Iterator, List
+from typing import Any
 
 # This is a development utility that instruments tasks (coroutines) and records
 # wall-clock time they spend in various functions. Since it relies on
@@ -15,7 +18,12 @@ from typing import Any, Dict, Iterator, List
 
 # to enable this instrumentation, set one of the environment variables:
 
-#   CHIA_INSTRUMENT_NODE=1
+#   CHIA_INSTRUMENT_DATA_LAYER=1
+#   CHIA_INSTRUMENT_FARMER=1
+#   CHIA_INSTRUMENT_FULL_NODE=1
+#   CHIA_INSTRUMENT_HARVESTER=1
+#   CHIA_INSTRUMENT_INTRODUCER=1
+#   CHIA_INSTRUMENT_TIMELORD=1
 #   CHIA_INSTRUMENT_WALLET=1
 
 # Before starting the daemon.
@@ -49,7 +57,7 @@ class CallInfo:
 
 
 class TaskInfo:
-    stack: Dict[FrameType, FrameInfo]
+    stack: dict[FrameType, FrameInfo]
     stack_pos: int
 
     def __init__(self) -> None:
@@ -65,7 +73,7 @@ class FunctionInfo:
     file: str
     num_calls: int
     duration: float
-    callers: Dict[str, CallInfo]
+    callers: dict[str, CallInfo]
     fun_id: int
 
     def __init__(self, name: str, file: str) -> None:
@@ -81,9 +89,9 @@ class FunctionInfo:
 
 
 # maps tasks to call-treea
-g_function_infos: Dict[str, Dict[str, FunctionInfo]] = {}
+g_function_infos: dict[str, dict[str, FunctionInfo]] = {}
 
-g_tasks: Dict[asyncio.Task[Any], TaskInfo] = {}
+g_tasks: dict[asyncio.Task[Any], TaskInfo] = {}
 
 g_cwd = os.getcwd() + "/"
 
@@ -125,7 +133,7 @@ g_cwd = os.getcwd() + "/"
 def get_stack(frame: FrameType) -> str:
     ret = ""
     code = frame.f_code
-    while code.co_flags & inspect.CO_COROUTINE:  # pylint: disable=no-member
+    while code.co_flags & inspect.CO_COROUTINE:
         ret = f"/{code.co_name}{ret}"
         if frame.f_back is None:
             break
@@ -155,11 +163,11 @@ def get_file(frame: FrameType) -> str:
 
 
 def trace_fun(frame: FrameType, event: str, arg: Any) -> None:
-    if event in ["c_call", "c_return", "c_exception"]:
+    if event in {"c_call", "c_return", "c_exception"}:
         return
 
     # we only care about instrumenting co-routines
-    if (frame.f_code.co_flags & inspect.CO_COROUTINE) == 0:  # pylint: disable=no-member
+    if (frame.f_code.co_flags & inspect.CO_COROUTINE) == 0:
         # with open("instrumentation.log", "a") as f:
         #    f.write(f"[1]    {event} {get_fun(frame)}\n")
         return
@@ -168,9 +176,6 @@ def trace_fun(frame: FrameType, event: str, arg: Any) -> None:
     if task is None:
         return
 
-    global g_tasks
-    global g_function_infos
-
     ti = g_tasks.get(task)
     if ti is None:
         ti = TaskInfo()
@@ -245,7 +250,7 @@ def start_task_instrumentation() -> None:
 
 def color(pct: float) -> str:
     assert pct >= 0 and pct <= 100
-    return f"{int((100.-pct)//10)+1}"
+    return f"{int((100. - pct) // 10) + 1}"
 
 
 def fontcolor(pct: float) -> str:
@@ -257,7 +262,6 @@ def fontcolor(pct: float) -> str:
 
 def stop_task_instrumentation(target_dir: str = f"task-profile-{os.getpid()}") -> None:
     sys.setprofile(None)
-    global g_function_infos
 
     try:
         os.mkdir(target_dir)
@@ -297,7 +301,7 @@ def stop_task_instrumentation(target_dir: str = f"task-profile-{os.getpid()}") -
                     f'frame_{fun_info.fun_id} [shape=box, label="{fun_info.name}()\\l'
                     f"{fun_info.file}\\l"
                     f"{percent:0.2f}%\\n"
-                    f"{fun_info.duration*1000:0.2f}ms\\n"
+                    f"{fun_info.duration * 1000:0.2f}ms\\n"
                     f'{fun_info.num_calls}x\\n",'
                     f"fillcolor={color(percent)}, "
                     f"color={color(percent)}, "
@@ -324,7 +328,7 @@ def stop_task_instrumentation(target_dir: str = f"task-profile-{os.getpid()}") -
                     f.write(
                         f"frame_{caller_info.fun_id} -> frame_{fun_info.fun_id} "
                         f'[label="{percent:0.2f}%\\n{ci.calls}x",'
-                        f"penwidth={0.3+(ci.duration*6/total_duration):0.2f},"
+                        f"penwidth={0.3 + (ci.duration * 6 / total_duration):0.2f},"
                         f"color={color(percent)}]\n"
                     )
             f.write("}\n")
@@ -348,13 +352,13 @@ def maybe_manage_task_instrumentation(enable: bool) -> Iterator[None]:
         yield
 
 
-def main(args: List[str]) -> int:
+def main(args: list[str]) -> int:
     import glob
     import pathlib
     import subprocess
 
     profile_dir = pathlib.Path(args[0])
-    queue: List[subprocess.Popen[bytes]] = []
+    queue: list[subprocess.Popen[bytes]] = []
     for file in glob.glob(str(profile_dir / "*.dot")):
         print(file)
         if os.path.exists(file + ".png"):

chia/util/timing.py

@@ -1,9 +1,12 @@
+# Package: utils
+
 from __future__ import annotations
 
 import os
 import sys
 import time
-from typing import Callable, Iterator, Optional, overload
+from collections.abc import Iterator
+from typing import Callable, Optional, overload
 
 system_delays = {
     # based on data from https://github.com/Chia-Network/chia-blockchain/pull/13724

chia/util/vdf_prover.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Tuple
-
 from chiavdf import prove
 
 from chia.consensus.constants import ConsensusConstants
@@ -17,13 +15,14 @@ def get_vdf_info_and_proof(
     challenge_hash: bytes32,
     number_iters: uint64,
     normalized_to_identity: bool = False,
-) -> Tuple[VDFInfo, VDFProof]:
+) -> tuple[VDFInfo, VDFProof]:
     form_size = ClassgroupElement.get_size()
     result: bytes = prove(
         bytes(challenge_hash),
         vdf_input.data,
         constants.DISCRIMINANT_SIZE_BITS,
         number_iters,
+        "",
     )
 
     output = ClassgroupElement.create(result[:form_size])