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

chia/util/config.py

@@ -10,20 +10,19 @@ import sys
 import tempfile
 import time
 import traceback
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from pathlib import Path
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Literal, cast
 
 import importlib_resources
 import yaml
-from typing_extensions import Literal
 
 from chia.util.lock import Lockfile
 
 log = logging.getLogger(__name__)
 
 
-def initial_config_file(filename: Union[str, Path]) -> str:
+def initial_config_file(filename: str | Path) -> str:
     initial_config_path = importlib_resources.files(__name__.rpartition(".")[0]).joinpath(f"initial-{filename}")
     contents: str = initial_config_path.read_text(encoding="utf-8")
     return contents
@@ -43,7 +42,7 @@ def create_default_chia_config(root_path: Path, filenames: list[str] = ["config.
             shutil.move(str(tmp_path), str(path))
 
 
-def config_path_for_filename(root_path: Path, filename: Union[str, Path]) -> Path:
+def config_path_for_filename(root_path: Path, filename: str | Path) -> Path:
     path_filename = Path(filename)
     if path_filename.is_absolute():
         return path_filename
@@ -51,7 +50,7 @@ def config_path_for_filename(root_path: Path, filename: Union[str, Path]) -> Pat
 
 
 @contextlib.contextmanager
-def lock_config(root_path: Path, filename: Union[str, Path]) -> Iterator[None]:
+def lock_config(root_path: Path, filename: str | Path) -> Iterator[None]:
     # TODO: This is presently used in some tests to lock the saving of the
     #       configuration file without having loaded it right there.  This usage
     #       should probably be removed and this function made private.
@@ -63,7 +62,7 @@ def lock_config(root_path: Path, filename: Union[str, Path]) -> Iterator[None]:
 @contextlib.contextmanager
 def lock_and_load_config(
     root_path: Path,
-    filename: Union[str, Path],
+    filename: str | Path,
     fill_missing_services: bool = False,
 ) -> Iterator[dict[str, Any]]:
     with lock_config(root_path=root_path, filename=filename):
@@ -76,7 +75,7 @@ def lock_and_load_config(
         yield config
 
 
-def save_config(root_path: Path, filename: Union[str, Path], config_data: Any) -> None:
+def save_config(root_path: Path, filename: str | Path, config_data: Any) -> None:
     # This must be called under an acquired config lock
     path: Path = config_path_for_filename(root_path, filename)
     with tempfile.TemporaryDirectory(dir=path.parent) as tmp_dir:
@@ -91,8 +90,8 @@ def save_config(root_path: Path, filename: Union[str, Path], config_data: Any) -
 
 def load_config(
     root_path: Path,
-    filename: Union[str, Path],
-    sub_config: Optional[str] = None,
+    filename: str | Path,
+    sub_config: str | None = None,
     exit_on_error: bool = True,
     fill_missing_services: bool = False,
 ) -> dict[str, Any]:
@@ -108,8 +107,8 @@ def load_config(
 
 def _load_config_maybe_locked(
     root_path: Path,
-    filename: Union[str, Path],
-    sub_config: Optional[str] = None,
+    filename: str | Path,
+    sub_config: str | None = None,
     exit_on_error: bool = True,
     acquire_lock: bool = True,
     fill_missing_services: bool = False,
@@ -154,7 +153,7 @@ def _load_config_maybe_locked(
 def load_config_cli(
     root_path: Path,
     filename: str,
-    sub_config: Optional[str] = None,
+    sub_config: str | None = None,
     fill_missing_services: bool = False,
 ) -> dict[str, Any]:
     """
@@ -215,7 +214,7 @@ def add_property(d: dict[str, Any], partial_key: str, value: Any) -> None:
             d[key_1][key_2] = value
 
 
-def str2bool(v: Union[str, bool]) -> bool:
+def str2bool(v: str | bool) -> bool:
     # Source from https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
     if isinstance(v, bool):
         return v
@@ -254,7 +253,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"]]
+method_values = Literal["fork", "forkserver", "spawn"] | None
 start_methods: dict[method_strings, method_values] = {
     "default": None,
     "python_default": None,
@@ -289,7 +288,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: dict[str, Any] | None) -> dict[str, Any]:
     new_config = copy.deepcopy(config)
     if config_overrides is None:
         return new_config

chia/util/db_wrapper.py

@@ -12,7 +12,7 @@ from collections.abc import AsyncIterator, Iterable
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional, TextIO, Union
+from typing import Any, TextIO
 
 import aiosqlite
 import anyio
@@ -32,7 +32,7 @@ class DBWrapperError(Exception):
 
 
 class ForeignKeyError(DBWrapperError):
-    def __init__(self, violations: Iterable[Union[aiosqlite.Row, tuple[str, object, str, object]]]) -> None:
+    def __init__(self, violations: Iterable[aiosqlite.Row | tuple[str, object, str, object]]) -> None:
         self.violations: list[dict[str, object]] = []
 
         for violation in violations:
@@ -67,8 +67,8 @@ def generate_in_memory_db_uri() -> str:
 
 
 async def execute_fetchone(
-    c: aiosqlite.Connection, sql: str, parameters: Optional[Iterable[Any]] = None
-) -> Optional[sqlite3.Row]:
+    c: aiosqlite.Connection, sql: str, parameters: Iterable[Any] | None = None
+) -> sqlite3.Row | None:
     rows = await c.execute_fetchall(sql, parameters)
     for row in rows:
         return row
@@ -76,10 +76,10 @@ async def execute_fetchone(
 
 
 async def _create_connection(
-    database: Union[str, Path],
+    database: str | Path,
     uri: bool = False,
-    log_file: Optional[TextIO] = None,
-    name: Optional[str] = None,
+    log_file: TextIO | None = None,
+    name: str | None = None,
 ) -> aiosqlite.Connection:
     # To avoid https://github.com/python/cpython/issues/118172
     connection = await aiosqlite.connect(database=database, uri=uri, cached_statements=0)
@@ -92,10 +92,10 @@ async def _create_connection(
 
 @contextlib.asynccontextmanager
 async def manage_connection(
-    database: Union[str, Path],
+    database: str | Path,
     uri: bool = False,
-    log_file: Optional[TextIO] = None,
-    name: Optional[str] = None,
+    log_file: TextIO | None = None,
+    name: str | None = None,
 ) -> AsyncIterator[aiosqlite.Connection]:
     connection: aiosqlite.Connection
     connection = await _create_connection(database=database, uri=uri, log_file=log_file, name=name)
@@ -107,7 +107,7 @@ async def manage_connection(
             await connection.close()
 
 
-def sql_trace_callback(req: str, file: TextIO, name: Optional[str] = None) -> None:
+def sql_trace_callback(req: str, file: TextIO, name: str | None = None) -> None:
     timestamp = datetime.now().strftime("%H:%M:%S.%f")
     if name is not None:
         line = f"{timestamp} {name} {req}\n"
@@ -120,10 +120,9 @@ def get_host_parameter_limit() -> int:
     # NOTE: This does not account for dynamically adjusted limits since it makes a
     #       separate db and connection.  If aiosqlite adds support we should use it.
     if sys.version_info >= (3, 11):
-        connection = sqlite3.connect(":memory:")
-
-        limit_number = sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER
-        host_parameter_limit = connection.getlimit(limit_number)
+        with contextlib.closing(sqlite3.connect(":memory:")) as connection:
+            limit_number = sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER
+            host_parameter_limit = connection.getlimit(limit_number)
     # guessing based on defaults, seems you can't query
 
     # https://www.sqlite.org/changes.html#version_3_32_0
@@ -140,13 +139,13 @@ def get_host_parameter_limit() -> int:
 class DBWrapper2:
     _write_connection: aiosqlite.Connection
     db_version: int = 1
-    _log_file: Optional[TextIO] = None
+    _log_file: TextIO | None = None
     host_parameter_limit: int = get_host_parameter_limit()
     _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)
-    _current_writer: Optional[asyncio.Task[object]] = None
+    _current_writer: asyncio.Task[object] | None = None
     _savepoint_name: int = 0
 
     async def add_connection(self, c: aiosqlite.Connection) -> None:
@@ -160,16 +159,16 @@ class DBWrapper2:
     @contextlib.asynccontextmanager
     async def managed(
         cls,
-        database: Union[str, Path],
+        database: str | Path,
         *,
         db_version: int = 1,
         uri: bool = False,
         reader_count: int = 4,
-        log_path: Optional[Path] = None,
+        log_path: Path | None = None,
         journal_mode: str = "WAL",
-        synchronous: Optional[str] = None,
-        foreign_keys: Optional[bool] = None,
-        row_factory: Optional[type[aiosqlite.Row]] = None,
+        synchronous: str | None = None,
+        foreign_keys: bool | None = None,
+        row_factory: type[aiosqlite.Row] | None = None,
     ) -> AsyncIterator[DBWrapper2]:
         if foreign_keys is None:
             foreign_keys = False
@@ -217,16 +216,16 @@ class DBWrapper2:
     @classmethod
     async def create(
         cls,
-        database: Union[str, Path],
+        database: str | Path,
         *,
         db_version: int = 1,
         uri: bool = False,
         reader_count: int = 4,
-        log_path: Optional[Path] = None,
+        log_path: Path | None = None,
         journal_mode: str = "WAL",
-        synchronous: Optional[str] = None,
+        synchronous: str | None = None,
         foreign_keys: bool = False,
-        row_factory: Optional[type[aiosqlite.Row]] = None,
+        row_factory: type[aiosqlite.Row] | None = None,
     ) -> DBWrapper2:
         # WARNING: please use .managed() instead
         if log_path is None:
@@ -290,7 +289,7 @@ class DBWrapper2:
     @contextlib.asynccontextmanager
     async def writer(
         self,
-        foreign_key_enforcement_enabled: Optional[bool] = None,
+        foreign_key_enforcement_enabled: bool | None = None,
     ) -> AsyncIterator[aiosqlite.Connection]:
         """
         Initiates a new, possibly nested, transaction. If this task is already

chia/util/default_root.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Optional
 
 DEFAULT_ROOT_PATH = Path(os.path.expanduser(os.getenv("CHIA_ROOT", "~/.chia/mainnet"))).resolve()
 
@@ -13,7 +12,7 @@ DEFAULT_KEYS_ROOT_PATH = Path(os.path.expanduser(os.getenv("CHIA_KEYS_ROOT", "~/
 SIMULATOR_ROOT_PATH = Path(os.path.expanduser(os.getenv("CHIA_SIMULATOR_ROOT", "~/.chia/simulator"))).resolve()
 
 
-def resolve_root_path(*, override: Optional[Path]) -> Path:
+def resolve_root_path(*, override: Path | None) -> Path:
     candidates = [
         override,
         os.environ.get("CHIA_ROOT"),

chia/util/errors.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from click import ClickException
 
@@ -227,11 +227,11 @@ class ProtocolError(Exception):
 
 
 class ApiError(Exception):
-    def __init__(self, code: Err, message: str, data: Optional[bytes] = None):
+    def __init__(self, code: Err, message: str, data: bytes | None = None):
         super().__init__(f"{code.name}: {message}")
         self.code: Err = code
         self.message: str = message
-        self.data: Optional[bytes] = data
+        self.data: bytes | None = data
 
 
 ##

chia/util/file_keyring.py

@@ -12,7 +12,7 @@ from dataclasses import asdict, dataclass, field
 from hashlib import pbkdf2_hmac
 from pathlib import Path
 from secrets import token_bytes
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 import yaml
 from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305  # pyright: reportMissingModuleSource=false
@@ -106,9 +106,9 @@ class FileKeyringContent:
     # Encrypted and base64 encoded keyring data.
     # - The data with CHECKBYTES_VALUE prepended is encrypted using ChaCha20Poly1305.
     # - The symmetric key is derived from the master passphrase using PBKDF2.
-    data: Optional[str] = None
+    data: str | None = None
     # An optional passphrase hint
-    passphrase_hint: Optional[str] = None
+    passphrase_hint: str | None = None
 
     def __post_init__(self) -> None:
         self.salt = convert_byte_type(bytes, self.salt)
@@ -165,16 +165,16 @@ class FileKeyringContent:
 @dataclass(frozen=True)
 class Key:
     secret: bytes
-    metadata: Optional[dict[str, Any]] = None
+    metadata: dict[str, Any] | None = None
 
     @classmethod
-    def parse(cls, data: str, metadata: Optional[dict[str, Any]]) -> Key:
+    def parse(cls, data: str, metadata: dict[str, Any] | None) -> Key:
         return cls(
             bytes.fromhex(data),
             metadata,
         )
 
-    def to_data(self) -> Union[str, dict[str, Any]]:
+    def to_data(self) -> str | dict[str, Any]:
         return self.secret.hex()
 
 
@@ -231,7 +231,7 @@ class FileKeyring(FileSystemEventHandler):
     needs_load_keyring: bool = False
     # Cache of the decrypted YAML contained in keyring.data
     cached_data_dict: DecryptedKeyringData = field(default_factory=default_file_keyring_data)
-    keyring_last_mod_time: Optional[float] = None
+    keyring_last_mod_time: float | None = None
     # Key/value pairs to set on the outer payload on the next write
     file_content_properties_for_next_write: dict[str, Any] = field(default_factory=dict)
 
@@ -284,7 +284,7 @@ class FileKeyring(FileSystemEventHandler):
             self.keyring_observer.stop()
             self.keyring_observer.join()
 
-    def on_modified(self, event: Union[FileSystemEvent, DirModifiedEvent]) -> None:
+    def on_modified(self, event: FileSystemEvent | DirModifiedEvent) -> None:
         self.check_if_keyring_file_modified()
 
     def check_if_keyring_file_modified(self) -> None:
@@ -316,7 +316,7 @@ class FileKeyring(FileSystemEventHandler):
         """
         return self.cached_data_dict.labels
 
-    def get_key(self, service: str, user: str) -> Optional[Key]:
+    def get_key(self, service: str, user: str) -> Key | None:
         """
         Returns the passphrase named by the 'user' parameter from the cached
         keyring data (does not force a read from disk)
@@ -350,7 +350,7 @@ class FileKeyring(FileSystemEventHandler):
                     keys.pop(service)
                 self.write_keyring()
 
-    def get_label(self, fingerprint: int) -> Optional[str]:
+    def get_label(self, fingerprint: int) -> str | None:
         """
         Returns the label for the given fingerprint or None if there is no label assigned.
         """
@@ -405,7 +405,7 @@ class FileKeyring(FileSystemEventHandler):
         except Exception:
             return False
 
-    def load_keyring(self, passphrase: Optional[str] = None) -> None:
+    def load_keyring(self, passphrase: str | None = None) -> None:
         from chia.util.keyring_wrapper import obtain_current_passphrase
 
         with self.load_keyring_lock:
@@ -450,18 +450,18 @@ class FileKeyring(FileSystemEventHandler):
             # Restore the correct content if we failed to write the updated cache, let it re-raise if loading also fails
             self.cached_file_content = FileKeyringContent.create_from_path(self.keyring_path)
 
-    def get_passphrase_hint(self) -> Optional[str]:
+    def get_passphrase_hint(self) -> str | None:
         """
         Return the passphrase hint (if set). The hint data may not yet be written to the keyring, so we
         return the hint data either from the staging dict (file_content_properties_for_next_write), or
         from cached_file_content (loaded from the keyring)
         """
-        passphrase_hint: Optional[str] = self.file_content_properties_for_next_write.get("passphrase_hint", None)
+        passphrase_hint: str | None = self.file_content_properties_for_next_write.get("passphrase_hint", None)
         if passphrase_hint is None:
             passphrase_hint = self.cached_file_content.passphrase_hint
         return passphrase_hint
 
-    def set_passphrase_hint(self, passphrase_hint: Optional[str]) -> None:
+    def set_passphrase_hint(self, passphrase_hint: str | None) -> None:
         """
         Store the new passphrase hint in the staging dict (file_content_properties_for_next_write) to
         be written-out on the next write to the keyring.

chia/util/files.py

@@ -7,10 +7,9 @@ import logging
 import os
 import shutil
 from pathlib import Path
-from typing import Union
+from typing import Literal
 
 from aiofiles import tempfile
-from typing_extensions import Literal
 
 log = logging.getLogger(__name__)
 
@@ -63,7 +62,7 @@ async def move_file_async(src: Path, dst: Path, *, reattempts: int = 6, reattemp
 
 
 async def write_file_async(
-    file_path: Path, data: Union[str, bytes], *, file_mode: int = 0o600, dir_mode: int = 0o700
+    file_path: Path, data: str | bytes, *, file_mode: int = 0o600, dir_mode: int = 0o700
 ) -> None:
     """
     Writes the provided data to a temporary file and then moves it to the final destination.

chia/util/hash.py

@@ -3,24 +3,24 @@
 from __future__ import annotations
 
 from hashlib import sha256
-from typing import Literal, SupportsBytes, Union, cast, overload
+from typing import Literal, SupportsBytes, cast, overload
 
 from chia_rs.sized_bytes import bytes32
 
 
 @overload
-def std_hash(b: Union[bytes, SupportsBytes]) -> bytes32: ...
+def std_hash(b: bytes | SupportsBytes) -> bytes32: ...
 
 
 @overload
-def std_hash(b: Union[bytes, SupportsBytes], skip_bytes_conversion: Literal[False]) -> bytes32: ...
+def std_hash(b: bytes | SupportsBytes, skip_bytes_conversion: Literal[False]) -> bytes32: ...
 
 
 @overload
 def std_hash(b: bytes, skip_bytes_conversion: Literal[True]) -> bytes32: ...
 
 
-def std_hash(b: Union[bytes, SupportsBytes], skip_bytes_conversion: bool = False) -> bytes32:
+def std_hash(b: bytes | SupportsBytes, skip_bytes_conversion: bool = False) -> bytes32:
     """
     The standard hash used in many places.
     """

chia/util/initial-config.yaml

@@ -20,7 +20,7 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
     testnet0:
       MIN_PLOT_SIZE_V1: 18
-      MIN_PLOT_SIZE_V2: 20
+      PLOT_SIZE_V2: 18
       GENESIS_CHALLENGE: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
@@ -34,11 +34,11 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 3ef7c233fc0785f3c0cae5992c1d35e7c955ca37a423571c1607ba392a9d12f7
       MEMPOOL_BLOCK_BUFFER: 10
       MIN_PLOT_SIZE_V1: 18
-      MIN_PLOT_SIZE_V2: 20
       NETWORK_TYPE: 1
       SUB_SLOT_ITERS_STARTING: 67108864
       # Forks activated from the beginning on this network
       HARD_FORK_HEIGHT: 0
+      SOFT_FORK8_HEIGHT: 3680000
       PLOT_FILTER_128_HEIGHT: 6029568
       PLOT_FILTER_64_HEIGHT: 11075328
       PLOT_FILTER_32_HEIGHT: 16121088
@@ -51,10 +51,9 @@ network_overrides: &network_overrides
       GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
       GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
       MEMPOOL_BLOCK_BUFFER: 10
-      MIN_PLOT_SIZE_V1: 18
-      MIN_PLOT_SIZE_V2: 20
       NETWORK_TYPE: 1
       SUB_SLOT_ITERS_STARTING: 67108864
+      HARD_FORK_HEIGHT: 3693395
   config:
     mainnet:
       address_prefix: "xch"
@@ -657,7 +656,7 @@ solver:
   selected_network: *selected_network
 
   # Number of threads for solver operations
-  num_threads: 4
+  num_threads: 1
 
   # RPC server configuration
   rpc_port: 8667

chia/util/inline_executor.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from concurrent.futures import Executor, Future
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 _T = TypeVar("_T")
 

chia/util/ip_address.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from ipaddress import IPv4Address, IPv6Address, ip_address
-from typing import Union
 
 
 @dataclass(frozen=True)
 class IPAddress:
-    _inner: Union[IPv4Address, IPv6Address]
+    _inner: IPv4Address | IPv6Address
 
     @classmethod
     def create(cls, ip: str) -> IPAddress: