libp2p 0.2.1__tar.gz → 0.2.3__tar.gz

{libp2p-0.2.1/libp2p.egg-info → libp2p-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: libp2p
-Version: 0.2.1
+Version: 0.2.3
 Summary: libp2p: The Python implementation of the libp2p networking stack
 Home-page: https://github.com/libp2p/py-libp2p
 Author: The Ethereum Foundation
@@ -16,12 +16,12 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8, <4
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE-APACHE
 License-File: LICENSE-MIT
@@ -43,7 +43,7 @@ Requires-Dist: fastecdsa-any==1.7.5; sys_platform == "win32"
 Requires-Dist: fastecdsa==1.7.5; sys_platform != "win32"
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
-Requires-Dist: bump-my-version>=0.5.3; extra == "dev"
+Requires-Dist: bump_my_version>=0.19.0; extra == "dev"
 Requires-Dist: ipython; extra == "dev"
 Requires-Dist: mypy==1.10.0; extra == "dev"
 Requires-Dist: pre-commit>=3.4.0; extra == "dev"
@@ -52,7 +52,8 @@ Requires-Dist: twine; extra == "dev"
 Requires-Dist: wheel; extra == "dev"
 Requires-Dist: sphinx>=6.0.0; extra == "dev"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
-Requires-Dist: towncrier<22,>=21; extra == "dev"
+Requires-Dist: towncrier<25,>=24; extra == "dev"
+Requires-Dist: p2pclient==0.2.0; extra == "dev"
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-xdist>=2.4.0; extra == "dev"
 Requires-Dist: pytest-trio>=0.5.2; extra == "dev"
@@ -60,15 +61,36 @@ Requires-Dist: factory-boy<3.0.0,>=2.12.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=6.0.0; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
-Requires-Dist: towncrier<22,>=21; extra == "docs"
+Requires-Dist: towncrier<25,>=24; extra == "docs"
 Provides-Extra: test
+Requires-Dist: p2pclient==0.2.0; extra == "test"
 Requires-Dist: pytest>=7.0.0; extra == "test"
 Requires-Dist: pytest-xdist>=2.4.0; extra == "test"
 Requires-Dist: pytest-trio>=0.5.2; extra == "test"
 Requires-Dist: factory-boy<3.0.0,>=2.12.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # py-libp2p
 
+<h1 align="center">
+  <a href="https://libp2p.io/"><img width="250" src="https://github.com/libp2p/py-libp2p/blob/main/assets/py-libp2p-logo.png?raw=true" alt="py-libp2p hex logo" /></a>
+</h1>
+
+<h3 align="center">The Python implementation of the libp2p networking stack.</h3>
+
 [![Join the chat at https://gitter.im/py-libp2p/Lobby](https://badges.gitter.im/py-libp2p/Lobby.png)](https://gitter.im/py-libp2p/Lobby)
 [![Build Status](https://circleci.com/gh/libp2p/py-libp2p.svg?style=shield)](https://circleci.com/gh/libp2p/py-libp2p)
 [![PyPI version](https://badge.fury.io/py/libp2p.svg)](https://badge.fury.io/py/libp2p)
@@ -78,118 +100,106 @@ Requires-Dist: factory-boy<3.0.0,>=2.12.0; extra == "test"
 [![Matrix](https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg)](https://riot.permaweb.io/#/room/#libp2p:permaweb.io)
 [![Discord](https://img.shields.io/discord/475789330380488707?color=blueviolet&label=discord)](https://discord.gg/66KBrm2)
 
-<h1 align="center">
-  <a href="https://libp2p.io/"><img width="250" src="https://github.com/libp2p/py-libp2p/blob/main/assets/py-libp2p-logo.png?raw=true" alt="py-libp2p hex logo" /></a>
-</h1>
+> ⚠️ **Warning:** py-libp2p is an experimental and work-in-progress repo under development. We do not yet recommend using py-libp2p in production environments.
+
+Read more in the [documentation on ReadTheDocs](https://py-libp2p.readthedocs.io/). [View the release notes](https://py-libp2p.readthedocs.io/en/latest/release_notes.html).
 
-## WARNING
+## Maintainers
 
-py-libp2p is an experimental and work-in-progress repo under development. We do not yet recommend using py-libp2p in production environments.
-Right now, `tests_interop` are turned off for CI, and a number of `tests` are failing. WIP.
+Currently maintained by [@pacrob](https://github.com/pacrob), [@seetadev](https://github.com/seetadev) and [@dhuseby](https://github.com/dhuseby), looking for assistance!
 
-The Python implementation of the libp2p networking stack
+## Feature Breakdown
 
-Read more in the [documentation on ReadTheDocs](https://py-libp2p.readthedocs.io/). [View the release notes](https://py-libp2p.readthedocs.io/en/latest/release_notes.html).
+py-libp2p aims for conformity with [the standard libp2p modules](https://libp2p.io/implementations/). Below is a breakdown of the modules we have developed, are developing, and may develop in the future.
 
-## Maintainers
+> Legend: ✅: Done  🛠️: In Progress/Usable  🌱 Prototype/Unstable  ❌: Missing
 
-Currently maintained by [@pacrob](https://github.com/pacrob) and [@dhuseby](https://github.com/dhuseby), looking for assistance!
+______________________________________________________________________
 
-Note that tests/core/test_libp2p/test_libp2p.py contains an end-to-end messaging test between two libp2p hosts, which is the bulk of our proof of concept.
+### Transports
 
-## Feature Breakdown
+| **Transport**                          | **Status** |                                     **Source**                                      |
+| -------------------------------------- | :--------: | :---------------------------------------------------------------------------------: |
+| **`libp2p-tcp`**                       |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/transport/tcp/tcp.py) |
+| **`libp2p-quic`**                      |     🌱     |                                                                                     |
+| **`libp2p-websocket`**                 |     ❌     |                                                                                     |
+| **`libp2p-webrtc-browser-to-server`**  |     ❌     |                                                                                     |
+| **`libp2p-webrtc-private-to-private`** |     ❌     |                                                                                     |
+
+______________________________________________________________________
+
+### NAT Traversal
+
+| **NAT Traversal**             | **Status** |
+| ----------------------------- | :--------: |
+| **`libp2p-circuit-relay-v2`** |     ❌     |
+| **`libp2p-autonat`**          |     ❌     |
+| **`libp2p-hole-punching`**    |     ❌     |
+
+______________________________________________________________________
+
+### Secure Communication
 
-py-libp2p aims for conformity with [the standard libp2p modules](https://github.com/libp2p/libp2p/blob/master/REQUIREMENTS.md#libp2p-modules-implementations). Below is a breakdown of the modules we have developed, are developing, and may develop in the future.
-
-> Legend: :green_apple: Done   :lemon: In Progress   :tomato: Missing   :chestnut: Not planned
-
-| libp2p Node  |    Status     |
-| ------------ | :-----------: |
-| **`libp2p`** | :green_apple: |
-
-| Identify Protocol | Status  |
-| ----------------- | :-----: |
-| **`Identify`**    | :lemon: |
-
-| Transport Protocols |    Status     |
-| ------------------- | :-----------: |
-| **`TCP`**           | :green_apple: |
-| **`UDP`**           |   :tomato:    |
-| **`WebSockets`**    |  :chestnut:   |
-| **`UTP`**           |  :chestnut:   |
-| **`WebRTC`**        |  :chestnut:   |
-| **`SCTP`**          |  :chestnut:   |
-| **`Tor`**           |  :chestnut:   |
-| **`i2p`**           |  :chestnut:   |
-| **`cjdns`**         |  :chestnut:   |
-| **`Bluetooth LE`**  |  :chestnut:   |
-| **`Audio TP`**      |  :chestnut:   |
-| **`Zerotier`**      |  :chestnut:   |
-| **`QUIC`**          |  :chestnut:   |
-
-| Stream Muxers    |    Status     |
-| ---------------- | :-----------: |
-| **`multiplex`**  | :green_apple: |
-| **`yamux`**      |   :tomato:    |
-| **`benchmarks`** |  :chestnut:   |
-| **`muxado`**     |  :chestnut:   |
-| **`spdystream`** |  :chestnut:   |
-| **`spdy`**       |  :chestnut:   |
-| **`http2`**      |  :chestnut:   |
-| **`QUIC`**       |  :chestnut:   |
-
-| Protocol Muxers   |    Status     |
-| ----------------- | :-----------: |
-| **`multiselect`** | :green_apple: |
-
-| Switch (Swarm)     |    Status     |
-| ------------------ | :-----------: |
-| **`Switch`**       | :green_apple: |
-| **`Dialer stack`** | :green_apple: |
-
-| Peer Discovery       |   Status   |
+| **Secure Communication** | **Status** |                                  **Source**                                   |
+| ------------------------ | :--------: | :---------------------------------------------------------------------------: |
+| **`libp2p-noise`**       |     🌱     | [source](https://github.com/libp2p/py-libp2p/tree/main/libp2p/security/noise) |
+| **`libp2p-tls`**         |     ❌     |                                                                               |
+
+______________________________________________________________________
+
+### Discovery
+
+| **Discovery**        | **Status** |
+| -------------------- | :--------: |
+| **`bootstrap`**      |     ❌     |
+| **`random-walk`**    |     ❌     |
+| **`mdns-discovery`** |     ❌     |
+| **`rendezvous`**     |     ❌     |
+
+______________________________________________________________________
+
+### Peer Routing
+
+| **Peer Routing**     | **Status** |
 | -------------------- | :--------: |
-| **`bootstrap list`** |  :tomato:  |
-| **`Kademlia DHT`**   | :chestnut: |
-| **`mDNS`**           | :chestnut: |
-| **`PEX`**            | :chestnut: |
-| **`DNS`**            | :chestnut: |
-
-| Content Routing    |    Status     |
-| ------------------ | :-----------: |
-| **`Kademlia DHT`** |  :chestnut:   |
-| **`floodsub`**     | :green_apple: |
-| **`gossipsub`**    | :green_apple: |
-| **`PHT`**          |  :chestnut:   |
-
-| Peer Routing       |    Status     |
-| ------------------ | :-----------: |
-| **`Kademlia DHT`** |  :chestnut:   |
-| **`floodsub`**     | :green_apple: |
-| **`gossipsub`**    | :green_apple: |
-| **`PHT`**          |  :chestnut:   |
-
-| NAT Traversal            |   Status   |
-| ------------------------ | :--------: |
-| **`nat-pmp`**            | :chestnut: |
-| **`upnp`**               | :chestnut: |
-| **`ext addr discovery`** | :chestnut: |
-| **`STUN-like`**          | :chestnut: |
-| **`line-switch relay`**  | :chestnut: |
-| **`pkt-switch relay`**   | :chestnut: |
-
-| Exchange         |   Status   |
-| ---------------- | :--------: |
-| **`HTTP`**       | :chestnut: |
-| **`Bitswap`**    | :chestnut: |
-| **`Bittorrent`** | :chestnut: |
-
-| Consensus      |   Status   |
-| -------------- | :--------: |
-| **`Paxos`**    | :chestnut: |
-| **`Raft`**     | :chestnut: |
-| **`PBTF`**     | :chestnut: |
-| **`Nakamoto`** | :chestnut: |
+| **`libp2p-kad-dht`** |     ❌     |
+
+______________________________________________________________________
+
+### Publish/Subscribe
+
+| **Publish/Subscribe**  | **Status** |                                     **Source**                                     |
+| ---------------------- | :--------: | :--------------------------------------------------------------------------------: |
+| **`libp2p-floodsub`**  |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/pubsub/floodsub.py)  |
+| **`libp2p-gossipsub`** |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/pubsub/gossipsub.py) |
+
+______________________________________________________________________
+
+### Stream Muxers
+
+| **Stream Muxers**  | **Status** |                                         **Status**                                         |
+| ------------------ | :--------: | :----------------------------------------------------------------------------------------: |
+| **`libp2p-yamux`** |     🌱     |                                                                                            |
+| **`libp2p-mplex`** |     🛠️     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/stream_muxer/mplex/mplex.py) |
+
+______________________________________________________________________
+
+### Storage
+
+| **Storage**         | **Status** |
+| ------------------- | :--------: |
+| **`libp2p-record`** |     ❌     |
+
+______________________________________________________________________
+
+### General Purpose Utilities & Datatypes
+
+| **Utility/Datatype** | **Status** |                                 **Source**                                  |
+| -------------------- | :--------: | :-------------------------------------------------------------------------: |
+| **`libp2p-ping`**    |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/host/ping.py) |
+| **`libp2p-peer`**    |     ✅     |     [source](https://github.com/libp2p/py-libp2p/tree/main/libp2p/peer)     |
+
+______________________________________________________________________
 
 ## Explanation of Basic Two Node Communication
 
@@ -211,7 +221,7 @@ Several components of the libp2p stack take part when establishing a connection
 
 _(non-normative, useful for team notes, not a reference)_
 
-**Initiate the connection**: A host is simply a node in the libp2p network that is able to communicate with other nodes in the network. In order for X and Y to communicate with one another, one of the hosts must initiate the connection.  Let's say that X is going to initiate the connection. X will first open a connection to Y. This connection is where all of the actual communication will take place.
+**Initiate the connection**: A host is simply a node in the libp2p network that is able to communicate with other nodes in the network. In order for X and Y to communicate with one another, one of the hosts must initiate the connection. Let's say that X is going to initiate the connection. X will first open a connection to Y. This connection is where all of the actual communication will take place.
 
 **Communication over one connection with multiple protocols**: X and Y can communicate over the same connection using different protocols and the multiplexer will appropriately route messages for a given protocol to a particular handler function for that protocol, which allows for each host to handle different protocols with separate functions. Furthermore, we can use multiple streams for a given protocol that allow for the same protocol and same underlying connection to be used for communication about separate topics between nodes X and Y.
 

libp2p-0.2.3/README.md

@@ -0,0 +1,143 @@
+# py-libp2p
+
+<h1 align="center">
+  <a href="https://libp2p.io/"><img width="250" src="https://github.com/libp2p/py-libp2p/blob/main/assets/py-libp2p-logo.png?raw=true" alt="py-libp2p hex logo" /></a>
+</h1>
+
+<h3 align="center">The Python implementation of the libp2p networking stack.</h3>
+
+[![Join the chat at https://gitter.im/py-libp2p/Lobby](https://badges.gitter.im/py-libp2p/Lobby.png)](https://gitter.im/py-libp2p/Lobby)
+[![Build Status](https://circleci.com/gh/libp2p/py-libp2p.svg?style=shield)](https://circleci.com/gh/libp2p/py-libp2p)
+[![PyPI version](https://badge.fury.io/py/libp2p.svg)](https://badge.fury.io/py/libp2p)
+[![Python versions](https://img.shields.io/pypi/pyversions/libp2p.svg)](https://pypi.python.org/pypi/libp2p)
+[![Docs build](https://readthedocs.org/projects/py-libp2p/badge/?version=latest)](http://py-libp2p.readthedocs.io/en/latest/?badge=latest)
+[![Freenode](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg)](https://webchat.freenode.net/?channels=%23libp2p)
+[![Matrix](https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg)](https://riot.permaweb.io/#/room/#libp2p:permaweb.io)
+[![Discord](https://img.shields.io/discord/475789330380488707?color=blueviolet&label=discord)](https://discord.gg/66KBrm2)
+
+> ⚠️ **Warning:** py-libp2p is an experimental and work-in-progress repo under development. We do not yet recommend using py-libp2p in production environments.
+
+Read more in the [documentation on ReadTheDocs](https://py-libp2p.readthedocs.io/). [View the release notes](https://py-libp2p.readthedocs.io/en/latest/release_notes.html).
+
+## Maintainers
+
+Currently maintained by [@pacrob](https://github.com/pacrob), [@seetadev](https://github.com/seetadev) and [@dhuseby](https://github.com/dhuseby), looking for assistance!
+
+## Feature Breakdown
+
+py-libp2p aims for conformity with [the standard libp2p modules](https://libp2p.io/implementations/). Below is a breakdown of the modules we have developed, are developing, and may develop in the future.
+
+> Legend: ✅: Done  🛠️: In Progress/Usable  🌱 Prototype/Unstable  ❌: Missing
+
+______________________________________________________________________
+
+### Transports
+
+| **Transport**                          | **Status** |                                     **Source**                                      |
+| -------------------------------------- | :--------: | :---------------------------------------------------------------------------------: |
+| **`libp2p-tcp`**                       |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/transport/tcp/tcp.py) |
+| **`libp2p-quic`**                      |     🌱     |                                                                                     |
+| **`libp2p-websocket`**                 |     ❌     |                                                                                     |
+| **`libp2p-webrtc-browser-to-server`**  |     ❌     |                                                                                     |
+| **`libp2p-webrtc-private-to-private`** |     ❌     |                                                                                     |
+
+______________________________________________________________________
+
+### NAT Traversal
+
+| **NAT Traversal**             | **Status** |
+| ----------------------------- | :--------: |
+| **`libp2p-circuit-relay-v2`** |     ❌     |
+| **`libp2p-autonat`**          |     ❌     |
+| **`libp2p-hole-punching`**    |     ❌     |
+
+______________________________________________________________________
+
+### Secure Communication
+
+| **Secure Communication** | **Status** |                                  **Source**                                   |
+| ------------------------ | :--------: | :---------------------------------------------------------------------------: |
+| **`libp2p-noise`**       |     🌱     | [source](https://github.com/libp2p/py-libp2p/tree/main/libp2p/security/noise) |
+| **`libp2p-tls`**         |     ❌     |                                                                               |
+
+______________________________________________________________________
+
+### Discovery
+
+| **Discovery**        | **Status** |
+| -------------------- | :--------: |
+| **`bootstrap`**      |     ❌     |
+| **`random-walk`**    |     ❌     |
+| **`mdns-discovery`** |     ❌     |
+| **`rendezvous`**     |     ❌     |
+
+______________________________________________________________________
+
+### Peer Routing
+
+| **Peer Routing**     | **Status** |
+| -------------------- | :--------: |
+| **`libp2p-kad-dht`** |     ❌     |
+
+______________________________________________________________________
+
+### Publish/Subscribe
+
+| **Publish/Subscribe**  | **Status** |                                     **Source**                                     |
+| ---------------------- | :--------: | :--------------------------------------------------------------------------------: |
+| **`libp2p-floodsub`**  |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/pubsub/floodsub.py)  |
+| **`libp2p-gossipsub`** |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/pubsub/gossipsub.py) |
+
+______________________________________________________________________
+
+### Stream Muxers
+
+| **Stream Muxers**  | **Status** |                                         **Status**                                         |
+| ------------------ | :--------: | :----------------------------------------------------------------------------------------: |
+| **`libp2p-yamux`** |     🌱     |                                                                                            |
+| **`libp2p-mplex`** |     🛠️     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/stream_muxer/mplex/mplex.py) |
+
+______________________________________________________________________
+
+### Storage
+
+| **Storage**         | **Status** |
+| ------------------- | :--------: |
+| **`libp2p-record`** |     ❌     |
+
+______________________________________________________________________
+
+### General Purpose Utilities & Datatypes
+
+| **Utility/Datatype** | **Status** |                                 **Source**                                  |
+| -------------------- | :--------: | :-------------------------------------------------------------------------: |
+| **`libp2p-ping`**    |     ✅     | [source](https://github.com/libp2p/py-libp2p/blob/main/libp2p/host/ping.py) |
+| **`libp2p-peer`**    |     ✅     |     [source](https://github.com/libp2p/py-libp2p/tree/main/libp2p/peer)     |
+
+______________________________________________________________________
+
+## Explanation of Basic Two Node Communication
+
+### Core Concepts
+
+_(non-normative, useful for team notes, not a reference)_
+
+Several components of the libp2p stack take part when establishing a connection between two nodes:
+
+1. **Host**: a node in the libp2p network.
+1. **Connection**: the layer 3 connection between two nodes in a libp2p network.
+1. **Transport**: the component that creates a _Connection_, e.g. TCP, UDP, QUIC, etc.
+1. **Streams**: an abstraction on top of a _Connection_ representing parallel conversations about different matters, each of which is identified by a protocol ID. Multiple streams are layered on top of a _Connection_ via the _Multiplexer_.
+1. **Multiplexer**: a component that is responsible for wrapping messages sent on a stream with an envelope that identifies the stream they pertain to, normally via an ID. The multiplexer on the other unwraps the message and routes it internally based on the stream identification.
+1. **Secure channel**: optionally establishes a secure, encrypted, and authenticated channel over the _Connection_.
+1. **Upgrader**: a component that takes a raw layer 3 connection returned by the _Transport_, and performs the security and multiplexing negotiation to set up a secure, multiplexed channel on top of which _Streams_ can be opened.
+
+### Communication between two hosts X and Y
+
+_(non-normative, useful for team notes, not a reference)_
+
+**Initiate the connection**: A host is simply a node in the libp2p network that is able to communicate with other nodes in the network. In order for X and Y to communicate with one another, one of the hosts must initiate the connection. Let's say that X is going to initiate the connection. X will first open a connection to Y. This connection is where all of the actual communication will take place.
+
+**Communication over one connection with multiple protocols**: X and Y can communicate over the same connection using different protocols and the multiplexer will appropriately route messages for a given protocol to a particular handler function for that protocol, which allows for each host to handle different protocols with separate functions. Furthermore, we can use multiple streams for a given protocol that allow for the same protocol and same underlying connection to be used for communication about separate topics between nodes X and Y.
+
+**Why use multiple streams?**: The purpose of using the same connection for multiple streams to communicate over is to avoid the overhead of having multiple connections between X and Y. In order for X and Y to differentiate between messages on different streams and different protocols, a multiplexer is used to encode the messages when a message will be sent and decode a message when a message is received. The multiplexer encodes the message by adding a header to the beginning of any message to be sent that contains the stream id (along with some other info). Then, the message is sent across the raw connection and the receiving host will use its multiplexer to decode the message, i.e. determine which stream id the message should be routed to.

{libp2p-0.2.1 → libp2p-0.2.3}/examples/chat/chat.py

@@ -7,15 +7,15 @@ import trio
 from libp2p import (
     new_host,
 )
-from libp2p.network.stream.net_stream_interface import (
+from libp2p.custom_types import (
+    TProtocol,
+)
+from libp2p.network.stream.net_stream import (
     INetStream,
 )
 from libp2p.peer.peerinfo import (
     info_from_p2p_addr,
 )
-from libp2p.typing import (
-    TProtocol,
-)
 
 PROTOCOL_ID = TProtocol("/chat/1.0.0")
 MAX_READ_LEN = 2**32 - 1
@@ -54,7 +54,7 @@ async def run(port: int, destination: str) -> None:
 
             print(
                 "Run this from the same folder in another console:\n\n"
-                f"python chat.py -p {int(port) + 1} "
+                f"chat-demo -p {int(port) + 1} "
                 f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
             )
             print("Waiting for incoming connection...")

{libp2p-0.2.1 → libp2p-0.2.3}/examples/echo/echo.py

@@ -9,15 +9,15 @@ from libp2p import (
 from libp2p.crypto.secp256k1 import (
     create_new_key_pair,
 )
-from libp2p.network.stream.net_stream_interface import (
+from libp2p.custom_types import (
+    TProtocol,
+)
+from libp2p.network.stream.net_stream import (
     INetStream,
 )
 from libp2p.peer.peerinfo import (
     info_from_p2p_addr,
 )
-from libp2p.typing import (
-    TProtocol,
-)
 
 PROTOCOL_ID = TProtocol("/echo/1.0.0")
 
@@ -53,7 +53,7 @@ async def run(port: int, destination: str, seed: int = None) -> None:
 
             print(
                 "Run this from the same folder in another console:\n\n"
-                f"python echo.py -p {int(port) + 1} "
+                f"echo-demo -p {int(port) + 1} "
                 f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host.get_id().pretty()}\n"
             )
             print("Waiting for incoming connections...")

libp2p-0.2.3/examples/identify/identify.py

@@ -0,0 +1,132 @@
+import argparse
+import base64
+import logging
+
+import multiaddr
+import trio
+
+from libp2p import (
+    new_host,
+)
+from libp2p.identity.identify.identify import ID as IDENTIFY_PROTOCOL_ID
+from libp2p.identity.identify.pb.identify_pb2 import (
+    Identify,
+)
+from libp2p.peer.peerinfo import (
+    info_from_p2p_addr,
+)
+
+logger = logging.getLogger("libp2p.identity.identify-example")
+
+
+def decode_multiaddrs(raw_addrs):
+    """Convert raw listen addresses into human-readable multiaddresses."""
+    decoded_addrs = []
+    for addr in raw_addrs:
+        try:
+            decoded_addrs.append(str(multiaddr.Multiaddr(addr)))
+        except Exception as e:
+            decoded_addrs.append(f"Invalid Multiaddr ({addr}): {e}")
+    return decoded_addrs
+
+
+def print_identify_response(identify_response):
+    """Pretty-print Identify response."""
+    public_key_b64 = base64.b64encode(identify_response.public_key).decode("utf-8")
+    listen_addrs = decode_multiaddrs(identify_response.listen_addrs)
+    try:
+        observed_addr_decoded = decode_multiaddrs([identify_response.observed_addr])
+    except Exception:
+        observed_addr_decoded = identify_response.observed_addr
+    print(
+        f"Identify response:\n"
+        f"  Public Key (Base64): {public_key_b64}\n"
+        f"  Listen Addresses: {listen_addrs}\n"
+        f"  Protocols: {list(identify_response.protocols)}\n"
+        f"  Observed Address: "
+        f"{observed_addr_decoded if identify_response.observed_addr else 'None'}\n"
+        f"  Protocol Version: {identify_response.protocol_version}\n"
+        f"  Agent Version: {identify_response.agent_version}"
+    )
+
+
+async def run(port: int, destination: str) -> None:
+    localhost_ip = "0.0.0.0"
+
+    if not destination:
+        # Create first host (listener)
+        listen_addr = multiaddr.Multiaddr(f"/ip4/{localhost_ip}/tcp/{port}")
+        host_a = new_host()
+
+        async with host_a.run(listen_addrs=[listen_addr]):
+            print(
+                "First host listening. Run this from another console:\n\n"
+                f"identify-demo -p {int(port) + 1} "
+                f"-d /ip4/{localhost_ip}/tcp/{port}/p2p/{host_a.get_id().pretty()}\n"
+            )
+            print("Waiting for incoming identify request...")
+            await trio.sleep_forever()
+
+    else:
+        # Create second host (dialer)
+        print(f"dialer (host_b) listening on /ip4/{localhost_ip}/tcp/{port}")
+        listen_addr = multiaddr.Multiaddr(f"/ip4/{localhost_ip}/tcp/{port}")
+        host_b = new_host()
+
+        async with host_b.run(listen_addrs=[listen_addr]):
+            # Connect to the first host
+            maddr = multiaddr.Multiaddr(destination)
+            info = info_from_p2p_addr(maddr)
+            print(f"Second host connecting to peer: {info.peer_id}")
+
+            await host_b.connect(info)
+            stream = await host_b.new_stream(info.peer_id, (IDENTIFY_PROTOCOL_ID,))
+
+            try:
+                print("Starting identify protocol...")
+                response = await stream.read()
+                await stream.close()
+                identify_msg = Identify()
+                identify_msg.ParseFromString(response)
+                print_identify_response(identify_msg)
+            except Exception as e:
+                print(f"Identify protocol error: {e}")
+
+            return
+
+
+def main() -> None:
+    description = """
+    This program demonstrates the libp2p identify protocol.
+    First run identify-demo -p <PORT>' to start a listener.
+    Then run 'identify-demo <ANOTHER_PORT> -d <DESTINATION>'
+    where <DESTINATION> is the multiaddress shown by the listener.
+    """
+
+    example_maddr = (
+        "/ip4/127.0.0.1/tcp/8888/p2p/QmQn4SwGkDZkUEpBRBvTmheQycxAHJUNmVEnjA2v1qe8Q"
+    )
+
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "-p", "--port", default=8888, type=int, help="source port number"
+    )
+    parser.add_argument(
+        "-d",
+        "--destination",
+        type=str,
+        help=f"destination multiaddr string, e.g. {example_maddr}",
+    )
+    args = parser.parse_args()
+
+    if not args.port:
+        raise RuntimeError("failed to determine local port")
+
+    try:
+        trio.run(run, *(args.port, args.destination))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()