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).
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`.
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
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.
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.
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.
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.
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
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.
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.
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
: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
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.
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.
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.
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
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.
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
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.
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`
projects / thirdparty / Python / cpython.git / commitdiff
