chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/util/keychain.py

@@ -8,7 +8,7 @@ from collections.abc import Iterator
 from dataclasses import dataclass
 from hashlib import pbkdf2_hmac
 from pathlib import Path
-from typing import Any, Literal, Optional, Union, overload
+from typing import Any, Literal, overload
 
 import importlib_resources
 from bitstring import BitArray  # pyright: reportMissingImports=false
@@ -231,8 +231,8 @@ class KeyDataSecrets(Streamable):
 class KeyData(Streamable):
     fingerprint: uint32
     public_key: G1Element
-    label: Optional[str]
-    secrets: Optional[KeyDataSecrets]
+    label: str | None
+    secrets: KeyDataSecrets | None
 
     def __post_init__(self) -> None:
         # This is redundant if `from_*` methods are used but its to make sure there can't be an `KeyData` instance with
@@ -243,7 +243,7 @@ class KeyData(Streamable):
             raise KeychainKeyDataMismatch("fingerprint")
 
     @classmethod
-    def from_mnemonic(cls, mnemonic: str, label: Optional[str] = None) -> KeyData:
+    def from_mnemonic(cls, mnemonic: str, label: str | None = None) -> KeyData:
         private_key = AugSchemeMPL.key_gen(mnemonic_to_seed(mnemonic))
         return cls(
             fingerprint=uint32(private_key.get_g1().get_fingerprint()),
@@ -253,11 +253,11 @@ class KeyData(Streamable):
         )
 
     @classmethod
-    def from_entropy(cls, entropy: bytes, label: Optional[str] = None) -> KeyData:
+    def from_entropy(cls, entropy: bytes, label: str | None = None) -> KeyData:
         return cls.from_mnemonic(bytes_to_mnemonic(entropy), label)
 
     @classmethod
-    def generate(cls, label: Optional[str] = None) -> KeyData:
+    def generate(cls, label: str | None = None) -> KeyData:
         return cls.from_mnemonic(generate_mnemonic(), label)
 
     @property
@@ -295,11 +295,11 @@ class Keychain:
     list of all keys.
     """
 
-    def __init__(self, user: Optional[str] = None, service: Optional[str] = None):
+    def __init__(self, user: str | None = None, service: str | None = None):
         self.user = user if user is not None else default_keychain_user()
         self.service = service if service is not None else default_keychain_service()
 
-        keyring_wrapper: Optional[KeyringWrapper] = KeyringWrapper.get_shared_instance()
+        keyring_wrapper: KeyringWrapper | None = KeyringWrapper.get_shared_instance()
 
         if keyring_wrapper is None:
             raise KeychainNotSet("KeyringWrapper not set")
@@ -347,25 +347,23 @@ class Keychain:
     def add_key(self, mnemonic_or_pk: str) -> PrivateKey: ...
 
     @overload
-    def add_key(self, mnemonic_or_pk: str, label: Optional[str]) -> PrivateKey: ...
+    def add_key(self, mnemonic_or_pk: str, label: str | None) -> PrivateKey: ...
 
     @overload
-    def add_key(self, mnemonic_or_pk: str, label: Optional[str], private: Literal[True]) -> PrivateKey: ...
+    def add_key(self, mnemonic_or_pk: str, label: str | None, private: Literal[True]) -> PrivateKey: ...
 
     @overload
-    def add_key(self, mnemonic_or_pk: str, label: Optional[str], private: Literal[False]) -> G1Element: ...
+    def add_key(self, mnemonic_or_pk: str, label: str | None, private: Literal[False]) -> G1Element: ...
 
     @overload
-    def add_key(self, mnemonic_or_pk: str, label: Optional[str], private: bool) -> Union[PrivateKey, G1Element]: ...
+    def add_key(self, mnemonic_or_pk: str, label: str | None, private: bool) -> PrivateKey | G1Element: ...
 
-    def add_key(
-        self, mnemonic_or_pk: str, label: Optional[str] = None, private: bool = True
-    ) -> Union[PrivateKey, G1Element]:
+    def add_key(self, mnemonic_or_pk: str, label: str | None = None, private: bool = True) -> PrivateKey | G1Element:
         """
         Adds a key to the keychain. The keychain itself will store the public key, and the entropy bytes (if given),
         but not the passphrase.
         """
-        key: Union[PrivateKey, G1Element]
+        key: PrivateKey | G1Element
         if private:
             seed = mnemonic_to_seed(mnemonic_or_pk)
             entropy = bytes_from_mnemonic(mnemonic_or_pk)
@@ -436,7 +434,7 @@ class Keychain:
                 pass
         return None
 
-    def get_first_private_key(self) -> Optional[tuple[PrivateKey, bytes]]:
+    def get_first_private_key(self) -> tuple[PrivateKey, bytes] | None:
         """
         Returns the first key in the keychain that has one of the passed in passphrases.
         """
@@ -444,7 +442,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) -> tuple[PrivateKey, bytes] | None:
         """
         Return first private key which have the given public key fingerprint.
         """
@@ -492,7 +490,7 @@ class Keychain:
 
         return all_keys
 
-    def get_first_public_key(self) -> Optional[G1Element]:
+    def get_first_public_key(self) -> G1Element | None:
         """
         Returns the first public key.
         """
@@ -578,7 +576,7 @@ class Keychain:
         return passphrase_requirements().get("min_length", 0)  # type: ignore[no-any-return]
 
     @staticmethod
-    def passphrase_meets_requirements(passphrase: Optional[str]) -> bool:
+    def passphrase_meets_requirements(passphrase: str | None) -> bool:
         """
         Returns whether the provided passphrase satisfies the passphrase requirements.
         """
@@ -617,7 +615,7 @@ class Keychain:
         return KeyringWrapper.get_shared_instance().has_cached_master_passphrase()
 
     @staticmethod
-    def get_cached_master_passphrase() -> Optional[str]:
+    def get_cached_master_passphrase() -> str | None:
         """
         Returns the cached master passphrase
         """
@@ -625,7 +623,7 @@ class Keychain:
         return passphrase
 
     @staticmethod
-    def set_cached_master_passphrase(passphrase: Optional[str]) -> None:
+    def set_cached_master_passphrase(passphrase: str | None) -> None:
         """
         Caches the provided master passphrase
         """
@@ -633,10 +631,10 @@ class Keychain:
 
     @staticmethod
     def set_master_passphrase(
-        current_passphrase: Optional[str],
+        current_passphrase: str | None,
         new_passphrase: str,
         *,
-        passphrase_hint: Optional[str] = None,
+        passphrase_hint: str | None = None,
         save_passphrase: bool = False,
     ) -> None:
         """
@@ -651,7 +649,7 @@ class Keychain:
         )
 
     @staticmethod
-    def remove_master_passphrase(current_passphrase: Optional[str]) -> None:
+    def remove_master_passphrase(current_passphrase: str | None) -> None:
         """
         Removes the user-provided master passphrase, and replaces it with the default
         master passphrase. The keyring contents will remain encrypted, but to the
@@ -660,14 +658,14 @@ class Keychain:
         KeyringWrapper.get_shared_instance().remove_master_passphrase(current_passphrase)
 
     @staticmethod
-    def get_master_passphrase_hint() -> Optional[str]:
+    def get_master_passphrase_hint() -> str | None:
         """
         Returns the passphrase hint from the keyring
         """
         return KeyringWrapper.get_shared_instance().get_master_passphrase_hint()
 
     @staticmethod
-    def set_master_passphrase_hint(current_passphrase: str, passphrase_hint: Optional[str]) -> None:
+    def set_master_passphrase_hint(current_passphrase: str, passphrase_hint: str | None) -> None:
         """
         Convenience method for setting/removing the passphrase hint. Requires the current
         passphrase, as the passphrase hint is written as part of a passphrase update.

chia/util/keyring_wrapper.py

@@ -7,13 +7,12 @@ import time
 from getpass import getpass
 from pathlib import Path
 from sys import platform
-from typing import ClassVar, Optional, Union, overload
+from typing import ClassVar, Literal, 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
@@ -30,10 +29,10 @@ MASTER_PASSPHRASE_SERVICE_NAME = "Chia Passphrase"  # noqa: S105
 MASTER_PASSPHRASE_USER_NAME = "Chia Passphrase"  # noqa: S105
 
 
