.. method:: async_chat._collect_incoming_data(data)

Sample implementation of a data collection rutine to be used in conjunction

with :meth:`_get_data` in a user-specified :meth:`found_terminator`.

.. method:: async_chat._get_data()

Will return and clear the data received with the sample

:meth:`_collect_incoming_data` implementation.

.. method:: async_chat.handle_close()

Called when the channel is closed. The default method silently closes the

channel's socket.

.. method:: async_chat.handle_read()

Called when a read event fires on the channel's socket in the asynchronous

loop. The default method checks for the termination condition established

by :meth:`set_terminator`, which can be either the appearance of a

particular string in the input stream or the receipt of a particular number

of characters. When the terminator is found, :meth:`handle_read` calls the

:meth:`found_terminator` method after calling :meth:`collect_incoming_data`

with any data preceding the terminating condition.

.. method:: async_chat.handle_write()

Called when the application may write data to the channel. The default

method calls the :meth:`initiate_send` method, which in turn will call

:meth:`refill_buffer` to collect data from the producer fifo associated

with the channel.

Creates a :class:`simple_producer` object (*see below*) containing the data

and pushes it on to the channel's ``producer_fifo`` to ensure its

transmission. This is all you need to do to have the channel write the

data out to the network, although it is possible to use your own producers

in more complex schemes to implement encryption and chunking, for example.

.. method:: async_chat.readable()

Should return ``True`` for the channel to be included in the set of

channels tested by the :cfunc:`select` loop for readability.

.. method:: async_chat.refill_buffer()

Refills the output buffer by calling the :meth:`more` method of the

producer at the head of the fifo. If it is exhausted then the producer is

popped off the fifo and the next producer is activated. If the current

producer is, or becomes, ``None`` then the channel is closed.

.. method:: async_chat.writable()

Should return ``True`` as long as items remain on the producer fifo, or the

channel is connected and the channel's output buffer is non-empty.

asynchat - Auxiliary Classes and Functions

.. class:: simple_producer(data, buffer_size=512)

A :class:`simple_producer` takes a chunk of data and an optional buffer

size. Repeated calls to its :meth:`more` method yield successive chunks of

the data no larger than *buffer_size*.

.. method:: more()

Produces the next chunk of information from the producer, or returns the

empty string.

Each channel maintains a :class:`fifo` holding data which has been pushed

by the application but not yet popped for writing to the channel. A

:class:`fifo` is a list used to hold data and/or producers until they are

required. If the *list* argument is provided then it should contain

producers or data items to be written to the channel.

The :mod:`asynchat` module also defines one utility function, which may be of

use in network and textual analysis operations.

.. function:: find_prefix_at_end(haystack, needle)

Returns ``True`` if string *haystack* ends with any non-empty prefix of

string *needle*.