]> gitweb.pimeys.fr Git - bots/parrot.git/blob - parrot.py
Affichage du contexte des quotes, si présent
[bots/parrot.git] / parrot.py
1 #!/usr/bin/python
2 # -*- encoding: utf-8 -*-
3
4 """ Un bot IRC qui enregistre et ressort des citations """
5
6 import threading
7 import random
8 import time
9 import json
10 import re
11 import os
12 import signal
13 import sys
14
15 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
16 sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
17 import irclib
18 import ircbot
19
20 from commands import getstatusoutput as ex
21
22 #: Config du bot
23 import config
24 #: Module définissant les erreurs
25 import errors
26 #: Module de gestion des quotes
27 import quotes
28
29 # Je veux pouvoir éditer ce que crée ce bot
30 os.umask(002)
31
32 def get_config_logfile(serveur):
33 """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
34 serveurs = {"irc.crans.org" : "crans"}
35 return config.logfile_template % (serveurs[serveur],)
36
37 def log(serveur, channel, auteur=None, message=None):
38 """Enregistre une ligne de log."""
39 if auteur == message == None:
40 # alors c'est que c'est pas un channel mais juste une ligne de log
41 chain = u"%s %s" % (time.strftime("%F %T"), channel)
42 else:
43 chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
44 f = open(get_config_logfile(serveur), "a")
45 f.write((chain + u"\n").encode("utf-8"))
46 f.close()
47 if config.debug_stdout:
48 print chain.encode("utf-8")
49
50 def ignore_event(serv, ev):
51 """Retourne ``True`` si il faut ignorer cet évènement."""
52 for (blackmask, exceptlist) in config.blacklisted_masks:
53 usermask = ev.source()
54 blackit = bool(irclib.mask_matches(usermask, blackmask))
55 exceptit = any([bool(irclib.mask_matches(usermask, exceptmask)) for exceptmask in exceptlist])
56 if exceptit: # Il est exempté
57 return False
58 else:
59 if blackit: # Il n'est pas exempté et matche la blacklist
60 return True
61
62
63 def bot_unicode(chain):
64 """Essaye de décoder ``chain`` en UTF-8.
65 Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
66 try:
67 return chain.decode("utf8")
68 except UnicodeDecodeError as exc:
69 raise errors.UnicodeBotError
70
71
72 class Parrot(ircbot.SingleServerIRCBot):
73 """Classe principale : définition du bot."""
74 def __init__(self, serveur, debug=False):
75 temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
76 ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
77 temporary_pseudo, "Parrot, le bot irc. [Codé par 20-100]", 10)
78 self.debug = debug
79 self.serveur = serveur
80 self.overops = config.overops
81 self.ops = self.overops + config.ops
82 self.report_bugs_to = config.report_bugs_to
83 self.chanlist = config.chanlist
84 self.stay_channels = config.stay_channels
85 self.quiet_channels = config.quiet_channels
86 self.last_perdu = 0
87
88 self.quotedb = quotes.QuoteDB()
89 self.reload_quotes()
90
91
92 ### Utilitaires
93 def _getnick(self):
94 """Récuère le nick effectif du bot sur le serveur."""
95 return self.serv.get_nickname()
96 nick = property(_getnick)
97
98 def give_me_my_pseudo(self, serv):
99 """Récupère le pseudo auprès de NickServ."""
100 serv.privmsg("NickServ", "GHOST %s %s" % (config.irc_pseudo, config.irc_password))
101 serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
102 time.sleep(0.3)
103 serv.nick(config.irc_pseudo)
104
105 def pourmoi(self, serv, message):
106 """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
107 pseudo = self.nick
108 pseudo = pseudo.decode("utf-8")
109 size = len(pseudo)
110 if message[:size] == pseudo and len(message) > size and message[size] == ":":
111 return (True, message[size+1:].lstrip(" "))
112 else:
113 return (False, message)
114
115 ### Exécution d'actions
116 def quitter(self, chan, leave_message=None):
117 """Quitter un channel avec un message customisable."""
118 if leave_message == None:
119 leave_message = random.choice(config.leave_messages)
120 self.serv.part(chan, message=leave_message.encode("utf8"))
121
122 def mourir(self):
123 """Se déconnecter du serveur IRC avec un message customisable."""
124 quit_message = random.choice(config.quit_messages)
125 self.die(msg=quit_message.encode("utf8"))
126
127 def reload_quotes(self):
128 """ Recharge la base de données des quotes et recompile la regexp de quote """
129 self.quotedb.load()
130 self.quote_pattern = re.compile(config.quote_regexp, flags=re.UNICODE)
131
132 def execute_reload(self, auteur=None):
133 """Recharge la config."""
134 reload(config)
135 self.reload_quotes()
136 if auteur in [None, "SIGHUP"]:
137 towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
138 for to in config.report_bugs_to:
139 self.serv.privmsg(to, towrite)
140 log(self.serveur, towrite)
141 return True, None
142 else:
143 return True, u"Config reloaded"
144
145 def crash(self, who="nobody", chan="nowhere"):
146 """Fait crasher le bot."""
147 where = "en privé" if chan == "priv" else "sur le chan %s" % chan
148 raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
149
150 ACTIONS = {
151 "reload" : execute_reload,
152 }
153
154 def execute_something(self, something, params, place=None, auteur=None):
155 """Exécute une action et répond son résultat à ``auteur``
156 sur un chan ou en privé en fonction de ``place``"""
157 action = self.ACTIONS[something]
158 success, message = action(self, **params)
159 if message:
160 if irclib.is_channel(place):
161 message = "%s: %s" % (auteur, message.encode("utf-8"))
162 self.serv.privmsg(place, message)
163 log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
164
165
166 def acknowledge(self, asked_by, asked_where, message):
167 """Répond quelque chose au demandeur d'une action.
168 ``asked_where=None`` signifie en privé."""
169 if asked_where is None:
170 self.serv.privmsg(asked_by, message)
171 else:
172 self.serv.privmsg(asked_where, "%s: %s" % (asked_by, message))
173
174 def dump(self, asked_by, asked_where=None):
175 """Dumpe les quotes. ``asked_where=None`` signifie en privé."""
176 quotes.dump(self.quotedb)
177 self.acknowledge(asked_by, asked_where, "Quotes dumpées")
178
179 def restore(self, asked_by, asked_where=None):
180 """Restaure les quotes à partir du dump. ``asked_where=None`` signifie en privé."""
181 self.quotedb = quotes.restore()
182 self.acknowledge(asked_by, asked_where, "Quotes restaurées à partir du dump (pas de backup effectué).")
183 many = self.quotedb.get_clash_authors()
184 if many:
185 self.acknowledge(asked_by, asked_where, "Auteurs de casse différente : %s" % (many))
186
187 ### Surcharge des events du Bot
188 def on_welcome(self, serv, ev):
189 """À l'arrivée sur le serveur."""
190 self.serv = serv # ça serv ira :)
191 self.give_me_my_pseudo(serv)
192 serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
193 log(self.serveur, "Connected")
194 if self.debug:
195 self.chanlist = ["#bot"]
196 for c in self.chanlist:
197 log(self.serveur, "JOIN %s" % (c))
198 serv.join(c)
199
200 def on_privmsg(self, serv, ev):
201 """À la réception d'un message en privé."""
202 if ignore_event(serv, ev):
203 return
204 message = ev.arguments()[0]
205 auteur = irclib.nm_to_n(ev.source())
206 try:
207 message = bot_unicode(message)
208 except errors.UnicodeBotError:
209 if config.utf8_trigger:
210 serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
211 return
212 message = message.split()
213 cmd = message[0].lower()
214 notunderstood = False
215 if cmd == u"help":
216 op,overop=auteur in self.ops, auteur in self.overops
217 if len(message)==1:
218 helpmsg = config.helpmsg_default
219 if op:
220 helpmsg += config.helpmsg_ops
221 if overop:
222 helpmsg += config.helpmsg_overops
223 else:
224 helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
225 helpmsg = helpmsgs[0]
226 if op and helpmsgs[1]:
227 if helpmsg:
228 helpmsg += "\n" + helpmsgs[1]
229 else:
230 helpmsg = helpmsgs[1]
231 if overop and helpmsgs[2]:
232 if helpmsg:
233 helpmsg += "\n" + helpmsgs[2]
234 else:
235 helpmsg = helpmsgs[2]
236 for ligne in helpmsg.split("\n"):
237 serv.privmsg(auteur, ligne.encode("utf-8"))
238 elif cmd == u"join":
239 if auteur in self.ops:
240 if len(message) > 1:
241 if message[1] in self.chanlist:
242 serv.privmsg(auteur, "Je suis déjà sur %s" % (message[1]))
243 else:
244 serv.join(message[1])
245 self.chanlist.append(message[1])
246 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
247 log(self.serveur, "priv", auteur, " ".join(message))
248 else:
249 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
250 else:
251 notunderstood = True
252 elif cmd == u"leave":
253 if auteur in self.ops and len(message) > 1:
254 if message[1] in self.chanlist:
255 if not (message[1] in self.stay_channels) or auteur in self.overops:
256 self.quitter(message[1].encode("utf-8"), " ".join(message[2:]))
257 self.chanlist.remove(message[1])
258 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
259 else:
260 serv.privmsg(auteur, "Non, je reste !")
261 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
262 else:
263 serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
264 else:
265 notunderstood = True
266 elif cmd == u"stay":
267 if auteur in self.overops:
268 if len(message) > 1:
269 if message[1] in self.stay_channels:
270 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
271 serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
272 else:
273 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
274 self.stay_channels.append(message[1])
275 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
276 else:
277 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
278 else:
279 notunderstood = True
280 elif cmd == u"nostay":
281 if auteur in self.overops:
282 if len(message) > 1:
283 if message[1] in self.stay_channels:
284 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
285 self.stay_channels.remove(message[1])
286 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
287 else:
288 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
289 serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
290 else:
291 notunderstood = True
292 elif cmd == u"die":
293 if auteur in self.overops:
294 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
295 self.mourir()
296 else:
297 notunderstood = True
298 elif cmd == u"crash":
299 if auteur in self.overops:
300 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
301 self.crash(auteur, "priv")
302 else:
303 notunderstood = True
304 elif cmd == u"reload":
305 if auteur in self.ops:
306 self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
307 else:
308 notunderstood = True
309 elif cmd == u"quiet":
310 if auteur in self.ops:
311 if len(message) > 1:
312 if message[1] in self.quiet_channels:
313 serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
314 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
315 else:
316 self.quiet_channels.append(message[1])
317 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
318 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
319 else:
320 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
321 else:
322 notunderstood = True
323 elif cmd == u"noquiet":
324 if auteur in self.ops:
325 if len(message) > 1:
326 if message[1] in self.quiet_channels:
327 self.quiet_channels.remove(message[1])
328 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
329 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
330 else:
331 serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
332 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
333 else:
334 notunderstood = True
335 elif cmd == u"say":
336 if auteur in self.overops and len(message) > 2:
337 serv.privmsg(message[1].encode("utf-8"), (u" ".join(message[2:])).encode("utf-8"))
338 log(self.serveur, "priv", auteur, " ".join(message))
339 elif len(message) <= 2:
340 serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
341 else:
342 notunderstood = True
343 elif cmd == u"do":
344 if auteur in self.overops and len(message) > 2:
345 serv.action(message[1], " ".join(message[2:]))
346 log(self.serveur, "priv", auteur, " ".join(message))
347 elif len(message) <= 2:
348 serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
349 else:
350 notunderstood = True
351 elif cmd == u"kick":
352 if auteur in self.overops and len(message) > 2:
353 serv.kick(message[1].encode("utf-8"), message[2].encode("utf-8"), " ".join(message[3:]).encode("utf-8"))
354 log(self.serveur, "priv", auteur, " ".join(message))
355 elif len(message) <= 2:
356 serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
357 else:
358 notunderstood = True
359 elif cmd == u"ops":
360 if auteur in self.overops:
361 serv.privmsg(auteur, " ".join(self.ops))
362 else:
363 notunderstood = True
364 elif cmd == u"overops":
365 if auteur in self.overops:
366 serv.privmsg(auteur, " ".join(self.overops))
367 else:
368 notunderstood = True
369 elif cmd == u"dump" and auteur in self.ops:
370 self.dump(asked_by=auteur)
371 elif cmd == u"restore" and auteur in self.overops:
372 self.restore(asked_by=auteur)
373 else:
374 notunderstood = True
375 if notunderstood:
376 serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
377
378 def on_pubmsg(self, serv, ev):
379 """À la réception d'un message sur un channel."""
380 if ignore_event(serv, ev):
381 return
382 auteur = irclib.nm_to_n(ev.source())
383 canal = ev.target()
384 message = ev.arguments()[0]
385 try:
386 message = bot_unicode(message)
387 except errors.UnicodeBotError:
388 if config.utf8_trigger and not canal in self.quiet_channels:
389 serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
390 return
391 pour_moi, message = self.pourmoi(serv, message)
392 if pour_moi and message.split()!=[]:
393 cmd = message.split()[0].lower()
394 try:
395 args = " ".join(message.split()[1:])
396 except:
397 args = ""
398 if cmd in [u"meurs", u"die", u"crève"]:
399 if auteur in self.overops:
400 log(self.serveur, canal, auteur, message + "[successful]")
401 self.mourir()
402 else:
403 serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
404 log(self.serveur, canal, auteur, message + "[failed]")
405 elif cmd == u"reload":
406 if auteur in self.ops:
407 self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
408 elif cmd == u"crash":
409 if auteur in self.overops:
410 self.crash(auteur, canal)
411 elif cmd in [u"part", u"leave", u"dégage", u"va-t-en"]:
412 if auteur in self.ops and (not (canal in self.stay_channels)
413 or auteur in self.overops):
414 self.quitter(canal)
415 log(self.serveur, canal, auteur, message + "[successful]")
416 if canal in self.chanlist:
417 self.chanlist.remove(canal)
418 else:
419 serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
420 log(self.serveur, canal, auteur, message + "[failed]")
421
422 elif cmd in [u"ping"] and not canal in self.quiet_channels:
423 serv.privmsg(canal, "%s: pong" % (auteur))
424 elif cmd in [u"dump"]:
425 self.dump(asked_by=auteur, asked_where=canal)
426 elif cmd in [u"restore"] and auteur in self.overops:
427 self.restore(asked_by=auteur, asked_where=canal)
428 elif cmd in [u"display"]:
429 self.serv.privmsg(canal, "%s: %s" % (auteur, config.quote_display_url.encode("utf-8")))
430 else:
431 # Vu que ce bot est prévu pour parser des quotes il va falloir bosser ici
432 match = self.quote_pattern.match(message)
433 if match:
434 d = match.groupdict()
435 # On n'autorise pas les gens à déclarer le quoter
436 d["quoter"] = auteur.decode("utf-8")
437 if self.quotedb.store(**d):
438 serv.privmsg(canal, (u"%s: Ce sera retenu, répété, amplifié" % (auteur,)).encode("utf-8"))
439 self.quotedb.save()
440 else:
441 serv.privmsg(canal, (u"%s: Je le savais déjà." % (auteur,)).encode("utf-8"))
442 if message.startswith(u"!quote"):
443 if message.strip() == u"!quote":
444 q = self.quotedb.random()
445 serv.privmsg(canal, str(q))
446 elif message.startswith("!quote "):
447 author = message[7:].strip()
448 try:
449 q = self.quotedb.randomfrom(author)
450 except IndexError:
451 serv.privmsg(canal, (u"Pas de quote de %s en mémoire." % author).encode("utf-8"))
452 return
453 serv.privmsg(canal, str(q))
454 elif message.startswith(u"!author") or message.startswith(u"!from"):
455 words = message.split()
456 cmd = words[0].lstrip("!")
457 regexp = any([cmd.endswith(suffix) for suffix in config.regex_suffixes])
458 search = u" ".join(words[1:])
459 authors = self.quotedb.search_authors(search, regexp)
460 if not authors:
461 serv.privmsg(canal, "%s: Pas d'auteur correspondant à la recherche." % (auteur,))
462 return
463 if cmd.startswith("author"):
464 if len(authors) > config.search_max_authors:
465 authors = authors[:config.search_max_authors+1] + ["+%s" % (len(authors) - config.search_max_authors)]
466 serv.privmsg(canal, "%s: %s" % (auteur, (u", ".join(authors)).encode("utf-8")))
467 elif cmd.startswith("from"):
468 quotes = sum([self.quotedb.quotesfrom(a) for a in authors], [])
469 q = random.choice(quotes)
470 serv.privmsg(canal, str(q))
471 elif message.startswith(u"!search"):
472 words = message.split()
473 cmd = words[0].lstrip("!")
474 regexp = cmd in ["search" + suffix for suffix in config.regex_suffixes]
475 search = u" ".join(words[1:])
476 quotes = self.quotedb.search(inquote=search, regexp=regexp)
477 if quotes:
478 q = random.choice(quotes)
479 serv.privmsg(canal, str(q))
480 else:
481 serv.privmsg(canal, "%s: Pas de quotes correspondant à la recherche." % (auteur,))
482
483 def on_action(self, serv, ev):
484 """À la réception d'une action."""
485 if ignore_event(serv, ev):
486 return
487 action = ev.arguments()[0]
488 auteur = irclib.nm_to_n(ev.source())
489 channel = ev.target()
490 try:
491 action = bot_unicode(action)
492 except errors.UnicodeBotError:
493 if config.utf8_trigger and not channel in self.quiet_channels:
494 serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
495 return
496 mypseudo = self.nick
497
498 def on_kick(self, serv, ev):
499 """À la réception d'une action."""
500 auteur = irclib.nm_to_n(ev.source())
501 channel = ev.target()
502 victime = ev.arguments()[0]
503 raison = ev.arguments()[1]
504 if victime == self.nick:
505 log(self.serveur, ("%s kické de %s par %s (raison : %s)" % (victime, channel, auteur, raison)).decode("utf-8"))
506 time.sleep(2)
507 serv.join(channel)
508
509 ### .fork trick
510 def start_as_daemon(self, outfile):
511 sys.stderr = Logger(outfile)
512 self.start()
513
514
515 class Logger(object):
516 """Pour écrire ailleurs que sur stdout"""
517 def __init__(self, filename="parrot.full.log"):
518 self.filename = filename
519
520 def write(self, message):
521 f = open(self.filename, "a")
522 f.write(message)
523 f.close()
524
525 def main():
526 """Exécution principale : lecture des paramètres et lancement du bot."""
527 if len(sys.argv) == 1:
528 print "Usage : parrot.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
529 print " --outfile sans --no-output ni --daemon n'a aucun effet"
530 exit(1)
531 serveur = sys.argv[1]
532 if "--daemon" in sys.argv:
533 thisfile = os.path.realpath(__file__)
534 thisdirectory = thisfile.rsplit("/", 1)[0]
535 os.chdir(thisdirectory)
536 daemon = True
537 else:
538 daemon = False
539 if "debug" in sys.argv or "--debug" in sys.argv:
540 debug = True
541 else:
542 debug = False
543 if "--quiet" in sys.argv:
544 config.debug_stdout = False
545 serveurs = {
546 "irc" : "irc.crans.org",
547 "crans" : "irc.crans.org",
548 "irc.crans.org" : "irc.crans.org"}
549 if "--no-output" in sys.argv or "--daemon" in sys.argv:
550 outfile = "/var/log/bots/parrot.full.log"
551 for arg in sys.argv:
552 arg = arg.split("=")
553 if arg[0].strip('-') in ["out", "outfile", "logfile"]:
554 outfile = arg[1]
555 sys.stdout = Logger(outfile)
556 try:
557 serveur = serveurs[serveur]
558 except KeyError:
559 print "Server Unknown : %s" % (serveur)
560 exit(404)
561 parrot = Parrot(serveur,debug)
562 # Si on reçoit un SIGHUP, on reload la config
563 def sighup_handler(signum, frame):
564 parrot.execute_reload(auteur="SIGHUP")
565 signal.signal(signal.SIGHUP, sighup_handler)
566 # Daemonization
567 if daemon:
568 child_pid = os.fork()
569 if child_pid == 0:
570 os.setsid()
571 parrot.start_as_daemon(outfile)
572 else:
573 # on enregistre le pid de parrot
574 pidfile = "/var/run/bots/parrot.pid"
575 for arg in sys.argv:
576 arg = arg.split("=")
577 if arg[0].strip('-') in ["pidfile"]:
578 pidfile = arg[1]
579 f = open(pidfile, "w")
580 f.write("%s\n" % child_pid)
581 f.close()
582 else:
583 parrot.start()
584
585 if __name__ == "__main__":
586 main()