-OSPassphraseStore = Union[MacKeyring, WinKeyring]
+OSPassphraseStore = MacKeyring | WinKeyring
 
 
-def get_os_passphrase_store() -> Optional[OSPassphraseStore]:
+def get_os_passphrase_store() -> OSPassphraseStore | None:
     if platform == "darwin":
         return MacKeyring()  # type: ignore[no-untyped-call]
     elif platform == "win32" or platform == "cygwin":
@@ -126,13 +125,13 @@ class KeyringWrapper:
     """
 
     # Static members
-    __shared_instance: ClassVar[Optional[KeyringWrapper]] = None
+    __shared_instance: ClassVar[KeyringWrapper | None] = None
     __keys_root_path: ClassVar[Path] = DEFAULT_KEYS_ROOT_PATH
 
     # Instance members
     keys_root_path: Path
     keyring: FileKeyring
-    cached_passphrase: Optional[str] = None
+    cached_passphrase: str | None = None
     cached_passphrase_is_validated: bool = False
 
     def __init__(self, keys_root_path: Path = DEFAULT_KEYS_ROOT_PATH):
@@ -156,7 +155,7 @@ class KeyringWrapper:
         """
         from chia.util.keychain import supports_os_passphrase_storage
 
-        passphrase: Optional[str] = None
+        passphrase: str | None = None
 
         if supports_os_passphrase_storage():
             passphrase = self.get_master_passphrase_from_credential_store()
@@ -183,10 +182,10 @@ class KeyringWrapper:
 
     @overload
     @staticmethod
-    def get_shared_instance(create_if_necessary: bool) -> Optional[KeyringWrapper]: ...
+    def get_shared_instance(create_if_necessary: bool) -> KeyringWrapper | None: ...
 
     @staticmethod
-    def get_shared_instance(create_if_necessary: bool = True) -> Optional[KeyringWrapper]:
+    def get_shared_instance(create_if_necessary: bool = True) -> KeyringWrapper | None:
         if not KeyringWrapper.__shared_instance and create_if_necessary:
             KeyringWrapper.__shared_instance = KeyringWrapper(keys_root_path=KeyringWrapper.__keys_root_path)
 
@@ -204,14 +203,14 @@ class KeyringWrapper:
 
     # Master passphrase support
 
-    def get_cached_master_passphrase(self) -> tuple[Optional[str], bool]:
+    def get_cached_master_passphrase(self) -> tuple[str | None, bool]:
         """
         Returns a tuple including the currently cached passphrase and a bool
         indicating whether the passphrase has been previously validated.
         """
         return self.cached_passphrase, self.cached_passphrase_is_validated
 
-    def set_cached_master_passphrase(self, passphrase: Optional[str], validated: bool = False) -> None:
+    def set_cached_master_passphrase(self, passphrase: str | None, validated: bool = False) -> None:
         """
         Cache the provided passphrase and optionally indicate whether the passphrase
         has been validated.
@@ -235,11 +234,11 @@ class KeyringWrapper:
 
     def set_master_passphrase(
         self,
-        current_passphrase: Optional[str],
+        current_passphrase: str | None,
         new_passphrase: str,
         *,
         write_to_keyring: bool = True,
-        passphrase_hint: Optional[str] = None,
+        passphrase_hint: str | None = None,
         save_passphrase: bool = False,
     ) -> None:
         """
@@ -272,7 +271,7 @@ class KeyringWrapper:
             else:
                 self.remove_master_passphrase_from_credential_store()
 
-    def remove_master_passphrase(self, current_passphrase: Optional[str]) -> None:
+    def remove_master_passphrase(self, current_passphrase: str | None) -> None:
         """
         Remove the user-specific master passphrase. We still keep the keyring contents encrypted
         using the default passphrase.
@@ -280,7 +279,7 @@ class KeyringWrapper:
         self.set_master_passphrase(current_passphrase, DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE)
 
     def save_master_passphrase_to_credential_store(self, passphrase: str) -> None:
-        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+        passphrase_store: OSPassphraseStore | None = get_os_passphrase_store()
         if passphrase_store is not None:
             try:
                 passphrase_store.set_password(
@@ -293,7 +292,7 @@ class KeyringWrapper:
                     raise
 
     def remove_master_passphrase_from_credential_store(self) -> None:
-        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+        passphrase_store: OSPassphraseStore | None = get_os_passphrase_store()
         if passphrase_store is not None:
             try:
                 passphrase_store.delete_password(
@@ -310,8 +309,8 @@ class KeyringWrapper:
                 if not warn_if_macos_errSecInteractionNotAllowed(e):
                     raise
 
-    def get_master_passphrase_from_credential_store(self) -> Optional[str]:
-        passphrase_store: Optional[OSPassphraseStore] = get_os_passphrase_store()
+    def get_master_passphrase_from_credential_store(self) -> str | None:
+        passphrase_store: OSPassphraseStore | None = get_os_passphrase_store()
         if passphrase_store is not None:
             try:
                 return passphrase_store.get_password(  # type: ignore[no-any-return]
@@ -323,5 +322,5 @@ class KeyringWrapper:
                     raise
         return None
 
-    def get_master_passphrase_hint(self) -> Optional[str]:
+    def get_master_passphrase_hint(self) -> str | None:
         return self.keyring.get_passphrase_hint()

chia/util/lock.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 from types import TracebackType
-from typing import Optional
 
 from filelock import BaseFileLock, FileLock, Timeout
 from typing_extensions import final
@@ -33,9 +32,9 @@ class Lockfile:
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
         self.release()
 

chia/util/log_exceptions.py

@@ -6,7 +6,6 @@ import logging
 import traceback
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Union
 
 
 @contextmanager
@@ -17,7 +16,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: type[BaseException] | tuple[type[BaseException], ...] = Exception,
 ) -> Iterator[None]:
     try:
         yield

chia/util/lru_cache.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import OrderedDict
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 K = TypeVar("K")
 V = TypeVar("V")
@@ -14,7 +14,7 @@ class LRUCache(Generic[K, V]):
         self.cache: OrderedDict[K, V] = OrderedDict()
         self.capacity = capacity
 
-    def get(self, key: K) -> Optional[V]:
+    def get(self, key: K) -> V | None:
         if key not in self.cache:
             return None
         else:

chia/util/network.py

@@ -8,7 +8,7 @@ import ssl
 from collections.abc import Iterable
 from dataclasses import dataclass
 from ipaddress import IPv4Network, IPv6Network, ip_address
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 from urllib.parse import urlsplit
 
 from aiohttp import web
@@ -36,8 +36,8 @@ class WebServer:
     hostname: str
     listen_port: uint16
     scheme: Literal["http", "https"]
-    _ssl_context: Optional[ssl.SSLContext] = None
-    _close_task: Optional[asyncio.Task[None]] = None
+    _ssl_context: ssl.SSLContext | None = None
+    _close_task: asyncio.Task[None] | None = None
     _prefer_ipv6: bool = False
 
     @classmethod
@@ -47,7 +47,7 @@ class WebServer:
         port: uint16,
         routes: Iterable[web.RouteDef] = (),
         max_request_body_size: int = 1024**2,  # Default `client_max_size` from web.Application
-        ssl_context: Optional[ssl.SSLContext] = None,
+        ssl_context: ssl.SSLContext | None = None,
         keepalive_timeout: int = 75,  # Default from aiohttp.web
         shutdown_timeout: int = 60,  # Default `shutdown_timeout` from aiohttp.web_runner.BaseRunner
         prefer_ipv6: bool = False,
@@ -115,7 +115,7 @@ class WebServer:
         await self._close_task
 
 
-def is_in_network(peer_host: str, networks: Iterable[Union[IPv4Network, IPv6Network]]) -> bool:
+def is_in_network(peer_host: str, networks: Iterable[IPv4Network | IPv6Network]) -> bool:
     try:
         peer_host_ip = ip_address(peer_host)
         return any(peer_host_ip in network for network in networks)
@@ -155,7 +155,7 @@ async def resolve(host: str, *, prefer_ipv6: bool = False) -> IPAddress:
     except ValueError:
         pass
     addrset: list[
-        tuple[socket.AddressFamily, socket.SocketKind, int, str, Union[tuple[str, int], tuple[str, int, int, int]]]
+        tuple[socket.AddressFamily, socket.SocketKind, int, str, 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 = []

chia/util/path.py

@@ -4,10 +4,9 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Union
 
 
-def path_from_root(root: Path, path_str: Union[str, Path]) -> Path:
+def path_from_root(root: Path, path_str: str | Path) -> Path:
     """
     If path is relative, prepend root
     If path is absolute, return it directly.
