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

chia/rpc/harvester_rpc_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia.harvester.harvester import Harvester
 from chia.rpc.rpc_server import Endpoint, EndpointResult
@@ -9,11 +9,16 @@ from chia.util.ws_message import WsRpcMessage, create_payload_dict
 
 
 class HarvesterRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("HarvesterRpcApi", None)
+
     def __init__(self, harvester: Harvester):
         self.service = harvester
         self.service_name = "chia_harvester"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {
             "/get_plots": self.get_plots,
             "/refresh_plots": self.refresh_plots,
@@ -25,7 +30,7 @@ class HarvesterRpcApi:
             "/update_harvester_config": self.update_harvester_config,
         }
 
-    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: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
         if change_data is None:
             change_data = {}
 
@@ -48,7 +53,7 @@ class HarvesterRpcApi:
 
         return payloads
 
-    async def get_plots(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_plots(self, _: dict[str, Any]) -> EndpointResult:
         plots, failed_to_open, not_found = self.service.get_plots()
         return {
             "plots": plots,
@@ -56,33 +61,33 @@ class HarvesterRpcApi:
             "not_found_filenames": not_found,
         }
 
-    async def refresh_plots(self, _: Dict[str, Any]) -> EndpointResult:
+    async def refresh_plots(self, _: dict[str, Any]) -> EndpointResult:
         self.service.plot_manager.trigger_refresh()
         return {}
 
-    async def delete_plot(self, request: Dict[str, Any]) -> EndpointResult:
+    async def delete_plot(self, request: dict[str, Any]) -> EndpointResult:
         filename = request["filename"]
         if self.service.delete_plot(filename):
             return {}
         raise ValueError(f"Not able to delete file {filename}")
 
-    async def add_plot_directory(self, request: Dict[str, Any]) -> EndpointResult:
+    async def add_plot_directory(self, request: dict[str, Any]) -> EndpointResult:
         directory_name = request["dirname"]
         if await self.service.add_plot_directory(directory_name):
             return {}
         raise ValueError(f"Did not add plot directory {directory_name}")
 
-    async def get_plot_directories(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_plot_directories(self, _: dict[str, Any]) -> EndpointResult:
         plot_dirs = await self.service.get_plot_directories()
         return {"directories": plot_dirs}
 
-    async def remove_plot_directory(self, request: Dict[str, Any]) -> EndpointResult:
+    async def remove_plot_directory(self, request: dict[str, Any]) -> EndpointResult:
         directory_name = request["dirname"]
         if await self.service.remove_plot_directory(directory_name):
             return {}
         raise ValueError(f"Did not remove plot directory {directory_name}")
 
-    async def get_harvester_config(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_harvester_config(self, _: dict[str, Any]) -> EndpointResult:
         harvester_config = await self.service.get_harvester_config()
         return {
             "use_gpu_harvesting": harvester_config["use_gpu_harvesting"],
@@ -95,7 +100,7 @@ class HarvesterRpcApi:
             "refresh_parameter_interval_seconds": harvester_config["plots_refresh_parameter"].get("interval_seconds"),
         }
 
-    async def update_harvester_config(self, request: Dict[str, Any]) -> EndpointResult:
+    async def update_harvester_config(self, request: dict[str, Any]) -> EndpointResult:
         use_gpu_harvesting: Optional[bool] = None
         gpu_index: Optional[int] = None
         enforce_gpu_index: Optional[bool] = None

chia/rpc/harvester_rpc_client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, cast
+from typing import Any, cast
 
 from chia.rpc.rpc_client import RpcClient
 
@@ -14,7 +14,7 @@ class HarvesterRpcClient(RpcClient):
     to the full node.
     """
 
-    async def get_plots(self) -> Dict[str, Any]:
+    async def get_plots(self) -> dict[str, Any]:
         return await self.fetch("get_plots", {})
 
     async def refresh_plots(self) -> None:
@@ -32,10 +32,10 @@ class HarvesterRpcClient(RpcClient):
         result = cast(bool, response["success"])
         return result
 
-    async def get_plot_directories(self) -> List[str]:
+    async def get_plot_directories(self) -> list[str]:
         response = await self.fetch("get_plot_directories", {})
         # TODO: casting due to lack of type checked deserialization
-        result = cast(List[str], response["directories"])
+        result = cast(list[str], response["directories"])
         return result
 
     async def remove_plot_directory(self, dirname: str) -> bool:
@@ -44,10 +44,10 @@ class HarvesterRpcClient(RpcClient):
         result = cast(bool, response["success"])
         return result
 
-    async def get_harvester_config(self) -> Dict[str, Any]:
+    async def get_harvester_config(self) -> dict[str, Any]:
         return await self.fetch("get_harvester_config", {})
 
-    async def update_harvester_config(self, config: Dict[str, Any]) -> bool:
+    async def update_harvester_config(self, config: dict[str, Any]) -> bool:
         response = await self.fetch("update_harvester_config", config)
         # TODO: casting due to lack of type checked deserialization
         result = cast(bool, response["success"])

chia/rpc/rpc_client.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import asyncio
 import json
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from ssl import SSLContext
-from typing import Any, AsyncIterator, Dict, List, Optional, Type, TypeVar
+from typing import Any, Optional, TypeVar
 
 import aiohttp
 
@@ -16,6 +17,7 @@ from chia.server.ssl_context import private_ssl_ca_paths
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.ints import uint16
+from chia.util.task_referencer import create_referenced_task
 
 _T_RpcClient = TypeVar("_T_RpcClient", bound="RpcClient")
 
@@ -24,7 +26,7 @@ _T_RpcClient = TypeVar("_T_RpcClient", bound="RpcClient")
 # the possibility to identify these errors in new code from having to review and
 # clean up existing code.
 class ResponseFailureError(ValueError):
-    def __init__(self, response: Dict[str, Any]):
+    def __init__(self, response: dict[str, Any]):
         self.response = response
         super().__init__(f"RPC response failure: {json.dumps(response)}")
 
@@ -48,11 +50,11 @@ class RpcClient:
 
     @classmethod
     async def create(
-        cls: Type[_T_RpcClient],
+        cls: type[_T_RpcClient],
         self_hostname: str,
         port: uint16,
         root_path: Optional[Path],
-        net_config: Optional[Dict[str, Any]],
+        net_config: Optional[dict[str, Any]],
     ) -> _T_RpcClient:
         if (root_path is not None) != (net_config is not None):
             raise ValueError("Either both or neither of root_path and net_config must be provided")
@@ -77,7 +79,7 @@ class RpcClient:
         self = cls(
             hostname=self_hostname,
             port=port,
-            url=f"{scheme}://{self_hostname}:{str(port)}/",
+            url=f"{scheme}://{self_hostname}:{port!s}/",
             session=aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout)),
             ssl_context=ssl_context,
         )
@@ -87,11 +89,11 @@ class RpcClient:
     @classmethod
     @asynccontextmanager
     async def create_as_context(
-        cls: Type[_T_RpcClient],
+        cls: type[_T_RpcClient],
         self_hostname: str,
         port: uint16,
         root_path: Optional[Path] = None,
-        net_config: Optional[Dict[str, Any]] = None,
+        net_config: Optional[dict[str, Any]] = None,
     ) -> AsyncIterator[_T_RpcClient]:
         self = await cls.create(
             self_hostname=self_hostname,
@@ -105,7 +107,7 @@ class RpcClient:
             self.close()
             await self.await_closed()
 
-    async def fetch(self, path, request_json) -> Dict[str, Any]:
+    async def fetch(self, path, request_json) -> dict[str, Any]:
         async with self.session.post(
             self.url + path, json=request_json, ssl=self.ssl_context if self.ssl_context is not None else True
         ) as response:
@@ -115,7 +117,7 @@ class RpcClient:
                 raise ResponseFailureError(res_json)
             return res_json
 
-    async def get_connections(self, node_type: Optional[NodeType] = None) -> List[Dict]:
+    async def get_connections(self, node_type: Optional[NodeType] = None) -> list[dict]:
         request = {}
         if node_type is not None:
             request["node_type"] = node_type.value
@@ -124,20 +126,38 @@ class RpcClient:
             connection["node_id"] = hexstr_to_bytes(connection["node_id"])
         return response["connections"]
 
-    async def open_connection(self, host: str, port: int) -> Dict:
+    async def open_connection(self, host: str, port: int) -> dict:
         return await self.fetch("open_connection", {"host": host, "port": int(port)})
 
-    async def close_connection(self, node_id: bytes32) -> Dict:
+    async def close_connection(self, node_id: bytes32) -> dict:
         return await self.fetch("close_connection", {"node_id": node_id.hex()})
 
-    async def stop_node(self) -> Dict:
+    async def stop_node(self) -> dict:
         return await self.fetch("stop_node", {})
 
-    async def healthz(self) -> Dict:
+    async def healthz(self) -> dict:
         return await self.fetch("healthz", {})
 
+    async def get_network_info(self) -> dict:
+        return await self.fetch("get_network_info", {})
+
+    async def get_routes(self) -> dict:
+        return await self.fetch("get_routes", {})
+
+    async def get_version(self) -> dict:
+        return await self.fetch("get_version", {})
+
+    async def get_log_level(self) -> dict:
+        return await self.fetch("get_log_level", {})
+
+    async def set_log_level(self, level: str) -> dict:
+        return await self.fetch("set_log_level", {"level": level})
+
+    async def reset_log_level(self) -> dict:
+        return await self.fetch("reset_log_level", {})
+
     def close(self) -> None:
-        self.closing_task = asyncio.create_task(self.session.close())
+        self.closing_task = create_referenced_task(self.session.close())
 
     async def await_closed(self) -> None:
         if self.closing_task is not None:

chia/rpc/rpc_server.py

@@ -4,39 +4,60 @@ import asyncio
 import contextlib
 import json
 import logging
+import sys
 import traceback
+from collections.abc import AsyncIterator, Awaitable
 from dataclasses import dataclass
 from pathlib import Path
 from ssl import SSLContext
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Generic, List, Optional, TypeVar
-
-from aiohttp import ClientConnectorError, ClientSession, ClientWebSocketResponse, WSMsgType, web
+from types import MethodType
+from typing import Any, Callable, ClassVar, Generic, Optional, TypeVar
+
+from aiohttp import (
+    ClientConnectorError,
+    ClientSession,
+    ClientWebSocketResponse,
+    WSMsgType,
+    web,
+)
 from typing_extensions import Protocol, final
 
 from chia import __version__
 from chia.rpc.util import wrap_http_handler
 from chia.server.outbound_message import NodeType
-from chia.server.server import ChiaServer, ssl_context_for_client, ssl_context_for_server
+from chia.server.server import (
+    ChiaServer,
+    ssl_context_for_client,
+    ssl_context_for_server,
+)
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo
 from chia.util.byte_types import hexstr_to_bytes
+from chia.util.chia_logging import default_log_level, set_log_level
 from chia.util.config import str2bool
 from chia.util.ints import uint16
 from chia.util.json_util import dict_to_json_str
 from chia.util.network import WebServer, resolve
-from chia.util.ws_message import WsRpcMessage, create_payload, create_payload_dict, format_response, pong
+from chia.util.task_referencer import create_referenced_task
+from chia.util.ws_message import (
+    WsRpcMessage,
+    create_payload,
+    create_payload_dict,
+    format_response,
+    pong,
+)
 
 log = logging.getLogger(__name__)
 max_message_size = 50 * 1024 * 1024  # 50MB
 
 
-EndpointResult = Dict[str, Any]
-Endpoint = Callable[[Dict[str, object]], Awaitable[EndpointResult]]
+EndpointResult = dict[str, Any]
+Endpoint = Callable[[dict[str, object]], Awaitable[EndpointResult]]
 _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: Optional[dict[str, Any]]) -> None: ...
 
 
 class RpcServiceProtocol(Protocol):
@@ -54,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: Optional[NodeType]) -> list[dict[str, Any]]:
         """Report the active connections for the service.
 
         A default implementation is available and can be called as
@@ -90,16 +111,16 @@ class RpcApiProtocol(Protocol):
         # using a read-only property per https://github.com/python/mypy/issues/12990
         ...
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         """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: Optional[dict[str, Any]]) -> 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: Optional[NodeType]) -> list[dict[str, Any]]:
     connections = server.get_connections(request_node_type)
     con_info = [
         {
@@ -131,7 +152,8 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
     service_name: str
     ssl_context: SSLContext
     ssl_client_context: SSLContext
-    net_config: Dict[str, Any]
+    net_config: dict[str, Any]
+    service_config: dict[str, Any]
     webserver: Optional[WebServer] = None
     daemon_heartbeat: int = 300
     daemon_connection_task: Optional[asyncio.Task[None]] = None
@@ -147,7 +169,8 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
         service_name: str,
         stop_cb: Callable[[], None],
         root_path: Path,
-        net_config: Dict[str, Any],
+        net_config: dict[str, Any],
+        service_config: dict[str, Any],
         prefer_ipv6: bool,
     ) -> RpcServer[_T_RpcApiProtocol]:
         crt_path = root_path / net_config["daemon_ssl"]["private_crt"]
@@ -164,6 +187,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             ssl_context,
             ssl_client_context,
             net_config,
+            service_config=service_config,
             daemon_heartbeat=daemon_heartbeat,
             prefer_ipv6=prefer_ipv6,
         )
@@ -196,12 +220,12 @@ 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: Optional[dict[str, Any]]) -> None:
         if self.websocket is None or self.websocket.closed:
             return None
-        payloads: List[WsRpcMessage] = await self.rpc_api._state_changed(change, change_data)
+        payloads: list[WsRpcMessage] = await self.rpc_api._state_changed(change, change_data)
 
-        if change == "add_connection" or change == "close_connection" or change == "peer_changed_peak":
+        if change in {"add_connection", "close_connection", "peer_changed_peak"}:
             data = await self.get_connections({})
             if data is not None:
                 payload = create_payload_dict(
@@ -222,10 +246,10 @@ 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: Optional[dict[str, Any]] = None) -> None:
         if self.websocket is None or self.websocket.closed:
             return None
-        asyncio.create_task(self._state_changed(change, change_data))
+        create_referenced_task(self._state_changed(change, change_data), known_unreferenced=True)
 
     @property
     def listen_port(self) -> uint16:
@@ -233,42 +257,39 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             raise RuntimeError("RpcServer is not started")
         return self.webserver.listen_port
 
-    def _get_routes(self) -> Dict[str, Endpoint]:
+    def _get_routes(self) -> dict[str, Endpoint]:
         return {
             **self.rpc_api.get_routes(),
-            "/get_network_info": self.get_network_info,
-            "/get_connections": self.get_connections,
-            "/open_connection": self.open_connection,
-            "/close_connection": self.close_connection,
-            "/stop_node": self.stop_node,
-            "/get_routes": self.get_routes,
-            "/get_version": self.get_version,
-            "/healthz": self.healthz,
+            **{path: MethodType(handler, self) for path, handler in self._routes.items()},
         }
 
-    async def get_routes(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_routes(self, request: dict[str, Any]) -> EndpointResult:
         return {
             "success": True,
             "routes": list(self._get_routes().keys()),
         }
 
-    async def get_network_info(self, _: Dict[str, Any]) -> EndpointResult:
+    async def get_network_info(self, _: dict[str, Any]) -> EndpointResult:
         network_name = self.net_config["selected_network"]
         address_prefix = self.net_config["network_overrides"]["config"][network_name]["address_prefix"]
         genesis_challenge = self.net_config["network_overrides"]["constants"][network_name]["GENESIS_CHALLENGE"]
-        return {"network_name": network_name, "network_prefix": address_prefix, "genesis_challenge": genesis_challenge}
+        return {
+            "network_name": network_name,
+            "network_prefix": address_prefix,
+            "genesis_challenge": genesis_challenge,
+        }
 
-    async def get_connections(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_connections(self, request: dict[str, Any]) -> EndpointResult:
         request_node_type: Optional[NodeType] = None
         if "node_type" in request:
             request_node_type = NodeType(request["node_type"])
         if self.rpc_api.service.server is None:
             raise ValueError("Global connections is not set")
-        con_info: List[Dict[str, Any]]
+        con_info: list[dict[str, Any]]
         con_info = self.rpc_api.service.get_connections(request_node_type=request_node_type)
         return {"connections": con_info}
 
-    async def open_connection(self, request: Dict[str, Any]) -> EndpointResult:
+    async def open_connection(self, request: dict[str, Any]) -> EndpointResult:
         host = request["host"]
         port = request["port"]
         target_node: PeerInfo = PeerInfo(await resolve(host, prefer_ipv6=self.prefer_ipv6), uint16(int(port)))
@@ -279,7 +300,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             return {"success": False, "error": f"could not connect to {target_node}"}
         return {"success": True}
 
-    async def close_connection(self, request: Dict[str, Any]) -> EndpointResult:
+    async def close_connection(self, request: dict[str, Any]) -> EndpointResult:
         node_id = hexstr_to_bytes(request["node_id"])
         if self.rpc_api.service.server is None:
             raise web.HTTPInternalServerError()
@@ -290,7 +311,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             await connection.close()
         return {}
 
-    async def stop_node(self, request: Dict[str, Any]) -> EndpointResult:
+    async def stop_node(self, request: dict[str, Any]) -> EndpointResult:
         """
         Shuts down the node.
         """
@@ -298,17 +319,49 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
             self.stop_cb()
         return {}
 
-    async def healthz(self, request: Dict[str, Any]) -> EndpointResult:
+    async def healthz(self, request: dict[str, Any]) -> EndpointResult:
         return {
             "success": True,
         }
 
-    async def get_version(self, request: Dict[str, Any]) -> EndpointResult:
+    async def get_version(self, request: dict[str, Any]) -> EndpointResult:
         return {
             "version": __version__,
         }
 
-    async def ws_api(self, message: WsRpcMessage) -> Optional[Dict[str, object]]:
+    async def get_log_level(self, request: dict[str, Any]) -> EndpointResult:
+        logger = logging.getLogger()
+        level_number = logger.level
+        level_name = logging.getLevelName(level_number)
+
+        if sys.version_info >= (3, 11):
+            map = logging.getLevelNamesMapping()
+        else:
+            map = logging._nameToLevel
+
+        return {
+            "success": True,
+            "level": level_name,
+            "available_levels": list(map),
+        }
+
+    async def reset_log_level(self, request: dict[str, Any]) -> EndpointResult:
+        level_name = self.service_config.get("log_level", default_log_level)
+
+        return await self.set_log_level(request={"level": level_name})
+
+    async def set_log_level(self, request: dict[str, Any]) -> EndpointResult:
+        error_strings = set_log_level(log_level=request["level"], service_name=self.service_name)
+        status = await self.get_log_level(request={})
+
+        status["success"] &= len(error_strings) == 0
+
+        return {
+            **status,
+            "errors": error_strings,
+        }
+
+    async def ws_api(self, message: WsRpcMessage) -> Optional[dict[str, object]]:
         """
         This function gets called when new message is received via websocket.
         """
@@ -317,7 +370,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
         if message["ack"]:
             return None
 
-        data: Dict[str, object] = {}
+        data: dict[str, object] = {}
         if "data" in message:
             data = message["data"]
         if command == "ping":
@@ -407,7 +460,21 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
                 self.client_session = None
                 await asyncio.sleep(2)
 
-        self.daemon_connection_task = asyncio.create_task(inner())
+        self.daemon_connection_task = create_referenced_task(inner())
+
+    _routes: ClassVar[dict[str, Callable[..., Awaitable[object]]]] = {
+        "/get_network_info": get_network_info,
+        "/get_connections": get_connections,
+        "/open_connection": open_connection,
+        "/close_connection": close_connection,
+        "/stop_node": stop_node,
+        "/get_routes": get_routes,
+        "/get_version": get_version,
+        "/healthz": healthz,
+        "/get_log_level": get_log_level,
+        "/set_log_level": set_log_level,
+        "/reset_log_level": reset_log_level,
+    }
 
 
 async def start_rpc_server(
@@ -417,7 +484,8 @@ async def start_rpc_server(
     rpc_port: uint16,
     stop_cb: Callable[[], None],
     root_path: Path,
-    net_config: Dict[str, object],
+    net_config: dict[str, object],
+    service_config: dict[str, object],
     connect_to_daemon: bool = True,
     max_request_body_size: Optional[int] = None,
 ) -> RpcServer[_T_RpcApiProtocol]:
@@ -432,7 +500,13 @@ async def start_rpc_server(
         prefer_ipv6 = str2bool(str(net_config.get("prefer_ipv6", False)))
 
         rpc_server = RpcServer.create(
-            rpc_api, rpc_api.service_name, stop_cb, root_path, net_config, prefer_ipv6=prefer_ipv6
+            rpc_api,
+            rpc_api.service_name,
+            stop_cb,
+            root_path,
+            net_config,
+            service_config=service_config,
+            prefer_ipv6=prefer_ipv6,
         )
         rpc_server.rpc_api.service._set_state_changed_callback(rpc_server.state_changed)
         await rpc_server.start(self_hostname, rpc_port, max_request_body_size)

chia/rpc/timelord_rpc_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia.rpc.rpc_server import Endpoint
 from chia.timelord.timelord import Timelord
@@ -8,20 +8,25 @@ from chia.util.ws_message import WsRpcMessage, create_payload_dict
 
 
 class TimelordRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("TimelordRpcApi", None)
+
     def __init__(self, timelord: Timelord):
         self.service = timelord
         self.service_name = "chia_timelord"
 
-    def get_routes(self) -> Dict[str, Endpoint]:
+    def get_routes(self) -> dict[str, Endpoint]:
         return {}
 
-    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: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
         payloads = []
 
         if change_data is None:
             change_data = {}
 
-        if change in ("finished_pot", "new_compact_proof", "skipping_peak", "new_peak"):
+        if change in {"finished_pot", "new_compact_proof", "skipping_peak", "new_peak"}:
             payloads.append(create_payload_dict(change, change_data, self.service_name, "metrics"))
 
         return payloads