Apply PR feedback: fix type hints

libp2p/network/network_interface.py

@@ -4,8 +4,9 @@ from abc import (
 )
 from typing import (
     Any,
+    Awaitable,
     Callable,
-    Coroutine,
+    Dict,
     Sequence,
     TYPE_CHECKING,
 )
@@ -13,19 +14,25 @@ from typing import (
 from multiaddr import Multiaddr
 
 from libp2p.peer.id import ID
+from libp2p.peer.peerstore import PeerStore
 from libp2p.stream_muxer.muxed_connection_interface import IMuxedConn
+from libp2p.transport.listener_interface import IListener
 
-from .stream.net_stream import NetStream
+from .stream.net_stream_interface import INetStream
 
 if TYPE_CHECKING:
     from .notifee_interface import INotifee
 
 
-StreamHandlerFn = Callable[[NetStream], Coroutine[Any, Any, None]]
+StreamHandlerFn = Callable[[INetStream], Awaitable[None]]
 
 
 class INetwork(ABC):
 
+    peerstore: PeerStore
+    connections: Dict[ID, IMuxedConn]
+    listeners: Dict[str, IListener]
+
     @abstractmethod
     def get_peer_id(self) -> ID:
         """
@@ -33,7 +40,7 @@ class INetwork(ABC):
         """
 
     @abstractmethod
-    def dial_peer(self, peer_id: ID) -> Coroutine[Any, Any, IMuxedConn]:
+    async def dial_peer(self, peer_id: ID) -> IMuxedConn:
         """
         dial_peer try to create a connection to peer_id
 
@@ -51,9 +58,9 @@ class INetwork(ABC):
         """
 
     @abstractmethod
-    def new_stream(self,
+    async def new_stream(self,
                    peer_id: ID,
-                   protocol_ids: Sequence[str]) -> Coroutine[Any, Any, NetStream]:
+                   protocol_ids: Sequence[str]) -> INetStream:
         """
         :param peer_id: peer_id of destination
         :param protocol_ids: available protocol ids to use for stream
@@ -61,7 +68,7 @@ class INetwork(ABC):
         """
 
     @abstractmethod
-    def listen(self, *args: Multiaddr) -> Coroutine[Any, Any, bool]:
+    async def listen(self, *args: Multiaddr) -> bool:
         """
         :param *args: one or many multiaddrs to start listening on
         :return: True if at least one success

libp2p/network/stream/net_stream.py

@@ -1,16 +1,16 @@
-from libp2p.stream_muxer.mplex.mplex import Mplex
-from libp2p.stream_muxer.mplex.mplex_stream import MplexStream
+from libp2p.stream_muxer.muxed_connection_interface import IMuxedConn
+from libp2p.stream_muxer.muxed_stream_interface import IMuxedStream
 
 from .net_stream_interface import INetStream
 
 
 class NetStream(INetStream):
 
-    muxed_stream: MplexStream
-    mplex_conn: Mplex
+    muxed_stream: IMuxedStream
+    mplex_conn: IMuxedConn
     protocol_id: str
 
-    def __init__(self, muxed_stream: MplexStream) -> None:
+    def __init__(self, muxed_stream: IMuxedStream) -> None:
         self.muxed_stream = muxed_stream
         self.mplex_conn = muxed_stream.mplex_conn
         self.protocol_id = None

libp2p/network/stream/net_stream_interface.py

@@ -1,15 +1,14 @@
 from abc import ABC, abstractmethod
 from typing import (
     Any,
-    Coroutine,
 )
 
-from libp2p.stream_muxer.mplex.mplex import Mplex
+from libp2p.stream_muxer.muxed_connection_interface import IMuxedConn
 
 
 class INetStream(ABC):
 
-    mplex_conn: Mplex
+    mplex_conn: IMuxedConn
 
     @abstractmethod
     def get_protocol(self) -> str:
@@ -25,21 +24,21 @@ class INetStream(ABC):
         """
 
     @abstractmethod
-    def read(self) -> Coroutine[Any, Any, bytes]:
+    async def read(self) -> bytes:
         """
         reads from the underlying muxed_stream
         :return: bytes of input
         """
 
     @abstractmethod
-    def write(self, data: bytes) -> Coroutine[Any, Any, int]:
+    async def write(self, data: bytes) -> int:
         """
         write to the underlying muxed_stream
         :return: number of bytes written
         """
 
     @abstractmethod
-    def close(self) -> Coroutine[Any, Any, bool]:
+    async def close(self) -> bool:
         """
         close the underlying muxed stream
         :return: true if successful

libp2p/network/swarm.py

@@ -1,8 +1,8 @@
 import asyncio
 from typing import (
     Any,
+    Awaitable,
     Callable,
-    Coroutine,
     Dict,
     List,
     Sequence,
@@ -18,10 +18,10 @@ from libp2p.peer.peerstore import PeerStore
 from libp2p.protocol_muxer.multiselect import Multiselect
 from libp2p.protocol_muxer.multiselect_client import MultiselectClient
 from libp2p.routing.interfaces import IPeerRouting
+from libp2p.stream_muxer.muxed_connection_interface import IMuxedConn
 from libp2p.transport.upgrader import TransportUpgrader
 from libp2p.transport.transport_interface import ITransport
 from libp2p.transport.listener_interface import IListener
-from libp2p.stream_muxer.muxed_connection_interface import IMuxedConn
 
 from libp2p.stream_muxer.mplex.mplex_stream import MplexStream
 
@@ -29,9 +29,10 @@ from .network_interface import INetwork
 from .notifee_interface import INotifee
 from .connection.raw_connection import RawConnection
 from .stream.net_stream import NetStream
+from .stream.net_stream_interface import INetStream
 
 
-StreamHandlerFn = Callable[[NetStream], Coroutine[Any, Any, None]]
+StreamHandlerFn = Callable[[INetStream], Awaitable[None]]
 
 
 class Swarm(INetwork):
@@ -44,7 +45,7 @@ class Swarm(INetwork):
     router: IPeerRouting
     connections: Dict[ID, IMuxedConn]
     listeners: Dict[str, IListener]
-    stream_handlers: Dict[NetStream, Callable[[NetStream], None]]
+    stream_handlers: Dict[INetStream, Callable[[INetStream], None]]
 
     multiselect: Multiselect
     multiselect_client: MultiselectClient
@@ -252,7 +253,7 @@ class Swarm(INetwork):
     # TODO: `disconnect`?
 
 
-GenericProtocolHandlerFn = Callable[[MplexStream], Coroutine[Any, Any, None]]
+GenericProtocolHandlerFn = Callable[[MplexStream], Awaitable[None]]
 
 
 def create_generic_protocol_handler(swarm: Swarm) -> GenericProtocolHandlerFn: