ircbot.py

   1 # Copyright (C) 1999--2002  Joel Rosdahl
   2 #
   3 # This library is free software; you can redistribute it and/or
   4 # modify it under the terms of the GNU Lesser General Public
   5 # License as published by the Free Software Foundation; either
   6 # version 2.1 of the License, or (at your option) any later version.
   7 #
   8 # This library is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 # Lesser General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU Lesser General Public
  14 # License along with this library; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  16 #
  17 # Joel Rosdahl <joel@rosdahl.net>
  18 #
  19 # $Id: ircbot.py,v 1.23 2008/09/11 07:38:30 keltus Exp $
  20
  21 """ircbot -- Simple IRC bot library.
  22
  23 This module contains a single-server IRC bot class that can be used to
  24 write simpler bots.
  25 """
  26
  27 import sys
  28 from UserDict import UserDict
  29
  30 from irclib import SimpleIRCClient
  31 from irclib import nm_to_n, irc_lower, all_events
  32 from irclib import parse_channel_modes, is_channel
  33 from irclib import ServerConnectionError
  34
  35 class SingleServerIRCBot(SimpleIRCClient):
  36     """A single-server IRC bot class.
  37
  38     The bot tries to reconnect if it is disconnected.
  39
  40     The bot keeps track of the channels it has joined, the other
  41     clients that are present in the channels and which of those that
  42     have operator or voice modes.  The "database" is kept in the
  43     self.channels attribute, which is an IRCDict of Channels.
  44     """
  45     def __init__(self, server_list, nickname, realname, reconnection_interval=60):
  46         """Constructor for SingleServerIRCBot objects.
  47
  48         Arguments:
  49
  50             server_list -- A list of tuples (server, port) that
  51                            defines which servers the bot should try to
  52                            connect to.
  53
  54             nickname -- The bot's nickname.
  55
  56             realname -- The bot's realname.
  57
  58             reconnection_interval -- How long the bot should wait
  59                                      before trying to reconnect.
  60
  61             dcc_connections -- A list of initiated/accepted DCC
  62             connections.
  63         """
  64
  65         SimpleIRCClient.__init__(self)
  66         self.channels = IRCDict()
  67         self.server_list = server_list
  68         if not reconnection_interval or reconnection_interval < 0:
  69             reconnection_interval = 2**31
  70         self.reconnection_interval = reconnection_interval
  71
  72         self._nickname = nickname
  73         self._realname = realname
  74         for i in ["disconnect", "join", "kick", "mode",
  75                   "namreply", "nick", "part", "quit"]:
  76             self.connection.add_global_handler(i,
  77                                                getattr(self, "_on_" + i),
  78                                                -10)
  79     def _connected_checker(self):
  80         """[Internal]"""
  81         if not self.connection.is_connected():
  82             self.connection.execute_delayed(self.reconnection_interval,
  83                                             self._connected_checker)
  84             self.jump_server()
  85
  86     def _connect(self):
  87         """[Internal]"""
  88         password = None
  89         if len(self.server_list[0]) > 2:
  90             password = self.server_list[0][2]
  91         try:
  92             self.connect(self.server_list[0][0],
  93                          self.server_list[0][1],
  94                          self._nickname,
  95                          password,
  96                          ircname=self._realname)
  97         except ServerConnectionError:
  98             pass
  99
 100     def _on_disconnect(self, c, e):
 101         """[Internal]"""
 102         self.channels = IRCDict()
 103         self.connection.execute_delayed(self.reconnection_interval,
 104                                         self._connected_checker)
 105
 106     def _on_join(self, c, e):
 107         """[Internal]"""
 108         ch = e.target()
 109         nick = nm_to_n(e.source())
 110         if nick == c.get_nickname():
 111             self.channels[ch] = Channel()
 112         self.channels[ch].add_user(nick)
 113
 114     def _on_kick(self, c, e):
 115         """[Internal]"""
 116         nick = e.arguments()[0]
 117         channel = e.target()
 118
 119         if nick == c.get_nickname():
 120             del self.channels[channel]
 121         else:
 122             self.channels[channel].remove_user(nick)
 123
 124     def _on_mode(self, c, e):
 125         """[Internal]"""
 126         modes = parse_channel_modes(" ".join(e.arguments()))
 127         t = e.target()
 128         if is_channel(t):
 129             ch = self.channels[t]
 130             for mode in modes:
 131                 if mode[0] == "+":
 132                     f = ch.set_mode
 133                 else:
 134                     f = ch.clear_mode
 135                 f(mode[1], mode[2])
 136         else:
 137             # Mode on self... XXX
 138             pass
 139
 140     def _on_namreply(self, c, e):
 141         """[Internal]"""
 142
 143         # e.arguments()[0] == "@" for secret channels,
 144         #                     "*" for private channels,
 145         #                     "=" for others (public channels)
 146         # e.arguments()[1] == channel
 147         # e.arguments()[2] == nick list
 148
 149         ch = e.arguments()[1]
 150         for nick in e.arguments()[2].split():
 151             if nick[0] == "@":
 152                 nick = nick[1:]
 153                 self.channels[ch].set_mode("o", nick)
 154             elif nick[0] == "+":
 155                 nick = nick[1:]
 156                 self.channels[ch].set_mode("v", nick)
 157             self.channels[ch].add_user(nick)
 158
 159     def _on_nick(self, c, e):
 160         """[Internal]"""
 161         before = nm_to_n(e.source())
 162         after = e.target()
 163         for ch in self.channels.values():
 164             if ch.has_user(before):
 165                 ch.change_nick(before, after)
 166
 167     def _on_part(self, c, e):
 168         """[Internal]"""
 169         nick = nm_to_n(e.source())
 170         channel = e.target()
 171
 172         if nick == c.get_nickname():
 173             del self.channels[channel]
 174         else:
 175             self.channels[channel].remove_user(nick)
 176
 177     def _on_quit(self, c, e):
 178         """[Internal]"""
 179         nick = nm_to_n(e.source())
 180         for ch in self.channels.values():
 181             if ch.has_user(nick):
 182                 ch.remove_user(nick)
 183
 184     def die(self, msg="Bye, cruel world!"):
 185         """Let the bot die.
 186
 187         Arguments:
 188
 189             msg -- Quit message.
 190         """
 191
 192         self.connection.disconnect(msg)
 193         sys.exit(0)
 194
 195     def disconnect(self, msg="I'll be back!"):
 196         """Disconnect the bot.
 197
 198         The bot will try to reconnect after a while.
 199
 200         Arguments:
 201
 202             msg -- Quit message.
 203         """
 204         self.connection.disconnect(msg)
 205
 206     def get_version(self):
 207         """Returns the bot version.
 208
 209         Used when answering a CTCP VERSION request.
 210         """
 211         return "ircbot.py by Joel Rosdahl <joel@rosdahl.net>"
 212
 213     def jump_server(self, msg="Changing servers"):
 214         """Connect to a new server, possibly disconnecting from the current.
 215
 216         The bot will skip to next server in the server_list each time
 217         jump_server is called.
 218         """
 219         if self.connection.is_connected():
 220             self.connection.disconnect(msg)
 221
 222         self.server_list.append(self.server_list.pop(0))
 223         self._connect()
 224
 225     def on_ctcp(self, c, e):
 226         """Default handler for ctcp events.
 227
 228         Replies to VERSION and PING requests and relays DCC requests
 229         to the on_dccchat method.
 230         """
 231         if e.arguments()[0] == "VERSION":
 232             c.ctcp_reply(nm_to_n(e.source()),
 233                          "VERSION " + self.get_version())
 234         elif e.arguments()[0] == "PING":
 235             if len(e.arguments()) > 1:
 236                 c.ctcp_reply(nm_to_n(e.source()),
 237                              "PING " + e.arguments()[1])
 238         elif e.arguments()[0] == "DCC" and e.arguments()[1].split(" ", 1)[0] == "CHAT":
 239             self.on_dccchat(c, e)
 240
 241     def on_dccchat(self, c, e):
 242         pass
 243
 244     def start(self):
 245         """Start the bot."""
 246         self._connect()
 247         SimpleIRCClient.start(self)
 248
 249
 250 class IRCDict:
 251     """A dictionary suitable for storing IRC-related things.
 252
 253     Dictionary keys a and b are considered equal if and only if
 254     irc_lower(a) == irc_lower(b)
 255
 256     Otherwise, it should behave exactly as a normal dictionary.
 257     """
 258
 259     def __init__(self, dict=None):
 260         self.data = {}
 261         self.canon_keys = {}  # Canonical keys
 262         if dict is not None:
 263             self.update(dict)
 264     def __repr__(self):
 265         return repr(self.data)
 266     def __cmp__(self, dict):
 267         if isinstance(dict, IRCDict):
 268             return cmp(self.data, dict.data)
 269         else:
 270             return cmp(self.data, dict)
 271     def __len__(self):
 272         return len(self.data)
 273     def __getitem__(self, key):
 274         return self.data[self.canon_keys[irc_lower(key)]]
 275     def __setitem__(self, key, item):
 276         if key in self:
 277             del self[key]
 278         self.data[key] = item
 279         self.canon_keys[irc_lower(key)] = key
 280     def __delitem__(self, key):
 281         ck = irc_lower(key)
 282         del self.data[self.canon_keys[ck]]
 283         del self.canon_keys[ck]
 284     def __iter__(self):
 285         return iter(self.data)
 286     def __contains__(self, key):
 287         return self.has_key(key)
 288     def clear(self):
 289         self.data.clear()
 290         self.canon_keys.clear()
 291     def copy(self):
 292         if self.__class__ is UserDict:
 293             return UserDict(self.data)
 294         import copy
 295         return copy.copy(self)
 296     def keys(self):
 297         return self.data.keys()
 298     def items(self):
 299         return self.data.items()
 300     def values(self):
 301         return self.data.values()
 302     def has_key(self, key):
 303         return irc_lower(key) in self.canon_keys
 304     def update(self, dict):
 305         for k, v in dict.items():
 306             self.data[k] = v
 307     def get(self, key, failobj=None):
 308         return self.data.get(key, failobj)
 309
 310
 311 class Channel:
 312     """A class for keeping information about an IRC channel.
 313
 314     This class can be improved a lot.
 315     """
 316
 317     def __init__(self):
 318         self.userdict = IRCDict()
 319         self.operdict = IRCDict()
 320         self.voiceddict = IRCDict()
 321         self.modes = {}
 322
 323     def users(self):
 324         """Returns an unsorted list of the channel's users."""
 325         return self.userdict.keys()
 326
 327     def opers(self):
 328         """Returns an unsorted list of the channel's operators."""
 329         return self.operdict.keys()
 330
 331     def voiced(self):
 332         """Returns an unsorted list of the persons that have voice
 333         mode set in the channel."""
 334         return self.voiceddict.keys()
 335
 336     def has_user(self, nick):
 337         """Check whether the channel has a user."""
 338         return nick in self.userdict
 339
 340     def is_oper(self, nick):
 341         """Check whether a user has operator status in the channel."""
 342         return nick in self.operdict
 343
 344     def is_voiced(self, nick):
 345         """Check whether a user has voice mode set in the channel."""
 346         return nick in self.voiceddict
 347
 348     def add_user(self, nick):
 349         self.userdict[nick] = 1
 350
 351     def remove_user(self, nick):
 352         for d in self.userdict, self.operdict, self.voiceddict:
 353             if nick in d:
 354                 del d[nick]
 355
 356     def change_nick(self, before, after):
 357         self.userdict[after] = 1
 358         del self.userdict[before]
 359         if before in self.operdict:
 360             self.operdict[after] = 1
 361             del self.operdict[before]
 362         if before in self.voiceddict:
 363             self.voiceddict[after] = 1
 364             del self.voiceddict[before]
 365
 366     def set_mode(self, mode, value=None):
 367         """Set mode on the channel.
 368
 369         Arguments:
 370
 371             mode -- The mode (a single-character string).
 372
 373             value -- Value
 374         """
 375         if mode == "o":
 376             self.operdict[value] = 1
 377         elif mode == "v":
 378             self.voiceddict[value] = 1
 379         else:
 380             self.modes[mode] = value
 381
 382     def clear_mode(self, mode, value=None):
 383         """Clear mode on the channel.
 384
 385         Arguments:
 386
 387             mode -- The mode (a single-character string).
 388
 389             value -- Value
 390         """
 391         try:
 392             if mode == "o":
 393                 del self.operdict[value]
 394             elif mode == "v":
 395                 del self.voiceddict[value]
 396             else:
 397                 del self.modes[mode]
 398         except KeyError:
 399             pass
 400
 401     def has_mode(self, mode):
 402         return mode in self.modes
 403
 404     def is_moderated(self):
 405         return self.has_mode("m")
 406
 407     def is_secret(self):
 408         return self.has_mode("s")
 409
 410     def is_protected(self):
 411         return self.has_mode("p")
 412
 413     def has_topic_lock(self):
 414         return self.has_mode("t")
 415
 416     def is_invite_only(self):
 417         return self.has_mode("i")
 418
 419     def has_allow_external_messages(self):
 420         return self.has_mode("n")
 421
 422     def has_limit(self):
 423         return self.has_mode("l")
 424
 425     def limit(self):
 426         if self.has_limit():
 427             return self.modes[l]
 428         else:
 429             return None
 430
 431     def has_key(self):
 432         return self.has_mode("k")
 433
 434     def key(self):
 435         if self.has_key():
 436             return self.modes["k"]
 437         else:
 438             return None