@@ -19,7 +18,7 @@ def path_from_root(root: Path, path_str: Union[str, Path]) -> Path:
     return path.resolve()
 
 
-def make_path_relative(path_str: Union[str, Path], root: Path) -> Path:
+def make_path_relative(path_str: str | Path, root: Path) -> Path:
     """
     Try to make the given path relative, given the default root.
     """

chia/util/priority_mutex.py

@@ -9,7 +9,7 @@ import dataclasses
 import logging
 from collections.abc import AsyncIterator
 from enum import IntEnum
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from typing_extensions import final
 
@@ -49,7 +49,7 @@ class PriorityMutex(Generic[_T_Priority]):
     """
 
     _deques: dict[_T_Priority, collections.deque[_Element]]
-    _active: Optional[_Element] = None
+    _active: _Element | None = None
 
     @classmethod
     def create(cls, priority_type: type[_T_Priority]) -> PriorityMutex[_T_Priority]:

chia/util/profiler.py

@@ -10,7 +10,6 @@ import tracemalloc
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from datetime import datetime
-from typing import Optional
 
 from chia.util.path import path_from_root
 
@@ -184,7 +183,7 @@ async def mem_profile_task(root_path: pathlib.Path, service: str, log: logging.L
 
 
 @asynccontextmanager
-async def enable_profiler(profile: bool) -> AsyncIterator[Optional[cProfile.Profile]]:
+async def enable_profiler(profile: bool) -> AsyncIterator[cProfile.Profile | None]:
     if not profile:
         yield None
         return

chia/util/safe_cancel_task.py

@@ -4,10 +4,9 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional
 
 
-def cancel_task_safe(task: Optional[asyncio.Task[None]], log: Optional[logging.Logger] = None) -> None:
+def cancel_task_safe(task: asyncio.Task[None] | None, log: logging.Logger | None = None) -> None:
     if task is not None:
         try:
             task.cancel()

chia/util/streamable.py

@@ -8,13 +8,25 @@ import io
 import os
 import pprint
 import traceback
-from collections.abc import Collection
+from collections.abc import Callable, Collection
 from enum import Enum, EnumMeta
-from typing import TYPE_CHECKING, Any, BinaryIO, Callable, ClassVar, Optional, TypeVar, Union, get_type_hints
+from types import UnionType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    BinaryIO,
+    ClassVar,
+    Literal,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
-from typing_extensions import Literal, Self, get_args, get_origin
+from typing_extensions import Self
 
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.hash import std_hash
@@ -120,7 +132,7 @@ def is_type_SpecificOptional(f_type: object) -> bool:
     """
     Returns true for types such as Optional[T], but not Optional, or T.
     """
-    return get_origin(f_type) == Union and get_args(f_type)[1]() is None
+    return get_origin(f_type) in {Union, UnionType} and get_args(f_type)[1]() is None
 
 
 def is_type_Tuple(f_type: object) -> bool:
@@ -211,7 +223,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, type[object]], Streamable]] = None
+    f_type: type[Any], json_parser: Callable[[object, type[object]], Streamable] | None = None
 ) -> ConvertFunctionType:
     if is_type_SpecificOptional(f_type):
         convert_inner_func = function_to_convert_one_item(get_args(f_type)[0], json_parser)
@@ -287,13 +299,15 @@ def function_to_post_init_process_one_item(f_type: type[object]) -> ConvertFunct
 
 
 def recurse_jsonify(
-    d: Any, next_recursion_step: Optional[Callable[[Any, Any], Any]] = None, **next_recursion_env: Any
+    d: Any, next_recursion_step: Callable[[Any, Any], Any] | None = None, **next_recursion_env: Any
 ) -> Any:
     """
     Makes bytes objects into strings with 0x, and makes large ints into strings.
     """
     if next_recursion_step is None:
         next_recursion_step = recurse_jsonify
+    if getattr(d, "json_serialization_override", None) is not None:
+        return d.json_serialization_override(d)
     if dataclasses.is_dataclass(d):
         new_dict = {}
         for field in dataclasses.fields(d):
@@ -324,7 +338,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, int, None] = d.to_json_dict()
+        ret: list[Any] | dict[str, Any] | str | int | None = d.to_json_dict()
         return ret
     raise UnsupportedType(f"failed to jsonify {d} (type: {type(d)})")
 
@@ -350,7 +364,7 @@ def write_uint32(f: BinaryIO, value: uint32, byteorder: Literal["little", "big"]
     f.write(value.to_bytes(4, byteorder))
 
 
-def parse_optional(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> Optional[object]:
+def parse_optional(f: BinaryIO, parse_inner_type_f: ParseFunctionType) -> object | None:
     is_present_bytes = f.read(1)
     assert is_present_bytes is not None and len(is_present_bytes) == 1  # Checks for EOF
     if is_present_bytes == bytes([0]):
@@ -654,12 +668,12 @@ class Streamable:
     def parse(cls, f: BinaryIO) -> Self:
         # Create the object without calling __init__() to avoid unnecessary post-init checks in strictdataclass
         obj: Self = object.__new__(cls)
-        for field in cls._streamable_fields:
+        for field in cls.streamable_fields():
             object.__setattr__(obj, field.name, field.parse_function(f))
         return obj
 
     def stream(self, f: BinaryIO) -> None:
-        for field in self._streamable_fields:
+        for field in self.streamable_fields():
             field.stream_function(getattr(self, field.name), f)
 
     def get_hash(self) -> bytes32:

chia/util/task_referencer.py

@@ -36,7 +36,7 @@ class _TaskReferencer:
         self,
         coroutine: typing.Coroutine[object, object, T],
         *,
-        name: typing.Optional[str] = None,
+        name: str | None = None,
         known_unreferenced: bool = False,
     ) -> asyncio.Task[T]:
         task = asyncio.create_task(coro=coroutine, name=name)  # noqa: TID251

chia/util/timing.py

@@ -5,8 +5,8 @@ from __future__ import annotations
 import os
 import sys
 import time
-from collections.abc import Iterator
-from typing import Callable, Optional, overload
+from collections.abc import Callable, Iterator
+from typing import overload
 
 system_delays = {
     # based on data from https://github.com/Chia-Network/chia-blockchain/pull/13724
@@ -42,7 +42,7 @@ def adjusted_timeout(timeout: float) -> float: ...
 def adjusted_timeout(timeout: None) -> None: ...
 
 
-def adjusted_timeout(timeout: Optional[float]) -> Optional[float]:
+def adjusted_timeout(timeout: float | None) -> float | None:
     if timeout is None:
         return None
 

chia/util/virtual_project_analysis.py

@@ -7,9 +7,10 @@ import json
 import os
 import re
 import sys
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Callable, Literal, Optional, Union
+from typing import Any, Literal
 
 import click
 import yaml
@@ -90,7 +91,7 @@ def build_dependency_graph(dir_params: DirectoryParameters) -> dict[Path, list[P
 
 
 def build_virtual_dependency_graph(
-    dir_params: DirectoryParameters, *, existing_graph: Optional[dict[Path, list[Path]]] = None
+    dir_params: DirectoryParameters, *, existing_graph: dict[Path, list[Path]] | None = None
 ) -> dict[str, list[str]]:
     if existing_graph is None:
         graph = build_dependency_graph(dir_params)
@@ -230,7 +231,7 @@ def find_cycles(
     return path_accumulator
 
 
-def print_graph(graph: Union[dict[str, list[str]], dict[Path, list[Path]]]) -> None:
+def print_graph(graph: dict[str, list[str]] | dict[Path, list[Path]]) -> None:
     print(json.dumps({str(k): list(str(v) for v in vs) for k, vs in graph.items()}, indent=4))
 
 
@@ -288,7 +289,7 @@ class Package:
     is_file: Literal[False] = False
 
 
-FileOrPackage = Union[File, Package]
+FileOrPackage = File | Package
 
 
 def parse_file_or_package(identifier: str) -> FileOrPackage:
@@ -335,7 +336,7 @@ def config(func: Callable[..., None]) -> Callable[..., None]:
         default=None,
         help="Path to the YAML configuration file.",
     )
-    def inner(config_path: Optional[str], *args: Any, **kwargs: Any) -> None:
+    def inner(config_path: str | None, *args: Any, **kwargs: Any) -> None:
         exclude_paths = []
         ignore_cycles_in: list[str] = []
         ignore_specific_files: list[str] = []