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

chia/plotters/plotters_util.py

@@ -7,12 +7,14 @@ import os
 import signal
 import subprocess
 import sys
+from collections.abc import Iterator
 from datetime import datetime
 from pathlib import Path
-from typing import Iterator, Optional, TextIO
+from typing import Optional, TextIO
 
 from chia.util.chia_version import chia_short_version
 from chia.util.config import lock_and_load_config
+from chia.util.task_referencer import create_referenced_task
 
 
 @contextlib.contextmanager
@@ -59,7 +61,7 @@ async def run_plotter(root_path, plotter, args, progress_dict):
         process.terminate()
 
     # For Windows, we'll install a SIGINT handler to catch Ctrl-C (KeyboardInterrupt isn't raised)
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         signal.signal(signal.SIGINT, sigint_handler)
         installed_sigint_handler = True
 
@@ -82,13 +84,13 @@ async def run_plotter(root_path, plotter, args, progress_dict):
         try:
             await asyncio.wait(
                 [
-                    asyncio.create_task(
+                    create_referenced_task(
                         _read_stream(
                             process.stdout,
                             process_stdout_line,
                         )
                     ),
-                    asyncio.create_task(
+                    create_referenced_task(
                         _read_stream(
                             process.stderr,
                             process_stderr_line,

chia/plotting/cache.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import logging
 import time
 import traceback
+from collections.abc import ItemsView, KeysView, ValuesView
 from dataclasses import dataclass, field
 from math import ceil
 from pathlib import Path
-from typing import Dict, ItemsView, KeysView, List, Optional, Tuple, ValuesView
+from typing import Optional
 
 from chia_rs import G1Element
 from chiapos import DiskProver
@@ -37,7 +38,7 @@ class DiskCacheEntry(Streamable):
 @streamable
 @dataclass(frozen=True)
 class CacheDataV1(Streamable):
-    entries: List[Tuple[str, DiskCacheEntry]]
+    entries: list[tuple[str, DiskCacheEntry]]
 
 
 @dataclass
@@ -84,7 +85,7 @@ class CacheEntry:
 class Cache:
     _path: Path
     _changed: bool = False
-    _data: Dict[Path, CacheEntry] = field(default_factory=dict)
+    _data: dict[Path, CacheEntry] = field(default_factory=dict)
     expiry_seconds: int = 7 * 24 * 60 * 60  # Keep the cache entries alive for 7 days after its last access
 
     def __post_init__(self) -> None:
@@ -97,7 +98,7 @@ class Cache:
         self._data[path] = entry
         self._changed = True
 
-    def remove(self, cache_keys: List[Path]) -> None:
+    def remove(self, cache_keys: list[Path]) -> None:
         for key in cache_keys:
             if key in self._data:
                 del self._data[key]
@@ -105,7 +106,7 @@ class Cache:
 
     def save(self) -> None:
         try:
-            disk_cache_entries: Dict[str, DiskCacheEntry] = {
+            disk_cache_entries: dict[str, DiskCacheEntry] = {
                 str(path): DiskCacheEntry(
                     bytes(cache_entry.prover),
                     cache_entry.farmer_public_key,
@@ -136,8 +137,8 @@ class Cache:
                 start = time.time()
                 cache_data: CacheDataV1 = CacheDataV1.from_bytes(stored_cache.blob)
                 self._data = {}
-                estimated_c2_sizes: Dict[int, int] = {}
-                measured_sizes: Dict[int, int] = {
+                estimated_c2_sizes: dict[int, int] = {}
+                measured_sizes: dict[int, int] = {
                     32: 738,
                     33: 1083,
                     34: 1771,

chia/plotting/check_plots.py

@@ -6,7 +6,7 @@ from collections import Counter
 from pathlib import Path
 from threading import Lock
 from time import sleep, time
-from typing import List, Optional
+from typing import Optional
 
 from chia_rs import G1Element
 from chiapos import Verifier
@@ -103,7 +103,7 @@ def check_plots(
         log.info("Plot filenames expected to end with -[64 char plot ID].plot")
 
     if list_duplicates:
-        all_filenames: List[Path] = []
+        all_filenames: list[Path] = []
         for paths in get_plot_filenames(root_path).values():
             all_filenames += paths
         find_duplicate_plot_IDs(all_filenames)
@@ -135,7 +135,7 @@ def check_plots(
         log.info(f"Starting to test each plot with {num} challenges each\n")
     total_good_plots: Counter[str] = Counter()
     total_size = 0
-    bad_plots_list: List[Path] = []
+    bad_plots_list: list[Path] = []
 
     with plot_manager:
 
@@ -148,7 +148,7 @@ def check_plots(
 
             # Look up local_sk from plot to save locked memory
             (
-                pool_public_key_or_puzzle_hash,
+                _pool_public_key_or_puzzle_hash,
                 farmer_public_key,
                 local_master_sk,
             ) = parse_plot_info(pr.get_memo())
@@ -161,8 +161,8 @@ def check_plots(
                 if plot_info.pool_contract_puzzle_hash is not None:
                     pca: str = encode_puzzle_hash(plot_info.pool_contract_puzzle_hash, address_prefix)
                     log.info(f"\t{'Pool contract address:':<23} {pca}")
-                log.info(f"\t{'Farmer public key:' :<23} {farmer_public_key}")
-                log.info(f"\t{'Local sk:' :<23} {local_sk}")
+                log.info(f"\t{'Farmer public key:':<23} {farmer_public_key}")
+                log.info(f"\t{'Local sk:':<23} {local_sk}")
 
             total_proofs = 0
             caught_exception: bool = False
@@ -229,14 +229,14 @@ def check_plots(
 
             if total_proofs > 0 and caught_exception is False:
                 log.info(
-                    f"\tProofs {total_proofs} / {challenges}, {round(total_proofs/float(challenges), 4)}. "
+                    f"\tProofs {total_proofs} / {challenges}, {round(total_proofs / float(challenges), 4)}. "
                     f"Filepath: {plot_path}"
                 )
                 total_good_plots[pr.get_size()] += 1
                 total_size += plot_path.stat().st_size
             else:
                 log.error(
-                    f"\tProofs {total_proofs} / {challenges}, {round(total_proofs/float(challenges), 4)} "
+                    f"\tProofs {total_proofs} / {challenges}, {round(total_proofs / float(challenges), 4)} "
                     f"Filepath: {plot_path}"
                 )
                 bad_plots_list.append(plot_path)

chia/plotting/create_plots.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 from chia_rs import AugSchemeMPL, G1Element, PrivateKey
 from chiapos import DiskPlotter
@@ -105,7 +105,7 @@ class PlotKeysResolver:
             except Exception as e:
                 log.error(f"Keychain proxy failed with error: {e}")
         else:
-            sk_ent: Optional[Tuple[PrivateKey, bytes]] = None
+            sk_ent: Optional[tuple[PrivateKey, bytes]] = None
             keychain: Keychain = Keychain()
             if self.alt_fingerprint is not None:
                 sk_ent = keychain.get_private_key_by_fingerprint(self.alt_fingerprint)
@@ -151,8 +151,8 @@ async def create_plots(
     args: Params,
     keys: PlotKeys,
     use_datetime: bool = True,
-    test_private_keys: Optional[List[PrivateKey]] = None,
-) -> Tuple[Dict[bytes32, Path], Dict[bytes32, Path]]:
+    test_private_keys: Optional[list[PrivateKey]] = None,
+) -> tuple[dict[bytes32, Path], dict[bytes32, Path]]:
     if args.tmp2_dir is None:
         args.tmp2_dir = args.tmp_dir
     assert (keys.pool_public_key is None) != (keys.pool_contract_puzzle_hash is None)
@@ -182,8 +182,8 @@ async def create_plots(
 
     args.final_dir.mkdir(parents=True, exist_ok=True)
 
-    created_plots: Dict[bytes32, Path] = {}
-    existing_plots: Dict[bytes32, Path] = {}
+    created_plots: dict[bytes32, Path] = {}
+    existing_plots: dict[bytes32, Path] = {}
     for i in range(num):
         # Generate a random master secret key
         if test_private_keys is not None:

chia/plotting/manager.py

@@ -6,7 +6,7 @@ import time
 import traceback
 from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple
+from typing import Any, Callable, Optional
 
 from chia_rs import G1Element
 from chiapos import DiskProver, decompressor_context_queue
@@ -27,13 +27,13 @@ log = logging.getLogger(__name__)
 
 
 class PlotManager:
-    plots: Dict[Path, PlotInfo]
-    plot_filename_paths: Dict[str, Tuple[str, Set[str]]]
+    plots: dict[Path, PlotInfo]
+    plot_filename_paths: dict[str, tuple[str, set[str]]]
     plot_filename_paths_lock: threading.Lock
-    failed_to_open_filenames: Dict[Path, int]
-    no_key_filenames: Set[Path]
-    farmer_public_keys: List[G1Element]
-    pool_public_keys: List[G1Element]
+    failed_to_open_filenames: dict[Path, int]
+    no_key_filenames: set[Path]
+    farmer_public_keys: list[G1Element]
+    pool_public_keys: list[G1Element]
     cache: Cache
     match_str: Optional[str]
     open_no_key_filenames: bool
@@ -137,7 +137,7 @@ class PlotManager:
     def set_refresh_callback(self, callback: Callable):
         self._refresh_callback = callback
 
-    def set_public_keys(self, farmer_public_keys: List[G1Element], pool_public_keys: List[G1Element]):
+    def set_public_keys(self, farmer_public_keys: list[G1Element], pool_public_keys: list[G1Element]):
         self.farmer_public_keys = farmer_public_keys
         self.pool_public_keys = pool_public_keys
 
@@ -151,7 +151,7 @@ class PlotManager:
         with self:
             return len(self.plots)
 
-    def get_duplicates(self) -> List[Path]:
+    def get_duplicates(self) -> list[Path]:
         result = []
         for plot_filename, paths_entry in self.plot_filename_paths.items():
             _, duplicated_paths = paths_entry
@@ -188,9 +188,9 @@ class PlotManager:
                 if not self._refreshing_enabled:
                     return
 
-                plot_filenames: Dict[Path, List[Path]] = get_plot_filenames(self.root_path)
-                plot_directories: Set[Path] = set(plot_filenames.keys())
-                plot_paths: Set[Path] = set()
+                plot_filenames: dict[Path, list[Path]] = get_plot_filenames(self.root_path)
+                plot_directories: set[Path] = set(plot_filenames.keys())
+                plot_paths: set[Path] = set()
                 for paths in plot_filenames.values():
                     plot_paths.update(paths)
 
@@ -208,7 +208,7 @@ class PlotManager:
                     if path not in plot_paths:
                         self.no_key_filenames.remove(path)
 
-                filenames_to_remove: List[str] = []
+                filenames_to_remove: list[str] = []
                 for plot_filename, paths_entry in self.plot_filename_paths.items():
                     loaded_path, duplicated_paths = paths_entry
                     loaded_plot = Path(loaded_path) / Path(plot_filename)
@@ -221,7 +221,7 @@ class PlotManager:
                         # No need to check the duplicates here since we drop the whole entry
                         continue
 
-                    paths_to_remove: List[str] = []
+                    paths_to_remove: list[str] = []
                     for path_str in duplicated_paths:
                         loaded_plot = Path(path_str) / Path(plot_filename)
                         if loaded_plot not in plot_paths:
@@ -258,7 +258,7 @@ class PlotManager:
 
                 # Cleanup unused cache
                 self.log.debug(f"_refresh_task: cached entries before cleanup: {len(self.cache)}")
-                remove_paths: List[Path] = []
+                remove_paths: list[Path] = []
                 for path, cache_entry in self.cache.items():
                     if cache_entry.expired(Cache.expiry_seconds) and path not in self.plots:
                         remove_paths.append(path)
@@ -281,7 +281,7 @@ class PlotManager:
                 log.error(f"_refresh_callback raised: {e} with the traceback: {traceback.format_exc()}")
                 self.reset()
 
-    def refresh_batch(self, plot_paths: List[Path], plot_directories: Set[Path]) -> PlotRefreshResult:
+    def refresh_batch(self, plot_paths: list[Path], plot_directories: set[Path]) -> PlotRefreshResult:
         start_time: float = time.time()
         result: PlotRefreshResult = PlotRefreshResult(processed=len(plot_paths))
         counter_lock = threading.Lock()
@@ -308,11 +308,11 @@ class PlotManager:
             if file_path in self.plots:
                 return self.plots[file_path]
 
-            entry: Optional[Tuple[str, Set[str]]] = self.plot_filename_paths.get(file_path.name)
+            entry: Optional[tuple[str, set[str]]] = self.plot_filename_paths.get(file_path.name)
             if entry is not None:
-                loaded_parent, duplicates = entry
+                _loaded_parent, duplicates = entry
                 if str(file_path.parent) in duplicates:
-                    log.debug(f"Skip duplicated plot {str(file_path)}")
+                    log.debug(f"Skip duplicated plot {file_path!s}")
                     return None
             try:
                 if not file_path.exists():
@@ -325,7 +325,7 @@ class PlotManager:
                 if not cache_hit:
                     prover = DiskProver(str(file_path))
 
-                    log.debug(f"process_file {str(file_path)}")
+                    log.debug(f"process_file {file_path!s}")
 
                     expected_size = _expected_plot_size(prover.get_size()) * UI_ACTUAL_SPACE_CONSTANT_FACTOR
 
@@ -383,7 +383,7 @@ class PlotManager:
                     self.no_key_filenames.remove(file_path)
 
                 with self.plot_filename_paths_lock:
-                    paths: Optional[Tuple[str, Set[str]]] = self.plot_filename_paths.get(file_path.name)
+                    paths: Optional[tuple[str, set[str]]] = self.plot_filename_paths.get(file_path.name)
                     if paths is None:
                         paths = (str(Path(cache_entry.prover.get_filename()).parent), set())
                         self.plot_filename_paths[file_path.name] = paths
@@ -419,7 +419,7 @@ class PlotManager:
             return new_plot_info
 
         with self, ThreadPoolExecutor() as executor:
-            plots_refreshed: Dict[Path, PlotInfo] = {}
+            plots_refreshed: dict[Path, PlotInfo] = {}
             for new_plot in executor.map(process_file, plot_paths):
                 if new_plot is not None:
                     plots_refreshed[Path(new_plot.prover.get_filename())] = new_plot

chia/plotting/util.py

@@ -4,7 +4,7 @@ import logging
 from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from chia_rs import G1Element, PrivateKey
 from chiapos import DiskProver
@@ -70,8 +70,8 @@ class PlotRefreshEvents(Enum):
 
 @dataclass
 class PlotRefreshResult:
-    loaded: List[PlotInfo] = field(default_factory=list)
-    removed: List[Path] = field(default_factory=list)
+    loaded: list[PlotInfo] = field(default_factory=list)
+    removed: list[Path] = field(default_factory=list)
     processed: int = 0
     remaining: int = 0
     duration: float = 0
@@ -99,28 +99,29 @@ class HarvestingMode(IntEnum):
     GPU = 2
 
 
-def get_plot_directories(root_path: Path, config: Dict = None) -> List[str]:
+def get_plot_directories(root_path: Path, config: Optional[dict] = None) -> list[str]:
     if config is None:
         config = load_config(root_path, "config.yaml")
     return config["harvester"]["plot_directories"] or []
 
 
-def get_plot_filenames(root_path: Path) -> Dict[Path, List[Path]]:
+def get_plot_filenames(root_path: Path) -> dict[Path, list[Path]]:
     # Returns a map from directory to a list of all plots in the directory
-    all_files: Dict[Path, List[Path]] = {}
+    all_files: dict[Path, list[Path]] = {}
     config = load_config(root_path, "config.yaml")
     recursive_scan: bool = config["harvester"].get("recursive_plot_scan", DEFAULT_RECURSIVE_PLOT_SCAN)
+    recursive_follow_links: bool = config["harvester"].get("recursive_follow_links", False)
     for directory_name in get_plot_directories(root_path, config):
         try:
             directory = Path(directory_name).resolve()
         except (OSError, RuntimeError):
             log.exception(f"Failed to resolve {directory_name}")
             continue
-        all_files[directory] = get_filenames(directory, recursive_scan)
+        all_files[directory] = get_filenames(directory, recursive_scan, recursive_follow_links)
     return all_files
 
 
-def add_plot_directory(root_path: Path, str_path: str) -> Dict:
+def add_plot_directory(root_path: Path, str_path: str) -> dict:
     path: Path = Path(str_path).resolve()
     if not path.exists():
         raise ValueError(f"Path doesn't exist: {path}")
@@ -140,7 +141,7 @@ def add_plot_directory(root_path: Path, str_path: str) -> Dict:
 def remove_plot_directory(root_path: Path, str_path: str) -> None:
     log.debug(f"remove_plot_directory {str_path}")
     with lock_and_load_config(root_path, "config.yaml") as config:
-        str_paths: List[str] = get_plot_directories(root_path, config)
+        str_paths: list[str] = get_plot_directories(root_path, config)
         # If path str matches exactly, remove
         if str_path in str_paths:
             str_paths.remove(str_path)
@@ -155,13 +156,13 @@ def remove_plot_directory(root_path: Path, str_path: str) -> None:
 
 
 def remove_plot(path: Path):
-    log.debug(f"remove_plot {str(path)}")
+    log.debug(f"remove_plot {path!s}")
     # Remove absolute and relative paths
     if path.exists():
         path.unlink()
 
 
-def get_harvester_config(root_path: Path) -> Dict[str, Any]:
+def get_harvester_config(root_path: Path) -> dict[str, Any]:
     config = load_config(root_path, "config.yaml")
 
     plots_refresh_parameter = (
@@ -219,7 +220,7 @@ def update_harvester_config(
         save_config(root_path, "config.yaml", config)
 
 
-def get_filenames(directory: Path, recursive: bool) -> List[Path]:
+def get_filenames(directory: Path, recursive: bool, follow_links: bool) -> list[Path]:
     try:
         if not directory.exists():
             log.warning(f"Directory: {directory} does not exist.")
@@ -227,17 +228,28 @@ def get_filenames(directory: Path, recursive: bool) -> List[Path]:
     except OSError as e:
         log.warning(f"Error checking if directory {directory} exists: {e}")
         return []
-    all_files: List[Path] = []
+    all_files: list[Path] = []
     try:
-        glob_function = directory.rglob if recursive else directory.glob
-        all_files = [child for child in glob_function("*.plot") if child.is_file() and not child.name.startswith("._")]
+        if follow_links and recursive:
+            import glob
+
+            files = glob.glob(str(directory / "**" / "*.plot"), recursive=True)
+            for file in files:
+                filepath = Path(file).resolve()
+                if filepath.is_file() and not filepath.name.startswith("._"):
+                    all_files.append(filepath)
+        else:
+            glob_function = directory.rglob if recursive else directory.glob
+            all_files = [
+                child for child in glob_function("*.plot") if child.is_file() and not child.name.startswith("._")
+            ]
         log.debug(f"get_filenames: {len(all_files)} files found in {directory}, recursive: {recursive}")
     except Exception as e:
         log.warning(f"Error reading directory {directory} {e}")
     return all_files
 
 
-def parse_plot_info(memo: bytes) -> Tuple[Union[G1Element, bytes32], G1Element, PrivateKey]:
+def parse_plot_info(memo: bytes) -> tuple[Union[G1Element, bytes32], G1Element, PrivateKey]:
     # Parses the plot info bytes into keys
     if len(memo) == (48 + 48 + 32):
         # This is a public key memo
@@ -286,12 +298,12 @@ def find_duplicate_plot_IDs(all_filenames=None) -> None:
         all_filenames = []
     plot_ids_set = set()
     duplicate_plot_ids = set()
-    all_filenames_str: List[str] = []
+    all_filenames_str: list[str] = []
 
     for filename in all_filenames:
         filename_str: str = str(filename)
         all_filenames_str.append(filename_str)
-        filename_parts: List[str] = filename_str.split("-")
+        filename_parts: list[str] = filename_str.split("-")
         plot_id: str = filename_parts[-1]
         # Skipped parsing and verifying plot ID for faster performance
         # Skipped checking K size for faster performance
@@ -306,7 +318,7 @@ def find_duplicate_plot_IDs(all_filenames=None) -> None:
 
     for plot_id in duplicate_plot_ids:
         log_message: str = plot_id + " found in multiple files:\n"
-        duplicate_filenames: List[str] = [filename_str for filename_str in all_filenames_str if plot_id in filename_str]
+        duplicate_filenames: list[str] = [filename_str for filename_str in all_filenames_str if plot_id in filename_str]
         for filename_str in duplicate_filenames:
             log_message += "\t" + filename_str + "\n"
         log.warning(f"{log_message}")

chia/pools/pool_config.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable
 
 from chia_rs import G1Element
 
@@ -22,7 +22,7 @@ pool_list:
     pool_url: localhost
     p2_singleton_puzzle_hash: 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
     target_puzzle_hash: 344587cf06a39db471d2cc027504e8688a0a67cce961253500c956c73603fd58
-"""  # noqa
+"""
 
 log = logging.getLogger(__name__)
 
@@ -38,9 +38,9 @@ class PoolWalletConfig(Streamable):
     owner_public_key: G1Element
 
 
-def load_pool_config(root_path: Path) -> List[PoolWalletConfig]:
+def load_pool_config(root_path: Path) -> list[PoolWalletConfig]:
     config = load_config(root_path, "config.yaml")
-    ret_list: List[PoolWalletConfig] = []
+    ret_list: list[PoolWalletConfig] = []
     pool_list = config["pool"].get("pool_list", [])
     if pool_list is None:
         return ret_list
@@ -63,7 +63,7 @@ def load_pool_config(root_path: Path) -> List[PoolWalletConfig]:
 
 
 def update_pool_url(root_path: Path, pool_wallet_config: PoolWalletConfig, pool_url: str) -> None:
-    def update_pool_url_for_entry(config_entry: Dict[str, Any]) -> bool:
+    def update_pool_url_for_entry(config_entry: dict[str, Any]) -> bool:
         if config_entry.get("pool_url", "") != pool_url:
             config_entry["pool_url"] = pool_url
 
@@ -82,7 +82,7 @@ def update_pool_url(root_path: Path, pool_wallet_config: PoolWalletConfig, pool_
 def update_pool_config_entry(
     root_path: Path,
     pool_wallet_config: PoolWalletConfig,
-    update_closure: Callable[[Dict[str, Any]], bool],
+    update_closure: Callable[[dict[str, Any]], bool],
     update_log_message: str,
 ) -> None:
     with lock_and_load_config(root_path, "config.yaml") as config:
@@ -104,7 +104,7 @@ def update_pool_config_entry(
         save_config(root_path, "config.yaml", config)
 
 
-async def update_pool_config(root_path: Path, pool_config_list: List[PoolWalletConfig]) -> None:
+async def update_pool_config(root_path: Path, pool_config_list: list[PoolWalletConfig]) -> None:
     with lock_and_load_config(root_path, "config.yaml") as full_config:
         full_config["pool"]["pool_list"] = [c.to_json_dict() for c in pool_config_list]
         save_config(root_path, "config.yaml", full_config)

chia/pools/pool_puzzles.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia_rs import G1Element
 from clvm.casts import int_to_bytes
@@ -115,7 +115,7 @@ def launcher_id_to_p2_puzzle_hash(launcher_id: bytes32, seconds_delay: uint64, d
     return create_p2_singleton_puzzle_hash(SINGLETON_MOD_HASH, launcher_id, seconds_delay, delayed_puzzle_hash)
 
 
-def get_delayed_puz_info_from_launcher_spend(coinsol: CoinSpend) -> Tuple[uint64, bytes32]:
+def get_delayed_puz_info_from_launcher_spend(coinsol: CoinSpend) -> tuple[uint64, bytes32]:
     extra_data = Program.from_bytes(bytes(coinsol.solution)).rest().rest().first()
     # Extra data is (pool_state delayed_puz_info)
     # Delayed puz info is (seconds delayed_puzzle_hash)
@@ -143,11 +143,11 @@ def get_template_singleton_inner_puzzle(inner_puzzle: Program) -> Program:
     r = inner_puzzle.uncurry()
     if r is None:
         return False
-    uncurried_inner_puzzle, args = r
+    uncurried_inner_puzzle, _args = r
     return uncurried_inner_puzzle
 
 
-def get_seconds_and_delayed_puzhash_from_p2_singleton_puzzle(puzzle: Program) -> Tuple[uint64, bytes32]:
+def get_seconds_and_delayed_puzhash_from_p2_singleton_puzzle(puzzle: Program) -> tuple[uint64, bytes32]:
     r = puzzle.uncurry()
     if r is None:
         return False
@@ -161,17 +161,17 @@ def get_seconds_and_delayed_puzhash_from_p2_singleton_puzzle(puzzle: Program) ->
 # Verify that a puzzle is a Pool Wallet Singleton
 def is_pool_singleton_inner_puzzle(inner_puzzle: Program) -> bool:
     inner_f = get_template_singleton_inner_puzzle(inner_puzzle)
-    return inner_f in [POOL_WAITING_ROOM_MOD, POOL_MEMBER_MOD]
+    return inner_f in (POOL_WAITING_ROOM_MOD, POOL_MEMBER_MOD)  # noqa: PLR6201
 
 
 def is_pool_waitingroom_inner_puzzle(inner_puzzle: Program) -> bool:
     inner_f = get_template_singleton_inner_puzzle(inner_puzzle)
-    return inner_f in [POOL_WAITING_ROOM_MOD]
+    return inner_f == POOL_WAITING_ROOM_MOD
 
 
 def is_pool_member_inner_puzzle(inner_puzzle: Program) -> bool:
     inner_f = get_template_singleton_inner_puzzle(inner_puzzle)
-    return inner_f in [POOL_MEMBER_MOD]
+    return inner_f == POOL_MEMBER_MOD
 
 
 # This spend will use the escape-type spend path for whichever state you are currently in
@@ -185,7 +185,7 @@ def create_travel_spend(
     genesis_challenge: bytes32,
     delay_time: uint64,
     delay_ph: bytes32,
-) -> Tuple[CoinSpend, Program]:
+) -> tuple[CoinSpend, Program]:
     inner_puzzle: Program = pool_state_to_inner_puzzle(
         current,
         launcher_coin.name(),
@@ -251,7 +251,7 @@ def create_absorb_spend(
     genesis_challenge: bytes32,
     delay_time: uint64,
     delay_ph: bytes32,
-) -> List[CoinSpend]:
+) -> list[CoinSpend]:
     inner_puzzle: Program = pool_state_to_inner_puzzle(
         current_state, launcher_coin.name(), genesis_challenge, delay_time, delay_ph
     )
@@ -309,7 +309,7 @@ def create_absorb_spend(
 
 
 def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Optional[Coin]:
-    additions: List[Coin] = compute_additions(coin_sol)
+    additions: list[Coin] = compute_additions(coin_sol)
     for coin in additions:
         if coin.amount % 2 == 1:
             return coin
@@ -335,7 +335,7 @@ def get_pubkey_from_member_inner_puzzle(inner_puzzle: Program) -> G1Element:
 
 def uncurry_pool_member_inner_puzzle(
     inner_puzzle: Program,
-) -> Tuple[Program, Program, Program, Program, Program, Program]:
+) -> tuple[Program, Program, Program, Program, Program, Program]:
     """
     Take a puzzle and return `None` if it's not a "pool member" inner puzzle, or
     a triple of `mod_hash, relative_lock_height, pubkey` if it is.
@@ -352,7 +352,7 @@ def uncurry_pool_member_inner_puzzle(
     return inner_f, target_puzzle_hash, p2_singleton_hash, owner_pubkey, pool_reward_prefix, escape_puzzlehash
 
 
-def uncurry_pool_waitingroom_inner_puzzle(inner_puzzle: Program) -> Tuple[Program, Program, Program, Program]:
+def uncurry_pool_waitingroom_inner_puzzle(inner_puzzle: Program) -> tuple[Program, Program, Program, Program]:
     """
     Take a puzzle and return `None` if it's not a "pool member" inner puzzle, or
     a triple of `mod_hash, relative_lock_height, pubkey` if it is.
@@ -362,9 +362,9 @@ def uncurry_pool_waitingroom_inner_puzzle(inner_puzzle: Program) -> Tuple[Progra
     r = inner_puzzle.uncurry()
     if r is None:
         raise ValueError("Failed to unpack inner puzzle")
-    inner_f, args = r
+    _inner_f, args = r
     v = args.as_iter()
-    target_puzzle_hash, p2_singleton_hash, owner_pubkey, genesis_challenge, relative_lock_height = tuple(v)
+    target_puzzle_hash, p2_singleton_hash, owner_pubkey, _genesis_challenge, relative_lock_height = tuple(v)
     return target_puzzle_hash, relative_lock_height, owner_pubkey, p2_singleton_hash
 
 
@@ -410,7 +410,7 @@ def solution_to_pool_state(full_spend: CoinSpend) -> Optional[PoolState]:
 
     # Spend which is not absorb, and is not the launcher
     num_args = len(inner_solution.as_python())
-    assert num_args in (2, 3)
+    assert num_args in {2, 3}
 
     if num_args == 2:
         # pool member
@@ -445,7 +445,7 @@ def pool_state_to_inner_puzzle(
         delay_time,
         delay_ph,
     )
-    if pool_state.state in [LEAVING_POOL.value, SELF_POOLING.value]:
+    if pool_state.state in {LEAVING_POOL.value, SELF_POOLING.value}:
         return escaping_inner_puzzle
     else:
         return create_pooling_inner_puzzle(