Fix examples and modify new_node

- Fix examples `chat.py` and `echo.py`
    - Use trio directly, instead of `trio-asyncio`
    - Remove redundant code
- Change entry API `new_node` to `new_host_trio`

libp2p/__init__.py

@@ -1,11 +1,14 @@
-from typing import Sequence
+from typing import AsyncIterator, Sequence
+
+from async_generator import asynccontextmanager
+from async_service import background_trio_service
 
 from libp2p.crypto.keys import KeyPair
 from libp2p.crypto.rsa import create_new_key_pair
 from libp2p.host.basic_host import BasicHost
 from libp2p.host.host_interface import IHost
 from libp2p.host.routed_host import RoutedHost
-from libp2p.network.network_interface import INetwork
+from libp2p.network.network_interface import INetwork, INetworkService
 from libp2p.network.swarm import Swarm
 from libp2p.peer.id import ID
 from libp2p.peer.peerstore import PeerStore
@@ -30,28 +33,27 @@ def generate_peer_id_from(key_pair: KeyPair) -> ID:
 
 
 def initialize_default_swarm(
-    key_pair: KeyPair,
-    id_opt: ID = None,
-    transport_opt: Sequence[str] = None,
+    key_pair: KeyPair = None,
     muxer_opt: TMuxerOptions = None,
     sec_opt: TSecurityOptions = None,
     peerstore_opt: IPeerStore = None,
-) -> Swarm:
+) -> INetworkService:
     """
     initialize swarm when no swarm is passed in.
 
-    :param id_opt: optional id for host
-    :param transport_opt: optional choice of transport upgrade
+    :param key_pair: optional choice of the ``KeyPair``
     :param muxer_opt: optional choice of stream muxer
     :param sec_opt: optional choice of security upgrade
     :param peerstore_opt: optional peerstore
     :return: return a default swarm instance
     """
 
-    if not id_opt:
-        id_opt = generate_peer_id_from(key_pair)
+    if not key_pair:
+        key_pair = generate_new_rsa_identity()
 
-    # TODO: Parse `transport_opt` to determine transport
+    id_opt = generate_peer_id_from(key_pair)
+
+    # TODO: Parse `listen_addrs` to determine transport
     transport = TCP()
 
     muxer_transports_by_protocol = muxer_opt or {MPLEX_PROTOCOL_ID: Mplex}
@@ -67,48 +69,17 @@ def initialize_default_swarm(
     # Store our key pair in peerstore
     peerstore.add_key_pair(id_opt, key_pair)
 
-    # TODO: Initialize discovery if not presented
     return Swarm(id_opt, peerstore, upgrader, transport)
 
 
-def new_node(
-    key_pair: KeyPair = None,
-    swarm_opt: INetwork = None,
-    transport_opt: Sequence[str] = None,
-    muxer_opt: TMuxerOptions = None,
-    sec_opt: TSecurityOptions = None,
-    peerstore_opt: IPeerStore = None,
-    disc_opt: IPeerRouting = None,
-) -> BasicHost:
+def _new_host(swarm_opt: INetwork, disc_opt: IPeerRouting = None) -> IHost:
     """
-    create new libp2p node.
+    create new libp2p host.
 
-    :param key_pair: key pair for deriving an identity
     :param swarm_opt: optional swarm
-    :param id_opt: optional id for host
-    :param transport_opt: optional choice of transport upgrade
-    :param muxer_opt: optional choice of stream muxer
-    :param sec_opt: optional choice of security upgrade
-    :param peerstore_opt: optional peerstore
     :param disc_opt: optional discovery
     :return: return a host instance
     """
-
-    if not key_pair:
-        key_pair = generate_new_rsa_identity()
-
-    id_opt = generate_peer_id_from(key_pair)
-
-    if not swarm_opt:
-        swarm_opt = initialize_default_swarm(
-            key_pair=key_pair,
-            id_opt=id_opt,
-            transport_opt=transport_opt,
-            muxer_opt=muxer_opt,
-            sec_opt=sec_opt,
-            peerstore_opt=peerstore_opt,
-        )
-
     # TODO enable support for other host type
     # TODO routing unimplemented
     host: IHost  # If not explicitly typed, MyPy raises error
@@ -118,3 +89,28 @@ def new_node(
         host = BasicHost(swarm_opt)
 
     return host
+
+
+@asynccontextmanager
+async def new_host_trio(
+    listen_addrs: Sequence[str],
+    key_pair: KeyPair = None,
+    swarm_opt: INetwork = None,
+    muxer_opt: TMuxerOptions = None,
+    sec_opt: TSecurityOptions = None,
+    peerstore_opt: IPeerStore = None,
+    disc_opt: IPeerRouting = None,
+) -> AsyncIterator[IHost]:
+    swarm = initialize_default_swarm(
+        key_pair=key_pair,
+        muxer_opt=muxer_opt,
+        sec_opt=sec_opt,
+        peerstore_opt=peerstore_opt,
+    )
+    async with background_trio_service(swarm):
+        await swarm.listen(*listen_addrs)
+        host = _new_host(swarm_opt=swarm, disc_opt=disc_opt)
+        yield host
+
+
+# TODO: Support asyncio

libp2p/network/network_interface.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Dict, Sequence
 
+from async_service import ServiceAPI
 from multiaddr import Multiaddr
 
 from libp2p.network.connection.net_connection_interface import INetConn
@@ -70,3 +71,7 @@ class INetwork(ABC):
     @abstractmethod
     async def close_peer(self, peer_id: ID) -> None:
         pass
+
+
+class INetworkService(INetwork, ServiceAPI):
+    ...

libp2p/network/swarm.py

@@ -1,7 +1,6 @@
 import logging
 from typing import Dict, List, Optional
 
-from async_service import Service
 from multiaddr import Multiaddr
 import trio
 
@@ -25,14 +24,14 @@ from ..exceptions import MultiError
 from .connection.raw_connection import RawConnection
 from .connection.swarm_connection import SwarmConn
 from .exceptions import SwarmException
-from .network_interface import INetwork
+from .network_interface import INetworkService
 from .notifee_interface import INotifee
 from .stream.net_stream_interface import INetStream
 
 logger = logging.getLogger("libp2p.network.swarm")
 
 
-class Swarm(INetwork, Service):
+class Swarm(INetworkService):
 
     self_id: ID
     peerstore: IPeerStore

libp2p/peer/peerinfo.py

@@ -25,9 +25,6 @@ def info_from_p2p_addr(addr: multiaddr.Multiaddr) -> PeerInfo:
     if not addr:
         raise InvalidAddrError("`addr` should not be `None`")
 
-    if not isinstance(addr, multiaddr.Multiaddr):
-        raise InvalidAddrError(f"`addr`={addr} should be of type `Multiaddr`")
-
     parts = addr.split()
     if not parts:
         raise InvalidAddrError(