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

chia/harvester/harvester_api.py

@@ -4,7 +4,7 @@ import asyncio
 import logging
 import time
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element
 
@@ -15,6 +15,7 @@ from chia.protocols import harvester_protocol
 from chia.protocols.farmer_protocol import FarmingInfo
 from chia.protocols.harvester_protocol import Plot, PlotSyncResponse
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.proof_of_space import (
@@ -24,14 +25,19 @@ from chia.types.blockchain_format.proof_of_space import (
     passes_plot_filter,
 )
 from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.api_decorators import api_request
 from chia.util.ints import uint8, uint32, uint64
 from chia.wallet.derive_keys import master_sk_to_local_sk
 
 
 class HarvesterAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("HarvesterAPI", None)
+
     log: logging.Logger
     harvester: Harvester
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, harvester: Harvester):
         self.log = logging.getLogger(__name__)
@@ -40,7 +46,7 @@ class HarvesterAPI:
     def ready(self) -> bool:
         return True
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def harvester_handshake(
         self, harvester_handshake: harvester_protocol.HarvesterHandshake, peer: WSChiaConnection
     ) -> None:
@@ -56,7 +62,7 @@ class HarvesterAPI:
         await self.harvester.plot_sync_sender.start()
         self.harvester.plot_manager.start_refreshing()
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def new_signage_point_harvester(
         self, new_challenge: harvester_protocol.NewSignagePointHarvester, peer: WSChiaConnection
     ) -> None:
@@ -87,7 +93,7 @@ class HarvesterAPI:
 
         loop = asyncio.get_running_loop()
 
-        def blocking_lookup(filename: Path, plot_info: PlotInfo) -> List[Tuple[bytes32, ProofOfSpace]]:
+        def blocking_lookup(filename: Path, plot_info: PlotInfo) -> list[tuple[bytes32, ProofOfSpace]]:
             # Uses the DiskProver object to lookup qualities. This is a blocking call,
             # so it should be run in a thread pool.
             try:
@@ -123,7 +129,7 @@ class HarvesterAPI:
                     )
                     return []
 
-                responses: List[Tuple[bytes32, ProofOfSpace]] = []
+                responses: list[tuple[bytes32, ProofOfSpace]] = []
                 if quality_strings is not None:
                     difficulty = new_challenge.difficulty
                     sub_slot_iters = new_challenge.sub_slot_iters
@@ -205,12 +211,12 @@ class HarvesterAPI:
 
         async def lookup_challenge(
             filename: Path, plot_info: PlotInfo
-        ) -> Tuple[Path, List[harvester_protocol.NewProofOfSpace]]:
+        ) -> tuple[Path, list[harvester_protocol.NewProofOfSpace]]:
             # Executes a DiskProverLookup in a thread pool, and returns responses
-            all_responses: List[harvester_protocol.NewProofOfSpace] = []
+            all_responses: list[harvester_protocol.NewProofOfSpace] = []
             if self.harvester._shut_down:
                 return filename, []
-            proofs_of_space_and_q: List[Tuple[bytes32, ProofOfSpace]] = await loop.run_in_executor(
+            proofs_of_space_and_q: list[tuple[bytes32, ProofOfSpace]] = await loop.run_in_executor(
                 self.harvester.executor, blocking_lookup, filename, plot_info
             )
             for quality_str, proof_of_space in proofs_of_space_and_q:
@@ -296,7 +302,7 @@ class HarvesterAPI:
             },
         )
 
