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

chia/seeder/start_crawler.py

@@ -4,8 +4,9 @@ import logging
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
+from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.rpc.crawler_rpc_api import CrawlerRpcApi
@@ -17,7 +18,7 @@ from chia.server.start_service import RpcInfo, Service, async_run
 from chia.types.aliases import CrawlerService
 from chia.util.chia_logging import initialize_service_logging
 from chia.util.config import load_config, load_config_cli
-from chia.util.default_root import DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")
@@ -28,7 +29,7 @@ log = logging.getLogger(__name__)
 
 def create_full_node_crawler_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     consensus_constants: ConsensusConstants,
     connect_to_daemon: bool = True,
     start_crawler_loop: bool = True,
@@ -60,18 +61,19 @@ def create_full_node_crawler_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
     overrides = service_config["network_overrides"]["constants"][service_config["selected_network"]]
     updated_constants = replace_str_to_bytes(DEFAULT_CONSTANTS, **overrides)
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
-    service = create_full_node_crawler_service(DEFAULT_ROOT_PATH, config, updated_constants)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+    service = create_full_node_crawler_service(root_path, config, updated_constants)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -81,7 +83,9 @@ async def async_main() -> int:
 
 def main() -> int:
     freeze_support()
-    return async_run(async_main())
+    root_path = resolve_root_path(override=None)
+
+    return async_run(async_main(root_path=root_path))
 
 
 if __name__ == "__main__":

chia/server/address_manager.py

@@ -6,7 +6,7 @@ import time
 from asyncio import Lock
 from random import choice, randrange
 from secrets import randbits
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 from chia.types.peer_info import PeerInfo, TimestampedPeerInfo
 from chia.util.hash import std_hash
@@ -81,7 +81,7 @@ class ExtendedPeerInfo:
             bytes(std_hash(key.to_bytes(32, byteorder="big") + self.peer_info.get_key())[:8]),
             byteorder="big",
         )
-        hash1 = hash1 % TRIED_BUCKETS_PER_GROUP
+        hash1 %= TRIED_BUCKETS_PER_GROUP
         hash2 = int.from_bytes(
             bytes(std_hash(key.to_bytes(32, byteorder="big") + self.peer_info.get_group() + bytes([hash1]))[:8]),
             byteorder="big",
@@ -96,7 +96,7 @@ class ExtendedPeerInfo:
             bytes(std_hash(key.to_bytes(32, byteorder="big") + self.peer_info.get_group() + src_peer.get_group())[:8]),
             byteorder="big",
         )
-        hash1 = hash1 % NEW_BUCKETS_PER_SOURCE_GROUP
+        hash1 %= NEW_BUCKETS_PER_SOURCE_GROUP
         hash2 = int.from_bytes(
             bytes(std_hash(key.to_bytes(32, byteorder="big") + src_peer.get_group() + bytes([hash1]))[:8]),
             byteorder="big",
@@ -162,17 +162,17 @@ class ExtendedPeerInfo:
 class AddressManager:
     id_count: int
     key: int
-    random_pos: List[int]
-    tried_matrix: List[List[int]]
-    new_matrix: List[List[int]]
+    random_pos: list[int]
+    tried_matrix: list[list[int]]
+    new_matrix: list[list[int]]
     tried_count: int
     new_count: int
-    map_addr: Dict[str, int]
-    map_info: Dict[int, ExtendedPeerInfo]
+    map_addr: dict[str, int]
+    map_info: dict[int, ExtendedPeerInfo]
     last_good: int
-    tried_collisions: List[int]
-    used_new_matrix_positions: Set[Tuple[int, int]]
-    used_tried_matrix_positions: Set[Tuple[int, int]]
+    tried_collisions: list[int]
+    used_new_matrix_positions: set[tuple[int, int]]
+    used_tried_matrix_positions: set[tuple[int, int]]
     allow_private_subnets: bool
 
     def __init__(self) -> None:
@@ -230,7 +230,7 @@ class AddressManager:
                 if self.tried_matrix[bucket][pos] != -1:
                     self.used_tried_matrix_positions.add((bucket, pos))
 
-    def create_(self, addr: TimestampedPeerInfo, addr_src: Optional[PeerInfo]) -> Tuple[ExtendedPeerInfo, int]:
+    def create_(self, addr: TimestampedPeerInfo, addr_src: Optional[PeerInfo]) -> tuple[ExtendedPeerInfo, int]:
         self.id_count += 1
         node_id = self.id_count
         self.map_info[node_id] = ExtendedPeerInfo(addr, addr_src)
@@ -239,7 +239,7 @@ class AddressManager:
         self.random_pos.append(node_id)
         return (self.map_info[node_id], node_id)
 
-    def find_(self, addr: PeerInfo) -> Tuple[Optional[ExtendedPeerInfo], Optional[int]]:
+    def find_(self, addr: PeerInfo) -> tuple[Optional[ExtendedPeerInfo], Optional[int]]:
         if addr.host not in self.map_addr:
             return (None, None)
         node_id = self.map_addr[addr.host]
@@ -445,7 +445,7 @@ class AddressManager:
         if not new_only and self.tried_count > 0 and (self.new_count == 0 or randrange(2) == 0):
             chance = 1.0
             start = time.time()
-            cached_tried_matrix_positions: List[Tuple[int, int]] = []
+            cached_tried_matrix_positions: list[tuple[int, int]] = []
             if len(self.used_tried_matrix_positions) < math.sqrt(TRIED_BUCKET_COUNT * BUCKET_SIZE):
                 cached_tried_matrix_positions = list(self.used_tried_matrix_positions)
             while True:
@@ -475,7 +475,7 @@ class AddressManager:
         else:
             chance = 1.0
             start = time.time()
-            cached_new_matrix_positions: List[Tuple[int, int]] = []
+            cached_new_matrix_positions: list[tuple[int, int]] = []
             if len(self.used_new_matrix_positions) < math.sqrt(NEW_BUCKET_COUNT * BUCKET_SIZE):
                 cached_new_matrix_positions = list(self.used_new_matrix_positions)
             while True:
@@ -542,8 +542,8 @@ class AddressManager:
         old_id = self.tried_matrix[tried_bucket][tried_bucket_pos]
         return self.map_info[old_id]
 
-    def get_peers_(self) -> List[TimestampedPeerInfo]:
-        addr: List[TimestampedPeerInfo] = []
+    def get_peers_(self) -> list[TimestampedPeerInfo]:
+        addr: list[TimestampedPeerInfo] = []
         num_nodes = min(1000, math.ceil(23 * len(self.random_pos) / 100))
         for n in range(len(self.random_pos)):
             if len(addr) >= num_nodes:
@@ -596,7 +596,7 @@ class AddressManager:
 
     async def add_to_new_table(
         self,
-        addresses: List[TimestampedPeerInfo],
+        addresses: list[TimestampedPeerInfo],
         source: Optional[PeerInfo] = None,
         penalty: int = 0,
     ) -> bool:
@@ -647,7 +647,7 @@ class AddressManager:
             return self.select_peer_(new_only)
 
     # Return a bunch of addresses, selected at random.
-    async def get_peers(self) -> List[TimestampedPeerInfo]:
+    async def get_peers(self) -> list[TimestampedPeerInfo]:
         async with self.lock:
             return self.get_peers_()
 

chia/server/address_manager_store.py

@@ -5,7 +5,7 @@ import logging
 from dataclasses import dataclass
 from pathlib import Path
 from timeit import default_timer as timer
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import aiofiles
 
@@ -30,19 +30,19 @@ class PeerDataSerialization(Streamable):
     Serializable property bag for the peer data that was previously stored in sqlite.
     """
 
-    metadata: List[Tuple[str, str]]
-    nodes: List[Tuple[uint64, str]]
-    new_table: List[Tuple[uint64, uint64]]
+    metadata: list[tuple[str, str]]
+    nodes: list[tuple[uint64, str]]
+    new_table: list[tuple[uint64, uint64]]
 
 
 async def makePeerDataSerialization(
-    metadata: List[Tuple[str, Any]], nodes: List[Tuple[int, ExtendedPeerInfo]], new_table: List[Tuple[int, int]]
+    metadata: list[tuple[str, Any]], nodes: list[tuple[int, ExtendedPeerInfo]], new_table: list[tuple[int, int]]
 ) -> bytes:
     """
     Create a PeerDataSerialization, adapting the provided collections
     """
-    transformed_nodes: List[Tuple[uint64, str]] = []
-    transformed_new_table: List[Tuple[uint64, uint64]] = []
+    transformed_nodes: list[tuple[uint64, str]] = []
+    transformed_new_table: list[tuple[uint64, uint64]] = []
 
     for index, [node_id, peer_info] in enumerate(nodes):
         transformed_nodes.append((uint64(node_id), peer_info.to_string()))
@@ -101,10 +101,10 @@ class AddressManagerStore:
         """
         Serialize the address manager's peer data to a file.
         """
-        metadata: List[Tuple[str, str]] = []
-        nodes: List[Tuple[int, ExtendedPeerInfo]] = []
-        new_table_entries: List[Tuple[int, int]] = []
-        unique_ids: Dict[int, int] = {}
+        metadata: list[tuple[str, str]] = []
+        nodes: list[tuple[int, ExtendedPeerInfo]] = []
+        new_table_entries: list[tuple[int, int]] = []
+        unique_ids: dict[int, int] = {}
         count_ids: int = 0
 
         log.info("Serializing peer data")
@@ -157,11 +157,11 @@ class AddressManagerStore:
             log.exception(f"Unable to deserialize peers from {peers_file_path}")
 
         if peer_data is not None:
-            metadata: Dict[str, str] = {key: value for key, value in peer_data.metadata}
-            nodes: List[Tuple[int, ExtendedPeerInfo]] = [
+            metadata: dict[str, str] = {key: value for key, value in peer_data.metadata}
+            nodes: list[tuple[int, ExtendedPeerInfo]] = [
                 (node_id, ExtendedPeerInfo.from_string(info_str)) for node_id, info_str in peer_data.nodes
             ]
-            new_table_entries: List[Tuple[int, int]] = [(node_id, bucket) for node_id, bucket in peer_data.new_table]
+            new_table_entries: list[tuple[int, int]] = [(node_id, bucket) for node_id, bucket in peer_data.new_table]
             log.debug(f"Deserializing peer data took {timer() - start_time} seconds")
 
             address_manager.key = int(metadata["key"])
@@ -226,9 +226,9 @@ class AddressManagerStore:
     async def _write_peers(
         cls,
         peers_file_path: Path,
-        metadata: List[Tuple[str, Any]],
-        nodes: List[Tuple[int, ExtendedPeerInfo]],
-        new_table: List[Tuple[int, int]],
+        metadata: list[tuple[str, Any]],
+        nodes: list[tuple[int, ExtendedPeerInfo]],
+        new_table: list[tuple[int, int]],
     ) -> None:
         """
         Serializes the given peer data and writes it to the peers file.

chia/server/api_protocol.py

@@ -1,11 +1,116 @@
 from __future__ import annotations
 
+import functools
+import logging
+from collections.abc import Awaitable
+from dataclasses import dataclass, field
 from logging import Logger
+from typing import Callable, ClassVar, Optional, TypeVar, Union, final, get_type_hints
 
-from typing_extensions import Protocol
+from typing_extensions import Concatenate, ParamSpec, Protocol
+
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.outbound_message import Message
+from chia.util.streamable import Streamable
 
 
 class ApiProtocol(Protocol):
     log: Logger
+    metadata: ClassVar[ApiMetadata]
 
     def ready(self) -> bool: ...
+
+
+log = logging.getLogger(__name__)
+P = ParamSpec("P")
+R = TypeVar("R", bound=Awaitable[Optional[Message]])
+S = TypeVar("S", bound=Streamable)
+Self = TypeVar("Self")
+api_attribute_name = "_chia_api"
+
+
+@dataclass
+class ApiRequest:
+    request_type: ProtocolMessageTypes
+    message_class: type[Streamable]
+    method: Callable[..., Awaitable[Optional[Message]]]
+    peer_required: bool = False
+    bytes_required: bool = False
+    execute_task: bool = False
+    reply_types: list[ProtocolMessageTypes] = field(default_factory=list)
+
+
+@final
+@dataclass
+class ApiMetadata:
+    message_type_to_request: dict[ProtocolMessageTypes, ApiRequest] = field(default_factory=dict)
+
+    @classmethod
+    def copy(cls, original: ApiMetadata) -> ApiMetadata:
+        return cls(message_type_to_request=dict(original.message_type_to_request))
+
+    @classmethod
+    def from_bound_method(cls, method: Callable[..., Awaitable[Optional[Message]]]) -> ApiRequest:
+        self: ApiMetadata = getattr(method, api_attribute_name)
+        message_type = ProtocolMessageTypes[method.__name__]
+        return self.message_type_to_request[message_type]
+
+    # TODO: This hinting does not express that the returned callable *_bytes parameter
+    #       corresponding to the first parameter name will be filled in by the wrapper.
+    def request(
+        self,
+        peer_required: bool = False,
+        bytes_required: bool = False,
+        execute_task: bool = False,
+        reply_types: Optional[list[ProtocolMessageTypes]] = None,
+        request_type: Optional[ProtocolMessageTypes] = None,
+    ) -> Callable[[Callable[Concatenate[Self, S, P], R]], Callable[Concatenate[Self, Union[bytes, S], P], R]]:
+        non_optional_reply_types: list[ProtocolMessageTypes]
+        if reply_types is None:
+            non_optional_reply_types = []
+        else:
+            non_optional_reply_types = reply_types
+
+        def inner(f: Callable[Concatenate[Self, S, P], R]) -> Callable[Concatenate[Self, Union[bytes, S], P], R]:
+            @functools.wraps(f)
+            def wrapper(self: Self, original: Union[bytes, S], *args: P.args, **kwargs: P.kwargs) -> R:
+                arg: S
+                if isinstance(original, bytes):
+                    if request.bytes_required:
+                        kwargs[message_name_bytes] = original
+                    arg = message_class.from_bytes(original)
+                else:
+                    arg = original
+                    if request.bytes_required:
+                        kwargs[message_name_bytes] = bytes(original)
+
+                return f(self, arg, *args, **kwargs)
+
+            setattr(wrapper, api_attribute_name, self)
+            message_name, message_class = next(
+                (name, hint) for name, hint in get_type_hints(f).items() if name not in {"self", "peer", "return"}
+            )
+            message_name_bytes = f"{message_name}_bytes"
+
+            nonlocal request_type
+            if request_type is None:
+                request_type = ProtocolMessageTypes[f.__name__]
+
+            request = ApiRequest(
+                request_type=request_type,
+                peer_required=peer_required,
+                bytes_required=bytes_required,
+                execute_task=execute_task,
+                reply_types=non_optional_reply_types,
+                message_class=message_class,
+                method=wrapper,
+            )
+
+            if request_type in self.message_type_to_request:
+                raise Exception(f"request type already registered: {request_type}")
+
+            self.message_type_to_request[request_type] = request
+
+            return wrapper
+
+        return inner

chia/server/capabilities.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
-from typing import Iterable, List, Set, Tuple
+from collections.abc import Iterable
 
 from chia.protocols.shared_protocol import Capability
 from chia.util.ints import uint16
 
 
-def known_active_capabilities(values: Iterable[Tuple[uint16, str]]) -> List[Capability]:
+def known_active_capabilities(values: Iterable[tuple[uint16, str]]) -> list[Capability]:
     # NOTE: order is not guaranteed
     # TODO: what if there's a claim for both supporting and not?
     #       presently it considers it supported
-    filtered: Set[Capability] = set()
+    filtered: set[Capability] = set()
     for value, state in values:
         if state != "1":
             continue

chia/server/chia_policy.py

@@ -11,7 +11,8 @@ if sys.platform == "win32":
     import _overlapped
     import _winapi
 
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Tuple, Union
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 
 from typing_extensions import Protocol, TypeAlias
 
@@ -30,7 +31,7 @@ if TYPE_CHECKING:
         # https://github.com/python/typeshed/pull/5718/files
         def __call__(self) -> asyncio.protocols.BaseProtocol: ...
 
-    _SSLContext: TypeAlias = Union[bool, None, ssl.SSLContext]
+    _SSLContext: TypeAlias = Union[bool, ssl.SSLContext, None]
 
     # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/base_events.py#L389
     # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/base_events.pyi#L64
@@ -83,7 +84,7 @@ if TYPE_CHECKING:
                 self,
                 ov: _overlapped.Overlapped,
                 obj: socket.socket,
-                callback: Callable[[object, socket.socket, _overlapped.Overlapped], Tuple[socket.socket, object]],
+                callback: Callable[[object, socket.socket, _overlapped.Overlapped], tuple[socket.socket, object]],
             ) -> _OverlappedFuture: ...
 
             def _get_accept_socket(self, family: socket.AddressFamily) -> socket.socket: ...
@@ -251,30 +252,30 @@ if sys.platform == "win32":
         def disable_connections(self) -> None:
             self.allow_connections = False
 
-        async def _chia_accept_loop(self, listener: socket.socket) -> Tuple[socket.socket, Tuple[object, ...]]:
+        async def _chia_accept_loop(self, listener: socket.socket) -> tuple[socket.socket, tuple[object, ...]]:
             while True:
-                # TODO: switch to Event code.
-                while not self.allow_connections:
+                # TODO: switch to event drive code
+                while not self.allow_connections:  # noqa: ASYNC110
                     await asyncio.sleep(0.01)
 
                 try:
                     return await self._chia_accept(listener)
                 except OSError as exc:
-                    if exc.winerror not in (  # pylint: disable=E1101
+                    if exc.winerror not in {
                         _winapi.ERROR_NETNAME_DELETED,
                         _winapi.ERROR_OPERATION_ABORTED,
-                    ):
+                    }:
                         raise
 
-        def _chia_accept(self, listener: socket.socket) -> asyncio.Future[Tuple[socket.socket, Tuple[object, ...]]]:
+        def _chia_accept(self, listener: socket.socket) -> asyncio.Future[tuple[socket.socket, tuple[object, ...]]]:
             self._register_with_iocp(listener)
-            conn = self._get_accept_socket(listener.family)  # pylint: disable=assignment-from-no-return
+            conn = self._get_accept_socket(listener.family)
             ov = _overlapped.Overlapped(_winapi.NULL)
             ov.AcceptEx(listener.fileno(), conn.fileno())
 
             def finish_accept(
                 trans: object, key: socket.socket, ov: _overlapped.Overlapped
-            ) -> Tuple[socket.socket, object]:
+            ) -> tuple[socket.socket, object]:
                 ov.getresult()
                 # Use SO_UPDATE_ACCEPT_CONTEXT so getsockname() etc work.
                 buf = struct.pack("@P", listener.fileno())
@@ -291,18 +292,18 @@ if sys.platform == "win32":
                     raise
                 except OSError as exc:
                     # https://github.com/python/cpython/issues/93821#issuecomment-1157945855
-                    if exc.winerror not in (  # pylint: disable=E1101
+                    if exc.winerror not in {
                         _winapi.ERROR_NETNAME_DELETED,
                         _winapi.ERROR_OPERATION_ABORTED,
-                    ):
+                    }:
                         raise
 
-            future = self._register(ov, listener, finish_accept)  # pylint: disable=assignment-from-no-return
+            future = self._register(ov, listener, finish_accept)
             coro = accept_coro(self, future, conn)
-            asyncio.ensure_future(coro, loop=self._loop)
+            asyncio.ensure_future(coro, loop=self._loop)  # noqa: RUF006
             return future
 
-        def accept(self, listener: socket.socket) -> asyncio.Future[Tuple[socket.socket, Tuple[object, ...]]]:
+        def accept(self, listener: socket.socket) -> asyncio.Future[tuple[socket.socket, tuple[object, ...]]]:
             coro = self._chia_accept_loop(listener)
             return asyncio.ensure_future(coro)
 

chia/server/introducer_peers.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import random
 import time
 from dataclasses import dataclass
-from typing import List, Optional, Set
+from typing import Optional
 
 from chia.types.peer_info import PeerInfo
 from chia.util.ints import uint16, uint64
@@ -40,7 +40,7 @@ class IntroducerPeers:
     """
 
     def __init__(self) -> None:
-        self._peers: Set[VettedPeer] = set()
+        self._peers: set[VettedPeer] = set()
 
     def add(self, peer: Optional[PeerInfo]) -> bool:
         if peer is None or not peer.port:
@@ -66,7 +66,7 @@ class IntroducerPeers:
 
     def get_peers(
         self, max_peers: int = 0, randomize: bool = False, recent_threshold: float = 9999999
-    ) -> List[VettedPeer]:
+    ) -> list[VettedPeer]:
         target_peers = [peer for peer in self._peers if time.time() - float(peer.time_added) < recent_threshold]
         if not max_peers or max_peers > len(target_peers):
             max_peers = len(target_peers)