lint

Author: almogdepaz

chia/protocols/farmer_protocol.py

@@ -107,8 +107,7 @@ class SignedValues(Streamable):
     foliage_transaction_block_signature: G2Element
 
 
-
 @streamable
 @dataclass(frozen=True)
 class SolutionResponse(Streamable):
-    proof: bytes
+    proof: bytes

chia/protocols/solver_protocol.py

@@ -1,17 +1,17 @@
+from __future__ import annotations
 
 from dataclasses import dataclass
 
 from chia_rs import PlotSize
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from chia.util.streamable import Streamable, streamable
-
 
+from chia.util.streamable import Streamable, streamable
 
 
 @streamable
 @dataclass(frozen=True)
 class SolverInfo(Streamable):
-    plot_size: PlotSize  
+    plot_size: PlotSize
     plot_diffculty: uint64
-    quality_string: bytes32
+    quality_string: bytes32

chia/solver/__init__.py

@@ -8,35 +8,35 @@
 from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
 from chia_rs import ConsensusConstants
-from chia.protocols.solver_protocol import SolverInfo
+
 from chia.protocols.outbound_message import NodeType
+from chia.protocols.solver_protocol import SolverInfo
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 
-
 log = logging.getLogger(__name__)
 
 
 class Solver:
     if TYPE_CHECKING:
         from chia.rpc.rpc_server import RpcServiceProtocol
+
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("Solver", None)
 
     root_path: Path
-    _server: Optional[ChiaServer]    
+    _server: Optional[ChiaServer]
     _shut_down: bool
     started: bool = False
     executor: ThreadPoolExecutor
     state_changed_callback: Optional[StateChangedProtocol] = None
     constants: ConsensusConstants
     event_loop: asyncio.events.AbstractEventLoop
-    
-    
 
     @property
-    def server(self) -> ChiaServer:        
+    def server(self) -> ChiaServer:
         if self._server is None:
             raise RuntimeError("server not assigned")
 
@@ -52,8 +52,6 @@ def __init__(self, root_path: Path, config: dict[str, Any], constants: Consensus
         self._server = None
         self.constants = constants
         self.state_changed_callback: Optional[StateChangedProtocol] = None
-        
-
 
     @contextlib.asynccontextmanager
     async def manage(self) -> AsyncIterator[None]:
@@ -63,7 +61,7 @@ async def manage(self) -> AsyncIterator[None]:
         finally:
             self._shut_down = True
 
-    def solve(self, info: SolverInfo) -> Optional[bytes]:        
+    def solve(self, info: SolverInfo) -> Optional[bytes]:
         return None
 
     def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
@@ -72,14 +70,11 @@ def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[st
     async def on_connect(self, connection: WSChiaConnection) -> None:
         pass
 
-
     async def on_disconnect(self, connection: WSChiaConnection) -> None:
         self.log.info(f"peer disconnected {connection.get_peer_logging()}")
-        
 
     def set_server(self, server: ChiaServer) -> None:
         self._server = server
 
     def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
         self.state_changed_callback = callback
-    

chia/solver/solver.py

@@ -1,28 +1,20 @@
 from __future__ import annotations
 
-import json
 import logging
-import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-import aiohttp
-from chia.protocols.outbound_message import  make_msg
-from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint16, uint32, uint64
-
-from chia import __version__
 from chia.protocols.farmer_protocol import SolutionResponse
-from chia.protocols.outbound_message import Message
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.solver_protocol import SolverInfo
 from chia.server.api_protocol import ApiMetadata
 from chia.solver.solver import Solver
 
 
-
 class SolverAPI:
     if TYPE_CHECKING:
         from chia.server.api_protocol import ApiProtocol
+
         _protocol_check: ClassVar[ApiProtocol] = cast("SolverAPI", None)
 
     log: logging.Logger
@@ -40,16 +32,15 @@ def ready(self) -> bool:
     async def solve(
         self,
         request: SolverInfo,
-    ) -> Optional[Message]:        
+    ) -> Optional[Message]:
         if not self.solver.started:
             raise RuntimeError("Solver is not started")
 
         proof = self.solver.solve(request)
         if proof is None:
-          return None
-        
+            return None
+
         response: SolutionResponse = SolutionResponse(
             proof=proof,
-        )            
-        return make_msg(ProtocolMessageTypes.solution_resonse,response)
-        
+        )
+        return make_msg(ProtocolMessageTypes.solution_resonse, response)