chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/rpc/rpc_server.py

@@ -6,12 +6,12 @@ import json
 import logging
 import sys
 import traceback
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass
 from pathlib import Path
 from ssl import SSLContext
 from types import MethodType
-from typing import Any, Callable, ClassVar, Generic, Optional, TypeVar
+from typing import Any, ClassVar, Generic, TypeVar
 
 from aiohttp import (
     ClientConnectorError,
@@ -57,7 +57,7 @@ _T_RpcApiProtocol = TypeVar("_T_RpcApiProtocol", bound="RpcApiProtocol")
 
 
 class StateChangedProtocol(Protocol):
-    def __call__(self, change: str, change_data: Optional[dict[str, Any]]) -> None: ...
+    def __call__(self, change: str, change_data: dict[str, Any] | None) -> None: ...
 
 
 class RpcServiceProtocol(Protocol):
@@ -75,7 +75,7 @@ class RpcServiceProtocol(Protocol):
         # Optional[ChiaServer]
         ...
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         """Report the active connections for the service.
 
         A default implementation is available and can be called as
@@ -115,12 +115,12 @@ class RpcApiProtocol(Protocol):
         """Return the mapping of endpoints to handler callables."""
         ...
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None) -> list[WsRpcMessage]:
         """Notify the state change system of a changed state."""
         ...
 
 
-def default_get_connections(server: ChiaServer, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+def default_get_connections(server: ChiaServer, request_node_type: NodeType | None) -> list[dict[str, Any]]:
     connections = server.get_connections(request_node_type)
     con_info = [
         {
@@ -154,12 +154,12 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
     ssl_client_context: SSLContext
     net_config: dict[str, Any]
     service_config: dict[str, Any]
-    webserver: Optional[WebServer] = None
+    webserver: WebServer | None = None
     daemon_heartbeat: int = 300
-    daemon_connection_task: Optional[asyncio.Task[None]] = None
+    daemon_connection_task: asyncio.Task[None] | None = None
     shut_down: bool = False
-    websocket: Optional[ClientWebSocketResponse] = None
-    client_session: Optional[ClientSession] = None
+    websocket: ClientWebSocketResponse | None = None
+    client_session: ClientSession | None = None
     prefer_ipv6: bool = False
 
     @classmethod
@@ -220,7 +220,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             await self.daemon_connection_task
             self.daemon_connection_task = None
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]]) -> None:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None) -> None:
         if self.websocket is None or self.websocket.closed:
             return None
         payloads: list[WsRpcMessage] = await self.rpc_api._state_changed(change, change_data)
@@ -246,7 +246,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
                 tb = traceback.format_exc()
                 log.warning(f"Sending data failed. Exception {tb}.")
 
-    def state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
+    def state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> None:
         if self.websocket is None or self.websocket.closed:
             return None
         create_referenced_task(self._state_changed(change, change_data), known_unreferenced=True)
@@ -280,7 +280,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
         }
 
     async def get_connections(self, request: dict[str, Any]) -> EndpointResult:
-        request_node_type: Optional[NodeType] = None
+        request_node_type: NodeType | None = None
         if "node_type" in request:
             request_node_type = NodeType(request["node_type"])
         if self.rpc_api.service.server is None:
@@ -361,7 +361,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             "errors": error_strings,
         }
 
-    async def ws_api(self, message: WsRpcMessage) -> Optional[dict[str, object]]:
+    async def ws_api(self, message: WsRpcMessage) -> dict[str, object] | None:
         """
         This function gets called when new message is received via websocket.
         """
@@ -376,10 +376,10 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
         if command == "ping":
             return pong()
 
-        f_internal: Optional[Endpoint] = getattr(self, command, None)
+        f_internal: Endpoint | None = getattr(self, command, None)
         if f_internal is not None:
             return await f_internal(data)
-        f_rpc_api: Optional[Endpoint] = getattr(self.rpc_api, command, None)
+        f_rpc_api: Endpoint | None = getattr(self.rpc_api, command, None)
         if f_rpc_api is not None:
             return await f_rpc_api(data)
 
@@ -487,7 +487,7 @@ async def start_rpc_server(
     net_config: dict[str, object],
     service_config: dict[str, object],
     connect_to_daemon: bool = True,
-    max_request_body_size: Optional[int] = None,
+    max_request_body_size: int | None = None,
 ) -> RpcServer[_T_RpcApiProtocol]:
     """
     Starts an HTTP server with the following RPC methods, to be used by local clients to

chia/rpc/util.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 import logging
 import traceback
-from collections.abc import Awaitable
-from typing import TYPE_CHECKING, Any, Callable, get_type_hints
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any, get_type_hints
 
 import aiohttp
 

chia/seeder/crawler.py

@@ -7,10 +7,10 @@ import logging
 import time
 import traceback
 from collections import defaultdict
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import aiosqlite
 from chia_rs import ConsensusConstants
@@ -45,10 +45,10 @@ class Crawler:
     root_path: Path
     constants: ConsensusConstants
     print_status: bool = True
-    state_changed_callback: Optional[StateChangedProtocol] = None
-    _server: Optional[ChiaServer] = None
-    crawl_task: Optional[asyncio.Task[None]] = None
-    crawl_store: Optional[CrawlStore] = None
+    state_changed_callback: StateChangedProtocol | None = None
+    _server: ChiaServer | None = None
+    crawl_task: asyncio.Task[None] | None = None
+    crawl_store: CrawlStore | None = None
     log: logging.Logger = log
     _shut_down: bool = False
     peer_count: int = 0
@@ -118,7 +118,7 @@ class Crawler:
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.state_changed_callback = callback
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def create_client(
@@ -322,7 +322,7 @@ class Crawler:
     def set_server(self, server: ChiaServer) -> None:
         self._server = server
 
-    def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> None:
+    def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> None:
         if self.state_changed_callback is not None:
             self.state_changed_callback(change, change_data)
 

chia/seeder/crawler_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia.protocols import full_node_protocol, wallet_protocol
 from chia.protocols.outbound_message import Message
@@ -34,76 +34,70 @@ class CrawlerAPI:
         return True
 
     @metadata.request(peer_required=True)
-    async def request_peers(
-        self, _request: full_node_protocol.RequestPeers, peer: WSChiaConnection
-    ) -> Optional[Message]:
+    async def request_peers(self, _request: full_node_protocol.RequestPeers, peer: WSChiaConnection) -> Message | None:
         pass
 
     @metadata.request(peer_required=True)
-    async def respond_peers(
-        self, request: full_node_protocol.RespondPeers, peer: WSChiaConnection
-    ) -> Optional[Message]:
+    async def respond_peers(self, request: full_node_protocol.RespondPeers, peer: WSChiaConnection) -> Message | None:
         pass
 
     @metadata.request(peer_required=True)
-    async def new_peak(self, request: full_node_protocol.NewPeak, peer: WSChiaConnection) -> Optional[Message]:
+    async def new_peak(self, request: full_node_protocol.NewPeak, peer: WSChiaConnection) -> Message | None:
         await self.crawler.new_peak(request, peer)
         return None
 
     @metadata.request()
-    async def new_transaction(self, transaction: full_node_protocol.NewTransaction) -> Optional[Message]:
+    async def new_transaction(self, transaction: full_node_protocol.NewTransaction) -> Message | None:
         pass
 
     @metadata.request(peer_required=True)
     async def new_signage_point_or_end_of_sub_slot(
         self, new_sp: full_node_protocol.NewSignagePointOrEndOfSubSlot, peer: WSChiaConnection
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request()
-    async def new_unfinished_block(
-        self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock
-    ) -> Optional[Message]:
+    async def new_unfinished_block(self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock) -> Message | None:
         pass
 
     @metadata.request()
     async def new_unfinished_block2(
         self, new_unfinished_block: full_node_protocol.NewUnfinishedBlock2
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request(peer_required=True)
     async def new_compact_vdf(
         self, request: full_node_protocol.NewCompactVDF, peer: WSChiaConnection
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_transaction(self, request: full_node_protocol.RequestTransaction) -> Optional[Message]:
+    async def request_transaction(self, request: full_node_protocol.RequestTransaction) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_proof_of_weight(self, request: full_node_protocol.RequestProofOfWeight) -> Optional[Message]:
+    async def request_proof_of_weight(self, request: full_node_protocol.RequestProofOfWeight) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_block(self, request: full_node_protocol.RequestBlock) -> Optional[Message]:
+    async def request_block(self, request: full_node_protocol.RequestBlock) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_blocks(self, request: full_node_protocol.RequestBlocks) -> Optional[Message]:
+    async def request_blocks(self, request: full_node_protocol.RequestBlocks) -> Message | None:
         pass
 
     @metadata.request()
     async def request_unfinished_block(
         self, request_unfinished_block: full_node_protocol.RequestUnfinishedBlock
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request()
     async def request_signage_point_or_end_of_sub_slot(
         self, request: full_node_protocol.RequestSignagePointOrEndOfSubSlot
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request(peer_required=True)
@@ -111,25 +105,25 @@ class CrawlerAPI:
         self,
         request: full_node_protocol.RequestMempoolTransactions,
         peer: WSChiaConnection,
-    ) -> Optional[Message]:
+    ) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_block_header(self, request: wallet_protocol.RequestBlockHeader) -> Optional[Message]:
+    async def request_block_header(self, request: wallet_protocol.RequestBlockHeader) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_additions(self, request: wallet_protocol.RequestAdditions) -> Optional[Message]:
+    async def request_additions(self, request: wallet_protocol.RequestAdditions) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_removals(self, request: wallet_protocol.RequestRemovals) -> Optional[Message]:
+    async def request_removals(self, request: wallet_protocol.RequestRemovals) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_puzzle_solution(self, request: wallet_protocol.RequestPuzzleSolution) -> Optional[Message]:
+    async def request_puzzle_solution(self, request: wallet_protocol.RequestPuzzleSolution) -> Message | None:
         pass
 
     @metadata.request()
-    async def request_header_blocks(self, request: wallet_protocol.RequestHeaderBlocks) -> Optional[Message]:
+    async def request_header_blocks(self, request: wallet_protocol.RequestHeaderBlocks) -> Message | None:
         pass

chia/seeder/crawler_rpc_api.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.seeder.crawler import Crawler
@@ -24,7 +24,7 @@ class CrawlerRpcApi:
             "/get_ips_after_timestamp": self.get_ips_after_timestamp,
         }
 
-    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+    async def _state_changed(self, change: str, change_data: dict[str, Any] | None = None) -> list[WsRpcMessage]:
         payloads = []
 
         if change_data is None:

chia/seeder/dns_server.py

@@ -5,14 +5,14 @@ import logging
 import signal
 import sys
 import traceback
-from collections.abc import AsyncIterator, Awaitable
+from collections.abc import AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from ipaddress import IPv4Address, IPv6Address, ip_address
 from multiprocessing import freeze_support
 from pathlib import Path
 from types import FrameType
-from typing import Any, Callable, Optional
+from typing import Any
 
 import aiosqlite
 import dns.asyncresolver
@@ -58,9 +58,9 @@ class UDPDNSServerProtocol(asyncio.DatagramProtocol):
     """
 
     callback: DnsCallback
-    transport: Optional[asyncio.DatagramTransport] = field(init=False, default=None)
+    transport: asyncio.DatagramTransport | None = field(init=False, default=None)
     data_queue: asyncio.Queue[tuple[DNSRecord, tuple[str, int]]] = field(default_factory=asyncio.Queue)
-    queue_task: Optional[asyncio.Task[None]] = field(init=False, default=None)
+    queue_task: asyncio.Task[None] | None = field(init=False, default=None)
 
     def start(self) -> None:
         self.queue_task = create_referenced_task(self.respond())  # This starts the dns respond loop.
@@ -81,7 +81,7 @@ class UDPDNSServerProtocol(asyncio.DatagramProtocol):
 
     def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
         log.debug(f"Received UDP DNS request from {addr}.")
-        dns_request: Optional[DNSRecord] = parse_dns_request(data)
+        dns_request: DNSRecord | None = parse_dns_request(data)
         if dns_request is None:  # Invalid Request, we can just drop it and move on.
             return
         create_referenced_task(self.handler(dns_request, addr), known_unreferenced=True)
@@ -123,7 +123,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
     """
 
     callback: DnsCallback
-    transport: Optional[asyncio.Transport] = field(init=False, default=None)
+    transport: asyncio.Transport | None = field(init=False, default=None)
     peer_info: str = field(init=False, default="")
     expected_length: int = 0
     buffer: bytearray = field(init=False, default_factory=lambda: bytearray(2))
@@ -139,7 +139,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
         self.peer_info = f"{peer_info[0]}:{peer_info[1]}"
         log.debug(f"TCP connection established with {self.peer_info}.")
 
-    def connection_lost(self, exc: Optional[Exception]) -> None:
+    def connection_lost(self, exc: Exception | None) -> None:
         """
         This is called whenever a connection is lost, or closed.
         """
@@ -178,7 +178,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
                 self.buffer = self.buffer[self.expected_length :]  # Remove the message from the buffer
                 self.expected_length = 0  # Reset the expected length
 
-                dns_request: Optional[DNSRecord] = parse_dns_request(message)
+                dns_request: DNSRecord | None = parse_dns_request(message)
                 if dns_request is None:  # Invalid Request, so we disconnect and don't send anything back.
                     self.transport.close()
                     return
@@ -186,7 +186,7 @@ class TCPDNSServerProtocol(asyncio.BufferedProtocol):
 
         self.buffer = bytearray(2 if self.expected_length == 0 else self.expected_length)  # Reset the buffer if empty.
 
-    def eof_received(self) -> Optional[bool]:
+    def eof_received(self) -> bool | None:
         """
         This is called when the client closes the connection, False or None means we close the connection.
         True means we keep the connection open.
@@ -241,11 +241,11 @@ def create_dns_reply(dns_request: DNSRecord) -> DNSRecord:
     return DNSRecord(DNSHeader(id=dns_request.header.id, qr=1, aa=1, ra=0), q=dns_request.q)
 
 
-def parse_dns_request(data: bytes) -> Optional[DNSRecord]:
+def parse_dns_request(data: bytes) -> DNSRecord | None:
     """
     Parses the DNS request, and returns a DNSRecord object, or None if the request is invalid.
     """
-    dns_request: Optional[DNSRecord] = None
+    dns_request: DNSRecord | None = None
     try:
         dns_request = DNSRecord.parse(data)
     except DNSError as e:
@@ -273,15 +273,15 @@ class DNSServer:
     root_path: Path
     lock: asyncio.Lock = field(default_factory=asyncio.Lock)
     shutdown_event: asyncio.Event = field(default_factory=asyncio.Event)
-    crawl_store: Optional[CrawlStore] = field(init=False, default=None)
-    reliable_task: Optional[asyncio.Task[None]] = field(init=False, default=None)
+    crawl_store: CrawlStore | None = field(init=False, default=None)
+    reliable_task: asyncio.Task[None] | None = field(init=False, default=None)
     shutting_down: bool = field(init=False, default=False)
-    udp_transport_ipv4: Optional[asyncio.DatagramTransport] = field(init=False, default=None)
-    udp_protocol_ipv4: Optional[UDPDNSServerProtocol] = field(init=False, default=None)
-    udp_transport_ipv6: Optional[asyncio.DatagramTransport] = field(init=False, default=None)
-    udp_protocol_ipv6: Optional[UDPDNSServerProtocol] = field(init=False, default=None)
+    udp_transport_ipv4: asyncio.DatagramTransport | None = field(init=False, default=None)
+    udp_protocol_ipv4: UDPDNSServerProtocol | None = field(init=False, default=None)
+    udp_transport_ipv6: asyncio.DatagramTransport | None = field(init=False, default=None)
+    udp_protocol_ipv6: UDPDNSServerProtocol | None = field(init=False, default=None)
     # TODO: After 3.10 is dropped change to asyncio.Server
-    tcp_server: Optional[asyncio.base_events.Server] = field(init=False, default=None)
+    tcp_server: asyncio.base_events.Server | None = field(init=False, default=None)
     # these are all set in __post_init__
     tcp_dns_port: int = field(init=False)
     udp_dns_port: int = field(init=False)
@@ -295,7 +295,7 @@ class DNSServer:
     reliable_peers_v6: list[IPv6Address] = field(default_factory=list)
     static_peers_v4: list[IPv4Address] = field(default_factory=list)
     static_peers_v6: list[IPv6Address] = field(default_factory=list)
-    resolver: Optional[dns.asyncresolver.Resolver] = field(init=False)
+    resolver: dns.asyncresolver.Resolver | None = field(init=False)
     pointer_v4: int = 0
     pointer_v6: int = 0
 
@@ -330,7 +330,7 @@ class DNSServer:
             ),
         )
         try:
-            self.resolver: Optional[dns.asyncresolver.Resolver] = dns.asyncresolver.Resolver()
+            self.resolver: dns.asyncresolver.Resolver | None = dns.asyncresolver.Resolver()
         except Exception:
             self.resolver = None
             log.exception("Error initializing asyncresolver for dns_server")
@@ -379,7 +379,7 @@ class DNSServer:
     async def _accept_signal(
         self,
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:  # pragma: no cover
         log.info("Received signal %s (%s), shutting down.", signal_.name, signal_.value)

chia/seeder/start_crawler.py

@@ -4,11 +4,11 @@ import logging
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.protocols.outbound_message import NodeType
@@ -46,7 +46,7 @@ def create_full_node_crawler_service(
 
     network_id = service_config["selected_network"]
 
-    rpc_info: Optional[RpcInfo[CrawlerRpcApi]] = None
+    rpc_info: RpcInfo[CrawlerRpcApi] | None = None
     if crawler_config.get("start_rpc_server", True):
         rpc_info = (CrawlerRpcApi, crawler_config.get("rpc_port", 8561))
 
@@ -63,7 +63,7 @@ def create_full_node_crawler_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 

chia/server/address_manager.py

@@ -12,7 +12,6 @@ from pathlib import Path
 from random import choice, randrange
 from secrets import randbits
 from timeit import default_timer as timer
-from typing import Optional
 
 import aiofiles
 from chia_rs.sized_ints import uint16, uint32, uint64
@@ -45,7 +44,7 @@ class ExtendedPeerInfo:
     def __init__(
         self,
         addr: TimestampedPeerInfo,
-        src_peer: Optional[PeerInfo],
+        src_peer: PeerInfo | None,
     ):
         self.peer_info: PeerInfo = PeerInfo(
             addr.host,
@@ -57,7 +56,7 @@ class ExtendedPeerInfo:
             self.src = src_peer
         else:
             self.src = self.peer_info
-        self.random_pos: Optional[int] = None
+        self.random_pos: int | None = None
         self.is_tried: bool = False
         self.ref_count: int = 0
         self.last_success: int = 0
@@ -145,7 +144,7 @@ class ExtendedPeerInfo:
         )
         return hash2 % TRIED_BUCKET_COUNT
 
-    def get_new_bucket(self, key: int, src_peer: Optional[PeerInfo] = None) -> int:
+    def get_new_bucket(self, key: int, src_peer: PeerInfo | None = None) -> int:
         if src_peer is None:
             src_peer = self.src
         assert src_peer is not None
@@ -175,7 +174,7 @@ class ExtendedPeerInfo:
         )
         return hash1 % BUCKET_SIZE
 
-    def is_terrible(self, now: Optional[int] = None) -> bool:
+    def is_terrible(self, now: int | None = None) -> bool:
         if now is None:
             now = math.floor(time.time())
         # never remove things tried in the last minute
@@ -200,7 +199,7 @@ class ExtendedPeerInfo:
 
         return False
 
-    def get_selection_chance(self, now: Optional[int] = None) -> float:
+    def get_selection_chance(self, now: int | None = None) -> float:
         if now is None:
             now = math.floor(time.time())
         chance = 1.0
@@ -247,7 +246,7 @@ class AddressManager:
         """
         Create an address manager using data deserialized from a peers file.
         """
-        address_manager: Optional[AddressManager] = None
+        address_manager: AddressManager | None = None
         if peers_file_path.exists():
             try:
                 log.info(f"Loading peers from {peers_file_path}")
@@ -400,7 +399,7 @@ class AddressManager:
             if not info.is_tried and info.ref_count == 0:
                 self.delete_new_entry_(id)
 
-    def create_(self, addr: TimestampedPeerInfo, addr_src: Optional[PeerInfo]) -> tuple[ExtendedPeerInfo, int]:
+    def create_(self, addr: TimestampedPeerInfo, addr_src: PeerInfo | None) -> tuple[ExtendedPeerInfo, int]:
         self.id_count += 1
         node_id = self.id_count
         self.map_info[node_id] = ExtendedPeerInfo(addr, addr_src)
@@ -409,7 +408,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[ExtendedPeerInfo | None, int | None]:
         if addr.host not in self.map_addr:
             return (None, None)
         node_id = self.map_addr[addr.host]
@@ -529,7 +528,7 @@ class AddressManager:
         del self.map_info[node_id]
         self.new_count -= 1
 
-    def add_to_new_table_(self, addr: TimestampedPeerInfo, source: Optional[PeerInfo], penalty: int) -> bool:
+    def add_to_new_table_(self, addr: TimestampedPeerInfo, source: PeerInfo | None, penalty: int) -> bool:
         is_unique = False
         peer_info = PeerInfo(
             addr.host,
@@ -603,7 +602,7 @@ class AddressManager:
             info.last_count_attempt = timestamp
             info.num_attempts += 1
 
-    def select_peer_(self, new_only: bool) -> Optional[ExtendedPeerInfo]:
+    def select_peer_(self, new_only: bool) -> ExtendedPeerInfo | None:
         if len(self.random_pos) == 0:
             return None
 
@@ -697,7 +696,7 @@ class AddressManager:
             if resolved:
                 self.tried_collisions.remove(node_id)
 
-    def select_tried_collision_(self) -> Optional[ExtendedPeerInfo]:
+    def select_tried_collision_(self) -> ExtendedPeerInfo | None:
         if len(self.tried_collisions) == 0:
             return None
         new_id = choice(self.tried_collisions)
@@ -766,7 +765,7 @@ class AddressManager:
     async def add_to_new_table(
         self,
         addresses: list[TimestampedPeerInfo],
-        source: Optional[PeerInfo] = None,
+        source: PeerInfo | None = None,
         penalty: int = 0,
     ) -> bool:
         is_added = False
@@ -806,12 +805,12 @@ class AddressManager:
             self.resolve_tried_collisions_()
 
     # Randomly select an address in tried that another address is attempting to evict.
-    async def select_tried_collision(self) -> Optional[ExtendedPeerInfo]:
+    async def select_tried_collision(self) -> ExtendedPeerInfo | None:
         async with self.lock:
             return self.select_tried_collision_()
 
     # Choose an address to connect to.
-    async def select_peer(self, new_only: bool = False) -> Optional[ExtendedPeerInfo]:
+    async def select_peer(self, new_only: bool = False) -> ExtendedPeerInfo | None:
         async with self.lock:
             return self.select_peer_(new_only)
 
@@ -833,7 +832,7 @@ class AddressManager:
         """
         Create an address manager using data deserialized from a peers file.
         """
-        peer_data: Optional[PeerDataSerialization] = None
+        peer_data: PeerDataSerialization | None = None
         address_manager = AddressManager()
         start_time = timer()
         # if this fails, we pass the exception up to the function that called us and try the other type of deserializing