-    @api_request(reply_types=[ProtocolMessageTypes.respond_signatures])
+    @metadata.request(reply_types=[ProtocolMessageTypes.respond_signatures])
     async def request_signatures(self, request: harvester_protocol.RequestSignatures) -> Optional[Message]:
         """
         The farmer requests a signature on the header hash, for one of the proofs that we found.
@@ -329,7 +335,7 @@ class HarvesterAPI:
 
         # This is only a partial signature. When combined with the farmer's half, it will
         # form a complete PrependSignature.
-        message_signatures: List[Tuple[bytes32, G2Element]] = []
+        message_signatures: list[tuple[bytes32, G2Element]] = []
         for message in request.messages:
             signature: G2Element = AugSchemeMPL.sign(local_sk, message, agg_pk)
             message_signatures.append((message, signature))
@@ -347,7 +353,7 @@ class HarvesterAPI:
 
         return make_msg(ProtocolMessageTypes.respond_signatures, response)
 
-    @api_request()
+    @metadata.request()
     async def request_plots(self, _: harvester_protocol.RequestPlots) -> Message:
         plots_response = []
         plots, failed_to_open_filenames, no_key_filenames = self.harvester.get_plots()
@@ -369,6 +375,6 @@ class HarvesterAPI:
         response = harvester_protocol.RespondPlots(plots_response, failed_to_open_filenames, no_key_filenames)
         return make_msg(ProtocolMessageTypes.respond_plots, response)
 
-    @api_request()
+    @metadata.request()
     async def plot_sync_response(self, response: PlotSyncResponse) -> None:
         self.harvester.plot_sync_sender.set_response(response)

chia/introducer/introducer.py

@@ -4,7 +4,8 @@ import asyncio
 import contextlib
 import logging
 import time
-from typing import TYPE_CHECKING, Any, AsyncIterator, ClassVar, Dict, List, Optional, cast
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.introducer_peers import VettedPeer
@@ -12,6 +13,7 @@ from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.ints import uint64
+from chia.util.task_referencer import create_referenced_task
 
 
 class Introducer:
@@ -38,7 +40,7 @@ class Introducer:
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
-        self._vetting_task = asyncio.create_task(self._vetting_loop())
+        self._vetting_task = create_referenced_task(self._vetting_loop())
         try:
             yield
         finally:
@@ -53,7 +55,7 @@ class Introducer:
         # TODO: fill this out?
         pass
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> List[Dict[str, Any]]:
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     def set_server(self, server: ChiaServer):
@@ -99,13 +101,13 @@ class Introducer:
                         peer.last_attempt = uint64(time.time())
 
                         self.log.info(f"Vetting peer {peer.host} {peer.port}")
-                        r, w = await asyncio.wait_for(
+                        _r, w = await asyncio.wait_for(
                             asyncio.open_connection(peer.host, int(peer.port)),
                             timeout=3,
                         )
                         w.close()
                     except Exception as e:
-                        self.log.warning(f"Could not vet {peer}, removing. {type(e)}{str(e)}")
+                        self.log.warning(f"Could not vet {peer}, removing. {type(e)}{e!s}")
                         peer.vetted = min(peer.vetted - 1, -1)
 
                         # if we have failed 6 times in a row, remove the peer

chia/introducer/introducer_api.py

@@ -1,22 +1,28 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia.introducer.introducer import Introducer
 from chia.protocols.introducer_protocol import RequestPeersIntroducer, RespondPeersIntroducer
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.rpc.rpc_server import StateChangedProtocol
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import TimestampedPeerInfo
-from chia.util.api_decorators import api_request
 from chia.util.ints import uint64
 
 
 class IntroducerAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("IntroducerAPI", None)
+
     log: logging.Logger
     introducer: Introducer
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, introducer) -> None:
         self.log = logging.getLogger(__name__)
@@ -28,7 +34,7 @@ class IntroducerAPI:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def request_peers_introducer(
         self,
         request: RequestPeersIntroducer,

chia/legacy/keyring.py

@@ -6,7 +6,7 @@ helper it's required to install the `legacy_keyring` extra dependency which can
 from __future__ import annotations
 
 import sys
-from typing import Callable, List, Union, cast
+from typing import Callable, Union, cast
 
 import click
 from chia_rs import G1Element
@@ -23,7 +23,6 @@ except ImportError:
     CryptFileKeyring = None
 
 
-from chia.cmds.cmds_util import prompt_yes_no
 from chia.util.errors import KeychainUserNotFound
 from chia.util.keychain import MAX_KEYS, KeyData, KeyDataSecrets, get_private_key_user
 
@@ -85,8 +84,8 @@ def get_key_data(keyring: LegacyKeyring, index: int) -> KeyData:
     )
 
 
-def get_keys(keyring: LegacyKeyring) -> List[KeyData]:
-    keys: List[KeyData] = []
+def get_keys(keyring: LegacyKeyring) -> list[KeyData]:
+    keys: list[KeyData] = []
     for index in range(MAX_KEYS):
         try:
             keys.append(get_key_data(keyring, index))
@@ -144,7 +143,9 @@ def clear() -> None:
 
     print_keys(keyring)
 
-    if not prompt_yes_no("\nDo you really want to remove all the keys from the legacy keyring? This can't be undone."):
+    if not click.confirm(
+        "\nDo you really want to remove all the keys from the legacy keyring? This can't be undone.", default=None
+    ):
         raise click.ClickException("Aborted!")
 
     remove_keys(keyring)

chia/plot_sync/delta.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Dict, List, Union
+from typing import Union
 
 from chia.protocols.harvester_protocol import Plot
 
 
 @dataclass
 class DeltaType:
-    additions: Union[Dict[str, Plot], List[str]]
-    removals: List[str]
+    additions: Union[dict[str, Plot], list[str]]
+    removals: list[str]
 
     def __str__(self) -> str:
         return f"+{len(self.additions)}/-{len(self.removals)}"
@@ -24,17 +24,17 @@ class DeltaType:
 
 @dataclass
 class PlotListDelta(DeltaType):
-    additions: Dict[str, Plot] = field(default_factory=dict)
-    removals: List[str] = field(default_factory=list)
+    additions: dict[str, Plot] = field(default_factory=dict)
+    removals: list[str] = field(default_factory=list)
 
 
 @dataclass
 class PathListDelta(DeltaType):
-    additions: List[str] = field(default_factory=list)
-    removals: List[str] = field(default_factory=list)
+    additions: list[str] = field(default_factory=list)
+    removals: list[str] = field(default_factory=list)
 
     @staticmethod
-    def from_lists(old: List[str], new: List[str]) -> PathListDelta:
+    def from_lists(old: list[str], new: list[str]) -> PathListDelta:
         return PathListDelta([x for x in new if x not in old], [x for x in old if x not in new])
 
 

chia/plot_sync/receiver.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import logging
 import time
+from collections.abc import Awaitable, Collection, Sequence
 from dataclasses import dataclass, field
-from typing import Any, Awaitable, Callable, Collection, Dict, List, Optional, Sequence, Union
+from typing import Any, Callable, Optional, Union
 
 from typing_extensions import Protocol
 
@@ -82,10 +83,10 @@ class Receiver:
     _connection: WSChiaConnection
     _current_sync: Sync
     _last_sync: Sync
-    _plots: Dict[str, Plot]
-    _invalid: List[str]
-    _keys_missing: List[str]
-    _duplicates: List[str]
+    _plots: dict[str, Plot]
+    _invalid: list[str]
+    _keys_missing: list[str]
+    _duplicates: list[str]
     _total_plot_size: int
     _total_effective_plot_size: int
     _update_callback: ReceiverUpdateCallback
@@ -138,16 +139,16 @@ class Receiver:
     def initial_sync(self) -> bool:
         return self._last_sync.sync_id == 0
 
-    def plots(self) -> Dict[str, Plot]:
+    def plots(self) -> dict[str, Plot]:
         return self._plots
 
-    def invalid(self) -> List[str]:
+    def invalid(self) -> list[str]:
         return self._invalid
 
-    def keys_missing(self) -> List[str]:
+    def keys_missing(self) -> list[str]:
         return self._keys_missing
 
-    def duplicates(self) -> List[str]:
+    def duplicates(self) -> list[str]:
         return self._duplicates
 
     def total_plot_size(self) -> int:
@@ -245,7 +246,7 @@ class Receiver:
         state: State,
         next_state: State,
         target: Collection[str],
-        delta: List[str],
+        delta: list[str],
         paths: PlotSyncPathList,
         is_removal: bool = False,
     ) -> None:
@@ -359,7 +360,7 @@ class Receiver:
     async def sync_done(self, data: PlotSyncDone) -> None:
         await self._process(self._sync_done, ProtocolMessageTypes.plot_sync_done, data)
 
-    def to_dict(self, counts_only: bool = False) -> Dict[str, Any]:
+    def to_dict(self, counts_only: bool = False) -> dict[str, Any]:
         syncing = None
         if self._current_sync.in_progress():
             syncing = {

chia/plot_sync/sender.py

@@ -4,9 +4,10 @@ import asyncio
 import logging
 import time
 import traceback
+from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Generic, Iterable, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Generic, Optional, TypeVar
 
 from typing_extensions import Protocol
 
@@ -28,12 +29,13 @@ from chia.server.outbound_message import NodeType, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.batches import to_batches
 from chia.util.ints import int16, uint32, uint64
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
 
-def _convert_plot_info_list(plot_infos: List[PlotInfo]) -> List[Plot]:
-    converted: List[Plot] = []
+def _convert_plot_info_list(plot_infos: list[PlotInfo]) -> list[Plot]:
+    converted: list[Plot] = []
     for plot_info in plot_infos:
         converted.append(
             Plot(
@@ -66,10 +68,10 @@ class MessageGenerator(Generic[T]):
     sync_id: uint64
     message_type: ProtocolMessageTypes
     message_id: uint64
-    payload_type: Type[T]
+    payload_type: type[T]
     args: Iterable[object]
 
-    def generate(self) -> Tuple[PlotSyncIdentifier, T]:
+    def generate(self) -> tuple[PlotSyncIdentifier, T]:
         identifier = PlotSyncIdentifier(uint64(int(time.time())), self.sync_id, self.message_id)
         payload = self.payload_type(identifier, *self.args)
         return identifier, payload
@@ -93,7 +95,7 @@ class Sender:
     _connection: Optional[WSChiaConnection]
     _sync_id: uint64
     _next_message_id: uint64
-    _messages: List[MessageGenerator[PayloadType]]
+    _messages: list[MessageGenerator[PayloadType]]
     _last_sync_id: uint64
     _stop_requested = False
     _task: Optional[asyncio.Task[None]]
@@ -119,7 +121,7 @@ class Sender:
         if self._task is not None and self._stop_requested:
             await self.await_closed()
         if self._task is None:
-            self._task = asyncio.create_task(self._run())
+            self._task = create_referenced_task(self._run())
             if not self._plot_manager.initial_refresh() or self._sync_id != 0:
                 self._reset()
         else:
@@ -161,7 +163,8 @@ class Sender:
     async def _wait_for_response(self) -> bool:
         start = time.time()
         assert self._response is not None
-        while time.time() - start < Constants.message_timeout and self._response.message is None:
+        # TODO: switch to event driven code
+        while time.time() - start < Constants.message_timeout and self._response.message is None:  # noqa: ASYNC110
             await asyncio.sleep(0.1)
         return self._response.message is not None
 
@@ -249,7 +252,7 @@ class Sender:
 
         return True
 
-    def _add_list_batched(self, message_type: ProtocolMessageTypes, payload_type: Any, data: List[Any]) -> None:
+    def _add_list_batched(self, message_type: ProtocolMessageTypes, payload_type: Any, data: list[Any]) -> None:
         if len(data) == 0:
             self._add_message(message_type, payload_type, [], True)
             return
@@ -266,7 +269,7 @@ class Sender:
         sync_id = int(time.time())
         # Make sure we have unique sync-id's even if we restart refreshing within a second (i.e. in tests)
         if sync_id == self._last_sync_id:
-            sync_id = sync_id + 1
+            sync_id += 1
         log.debug(f"sync_start {sync_id}")
         self._sync_id = uint64(sync_id)
         self._add_message(
@@ -278,13 +281,13 @@ class Sender:
             self._harvesting_mode,
         )
 
-    def process_batch(self, loaded: List[PlotInfo], remaining: int) -> None:
+    def process_batch(self, loaded: list[PlotInfo], remaining: int) -> None:
         log.debug(f"process_batch {self}: loaded {len(loaded)}, remaining {remaining}")
         if len(loaded) > 0 or remaining == 0:
             converted = _convert_plot_info_list(loaded)
             self._add_message(ProtocolMessageTypes.plot_sync_loaded, PlotSyncPlotList, converted, remaining == 0)
 
-    def sync_done(self, removed: List[Path], duration: float) -> None:
+    def sync_done(self, removed: list[Path], duration: float) -> None:
         log.debug(f"sync_done {self}: removed {len(removed)}, duration {duration}")
         removed_list = [str(x) for x in removed]
         self._add_list_batched(

chia/plotters/bladebit.py

@@ -7,7 +7,7 @@ import os
 import sys
 import traceback
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Literal, Optional, Union
 
 from chia.plotters.plotters_util import get_venv_bin, reset_loop_policy_for_windows, run_command, run_plotter
 from chia.plotting.create_plots import resolve_plot_keys
@@ -20,10 +20,10 @@ BLADEBIT_PLOTTER_DIR = "bladebit"
 
 def is_bladebit_supported() -> bool:
     # bladebit >= 2.0.0 now supports macOS
-    return sys.platform.startswith("linux") or sys.platform in ["win32", "cygwin", "darwin"]
+    return sys.platform.startswith("linux") or sys.platform in {"win32", "cygwin", "darwin"}
 
 
-def meets_memory_requirement(plotters_root_path: Path) -> Tuple[bool, Optional[str]]:
+def meets_memory_requirement(plotters_root_path: Path) -> tuple[bool, Optional[str]]:
     have_enough_memory: bool = False
     warning_string: Optional[str] = None
 
@@ -40,7 +40,7 @@ def meets_memory_requirement(plotters_root_path: Path) -> Tuple[bool, Optional[s
             if proc.returncode != 0:
                 return have_enough_memory, proc.stderr.strip()
 
-            memory_info: Dict[str, int] = json.loads(proc.stdout)
+            memory_info: dict[str, int] = json.loads(proc.stdout)
             total_bytes: int = memory_info.get("total", -1)
             required_bytes: int = memory_info.get("required", 0)
             have_enough_memory = total_bytes >= required_bytes
@@ -83,8 +83,8 @@ def get_bladebit_package_path() -> Path:
 
 def get_bladebit_exec_path(with_cuda: bool = False) -> str:
     if with_cuda:
-        return "bladebit_cuda.exe" if sys.platform in ["win32", "cygwin"] else "bladebit_cuda"
-    return "bladebit.exe" if sys.platform in ["win32", "cygwin"] else "bladebit"
+        return "bladebit_cuda.exe" if sys.platform in {"win32", "cygwin"} else "bladebit_cuda"
+    return "bladebit.exe" if sys.platform in {"win32", "cygwin"} else "bladebit"
 
 
 def get_bladebit_exec_venv_path(with_cuda: bool = False) -> Optional[Path]:
@@ -97,7 +97,7 @@ def get_bladebit_exec_venv_path(with_cuda: bool = False) -> Optional[Path]:
 
 def get_bladebit_exec_src_path(plotters_root_path: Path, with_cuda: bool = False) -> Path:
     bladebit_src_dir = get_bladebit_src_path(plotters_root_path)
-    build_dir = "build/Release" if sys.platform in ["win32", "cygwin"] else "build"
+    build_dir = "build/Release" if sys.platform in {"win32", "cygwin"} else "build"
     bladebit_exec = get_bladebit_exec_path(with_cuda)
     return bladebit_src_dir / build_dir / bladebit_exec
 
@@ -131,7 +131,7 @@ def get_bladebit_executable_path(plotters_root_path: Path) -> Path:
 
 def get_bladebit_version(
     plotters_root_path: Path,
-) -> Union[Tuple[Literal[False], str], Tuple[None, str], Tuple[Literal[True], List[str]]]:
+) -> Union[tuple[Literal[False], str], tuple[None, str], tuple[Literal[True], list[str]]]:
     bladebit_executable_path = get_bladebit_executable_path(plotters_root_path)
     if not bladebit_executable_path.exists():
         # (found=False, "")
@@ -157,8 +157,8 @@ def get_bladebit_version(
         return None, str(e)
 
 
-def get_bladebit_install_info(plotters_root_path: Path) -> Optional[Dict[str, Any]]:
-    info: Dict[str, Any] = {"display_name": "BladeBit Plotter"}
+def get_bladebit_install_info(plotters_root_path: Path) -> Optional[dict[str, Any]]:
+    info: dict[str, Any] = {"display_name": "BladeBit Plotter"}
     installed: bool = False
     supported: bool = is_bladebit_supported()
     cuda_available: bool = is_cudaplot_available(plotters_root_path)
@@ -272,7 +272,7 @@ def plot_bladebit(args, chia_root_path, root_path):
         print("Bladebit was not found.")
         return
 
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         reset_loop_policy_for_windows()
 
     plot_keys = asyncio.run(
@@ -286,7 +286,7 @@ def plot_bladebit(args, chia_root_path, root_path):
             args.connect_to_daemon,
         )
     )
-    if args.plot_type == "ramplot" or args.plot_type == "diskplot" or args.plot_type == "cudaplot":
+    if args.plot_type in {"ramplot", "diskplot", "cudaplot"}:
         plot_type = args.plot_type
     else:
         plot_type = "diskplot"

chia/plotters/chiapos.py

@@ -10,7 +10,7 @@ import importlib.metadata
 import logging
 from argparse import Namespace
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from chia.plotting.create_plots import create_plots, resolve_plot_keys
 from chia.plotting.util import Params, add_plot_directory, validate_plot_size
@@ -18,7 +18,7 @@ from chia.plotting.util import Params, add_plot_directory, validate_plot_size
 log = logging.getLogger(__name__)
 
 
-def get_chiapos_install_info() -> Optional[Dict[str, Any]]:
+def get_chiapos_install_info() -> Optional[dict[str, Any]]:
     chiapos_version = importlib.metadata.version("chiapos")
     return {"display_name": "Chia Proof of Space", "version": chiapos_version, "installed": True}
 

chia/plotters/madmax.py

@@ -6,7 +6,7 @@ import os
 import sys
 import traceback
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from chia.plotters.plotters_util import get_venv_bin, reset_loop_policy_for_windows, run_command, run_plotter
 from chia.plotting.create_plots import resolve_plot_keys
@@ -18,7 +18,7 @@ MADMAX_PLOTTER_DIR = "madmax-plotter"
 
 
 def is_madmax_supported() -> bool:
-    return sys.platform.startswith("linux") or sys.platform in ["darwin", "win32", "cygwin"]
+    return sys.platform.startswith("linux") or sys.platform in {"darwin", "win32", "cygwin"}
 
 
 def get_madmax_src_path(plotters_root_path: Path) -> Path:
@@ -39,7 +39,7 @@ def get_madmax_exec_venv_path(ksize: int = 32) -> Optional[Path]:
     madmax_exec = "chia_plot"
     if ksize > 32:
         madmax_exec += "_k34"  # Use the chia_plot_k34 executable for k-sizes > 32
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         madmax_exec += ".exe"
     return venv_bin_path / madmax_exec
 
@@ -49,7 +49,7 @@ def get_madmax_exec_src_path(plotters_root_path: Path, ksize: int = 32) -> Path:
     madmax_exec = "chia_plot"
     if ksize > 32:
         madmax_exec += "_k34"  # Use the chia_plot_k34 executable for k-sizes > 32
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         madmax_exec += ".exe"
     return madmax_src_dir / madmax_exec
 
@@ -59,7 +59,7 @@ def get_madmax_exec_package_path(ksize: int = 32) -> Path:
     madmax_exec: str = "chia_plot"
     if ksize > 32:
         madmax_exec += "_k34"  # Use the chia_plot_k34 executable for k-sizes > 32
-    if sys.platform in ["win32", "cygwin"]:
+    if sys.platform in {"win32", "cygwin"}:
         madmax_exec += ".exe"
     return madmax_dir / madmax_exec
 
@@ -100,8 +100,8 @@ def get_madmax_version(plotters_root_path: Path):
         return None, f"Failed to determine madmax version: {e} {tb}"
 
 
-def get_madmax_install_info(plotters_root_path: Path) -> Optional[Dict[str, Any]]:
-    info: Dict[str, Any] = {"display_name": "madMAx Plotter"}
+def get_madmax_install_info(plotters_root_path: Path) -> Optional[dict[str, Any]]:
+    info: dict[str, Any] = {"display_name": "madMAx Plotter"}
     installed: bool = False
     supported: bool = is_madmax_supported()
 
@@ -160,7 +160,7 @@ def plot_madmax(args, chia_root_path: Path, plotters_root_path: Path):
 
         # madMAx has a ulimit -n requirement > 296:
         # "Cannot open at least 296 files, please raise maximum open file limit in OS."
-        soft_limit, hard_limit = resource.getrlimit(resource.RLIMIT_NOFILE)
+        _soft_limit, hard_limit = resource.getrlimit(resource.RLIMIT_NOFILE)
         # Set soft limit to max (hard limit)
         resource.setrlimit(resource.RLIMIT_NOFILE, (hard_limit, hard_limit))
     else:

chia/plotters/plotters.py

@@ -5,7 +5,7 @@ import binascii
 import os
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from chia.plotters.bladebit import get_bladebit_install_info, plot_bladebit
 from chia.plotters.chiapos import get_chiapos_install_info, plot_chia
@@ -547,12 +547,12 @@ def call_plotters(root_path: Path, args):
         show_plotters_version(chia_root_path)
 
 
-def get_available_plotters(root_path) -> Dict[str, Any]:
+def get_available_plotters(root_path) -> dict[str, Any]:
     plotters_root_path: Path = get_plotters_root_path(root_path)
-    plotters: Dict[str, Any] = {}
-    chiapos: Optional[Dict[str, Any]] = get_chiapos_install_info()
-    bladebit: Optional[Dict[str, Any]] = get_bladebit_install_info(plotters_root_path)
-    madmax: Optional[Dict[str, Any]] = get_madmax_install_info(plotters_root_path)
+    plotters: dict[str, Any] = {}
+    chiapos: Optional[dict[str, Any]] = get_chiapos_install_info()
+    bladebit: Optional[dict[str, Any]] = get_bladebit_install_info(plotters_root_path)
+    madmax: Optional[dict[str, Any]] = get_madmax_install_info(plotters_root_path)
 
     if chiapos is not None:
         plotters["chiapos"] = chiapos