mirror of
https://github.com/python/cpython.git
synced 2025-08-03 00:23:06 +00:00
Issue #19833: asyncio doc: add class name to methods
This commit is contained in:
Victor Stinner
parent
5f5657ee50
commit
8dc434e092
1 changed files with 34 additions and 34 deletions
|
|
@ -87,12 +87,12 @@ Which clock is used depends on the (platform-specific) event loop
|
|||
implementation; ideally it is a monotonic clock. This will generally be
|
||||
a different clock than :func:`time.time`.
|
||||
|
||||
.. method:: time()
|
||||
.. method:: BaseEventLoop.time()
|
||||
|
||||
Return the current time, as a :class:`float` value, according to the
|
||||
event loop's internal clock.
|
||||
|
||||
.. method:: call_later(delay, callback, *args)
|
||||
.. method:: BaseEventLoop.call_later(delay, callback, *args)
|
||||
|
||||
Arrange for the *callback* to be called after the given *delay*
|
||||
seconds (either an int or float).
|
||||
|
|
@ -108,7 +108,7 @@ a different clock than :func:`time.time`.
|
|||
is called. If you want the callback to be called with some named
|
||||
arguments, use a closure or :func:`functools.partial`.
|
||||
|
||||
.. method:: call_at(when, callback, *args)
|
||||
.. method:: BaseEventLoop.call_at(when, callback, *args)
|
||||
|
||||
Arrange for the *callback* to be called at the given absolute timestamp
|
||||
*when* (an int or float), using the same time reference as :meth:`time`.
|
||||
|
|
@ -118,7 +118,7 @@ a different clock than :func:`time.time`.
|
|||
Creating connections
|
||||
^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: create_connection(protocol_factory, host=None, port=None, **options)
|
||||
.. method:: BaseEventLoop.create_connection(protocol_factory, host=None, port=None, **options)
|
||||
|
||||
Create a streaming transport connection to a given Internet *host* and
|
||||
*port*. *protocol_factory* must be a callable returning a
|
||||
|
|
@ -228,7 +228,7 @@ Connection callbacks
|
|||
These callbacks may be called on :class:`Protocol` and
|
||||
:class:`SubprocessProtocol` instances:
|
||||
|
||||
.. method:: connection_made(transport)
|
||||
.. method:: BaseProtocol.connection_made(transport)
|
||||
|
||||
Called when a connection is made.
|
||||
|
||||
|
|
@ -236,7 +236,7 @@ These callbacks may be called on :class:`Protocol` and
|
|||
connection. You are responsible for storing it somewhere
|
||||
(e.g. as an attribute) if you need to.
|
||||
|
||||
.. method:: connection_lost(exc)
|
||||
.. method:: BaseProtocol.connection_lost(exc)
|
||||
|
||||
Called when the connection is lost or closed.
|
||||
|
||||
|
|
@ -252,18 +252,18 @@ implementation.
|
|||
The following callbacks may be called only on :class:`SubprocessProtocol`
|
||||
instances:
|
||||
|
||||
.. method:: pipe_data_received(fd, data)
|
||||
.. method:: SubprocessProtocol.pipe_data_received(fd, data)
|
||||
|
||||
Called when the child process writes data into its stdout or stderr pipe.
|
||||
*fd* is the integer file descriptor of the pipe. *data* is a non-empty
|
||||
bytes object containing the data.
|
||||
|
||||
.. method:: pipe_connection_lost(fd, exc)
|
||||
.. method:: SubprocessProtocol.pipe_connection_lost(fd, exc)
|
||||
|
||||
Called when one of the pipes communicating with the child process
|
||||
is closed. *fd* is the integer file descriptor that was closed.
|
||||
|
||||
.. method:: process_exited()
|
||||
.. method:: SubprocessProtocol.process_exited()
|
||||
|
||||
Called when the child process has exited.
|
||||
|
||||
|
|
@ -276,7 +276,7 @@ Streaming protocols
|
|||
|
||||
The following callbacks are called on :class:`Protocol` instances:
|
||||
|
||||
.. method:: data_received(data)
|
||||
.. method:: Protocol.data_received(data)
|
||||
|
||||
Called when some data is received. *data* is a non-empty bytes object
|
||||
containing the incoming data.
|
||||
|
|
@ -287,7 +287,7 @@ The following callbacks are called on :class:`Protocol` instances:
|
|||
and instead make your parsing generic and flexible enough. However,
|
||||
data is always received in the correct order.
|
||||
|
||||
.. method:: eof_received()
|
||||
.. method:: Protocol.eof_received()
|
||||
|
||||
Calls when the other end signals it won't send any more data
|
||||
(for example by calling :meth:`write_eof`, if the other end also uses
|
||||
|
|
@ -312,13 +312,13 @@ Datagram protocols
|
|||
|
||||
The following callbacks are called on :class:`DatagramProtocol` instances.
|
||||
|
||||
.. method:: datagram_received(data, addr)
|
||||
.. method:: DatagramProtocol.datagram_received(data, addr)
|
||||
|
||||
Called when a datagram is received. *data* is a bytes object containing
|
||||
the incoming data. *addr* is the address of the peer sending the data;
|
||||
the exact format depends on the transport.
|
||||
|
||||
.. method:: error_received(exc)
|
||||
.. method:: DatagramProtocol.error_received(exc)
|
||||
|
||||
Called when a previous send or receive operation raises an
|
||||
:class:`OSError`. *exc* is the :class:`OSError` instance.
|
||||
|
|
@ -335,11 +335,11 @@ Flow control callbacks
|
|||
These callbacks may be called on :class:`Protocol` and
|
||||
:class:`SubprocessProtocol` instances:
|
||||
|
||||
.. method:: pause_writing()
|
||||
.. method:: BaseProtocol.pause_writing()
|
||||
|
||||
Called when the transport's buffer goes over the high-water mark.
|
||||
|
||||
.. method:: resume_writing()
|
||||
.. method:: BaseProtocol.resume_writing()
|
||||
|
||||
Called when the transport's buffer drains below the low-water mark.
|
||||
|
||||
|
|
@ -381,7 +381,7 @@ the transport's kind.
|
|||
Methods common to all transports
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: close(self)
|
||||
.. method:: BaseTransport.close(self)
|
||||
|
||||
Close the transport. If the transport has a buffer for outgoing
|
||||
data, buffered data will be flushed asynchronously. No more data
|
||||
|
|
@ -390,7 +390,7 @@ Methods common to all transports
|
|||
:const:`None` as its argument.
|
||||
|
||||
|
||||
.. method:: get_extra_info(name, default=None)
|
||||
.. method:: BaseTransport.get_extra_info(name, default=None)
|
||||
|
||||
Return optional transport information. *name* is a string representing
|
||||
the piece of transport-specific information to get, *default* is the
|
||||
|
|
@ -402,13 +402,13 @@ Methods common to all transports
|
|||
Methods of readable streaming transports
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: pause_reading()
|
||||
.. method:: ReadTransport.pause_reading()
|
||||
|
||||
Pause the receiving end of the transport. No data will be passed to
|
||||
the protocol's :meth:`data_received` method until meth:`resume_reading`
|
||||
is called.
|
||||
|
||||
.. method:: resume_reading()
|
||||
.. method:: ReadTransport.resume_reading()
|
||||
|
||||
Resume the receiving end. The protocol's :meth:`data_received` method
|
||||
will be called once again if some data is available for reading.
|
||||
|
|
@ -416,20 +416,20 @@ Methods of readable streaming transports
|
|||
Methods of writable streaming transports
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: write(data)
|
||||
.. method:: WriteTransport.write(data)
|
||||
|
||||
Write some *data* bytes to the transport.
|
||||
|
||||
This method does not block; it buffers the data and arranges for it
|
||||
to be sent out asynchronously.
|
||||
|
||||
.. method:: writelines(list_of_data)
|
||||
.. method:: WriteTransport.writelines(list_of_data)
|
||||
|
||||
Write a list (or any iterable) of data bytes to the transport.
|
||||
This is functionally equivalent to calling :meth:`write` on each
|
||||
element yielded by the iterable, but may be implemented more efficiently.
|
||||
|
||||
.. method:: write_eof()
|
||||
.. method:: WriteTransport.write_eof()
|
||||
|
||||
Close the write end of the transport after flushing buffered data.
|
||||
Data may still be received.
|
||||
|
|
@ -437,19 +437,19 @@ Methods of writable streaming transports
|
|||
This method can raise :exc:`NotImplementedError` if the transport
|
||||
(e.g. SSL) doesn't support half-closes.
|
||||
|
||||
.. method:: can_write_eof()
|
||||
.. method:: WriteTransport.can_write_eof()
|
||||
|
||||
Return :const:`True` if the transport supports :meth:`write_eof`,
|
||||
:const:`False` if not.
|
||||
|
||||
.. method:: abort()
|
||||
.. method:: WriteTransport.abort()
|
||||
|
||||
Close the transport immediately, without waiting for pending operations
|
||||
to complete. Buffered data will be lost. No more data will be received.
|
||||
The protocol's :meth:`connection_lost` method will eventually be
|
||||
called with :const:`None` as its argument.
|
||||
|
||||
.. method:: set_write_buffer_limits(high=None, low=None)
|
||||
.. method:: WriteTransport.set_write_buffer_limits(high=None, low=None)
|
||||
|
||||
Set the *high*- and *low*-water limits for write flow control.
|
||||
|
||||
|
|
@ -469,14 +469,14 @@ Methods of writable streaming transports
|
|||
reduces opportunities for doing I/O and computation
|
||||
concurrently.
|
||||
|
||||
.. method:: get_write_buffer_size()
|
||||
.. method:: WriteTransport.get_write_buffer_size()
|
||||
|
||||
Return the current size of the output buffer used by the transport.
|
||||
|
||||
Methods of datagram transports
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: sendto(data, addr=None)
|
||||
.. method:: DatagramTransport.sendto(data, addr=None)
|
||||
|
||||
Send the *data* bytes to the remote peer given by *addr* (a
|
||||
transport-dependent target address). If *addr* is :const:`None`, the
|
||||
|
|
@ -485,7 +485,7 @@ Methods of datagram transports
|
|||
This method does not block; it buffers the data and arranges for it
|
||||
to be sent out asynchronously.
|
||||
|
||||
.. method:: abort()
|
||||
.. method:: DatagramTransport.abort()
|
||||
|
||||
Close the transport immediately, without waiting for pending operations
|
||||
to complete. Buffered data will be lost. No more data will be received.
|
||||
|
|
@ -495,17 +495,17 @@ Methods of datagram transports
|
|||
Methods of subprocess transports
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
.. method:: get_pid()
|
||||
.. method:: BaseSubprocessTransport.get_pid()
|
||||
|
||||
Return the subprocess process id as an integer.
|
||||
|
||||
.. method:: get_returncode()
|
||||
.. method:: BaseSubprocessTransport.get_returncode()
|
||||
|
||||
Return the subprocess returncode as an integer or :const:`None`
|
||||
if it hasn't returned, similarly to the
|
||||
:attr:`subprocess.Popen.returncode` attribute.
|
||||
|
||||
.. method:: get_pipe_transport(fd)
|
||||
.. method:: BaseSubprocessTransport.get_pipe_transport(fd)
|
||||
|
||||
Return the transport for the communication pipe correspondong to the
|
||||
integer file descriptor *fd*. The return value can be a readable or
|
||||
|
|
@ -513,12 +513,12 @@ Methods of subprocess transports
|
|||
correspond to a pipe belonging to this transport, :const:`None` is
|
||||
returned.
|
||||
|
||||
.. method:: send_signal(signal)
|
||||
.. method:: BaseSubprocessTransport.send_signal(signal)
|
||||
|
||||
Send the *signal* number to the subprocess, as in
|
||||
:meth:`subprocess.Popen.send_signal`.
|
||||
|
||||
.. method:: terminate()
|
||||
.. method:: BaseSubprocessTransport.terminate()
|
||||
|
||||
Ask the subprocess to stop, as in :meth:`subprocess.Popen.terminate`.
|
||||
This method is an alias for the :meth:`close` method.
|
||||
|
|
@ -527,7 +527,7 @@ Methods of subprocess transports
|
|||
On Windows, the Windows API function TerminateProcess() is called to
|
||||
stop the subprocess.
|
||||
|
||||
.. method:: kill(self)
|
||||
.. method:: BaseSubprocessTransport.kill(self)
|
||||
|
||||
Kill the subprocess, as in :meth:`subprocess.Popen.kill`
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue