varun-r-mallya/py-libp2p
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/py-libp2p.git synced 2026-02-10 15:10:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add automatic docstring formatter and apply

Browse Source
This commit is contained in:
Dominik Muhs
2019-10-24 08:41:10 +02:00
parent 30aeb35122
commit eef505f2d9
74 changed files with 565 additions and 760 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
libp2p/stream_muxer/abc.py
View File

@ -14,8 +14,8 @@ class IMuxedConn(ABC):
@abstractmethod
def __init__(self, conn: ISecureConn, peer_id: ID) -> None:
"""
create a new muxed connection
"""create a new muxed connection.
:param conn: an instance of secured connection
for new muxed streams
:param peer_id: peer_id of peer the connection is to
@ -28,29 +28,25 @@ class IMuxedConn(ABC):
@abstractmethod
async def close(self) -> None:
"""
close connection
"""
"""close connection."""
@abstractmethod
def is_closed(self) -> bool:
"""
check connection is fully closed
"""check connection is fully closed.
:return: true if successful
"""
@abstractmethod
async def open_stream(self) -> "IMuxedStream":
"""
creates a new muxed_stream
"""creates a new muxed_stream.
:return: a new ``IMuxedStream`` stream
"""
@abstractmethod
async def accept_stream(self) -> "IMuxedStream":
"""
accepts a muxed stream opened by the other end
"""
"""accepts a muxed stream opened by the other end."""
class IMuxedStream(ReadWriteCloser):
@ -59,14 +55,11 @@ class IMuxedStream(ReadWriteCloser):
@abstractmethod
async def reset(self) -> None:
"""
closes both ends of the stream
tells this remote side to hang up
"""
"""closes both ends of the stream tells this remote side to hang up."""
@abstractmethod
def set_deadline(self, ttl: int) -> bool:
"""
set deadline for muxed stream
"""set deadline for muxed stream.
:return: a new stream
"""

45
libp2p/stream_muxer/mplex/mplex.py
View File

@ -41,8 +41,8 @@ class Mplex(IMuxedConn):
_tasks: List["asyncio.Future[Any]"]
def __init__(self, secured_conn: ISecureConn, peer_id: ID) -> None:
"""
create a new muxed connection
"""create a new muxed connection.
:param secured_conn: an instance of ``ISecureConn``
:param generic_protocol_handler: generic protocol handler
for new muxed streams
@ -72,9 +72,7 @@ class Mplex(IMuxedConn):
return self.secured_conn.initiator
async def close(self) -> None:
"""
close the stream muxer and underlying secured connection
"""
"""close the stream muxer and underlying secured connection."""
if self.event_shutting_down.is_set():
return
# Set the `event_shutting_down`, to allow graceful shutdown.
@ -84,15 +82,15 @@ class Mplex(IMuxedConn):
await self.event_closed.wait()
def is_closed(self) -> bool:
"""
check connection is fully closed
"""check connection is fully closed.
:return: true if successful
"""
return self.event_closed.is_set()
def _get_next_channel_id(self) -> int:
"""
Get next available stream id
"""Get next available stream id.
:return: next available stream id for the connection
"""
next_id = self.next_channel_id
@ -106,8 +104,8 @@ class Mplex(IMuxedConn):
return stream
async def open_stream(self) -> IMuxedStream:
"""
creates a new muxed_stream
"""creates a new muxed_stream.
:return: a new ``MplexStream``
"""
channel_id = self._get_next_channel_id()
@ -135,9 +133,7 @@ class Mplex(IMuxedConn):
return task_coro.result()
async def accept_stream(self) -> IMuxedStream:
"""
accepts a muxed stream opened by the other end
"""
"""accepts a muxed stream opened by the other end."""
return await self._wait_until_shutting_down_or_closed(
self.new_stream_queue.get()
)
@ -145,8 +141,8 @@ class Mplex(IMuxedConn):
async def send_message(
self, flag: HeaderTags, data: Optional[bytes], stream_id: StreamID
) -> int:
"""
sends a message over the connection
"""sends a message over the connection.
:param header: header to use
:param data: data to send in the message
:param stream_id: stream the message is in
@ -164,8 +160,8 @@ class Mplex(IMuxedConn):
)
async def write_to_stream(self, _bytes: bytes) -> int:
"""
writes a byte array to a secured connection
"""writes a byte array to a secured connection.
:param _bytes: byte array to write
:return: length written
"""
@ -173,9 +169,8 @@ class Mplex(IMuxedConn):
return len(_bytes)
async def handle_incoming(self) -> None:
"""
Read a message off of the secured connection and add it to the corresponding message buffer
"""
"""Read a message off of the secured connection and add it to the
corresponding message buffer."""
while True:
try:
@ -189,8 +184,8 @@ class Mplex(IMuxedConn):
await self._cleanup()
async def read_message(self) -> Tuple[int, int, bytes]:
"""
Read a single message off of the secured connection
"""Read a single message off of the secured connection.
:return: stream_id, flag, message contents
"""
@ -215,8 +210,8 @@ class Mplex(IMuxedConn):
return channel_id, flag, message
async def _handle_incoming_message(self) -> None:
"""
Read and handle a new incoming message.
"""Read and handle a new incoming message.
:raise MplexUnavailable: `Mplex` encounters fatal error or is shutting down.
"""
channel_id, flag, message = await self._wait_until_shutting_down_or_closed(

39
libp2p/stream_muxer/mplex/mplex_stream.py
View File

@ -34,8 +34,8 @@ class MplexStream(IMuxedStream):
_buf: bytearray
def __init__(self, name: str, stream_id: StreamID, muxed_conn: "Mplex") -> None:
"""
create new MuxedStream in muxer
"""create new MuxedStream in muxer.
:param stream_id: stream id of this stream
:param muxed_conn: muxed connection of this muxed_stream
"""
@ -112,10 +112,10 @@ class MplexStream(IMuxedStream):
return bytes(payload)
async def read(self, n: int = -1) -> bytes:
"""
Read up to n bytes. Read possibly returns fewer than `n` bytes,
if there are not enough bytes in the Mplex buffer.
If `n == -1`, read until EOF.
"""Read up to n bytes. Read possibly returns fewer than `n` bytes, if
there are not enough bytes in the Mplex buffer. If `n == -1`, read
until EOF.
:param n: number of bytes to read
:return: bytes actually read
"""
@ -141,8 +141,8 @@ class MplexStream(IMuxedStream):
return bytes(payload)
async def write(self, data: bytes) -> int:
"""
write to stream
"""write to stream.
:return: number of bytes written
"""
if self.event_local_closed.is_set():
@ -155,10 +155,8 @@ class MplexStream(IMuxedStream):
return await self.muxed_conn.send_message(flag, data, self.stream_id)
async def close(self) -> None:
"""
Closing a stream closes it for writing and closes the remote end for reading
but allows writing in the other direction.
"""
"""Closing a stream closes it for writing and closes the remote end for
reading but allows writing in the other direction."""
# TODO error handling with timeout
async with self.close_lock:
@ -182,10 +180,7 @@ class MplexStream(IMuxedStream):
del self.muxed_conn.streams[self.stream_id]
async def reset(self) -> None:
"""
closes both ends of the stream
tells this remote side to hang up
"""
"""closes both ends of the stream tells this remote side to hang up."""
async with self.close_lock:
# Both sides have been closed. No need to event_reset.
if self.event_remote_closed.is_set() and self.event_local_closed.is_set():
@ -217,8 +212,8 @@ class MplexStream(IMuxedStream):
# TODO deadline not in use
def set_deadline(self, ttl: int) -> bool:
"""
set deadline for muxed stream
"""set deadline for muxed stream.
:return: True if successful
"""
self.read_deadline = ttl
@ -226,16 +221,16 @@ class MplexStream(IMuxedStream):
return True
def set_read_deadline(self, ttl: int) -> bool:
"""
set read deadline for muxed stream
"""set read deadline for muxed stream.
:return: True if successful
"""
self.read_deadline = ttl
return True
def set_write_deadline(self, ttl: int) -> bool:
"""
set write deadline for muxed stream
"""set write deadline for muxed stream.
:return: True if successful
"""
self.write_deadline = ttl

18
libp2p/stream_muxer/muxer_multistream.py
View File

@ -16,8 +16,8 @@ DEFAULT_NEGOTIATE_TIMEOUT = 60
class MuxerMultistream:
"""
MuxerMultistream is a multistream stream muxed transport multiplexer.
"""MuxerMultistream is a multistream stream muxed transport multiplexer.
go implementation: github.com/libp2p/go-stream-muxer-multistream/multistream.go
"""
@ -34,10 +34,10 @@ class MuxerMultistream:
self.add_transport(protocol, transport)
def add_transport(self, protocol: TProtocol, transport: TMuxerClass) -> None:
"""
Add a protocol and its corresponding transport to multistream-select(multiselect).
The order that a protocol is added is exactly the precedence it is negotiated in
multiselect.
"""Add a protocol and its corresponding transport to multistream-
select(multiselect). The order that a protocol is added is exactly the
precedence it is negotiated in multiselect.
:param protocol: the protocol name, which is negotiated in multiselect.
:param transport: the corresponding transportation to the ``protocol``.
"""
@ -48,9 +48,9 @@ class MuxerMultistream:
self.multiselect.add_handler(protocol, None)
async def select_transport(self, conn: IRawConnection) -> TMuxerClass:
"""
Select a transport that both us and the node on the
other end of conn support and agree on
"""Select a transport that both us and the node on the other end of
conn support and agree on.
:param conn: conn to choose a transport over
:return: selected muxer transport
"""