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

chia/rpc/data_layer_rpc_client.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from chia.data_layer.data_layer_util import ClearPendingRootsRequest
 from chia.rpc.rpc_client import RpcClient
@@ -10,25 +10,25 @@ from chia.util.ints import uint64
 
 
 class DataLayerRpcClient(RpcClient):
-    async def create_data_store(self, fee: Optional[uint64], verbose: bool) -> Dict[str, Any]:
+    async def create_data_store(self, fee: Optional[uint64], verbose: bool) -> dict[str, Any]:
         response = await self.fetch("create_data_store", {"fee": fee, "verbose": verbose})
         return response
 
-    async def wallet_log_in(self, fingerprint: int) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"fingerprint": fingerprint}
+    async def wallet_log_in(self, fingerprint: int) -> dict[str, Any]:
+        request: dict[str, Any] = {"fingerprint": fingerprint}
         response = await self.fetch("wallet_log_in", request)
         return response
 
-    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32]) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"id": store_id.hex(), "key": key.hex()}
+    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32]) -> dict[str, Any]:
+        request: dict[str, Any] = {"id": store_id.hex(), "key": key.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
         response = await self.fetch("get_value", request)
         return response
 
     async def update_data_store(
-        self, store_id: bytes32, changelist: List[Dict[str, str]], fee: Optional[uint64], submit_on_chain: bool = True
-    ) -> Dict[str, Any]:
+        self, store_id: bytes32, changelist: list[dict[str, str]], fee: Optional[uint64], submit_on_chain: bool = True
+    ) -> dict[str, Any]:
         response = await self.fetch(
             "batch_update",
             {
@@ -41,8 +41,8 @@ class DataLayerRpcClient(RpcClient):
         return response
 
     async def update_multiple_stores(
-        self, store_updates: List[Dict[str, Any]], fee: Optional[uint64], submit_on_chain: bool = True
-    ) -> Dict[str, Any]:
+        self, store_updates: list[dict[str, Any]], fee: Optional[uint64], submit_on_chain: bool = True
+    ) -> dict[str, Any]:
         response = await self.fetch(
             "multistore_batch_update",
             {
@@ -53,18 +53,18 @@ class DataLayerRpcClient(RpcClient):
         )
         return response
 
-    async def submit_pending_root(self, store_id: bytes32, fee: Optional[uint64]) -> Dict[str, Any]:
+    async def submit_pending_root(self, store_id: bytes32, fee: Optional[uint64]) -> dict[str, Any]:
         response = await self.fetch("submit_pending_root", {"id": store_id.hex(), "fee": fee})
         return response
 
-    async def submit_all_pending_roots(self, fee: Optional[uint64]) -> Dict[str, Any]:
+    async def submit_all_pending_roots(self, fee: Optional[uint64]) -> dict[str, Any]:
         response = await self.fetch("submit_all_pending_roots", {"fee": fee})
         return response
 
     async def get_keys_values(
         self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
-    ) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"id": store_id.hex()}
+    ) -> dict[str, Any]:
+        request: dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
         if page is not None:
@@ -76,8 +76,8 @@ class DataLayerRpcClient(RpcClient):
 
     async def get_keys(
         self, store_id: bytes32, root_hash: Optional[bytes32], page: Optional[int], max_page_size: Optional[int]
-    ) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"id": store_id.hex()}
+    ) -> dict[str, Any]:
+        request: dict[str, Any] = {"id": store_id.hex()}
         if root_hash is not None:
             request["root_hash"] = root_hash.hex()
         if page is not None:
@@ -87,38 +87,38 @@ class DataLayerRpcClient(RpcClient):
         response = await self.fetch("get_keys", request)
         return response
 
-    async def get_ancestors(self, store_id: bytes32, hash: bytes32) -> Dict[str, Any]:
+    async def get_ancestors(self, store_id: bytes32, hash: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_ancestors", {"id": store_id.hex(), "hash": hash})
         return response
 
-    async def get_root(self, store_id: bytes32) -> Dict[str, Any]:
+    async def get_root(self, store_id: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_root", {"id": store_id.hex()})
         return response
 
-    async def get_local_root(self, store_id: bytes32) -> Dict[str, Any]:
+    async def get_local_root(self, store_id: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_local_root", {"id": store_id.hex()})
         return response
 
-    async def get_roots(self, store_ids: List[bytes32]) -> Dict[str, Any]:
+    async def get_roots(self, store_ids: list[bytes32]) -> dict[str, Any]:
         response = await self.fetch("get_roots", {"ids": store_ids})
         return response
 
-    async def subscribe(self, store_id: bytes32, urls: List[str]) -> Dict[str, Any]:
+    async def subscribe(self, store_id: bytes32, urls: list[str]) -> dict[str, Any]:
         response = await self.fetch("subscribe", {"id": store_id.hex(), "urls": urls})
         return response
 
-    async def remove_subscriptions(self, store_id: bytes32, urls: List[str]) -> Dict[str, Any]:
+    async def remove_subscriptions(self, store_id: bytes32, urls: list[str]) -> dict[str, Any]:
         response = await self.fetch("remove_subscriptions", {"id": store_id.hex(), "urls": urls})
         return response
 
-    async def unsubscribe(self, store_id: bytes32, retain: bool) -> Dict[str, Any]:
+    async def unsubscribe(self, store_id: bytes32, retain: bool) -> dict[str, Any]:
         response = await self.fetch("unsubscribe", {"id": store_id.hex(), "retain": retain})
         return response
 
     async def add_missing_files(
-        self, store_ids: Optional[List[bytes32]], overwrite: Optional[bool], foldername: Optional[Path]
-    ) -> Dict[str, Any]:
-        request: Dict[str, Any] = {}
+        self, store_ids: Optional[list[bytes32]], overwrite: Optional[bool], foldername: Optional[Path]
+    ) -> dict[str, Any]:
+        request: dict[str, Any] = {}
         if store_ids is not None:
             request["ids"] = [store_id.hex() for store_id in store_ids]
         if overwrite is not None:
@@ -130,8 +130,8 @@ class DataLayerRpcClient(RpcClient):
 
     async def get_kv_diff(
         self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32, page: Optional[int], max_page_size: Optional[int]
-    ) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"id": store_id.hex(), "hash_1": hash_1.hex(), "hash_2": hash_2.hex()}
+    ) -> dict[str, Any]:
+        request: dict[str, Any] = {"id": store_id.hex(), "hash_1": hash_1.hex(), "hash_2": hash_2.hex()}
         if page is not None:
             request["page"] = page
         if max_page_size is not None:
@@ -139,50 +139,50 @@ class DataLayerRpcClient(RpcClient):
         response = await self.fetch("get_kv_diff", request)
         return response
 
-    async def get_root_history(self, store_id: bytes32) -> Dict[str, Any]:
+    async def get_root_history(self, store_id: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_root_history", {"id": store_id.hex()})
         return response
 
     async def add_mirror(
-        self, store_id: bytes32, urls: List[str], amount: int, fee: Optional[uint64]
-    ) -> Dict[str, Any]:
+        self, store_id: bytes32, urls: list[str], amount: int, fee: Optional[uint64]
+    ) -> dict[str, Any]:
         response = await self.fetch("add_mirror", {"id": store_id.hex(), "urls": urls, "amount": amount, "fee": fee})
         return response
 
-    async def delete_mirror(self, coin_id: bytes32, fee: Optional[uint64]) -> Dict[str, Any]:
+    async def delete_mirror(self, coin_id: bytes32, fee: Optional[uint64]) -> dict[str, Any]:
         response = await self.fetch("delete_mirror", {"coin_id": coin_id.hex(), "fee": fee})
         return response
 
-    async def get_mirrors(self, store_id: bytes32) -> Dict[str, Any]:
+    async def get_mirrors(self, store_id: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_mirrors", {"id": store_id.hex()})
         return response
 
-    async def get_subscriptions(self) -> Dict[str, Any]:
+    async def get_subscriptions(self) -> dict[str, Any]:
         response = await self.fetch("subscriptions", {})
         return response
 
-    async def get_owned_stores(self) -> Dict[str, Any]:
+    async def get_owned_stores(self) -> dict[str, Any]:
         response = await self.fetch("get_owned_stores", {})
         return response
 
-    async def get_sync_status(self, store_id: bytes32) -> Dict[str, Any]:
+    async def get_sync_status(self, store_id: bytes32) -> dict[str, Any]:
         response = await self.fetch("get_sync_status", {"id": store_id.hex()})
         return response
 
-    async def check_plugins(self) -> Dict[str, Any]:
+    async def check_plugins(self) -> dict[str, Any]:
         response = await self.fetch("check_plugins", {})
         return response
 
-    async def clear_pending_roots(self, store_id: bytes32) -> Dict[str, Any]:
+    async def clear_pending_roots(self, store_id: bytes32) -> dict[str, Any]:
         request = ClearPendingRootsRequest(store_id=store_id)
         response = await self.fetch("clear_pending_roots", request.marshal())
         return response
 
-    async def get_proof(self, store_id: bytes32, keys: List[bytes]) -> Dict[str, Any]:
-        request: Dict[str, Any] = {"store_id": store_id.hex(), "keys": [key.hex() for key in keys]}
+    async def get_proof(self, store_id: bytes32, keys: list[bytes]) -> dict[str, Any]:
+        request: dict[str, Any] = {"store_id": store_id.hex(), "keys": [key.hex() for key in keys]}
         response = await self.fetch("get_proof", request)
         return response
 
-    async def verify_proof(self, proof: Dict[str, Any]) -> Dict[str, Any]:
+    async def verify_proof(self, proof: dict[str, Any]) -> dict[str, Any]:
         response = await self.fetch("verify_proof", proof)
         return response

chia/rpc/data_layer_rpc_util.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Type, TypeVar
+from typing import Any, TypeVar
 
 from typing_extensions import Protocol
 
@@ -13,22 +13,18 @@ _T = TypeVar("_T")
 
 class MarshallableProtocol(Protocol):
     @classmethod
-    def unmarshal(cls: Type[_T], marshalled: Dict[str, Any]) -> _T: ...
+    def unmarshal(cls: type[_T], marshalled: dict[str, Any]) -> _T: ...
 
-    def marshal(self) -> Dict[str, Any]: ...
+    def marshal(self) -> dict[str, Any]: ...
 
 
 class UnboundRoute(Protocol):
-    async def __call__(self, request: Dict[str, Any]) -> Dict[str, Any]:
+    async def __call__(self, request: dict[str, Any]) -> dict[str, Any]:
         pass
 
 
 class UnboundMarshalledRoute(Protocol):
-    # Ignoring pylint complaint about the name of the first argument since this is a
-    # special case.
-    async def __call__(  # pylint: disable=E0213
-        protocol_self, self: Any, request: MarshallableProtocol
-    ) -> MarshallableProtocol:
+    async def __call__(protocol_self, self: Any, request: MarshallableProtocol) -> MarshallableProtocol:
         pass
 
 
@@ -42,9 +38,9 @@ def marshal() -> RouteDecorator:
         from typing import get_type_hints
 
         hints = get_type_hints(route)
-        request_class: Type[MarshallableProtocol] = hints["request"]
+        request_class: type[MarshallableProtocol] = hints["request"]
 
-        async def wrapper(self: object, request: Dict[str, object]) -> Dict[str, object]:
+        async def wrapper(self: object, request: dict[str, object]) -> dict[str, object]:
             # import json
             # name = route.__name__
             # print(f"\n ==== {name} request.json\n{json.dumps(request, indent=2)}")

chia/rpc/farmer_rpc_api.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import operator
-from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, cast
 
 from typing_extensions import Protocol
 
@@ -23,7 +23,7 @@ class PaginatedRequestData(Protocol):
     page: uint32
     page_size: uint32
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
 
 @streamable
@@ -39,11 +39,11 @@ class PlotInfoRequestData(Streamable):
     node_id: bytes32
     page: uint32
     page_size: uint32
-    filter: List[FilterItem] = dataclasses.field(default_factory=list)
+    filter: list[FilterItem] = dataclasses.field(default_factory=list)
     sort_key: str = "filename"
     reverse: bool = False
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
 
 @streamable
@@ -52,13 +52,13 @@ class PlotPathRequestData(Streamable):
     node_id: bytes32
     page: uint32
     page_size: uint32
-    filter: List[str] = dataclasses.field(default_factory=list)
+    filter: list[str] = dataclasses.field(default_factory=list)
     reverse: bool = False
 
-    __match_args__: ClassVar[Tuple[str, ...]] = ()
+    __match_args__: ClassVar[tuple[str, ...]] = ()
 
 
-def paginated_plot_request(source: List[Any], request: PaginatedRequestData) -> Dict[str, object]:
+def paginated_plot_request(source: list[Any], request: PaginatedRequestData) -> dict[str, object]:
     paginator: Paginator = Paginator(source, request.page_size)
     return {
         "node_id": request.node_id.hex(),
@@ -78,11 +78,16 @@ def plot_matches_filter(plot: Plot, filter_item: FilterItem) -> bool:
 
 
 class FarmerRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("FarmerRpcApi", None)
+
     def __init__(self, farmer: Farmer):
         self.service = farmer
         self.service_name = "chia_farmer"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             "/get_signage_point": self.get_signage_point,
             "/get_signage_points": self.get_signage_points,
@@ -99,7 +104,7 @@ class FarmerRpcApi:
             "/get_pool_login_link": self.get_pool_login_link,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[Dict[str, Any]]) -> List[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
         payloads = []
 
         if change_data is None:
@@ -233,7 +238,7 @@ class FarmerRpcApi:
 
         return payloads
 
-    async def get_signage_point(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_signage_point(self, request: dict[str, Any]) -> EndpointResult:
         sp_hash = bytes32.from_hexstr(request["sp_hash"])
         sps = self.service.sps.get(sp_hash)
         if sps is None or len(sps) < 1:
@@ -253,8 +258,8 @@ class FarmerRpcApi:
             "proofs": pospaces,
         }
 
-    async def get_signage_points(self, _: Dict[str, Any]) -> EndpointResult:
-        result: List[Dict[str, Any]] = []
+    async def get_signage_points(self, _: dict[str, Any]) -> EndpointResult:
+        result: list[dict[str, Any]] = []
         for sps in self.service.sps.values():
             for sp in sps:
                 pospaces = self.service.proofs_of_space.get(sp.challenge_chain_sp, [])
@@ -273,12 +278,12 @@ class FarmerRpcApi:
                 )
         return {"signage_points": result}
 
-    async def get_reward_targets(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_reward_targets(self, request: dict[str, Any]) -> EndpointResult:
         search_for_private_key = request["search_for_private_key"]
         max_ph_to_search = request.get("max_ph_to_search", 500)
         return await self.service.get_reward_targets(search_for_private_key, max_ph_to_search)
 
-    async def set_reward_targets(self, request: Dict[str, Any]) -> EndpointResult:
+    async def set_reward_targets(self, request: dict[str, Any]) -> EndpointResult:
         farmer_target, pool_target = None, None
         if "farmer_target" in request:
             farmer_target = request["farmer_target"]
@@ -296,7 +301,7 @@ class FarmerRpcApi:
             )
         return plot_count
 
-    async def get_pool_state(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_pool_state(self, request: dict[str, Any]) -> EndpointResult:
         pools_list = []
         for p2_singleton_puzzle_hash, pool_dict in self.service.pool_state.items():
             pool_state = pool_dict.copy()
@@ -304,26 +309,26 @@ class FarmerRpcApi:
             pools_list.append(pool_state)
         return {"pool_state": pools_list}
 
-    async def set_payout_instructions(self, request: Dict[str, Any]) -> EndpointResult:
+    async def set_payout_instructions(self, request: dict[str, Any]) -> EndpointResult:
         launcher_id: bytes32 = bytes32.from_hexstr(request["launcher_id"])
         await self.service.set_payout_instructions(launcher_id, request["payout_instructions"])
         return {}
 
-    async def get_harvesters(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_harvesters(self, request: dict[str, Any]) -> EndpointResult:
         return await self.service.get_harvesters(False)
 
-    async def get_harvesters_summary(self, _: Dict[str, object]) -> EndpointResult:
+    async def get_harvesters_summary(self, _: dict[str, object]) -> EndpointResult:
         return await self.service.get_harvesters(True)
 
-    async def get_harvester_plots_valid(self, request_dict: Dict[str, object]) -> EndpointResult:
-        # TODO: Consider having a extra List[PlotInfo] in Receiver to avoid rebuilding the list for each call
+    async def get_harvester_plots_valid(self, request_dict: dict[str, object]) -> EndpointResult:
+        # TODO: Consider having a extra list[PlotInfo] in Receiver to avoid rebuilding the list for each call
         request = PlotInfoRequestData.from_json_dict(request_dict)
         plot_list = list(self.service.get_receiver(request.node_id).plots().values())
         # Apply filter
         plot_list = [
             plot for plot in plot_list if all(plot_matches_filter(plot, filter_item) for filter_item in request.filter)
         ]
-        restricted_sort_keys: List[str] = ["pool_contract_puzzle_hash", "pool_public_key", "plot_public_key"]
+        restricted_sort_keys: list[str] = ["pool_contract_puzzle_hash", "pool_public_key", "plot_public_key"]
         # Apply sort_key and reverse if sort_key is not restricted
         if request.sort_key in restricted_sort_keys:
             raise KeyError(f"Can't sort by optional attributes: {restricted_sort_keys}")
@@ -332,8 +337,8 @@ class FarmerRpcApi:
         return paginated_plot_request(plot_list, request)
 
     def paginated_plot_path_request(
-        self, source_func: Callable[[Receiver], List[str]], request_dict: Dict[str, object]
-    ) -> Dict[str, object]:
+        self, source_func: Callable[[Receiver], list[str]], request_dict: dict[str, object]
+    ) -> dict[str, object]:
         request: PlotPathRequestData = PlotPathRequestData.from_json_dict(request_dict)
         receiver = self.service.get_receiver(request.node_id)
         source = source_func(receiver)
@@ -343,16 +348,16 @@ class FarmerRpcApi:
         source = sorted(source, reverse=request.reverse)
         return paginated_plot_request(source, request)
 
-    async def get_harvester_plots_invalid(self, request_dict: Dict[str, object]) -> EndpointResult:
+    async def get_harvester_plots_invalid(self, request_dict: dict[str, object]) -> EndpointResult:
         return self.paginated_plot_path_request(Receiver.invalid, request_dict)
 
-    async def get_harvester_plots_keys_missing(self, request_dict: Dict[str, object]) -> EndpointResult:
+    async def get_harvester_plots_keys_missing(self, request_dict: dict[str, object]) -> EndpointResult:
         return self.paginated_plot_path_request(Receiver.keys_missing, request_dict)
 
-    async def get_harvester_plots_duplicates(self, request_dict: Dict[str, object]) -> EndpointResult:
+    async def get_harvester_plots_duplicates(self, request_dict: dict[str, object]) -> EndpointResult:
         return self.paginated_plot_path_request(Receiver.duplicates, request_dict)
 
-    async def get_pool_login_link(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_pool_login_link(self, request: dict[str, Any]) -> EndpointResult:
         launcher_id: bytes32 = bytes32.from_hexstr(request["launcher_id"])
         login_link: Optional[str] = await self.service.generate_login_link(launcher_id)
         if login_link is None:

chia/rpc/farmer_rpc_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
 from chia.rpc.farmer_rpc_api import PlotInfoRequestData, PlotPathRequestData
 from chia.rpc.rpc_client import RpcClient
@@ -17,16 +17,16 @@ class FarmerRpcClient(RpcClient):
     to the full node.
     """
 
-    async def get_signage_point(self, sp_hash: bytes32) -> Optional[Dict[str, Any]]:
+    async def get_signage_point(self, sp_hash: bytes32) -> Optional[dict[str, Any]]:
         try:
             return await self.fetch("get_signage_point", {"sp_hash": sp_hash.hex()})
         except ValueError:
             return None
 
-    async def get_signage_points(self) -> List[Dict[str, Any]]:
-        return cast(List[Dict[str, Any]], (await self.fetch("get_signage_points", {}))["signage_points"])
+    async def get_signage_points(self) -> list[dict[str, Any]]:
+        return cast(list[dict[str, Any]], (await self.fetch("get_signage_points", {}))["signage_points"])
 
-    async def get_reward_targets(self, search_for_private_key: bool, max_ph_to_search: int = 500) -> Dict[str, Any]:
+    async def get_reward_targets(self, search_for_private_key: bool, max_ph_to_search: int = 500) -> dict[str, Any]:
         response = await self.fetch(
             "get_reward_targets",
             {"search_for_private_key": search_for_private_key, "max_ph_to_search": max_ph_to_search},
@@ -45,7 +45,7 @@ class FarmerRpcClient(RpcClient):
         self,
         farmer_target: Optional[str] = None,
         pool_target: Optional[str] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         request = {}
         if farmer_target is not None:
             request["farmer_target"] = farmer_target
@@ -53,29 +53,29 @@ class FarmerRpcClient(RpcClient):
             request["pool_target"] = pool_target
         return await self.fetch("set_reward_targets", request)
 
-    async def get_pool_state(self) -> Dict[str, Any]:
+    async def get_pool_state(self) -> dict[str, Any]:
         return await self.fetch("get_pool_state", {})
 
-    async def set_payout_instructions(self, launcher_id: bytes32, payout_instructions: str) -> Dict[str, Any]:
+    async def set_payout_instructions(self, launcher_id: bytes32, payout_instructions: str) -> dict[str, Any]:
         request = {"launcher_id": launcher_id.hex(), "payout_instructions": payout_instructions}
         return await self.fetch("set_payout_instructions", request)
 
-    async def get_harvesters(self) -> Dict[str, Any]:
+    async def get_harvesters(self) -> dict[str, Any]:
         return await self.fetch("get_harvesters", {})
 
-    async def get_harvesters_summary(self) -> Dict[str, Any]:
+    async def get_harvesters_summary(self) -> dict[str, Any]:
         return await self.fetch("get_harvesters_summary", {})
 
-    async def get_harvester_plots_valid(self, request: PlotInfoRequestData) -> Dict[str, Any]:
+    async def get_harvester_plots_valid(self, request: PlotInfoRequestData) -> dict[str, Any]:
         return await self.fetch("get_harvester_plots_valid", recurse_jsonify(request))
 
-    async def get_harvester_plots_invalid(self, request: PlotPathRequestData) -> Dict[str, Any]:
+    async def get_harvester_plots_invalid(self, request: PlotPathRequestData) -> dict[str, Any]:
         return await self.fetch("get_harvester_plots_invalid", recurse_jsonify(request))
 
-    async def get_harvester_plots_keys_missing(self, request: PlotPathRequestData) -> Dict[str, Any]:
+    async def get_harvester_plots_keys_missing(self, request: PlotPathRequestData) -> dict[str, Any]:
         return await self.fetch("get_harvester_plots_keys_missing", recurse_jsonify(request))
 
-    async def get_harvester_plots_duplicates(self, request: PlotPathRequestData) -> Dict[str, Any]:
+    async def get_harvester_plots_duplicates(self, request: PlotPathRequestData) -> dict[str, Any]:
         return await self.fetch("get_harvester_plots_duplicates", recurse_jsonify(request))
 
     async def get_pool_login_link(self, launcher_id: bytes32) -> Optional[str]: