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

chia/server/api_protocol.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import functools
 import logging
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from logging import Logger
-from typing import Callable, ClassVar, Optional, TypeVar, Union, final, get_type_hints
+from typing import ClassVar, Concatenate, TypeVar, final, get_type_hints
 
-from typing_extensions import Concatenate, ParamSpec, Protocol
+from typing_extensions import ParamSpec, Protocol
 
 from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
@@ -23,7 +23,7 @@ class ApiProtocol(Protocol):
 
 log = logging.getLogger(__name__)
 P = ParamSpec("P")
-R = TypeVar("R", bound=Awaitable[Optional[Message]])
+R = TypeVar("R", bound=Awaitable[Message | None])
 S = TypeVar("S", bound=Streamable)
 Self = TypeVar("Self")
 api_attribute_name = "_chia_api"
@@ -33,7 +33,7 @@ api_attribute_name = "_chia_api"
 class ApiRequest:
     request_type: ProtocolMessageTypes
     message_class: type[Streamable]
-    method: Callable[..., Awaitable[Optional[Message]]]
+    method: Callable[..., Awaitable[Message | None]]
     peer_required: bool = False
     bytes_required: bool = False
     execute_task: bool = False
@@ -50,7 +50,7 @@ class 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:
+    def from_bound_method(cls, method: Callable[..., Awaitable[Message | None]]) -> ApiRequest:
         self: ApiMetadata = getattr(method, api_attribute_name)
         message_type = ProtocolMessageTypes[method.__name__]
         return self.message_type_to_request[message_type]
@@ -62,18 +62,18 @@ class ApiMetadata:
         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]]:
+        reply_types: list[ProtocolMessageTypes] | None = None,
+        request_type: ProtocolMessageTypes | None = None,
+    ) -> Callable[[Callable[Concatenate[Self, S, P], R]], Callable[Concatenate[Self, 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]:
+        def inner(f: Callable[Concatenate[Self, S, P], R]) -> Callable[Concatenate[Self, bytes | S, P], R]:
             @functools.wraps(f)
-            def wrapper(self: Self, original: Union[bytes, S], *args: P.args, **kwargs: P.kwargs) -> R:
+            def wrapper(self: Self, original: bytes | S, *args: P.args, **kwargs: P.kwargs) -> R:
                 arg: S
                 if isinstance(original, bytes):
                     if request.bytes_required:

chia/server/chia_policy.py

@@ -6,15 +6,16 @@ import socket
 import ssl
 import struct
 import sys
+import weakref
 
 if sys.platform == "win32":
     import _overlapped  # type: ignore[import-not-found]
     import _winapi
 
-from collections.abc import Iterable
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Any, TypeAlias
 
-from typing_extensions import Protocol, TypeAlias
+from typing_extensions import Protocol
 
 # https://github.com/python/asyncio/pull/448
 global_max_concurrent_connections: int = 250
@@ -31,7 +32,7 @@ if TYPE_CHECKING:
         # https://github.com/python/typeshed/pull/5718/files
         def __call__(self) -> asyncio.protocols.BaseProtocol: ...
 
-    _SSLContext: TypeAlias = Union[bool, ssl.SSLContext, None]
+    _SSLContext: TypeAlias = 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
@@ -42,11 +43,11 @@ if TYPE_CHECKING:
             self,
             protocol_factory: _ProtocolFactory,
             sock: socket.socket,
-            sslcontext: Optional[_SSLContext] = ...,
-            server: Optional[asyncio.base_events.Server] = ...,
+            sslcontext: _SSLContext | None = ...,
+            server: asyncio.base_events.Server | None = ...,
             backlog: int = ...,
             # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/constants.py#L16
-            ssl_handshake_timeout: Optional[float] = ...,
+            ssl_handshake_timeout: float | None = ...,
         ) -> None: ...
 
     # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/base_events.py#L278
@@ -57,15 +58,26 @@ if TYPE_CHECKING:
         else:
             _loop: EventsAbstractEventLoop
         _sockets: Iterable[socket.socket]
-        _active_count: int
+        if sys.version_info >= (3, 13):
+            # https://github.com/python/cpython/blob/v3.13.7/Lib/asyncio/base_events.py#L283
+            _clients: weakref.WeakSet[object]
+        else:
+            _active_count: int
         _protocol_factory: _ProtocolFactory
         _backlog: int
         _ssl_context: _SSLContext
-        _ssl_handshake_timeout: Optional[float]
+        _ssl_handshake_timeout: float | None
+
+        if sys.version_info >= (3, 13):
+            # https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Lib/asyncio/base_events.py#L296
+            def _attach(self, transport: object) -> None: ...
+
+            def _detach(self, transport: object) -> None: ...
+        else:
 
-        def _attach(self) -> None: ...
+            def _attach(self) -> None: ...
 
-        def _detach(self) -> None: ...
+            def _detach(self) -> None: ...
 
         def _start_serving(self) -> None: ...
 
@@ -76,7 +88,7 @@ if TYPE_CHECKING:
         # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/windows_events.py#L410
         # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/windows_events.pyi#L44
         class IocpProactor(asyncio.windows_events.IocpProactor):
-            _loop: Optional[asyncio.events.AbstractEventLoop]
+            _loop: asyncio.events.AbstractEventLoop | None
 
             def _register_with_iocp(self, obj: object) -> None: ...
 
@@ -116,8 +128,8 @@ class PausableServer(BaseEventsServer):
         protocol_factory: _ProtocolFactory,
         ssl_context: _SSLContext,
         backlog: int,
-        ssl_handshake_timeout: Optional[float],
-        max_concurrent_connections: Optional[int] = None,
+        ssl_handshake_timeout: float | None,
+        max_concurrent_connections: int | None = None,
     ) -> None:
         super().__init__(
             loop=loop,
@@ -132,20 +144,22 @@ class PausableServer(BaseEventsServer):
             max_concurrent_connections if max_concurrent_connections is not None else global_max_concurrent_connections
         )
 
-    def _attach(self) -> None:
-        super()._attach()
-        logging.getLogger(__name__).debug(f"New connection. Total connections: {self._active_count}")
-        if not self._paused and self._active_count >= self.max_concurrent_connections:
+    def _attach(self, *args: object, **kwargs: object) -> None:
+        super()._attach(*args, **kwargs)
+        active_connections = self._chia_active_connections()
+        logging.getLogger(__name__).debug(f"New connection. Total connections: {active_connections}")
+        if not self._paused and active_connections >= self.max_concurrent_connections:
             self._chia_pause()
 
-    def _detach(self) -> None:
-        super()._detach()
-        logging.getLogger(__name__).debug(f"Connection lost. Total connections: {self._active_count}")
+    def _detach(self, *args: object, **kwargs: object) -> None:
+        super()._detach(*args, **kwargs)
+        active_connections = self._chia_active_connections()
+        logging.getLogger(__name__).debug(f"Connection lost. Total connections: {active_connections}")
         if (
-            self._active_count > 0
+            active_connections > 0
             and self._sockets is not None
             and self._paused
-            and self._active_count < self.max_concurrent_connections
+            and active_connections < self.max_concurrent_connections
         ):
             self._chia_resume()
 
@@ -180,6 +194,12 @@ class PausableServer(BaseEventsServer):
                 )
         logging.getLogger(__name__).debug("Resumed accepting connections.")
 
+    def _chia_active_connections(self) -> int:
+        if sys.version_info >= (3, 13):
+            return len(self._clients)
+        else:
+            return self._active_count
+
 
 async def _chia_create_server(
     cls: Any,
@@ -192,9 +212,9 @@ async def _chia_create_server(
     sock: Any = None,
     backlog: int = 100,
     ssl: _SSLContext = None,
-    reuse_address: Optional[bool] = None,
-    reuse_port: Optional[bool] = None,
-    ssl_handshake_timeout: Optional[float] = 30,
+    reuse_address: bool | None = None,
+    reuse_port: bool | None = None,
+    ssl_handshake_timeout: float | None = 30,
     start_serving: bool = True,
 ) -> PausableServer:
     server: BaseEventsServer = await cls.create_server(

chia/server/introducer_peers.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import random
 import time
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs.sized_ints import uint16, uint64
 
@@ -43,7 +42,7 @@ class IntroducerPeers:
     def __init__(self) -> None:
         self._peers: set[VettedPeer] = set()
 
-    def add(self, peer: Optional[PeerInfo]) -> bool:
+    def add(self, peer: PeerInfo | None) -> bool:
         if peer is None or not peer.port:
             return False
 
@@ -56,7 +55,7 @@ class IntroducerPeers:
         self._peers.add(p)
         return True
 
-    def remove(self, peer: Optional[VettedPeer]) -> bool:
+    def remove(self, peer: VettedPeer | None) -> bool:
         if peer is None or not peer.port:
             return False
         try:

chia/server/node_discovery.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass, field
 from logging import Logger
 from pathlib import Path
 from random import Random
-from typing import Any, Optional
+from typing import Any
 
 import dns.asyncresolver
 from chia_rs.sized_ints import uint16, uint64
@@ -51,24 +51,24 @@ class FullNodeDiscovery:
     peer_connect_interval: int
     selected_network: str
     log: Logger
-    introducer_info: Optional[dict[str, Any]] = None
-    default_port: Optional[int] = None
-    resolver: Optional[dns.asyncresolver.Resolver] = field(default=None)
+    introducer_info: dict[str, Any] | None = None
+    default_port: int | None = None
+    resolver: dns.asyncresolver.Resolver | None = field(default=None)
     enable_private_networks: bool = field(default=False)
     is_closed: bool = field(default=False)
     legacy_peer_db_migrated: bool = field(default=False)
-    relay_queue: Optional[asyncio.Queue[tuple[TimestampedPeerInfo, int]]] = field(default=None)
-    address_manager: Optional[AddressManager] = field(default=None)
+    relay_queue: asyncio.Queue[tuple[TimestampedPeerInfo, int]] | None = field(default=None)
+    address_manager: AddressManager | None = field(default=None)
     connection_time_pretest: dict[str, Any] = field(default_factory=dict)
     received_count_from_peers: dict[str, Any] = field(default_factory=dict)
     lock: asyncio.Lock = field(default_factory=asyncio.Lock)
-    connect_peers_task: Optional[asyncio.Task[None]] = field(default=None)
-    serialize_task: Optional[asyncio.Task[None]] = field(default=None)
-    cleanup_task: Optional[asyncio.Task[None]] = field(default=None)
+    connect_peers_task: asyncio.Task[None] | None = field(default=None)
+    serialize_task: asyncio.Task[None] | None = field(default=None)
+    cleanup_task: asyncio.Task[None] | None = field(default=None)
     initial_wait: int = field(default=0)
     pending_outbound_connections: set[str] = field(default_factory=set)
     pending_tasks: set[asyncio.Task[None]] = field(default_factory=set)
-    introducer_info_obj: Optional[UnresolvedPeerInfo] = field(default=None)
+    introducer_info_obj: UnresolvedPeerInfo | None = field(default=None)
 
     def __post_init__(self) -> None:
         random.shuffle(self.dns_servers)  # Don't always start with the same DNS server
@@ -245,7 +245,7 @@ class FullNodeDiscovery:
         retry_introducers = False
         dns_server_index: int = 0
         tried_all_dns_servers: bool = False
-        local_peerinfo: Optional[PeerInfo] = await self.server.get_peer_info()
+        local_peerinfo: PeerInfo | None = await self.server.get_peer_info()
         last_timestamp_local_info: uint64 = uint64(time.time())
         last_collision_timestamp = 0
 
@@ -327,7 +327,7 @@ class FullNodeDiscovery:
                 tries = 0
                 now = time.time()
                 got_peer = False
-                addr: Optional[PeerInfo] = None
+                addr: PeerInfo | None = None
                 max_tries = 50
                 if len(groups) < 3:
                     max_tries = 10
@@ -345,7 +345,7 @@ class FullNodeDiscovery:
                         addr = None
                         retry_introducers = True
                         break
-                    info: Optional[ExtendedPeerInfo] = await self.address_manager.select_tried_collision()
+                    info: ExtendedPeerInfo | None = await self.address_manager.select_tried_collision()
                     if info is None or time.time() - last_collision_timestamp <= 60:
                         info = await self.address_manager.select_peer(is_feeler)
                     else:
@@ -440,7 +440,7 @@ class FullNodeDiscovery:
         return port in NETWORK_ID_DEFAULT_PORTS.values() and port != self.default_port
 
     async def _add_peers_common(
-        self, peer_list: list[TimestampedPeerInfo], peer_src: Optional[PeerInfo], is_full_node: bool
+        self, peer_list: list[TimestampedPeerInfo], peer_src: PeerInfo | None, is_full_node: bool
     ) -> None:
         # Check if we got the peers from a full node or from the introducer.
         peers_adjusted_timestamp = []
@@ -488,8 +488,8 @@ class FullNodeDiscovery:
 
 @dataclass
 class FullNodePeers(FullNodeDiscovery):
-    self_advertise_task: Optional[asyncio.Task[None]] = field(default=None)
-    address_relay_task: Optional[asyncio.Task[None]] = field(default=None)
+    self_advertise_task: asyncio.Task[None] | None = field(default=None)
+    address_relay_task: asyncio.Task[None] | None = field(default=None)
     relay_queue: asyncio.Queue[tuple[TimestampedPeerInfo, int]] = field(default_factory=asyncio.Queue)
     neighbour_known_peers: dict[PeerInfo, set[str]] = field(default_factory=dict)
     key: int = field(default_factory=lambda: random.getrandbits(256))
@@ -557,7 +557,7 @@ class FullNodePeers(FullNodeDiscovery):
                 if peer.host not in self.neighbour_known_peers[neighbour_info]:
                     self.neighbour_known_peers[neighbour_info].add(peer.host)
 
-    async def request_peers(self, peer_info: PeerInfo) -> Optional[Message]:
+    async def request_peers(self, peer_info: PeerInfo) -> Message | None:
         try:
             # Prevent a fingerprint attack: do not send peers to inbound connections.
             # This asymmetric behavior for inbound and outbound connections was introduced
@@ -582,7 +582,7 @@ class FullNodePeers(FullNodeDiscovery):
             return None
 
     async def add_peers(
-        self, peer_list: list[TimestampedPeerInfo], peer_src: Optional[PeerInfo], is_full_node: bool
+        self, peer_list: list[TimestampedPeerInfo], peer_src: PeerInfo | None, is_full_node: bool
     ) -> None:
         try:
             await self._add_peers_common(peer_list, peer_src, is_full_node)
@@ -671,6 +671,6 @@ class WalletPeers(FullNodeDiscovery):
         await self._close_common()
 
     async def add_peers(
-        self, peer_list: list[TimestampedPeerInfo], peer_src: Optional[PeerInfo], is_full_node: bool
+        self, peer_list: list[TimestampedPeerInfo], peer_src: PeerInfo | None, is_full_node: bool
     ) -> None:
         await self._add_peers_common(peer_list, peer_src, is_full_node)

chia/server/rate_limit_numbers.py

@@ -2,12 +2,11 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Optional, Union
 
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
 
-compose_rate_limits_cache: dict[int, dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]] = {}
+compose_rate_limits_cache: dict[int, dict[ProtocolMessageTypes, RLSettings | Unlimited]] = {}
 
 
 # this class is used to configure the *rate* limit for a message type. The
@@ -19,7 +18,7 @@ class RLSettings:
     aggregate_limit: bool
     frequency: int  # Max request per time period (ie 1 min)
     max_size: int  # Max size of each request
-    max_total_size: Optional[int] = None  # Max cumulative size of all requests in that period
+    max_total_size: int | None = None  # Max cumulative size of all requests in that period
 
 
 # this class is used to indicate that a message type is not subject to a rate
@@ -43,7 +42,7 @@ aggregate_limit = RLSettings(
 
 def get_rate_limits_to_use(
     our_capabilities: list[Capability], peer_capabilities: list[Capability]
-) -> tuple[dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]], RLSettings]:
+) -> tuple[dict[ProtocolMessageTypes, RLSettings | Unlimited], RLSettings]:
     # This will use the newest possible rate limits that both peers support. At this time there are only two
     # options, v1 and v2.
 
@@ -64,7 +63,7 @@ def get_rate_limits_to_use(
 
 # Each number in this dict corresponds to a specific version of rate limits (1, 2,  etc).
 # Version 1 includes the original limits for chia software from versions 1.0 to 1.4.
-rate_limits: dict[int, dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]] = {
+rate_limits: dict[int, dict[ProtocolMessageTypes, RLSettings | Unlimited]] = {
     1: {
         ProtocolMessageTypes.new_transaction: RLSettings(False, 5000, 100, 5000 * 100),
         ProtocolMessageTypes.request_transaction: RLSettings(False, 5000, 100, 5000 * 100),

chia/server/rate_limits.py

@@ -4,7 +4,7 @@ import dataclasses
 import logging
 import time
 from collections import Counter
-from typing import Callable, Optional, Union
+from collections.abc import Callable
 
 from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
@@ -53,7 +53,7 @@ class RateLimiter:
 
     def process_msg_and_check(
         self, message: Message, our_capabilities: list[Capability], peer_capabilities: list[Capability]
-    ) -> Optional[str]:
+    ) -> str | None:
         """
         Returns a string indicating which limit was hit if a rate limit is
         exceeded, and the message should be blocked. Returns None if the limit was not
@@ -80,11 +80,11 @@ class RateLimiter:
         proportion_of_limit: float = self.percentage_of_limit / 100
 
         ret: bool = False
-        rate_limits: dict[ProtocolMessageTypes, Union[RLSettings, Unlimited]]
+        rate_limits: dict[ProtocolMessageTypes, RLSettings | Unlimited]
         rate_limits, agg_limit = get_rate_limits_to_use(our_capabilities, peer_capabilities)
 
         try:
-            limits: Union[RLSettings, Unlimited] = rate_limits[message_type]
+            limits: RLSettings | Unlimited = rate_limits[message_type]
             if isinstance(limits, RLSettings) and limits.aggregate_limit:
                 non_tx_freq = agg_limit.frequency
                 assert agg_limit.max_total_size is not None

chia/server/resolve_peer_info.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional
+from typing import Any
 
 from chia.protocols.outbound_message import NodeType
 from chia.types.peer_info import UnresolvedPeerInfo
@@ -18,7 +18,7 @@ PEER_INFO_MAPPING: dict[NodeType, str] = {
 def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeType) -> set[UnresolvedPeerInfo]:
     peer_info_key = PEER_INFO_MAPPING[peer_type]
     peer_infos: list[dict[str, Any]] = service_config.get(f"{peer_info_key}s", [])
-    peer_info: Optional[dict[str, Any]] = service_config.get(peer_info_key)
+    peer_info: dict[str, Any] | None = service_config.get(peer_info_key)
     if peer_info is not None:
         peer_infos.append(peer_info)
 
@@ -32,8 +32,8 @@ def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeTyp
 def set_peer_info(
     service_config: dict[str, Any],
     peer_type: NodeType,
-    peer_host: Optional[str] = None,
-    peer_port: Optional[int] = None,
+    peer_host: str | None = None,
+    peer_port: int | None = None,
 ) -> None:
     peer_info_key = PEER_INFO_MAPPING[peer_type]
     if peer_info_key in service_config: