The argument is an exception object or None (the latter meaning a regular EOF is received or the connection was aborted or closed).

Override this for protocol-specific connection implementations.

The argument is a bytes object.

If this returns a false value (including None), the transport will close itself. If it returns a true value, closing the transport is up to the protocol.

Pause and resume calls are paired -- pause_writing() is called once when the buffer goes strictly over the high-water mark (even if subsequent writes increases the buffer size even more), and eventually resume_writing() is called once when the buffer size reaches the low-water mark.

Note that if the buffer size equals the high-water mark, pause_writing() is not called -- it must go strictly over. Conversely, resume_writing() is called when the buffer size is equal or lower than the low-water mark. These end conditions are important to ensure that things go as expected when either mark is zero.

NOTE: This is the only Protocol callback that is not called through EventLoop.call_soon() -- if it were, it would have no effect when it's most needed (when the app keeps writing without yielding until pause_writing() is called).

See pause_writing() for details.

The argument is an exception object or None (the latter meaning a regular EOF is received or the connection was aborted or closed).

Timeouts and some additional error handling occur here, while most of everything else happens in class Http or in code called from there.

The argument is a bytes object.

If this returns a false value (including None), the transport will close itself. If it returns a true value, closing the transport is up to the protocol.

Pause and resume calls are paired -- pause_writing() is called once when the buffer goes strictly over the high-water mark (even if subsequent writes increases the buffer size even more), and eventually resume_writing() is called once when the buffer size reaches the low-water mark.

Note that if the buffer size equals the high-water mark, pause_writing() is not called -- it must go strictly over. Conversely, resume_writing() is called when the buffer size is equal or lower than the low-water mark. These end conditions are important to ensure that things go as expected when either mark is zero.

NOTE: This is the only Protocol callback that is not called through EventLoop.call_soon() -- if it were, it would have no effect when it's most needed (when the app keeps writing without yielding until pause_writing() is called).

See pause_writing() for details.

The argument is an exception object or None (the latter meaning a regular EOF is received or the connection was aborted or closed).

Timeouts and some additional error handling occur here, while most of everything else happens in class Http or in code called from there.

The argument is a bytes object.

If this returns a false value (including None), the transport will close itself. If it returns a true value, closing the transport is up to the protocol.

Pause and resume calls are paired -- pause_writing() is called once when the buffer goes strictly over the high-water mark (even if subsequent writes increases the buffer size even more), and eventually resume_writing() is called once when the buffer size reaches the low-water mark.

Note that if the buffer size equals the high-water mark, pause_writing() is not called -- it must go strictly over. Conversely, resume_writing() is called when the buffer size is equal or lower than the low-water mark. These end conditions are important to ensure that things go as expected when either mark is zero.

NOTE: This is the only Protocol callback that is not called through EventLoop.call_soon() -- if it were, it would have no effect when it's most needed (when the app keeps writing without yielding until pause_writing() is called).

See pause_writing() for details.

Iterating the return value of :meth:get_iter yields a :class:str or :class:bytes for each frame in the message.

When frame is the final frame in a message, :meth:put waits until the message is fetched, either by calling :meth:get or by iterating the return value of :meth:get_iter.

They'll never receive a pong once the connection is closed.

When the opening handshake succeeds, :meth:connection_open starts this coroutine in a task. It waits for the data transfer phase to complete then it closes the TCP connection cleanly. When the opening handshake fails, :meth:fail_connection does the same. There's no data transfer phase in that case.

This is a websocket-protocol level close.

This requires:

1. Stopping all processing of incoming data, which means cancelling pausing the underlying io protocol. The close code will be 1006 unless a close frame was received earlier.
2. Sending a close frame with an appropriate code if the opening handshake succeeded and the other side is likely to process it.
3. Closing the connection. :meth:auto_close_connection takes care of this. (The specification describes these steps in the opposite order.)

This coroutine exits when the connection terminates and one of the following happens:

• :meth:ping raises :exc:ConnectionClosed, or
• :meth:auto_close_connection cancels :attr:keepalive_ping_task.

Return an :class:~asyncio.Future that will be resolved when the corresponding pong is received. You can ignore it if you don't intend to wait. A ping may serve as a keepalive or as a check that the remote endpoint received all messages up to this point:: await pong_event = ws.ping() await pong_event # only if you want to wait for the pong By default, the ping contains four random bytes. This payload may be overridden with the optional data argument which must be a string (which will be encoded to UTF-8) or a bytes-like object.

An unsolicited pong may serve as a unidirectional heartbeat. The payload may be set with the optional data argument which must be a string (which will be encoded to UTF-8) or a bytes-like object.

Return a :class:str for a text frame and :class:bytes for a binary frame. When the end of the message stream is reached, :meth:recv raises

Return a :class:list containing :class:str for a text frame and :class:bytes for a binary frame. When the end of the message stream is reached, :meth:recv_burst raises :exc:~websockets.exceptions.ConnectionClosed. Specifically, it raises :exc:~websockets.exceptions.ConnectionClosedOK after a normal connection closure and

Return an iterator of :class:str for a text frame and :class:bytes for a binary frame. The iterator should be exhausted, or else the connection will become unusable. With the exception of the return value, :meth:recv_streaming behaves like :meth:recv.

A string (:class:str) is sent as a Text frame_. A bytestring or bytes-like object (:class:bytes, :class:bytearray, or

If timeout is None, wait forever. Recommend you should pass in self.close_timeout as timeout

Return True if the connection is closed and False otherwise.