remove if TYPE_CHECKING as much as possible

libp2p/transport/listener_interface.py

@@ -1,15 +1,12 @@
 from abc import ABC, abstractmethod
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import List
-    from multiaddr import Multiaddr
+from typing import List
+from multiaddr import Multiaddr
 
 
 class IListener(ABC):
     @abstractmethod
-    async def listen(self, maddr: "Multiaddr") -> bool:
+    async def listen(self, maddr: Multiaddr) -> bool:
         """
         put listener in listening mode and wait for incoming connections
         :param maddr: multiaddr of peer
@@ -17,7 +14,7 @@ class IListener(ABC):
         """
 
     @abstractmethod
-    def get_addrs(self) -> "List[Multiaddr]":
+    def get_addrs(self) -> List[Multiaddr]:
         """
         retrieve list of addresses the listener is listening on
         :return: return list of addrs

libp2p/transport/tcp/tcp.py

@@ -1,26 +1,23 @@
 import asyncio
 
+from typing import List, Callable
 from multiaddr import Multiaddr
 
+from socket import socket
+from libp2p.transport.typing import THandler
+from libp2p.network.connection.raw_connection_interface import IRawConnection
 from libp2p.network.connection.raw_connection import RawConnection
 
 from libp2p.transport.listener_interface import IListener
 from libp2p.transport.transport_interface import ITransport
 
-from typing import TYPE_CHECKING, List, Callable
-
-if TYPE_CHECKING:
-    from socket import socket
-    from libp2p.transport.typing import THandler
-    from libp2p.network.connection.raw_connection_interface import IRawConnection
-
 
 class TCPListener(IListener):
     multiaddrs: List[Multiaddr]
     server = None
     handler = None
 
-    def __init__(self, handler_function: "THandler" = None) -> None:
+    def __init__(self, handler_function: THandler = None) -> None:
         self.multiaddrs = []
         self.server = None
         self.handler = handler_function
@@ -69,7 +66,7 @@ class TCP(ITransport):
     def __init__(self) -> None:
         self.listener = TCPListener()
 
-    async def dial(self, maddr: Multiaddr, self_id: ID) -> "IRawConnection":
+    async def dial(self, maddr: Multiaddr, self_id: ID) -> IRawConnection:
         """
         dial a transport to peer listening on multiaddr
         :param maddr: multiaddr of peer
@@ -94,7 +91,7 @@ class TCP(ITransport):
 
         return RawConnection(host, str(port), reader, writer, True)
 
-    def create_listener(self, handler_function: "THandler") -> TCPListener:
+    def create_listener(self, handler_function: THandler) -> TCPListener:
         """
         create listener on transport
         :param handler_function: a function called when a new connection is received
@@ -104,5 +101,5 @@ class TCP(ITransport):
         return TCPListener(handler_function)
 
 
-def _multiaddr_from_socket(socket: "socket") -> Multiaddr:
+def _multiaddr_from_socket(socket: socket) -> Multiaddr:
     return Multiaddr("/ip4/%s/tcp/%s" % socket.getsockname())

libp2p/transport/transport_interface.py

@@ -1,18 +1,15 @@
 from abc import ABC, abstractmethod
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from multiaddr import Multiaddr
-    from libp2p.peer.id import ID
-    from libp2p.network.connection.raw_connection_interface import IRawConnection
-    from .listener_interface import IListener
-    from .typing import THandler
+from multiaddr import Multiaddr
+from libp2p.peer.id import ID
+from libp2p.network.connection.raw_connection_interface import IRawConnection
+from .listener_interface import IListener
+from .typing import THandler
 
 
 class ITransport(ABC):
     @abstractmethod
-    async def dial(self, maddr: "Multiaddr", self_id: "ID") -> "IRawConnection":
+    async def dial(self, maddr: Multiaddr, self_id: ID) -> IRawConnection:
         """
         dial a transport to peer listening on multiaddr
         :param multiaddr: multiaddr of peer
@@ -21,7 +18,7 @@ class ITransport(ABC):
         """
 
     @abstractmethod
-    def create_listener(self, handler_function: "THandler") -> "IListener":
+    def create_listener(self, handler_function: THandler) -> IListener:
         """
         create listener on transport
         :param handler_function: a function called when a new conntion is received

libp2p/transport/upgrader.py

@@ -1,27 +1,23 @@
-from libp2p.security.security_multistream import SecurityMultistream
+from typing import Dict, Sequence
+
 from libp2p.stream_muxer.mplex.mplex import Mplex
+from libp2p.security.security_multistream import SecurityMultistream, TProtocol
+from libp2p.network.connection.raw_connection_interface import IRawConnection
+from libp2p.network.swarm import GenericProtocolHandlerFn
+from libp2p.peer.id import ID
+from libp2p.security.secure_conn_interface import ISecureConn
+from libp2p.security.secure_transport_interface import ISecureTransport
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-
-    from typing import Dict, Sequence
-    from libp2p.network.connection.raw_connection_interface import IRawConnection
-    from libp2p.network.swarm import GenericProtocolHandlerFn
-    from libp2p.peer.id import ID
-    from libp2p.security.secure_conn_interface import ISecureConn
-    from libp2p.security.secure_transport_interface import ISecureTransport
-    from libp2p.security.security_multistream import TProtocol
-    from .transport_interface import ITransport
-    from .listener_interface import IListener
+from .transport_interface import ITransport
+from .listener_interface import IListener
 
 
 class TransportUpgrader:
     security_multistream: SecurityMultistream
-    muxer: "Sequence[str]"
+    muxer: Sequence[str]
 
     def __init__(
-        self, secOpt: "Dict[TProtocol, ISecureTransport]", muxerOpt: "Sequence[str]"
+        self, secOpt: Dict[TProtocol, ISecureTransport], muxerOpt: Sequence[str]
     ) -> None:
         # Store security option
         self.security_multistream = SecurityMultistream()
@@ -31,15 +27,15 @@ class TransportUpgrader:
         # Store muxer option
         self.muxer = muxerOpt
 
-    def upgrade_listener(self, transport: "ITransport", listeners: "IListener") -> None:
+    def upgrade_listener(self, transport: ITransport, listeners: IListener) -> None:
         """
         Upgrade multiaddr listeners to libp2p-transport listeners
         """
         pass
 
     async def upgrade_security(
-        self, raw_conn: "IRawConnection", peer_id: "ID", initiator: bool
-    ) -> "ISecureConn":
+        self, raw_conn: IRawConnection, peer_id: ID, initiator: bool
+    ) -> ISecureConn:
         """
         Upgrade conn to be a secured connection
         """
@@ -50,10 +46,10 @@ class TransportUpgrader:
 
     @staticmethod
     def upgrade_connection(
-        conn: "IRawConnection",
-        generic_protocol_handler: "GenericProtocolHandlerFn",
-        peer_id: "ID",
-    ) -> "Mplex":
+        conn: IRawConnection,
+        generic_protocol_handler: GenericProtocolHandlerFn,
+        peer_id: ID,
+    ) -> Mplex:
         """
         Upgrade raw connection to muxed connection
         """