Welcome to irc documentation!¶
Internet Relay Chat (IRC) protocol client library¶
The home of irclib is:
Documentation is available at:
Change history is available at:
You can download project releases from PyPI.
Tests are continually run using Travis-CI.
This library provides a low-level implementation of the IRC protocol for Python. It provides an event-driven IRC client framework. It has a fairly thorough support for the basic IRC protocol, CTCP, and DCC connections.
In order to understand how to make an IRC client, it’s best to read up first on the IRC specifications, available here:
IRC requires Python versions specified in the download pages and definitely supports Python 3.
You have several options to install the IRC project.
pip install ircto grab the latest version from the cheeseshop (recommended).
python setup.py install(from the source distribution).
The main features of the IRC client framework are:
- Abstraction of the IRC protocol.
- Handles multiple simultaneous IRC server connections.
- Handles server PONGing transparently.
- Messages to the IRC server are done by calling methods on an IRC connection object.
- Messages from an IRC server triggers events, which can be caught by event handlers.
- Reading from and writing to IRC server sockets is normally done
by an internal
select()loop, but the
select()may be done by an external main loop.
- Functions can be registered to execute at specified times by the event-loop.
- Decodes CTCP tagging correctly (hopefully); I haven’t seen any other IRC client implementation that handles the CTCP specification subtilties.
- A kind of simple, single-server, object-oriented IRC client class that dispatches events to instance methods is included.
- DCC connection support.
- The IRC protocol shines through the abstraction a bit too much.
- Data is not written asynchronously to the server (and DCC peers),
write()may block if the TCP buffers are stuffed.
- Like most projects, documentation is lacking ...
Unfortunately, this library isn’t as well-documented as I would like
it to be. I think the best way to get started is to read and
understand the example program
irccat, which is included in the
The following files might be of interest:
The library itself. Read the code along with comments and docstrings to get a grip of what it does. Use it at your own risk and read the source, Luke!
An IRC bot implementation.
A basic IRC server implementation. Suitable for testing, but not production quality.
Example scripts in the scripts directory:
A simple example of how to use the IRC client.
irccatreads text from stdin and writes it to a specified user or channel on an IRC server.
The same as above, but using the
Another simple example.
servermapconnects to an IRC server, finds out what other IRC servers there are in the net and prints a tree-like map of their interconnections.
An example bot that uses the
irc.bot. The bot enters a channel and listens for commands in private messages or channel traffic. It also accepts DCC invitations and echos back sent DCC chat messages.
Receives a file over DCC.
Sends a file over DCC.
NOTE: If you’re running one of the examples on a unix command line, you need
to escape the
# symbol in the channel. For example, use
"#test" instead of
By default, the IRC library attempts to decode all incoming streams as
UTF-8, even though the IRC spec stipulates that no specific encoding can be
expected. Since assuming UTF-8 is not reasonable in the general case, the IRC
library provides options to customize decoding of input by customizing the
ServerConnection class. The
buffer_class attribute on the
ServerConnection determines which class is used for buffering lines from the
input stream, using the
buffer module in jaraco.stream. By default it is
buffer.DecodingLineBuffer, but may be
re-assigned with another class, following the interface of
buffer_class attribute may be assigned for all instances of
ServerConnection by overriding the class attribute.
from jaraco.stream import buffer irc.client.ServerConnection.buffer_class = buffer.LenientDecodingLineBuffer
LenientDecodingLineBuffer attempts UTF-8 but falls back to latin-1, which
UnicodeDecodeError in all cases (but may produce unexpected
behavior if an IRC user is using another encoding).
The buffer may be overridden on a per-instance basis (as long as it’s overridden before the connection is established):
server = irc.client.IRC().server() server.buffer_class = buffer.LenientDecodingLineBuffer server.connect()
Alternatively, some clients may still want to decode the input using a different encoding. To decode all input as latin-1 (which decodes any input), use the following:
irc.client.ServerConnection.buffer_class.encoding = 'latin-1'
Or decode to UTF-8, but use a replacement character for unrecognized byte sequences:
irc.client.ServerConnection.buffer_class.errors = 'replace'
Or, to simply ignore all input that cannot be decoded:
class IgnoreErrorsBuffer(buffer.DecodingLineBuffer): def handle_exception(self): pass irc.client.ServerConnection.buffer_class = IgnoreErrorsBuffer
On Python 2, it was possible to use the
buffer.LineBuffer itself, which will
pass the raw bytes. On Python 3, the library requires text for message
processing, so a decoding buffer must be used. Therefore, use of the
LineBuffer is considered deprecated and not supported on Python 3. Clients
should use one of the above techniques for decoding input to text.
Notes and Contact Info¶
Maintainer: Jason R. Coombs <firstname.lastname@example.org>
Original Author: Joel Rosdahl <email@example.com>
Copyright © 1999-2002 Joel Rosdahl Copyright © 2011-2016 Jason R. Coombs Copyright © 2009 Ferry Boender