]>
gitweb.pimeys.fr Git - bots/parrot.git/blob - parrot.py
2 # -*- encoding: utf-8 -*-
4 """ Un bot IRC qui enregistre et ressort des citations """
15 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
16 sys
.path
.insert(0, "/home/vincent/scripts/python-myirclib")
20 from commands
import getstatusoutput
as ex
24 #: Module définissant les erreurs
26 #: Module de gestion des quotes
29 # Je veux pouvoir éditer ce que crée ce bot
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
],)
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
)
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"))
47 if config
.debug_stdout
:
48 print chain
.encode("utf-8")
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é
59 if blackit
: # Il n'est pas exempté et matche la blacklist
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."""
67 return chain
.decode("utf-8")
68 except UnicodeDecodeError as exc
:
69 raise errors
.UnicodeBotError
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)
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
88 self
.quotedb
= quotes
.QuoteDB()
94 """Récuère le nick effectif du bot sur le serveur."""
95 return self
.serv
.get_nickname()
96 nick
= property(_getnick
)
98 def give_me_my_pseudo(self
, serv
):
99 """Récupère le pseudo auprès de NickServ."""
100 serv
.privmsg("NickServ", "RECOVER %s %s" % (config
.irc_pseudo
, config
.irc_password
))
102 serv
.nick(config
.irc_pseudo
)
104 def pourmoi(self
, serv
, message
):
105 """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
107 pseudo
= pseudo
.decode("utf-8")
109 if message
[:size
] == pseudo
and len(message
) > size
and message
[size
] == ":":
110 return (True, message
[size
+1:].lstrip(" "))
112 return (False, message
)
114 ### Exécution d'actions
115 def quitter(self
, chan
, leave_message
=None):
116 """Quitter un channel avec un message customisable."""
117 if leave_message
== None:
118 leave_message
= random
.choice(config
.leave_messages
)
119 self
.serv
.part(chan
, message
=leave_message
.encode("utf-8"))
122 """Se déconnecter du serveur IRC avec un message customisable."""
123 quit_message
= random
.choice(config
.quit_messages
)
124 self
.die(msg
=quit_message
.encode("utf-8"))
126 def reload_quotes(self
):
127 """ Recharge la base de données des quotes et recompile la regexp de quote """
129 self
.quote_pattern
= re
.compile(config
.quote_regexp
, flags
=re
.UNICODE
)
131 def execute_reload(self
, auteur
=None):
132 """Recharge la config."""
135 if auteur
in [None, "SIGHUP"]:
136 towrite
= "Config reloaded" + " (SIGHUP received)" * (auteur
== "SIGHUP")
137 for to
in config
.report_bugs_to
:
138 self
.serv
.privmsg(to
, towrite
)
139 log(self
.serveur
, towrite
)
142 return True, u
"Config reloaded"
144 def crash(self
, who
="nobody", chan
="nowhere"):
145 """Fait crasher le bot."""
146 where
= "en privé" if chan
== "priv" else "sur le chan %s" % chan
147 raise errors
.CrashError((u
"Crash demandé par %s %s" % (who
, where
)).encode("utf-8"))
150 "reload" : execute_reload
,
153 def execute_something(self
, something
, params
, place
=None, auteur
=None):
154 """Exécute une action et répond son résultat à ``auteur``
155 sur un chan ou en privé en fonction de ``place``"""
156 action
= self
.ACTIONS
[something
]
157 success
, message
= action(self
, **params
)
159 if irclib
.is_channel(place
):
160 message
= "%s: %s" % (auteur
, message
.encode("utf-8"))
161 self
.serv
.privmsg(place
, message
)
162 log(self
.serveur
, place
, auteur
, something
+ "%r" % params
+ ("[successful]" if success
else "[failed]"))
165 def acknowledge(self
, asked_by
, asked_where
, message
):
166 """Répond quelque chose au demandeur d'une action.
167 ``asked_where=None`` signifie en privé."""
168 if asked_where
is None:
169 self
.serv
.privmsg(asked_by
, message
)
171 self
.serv
.privmsg(asked_where
, "%s: %s" % (asked_by
, message
))
173 def dump(self
, asked_by
, asked_where
=None):
174 """Dumpe les quotes. ``asked_where=None`` signifie en privé."""
175 quotes
.dump(self
.quotedb
)
176 self
.acknowledge(asked_by
, asked_where
, "Quotes dumpées")
178 def restore(self
, asked_by
, asked_where
=None):
179 """Restaure les quotes à partir du dump. ``asked_where=None`` signifie en privé."""
180 self
.quotedb
= quotes
.restore()
181 self
.acknowledge(asked_by
, asked_where
, "Quotes restaurées à partir du dump (pas de backup effectué).")
182 many
= self
.quotedb
.get_clash_authors()
184 self
.acknowledge(asked_by
, asked_where
, "Auteurs de casse différente : %s" % (many
))
186 ### Surcharge des events du Bot
187 def on_welcome(self
, serv
, ev
):
188 """À l'arrivée sur le serveur."""
189 self
.serv
= serv
# ça serv ira :)
190 self
.give_me_my_pseudo(serv
)
191 serv
.privmsg("NickServ", "IDENTIFY %s" % (config
.irc_password
))
192 log(self
.serveur
, "Connected")
194 self
.chanlist
= ["#bot"]
195 for c
in self
.chanlist
:
196 log(self
.serveur
, "JOIN %s" % (c
))
199 def on_privmsg(self
, serv
, ev
):
200 """À la réception d'un message en privé."""
201 if ignore_event(serv
, ev
):
203 message
= ev
.arguments()[0]
204 auteur
= irclib
.nm_to_n(ev
.source())
206 message
= bot_unicode(message
)
207 except errors
.UnicodeBotError
:
208 if config
.utf8_trigger
:
209 serv
.privmsg(auteur
, random
.choice(config
.utf8_fail_answers
).encode("utf-8"))
211 message
= message
.split()
212 cmd
= message
[0].lower()
213 notunderstood
= False
215 op
,overop
=auteur
in self
.ops
, auteur
in self
.overops
217 helpmsg
= config
.helpmsg_default
219 helpmsg
+= config
.helpmsg_ops
221 helpmsg
+= config
.helpmsg_overops
223 helpmsgs
= config
.helpdico
.get(message
[1].lower(), ["Commande inconnue.", None, None])
224 helpmsg
= helpmsgs
[0]
225 if op
and helpmsgs
[1]:
227 helpmsg
+= "\n" + helpmsgs
[1]
229 helpmsg
= helpmsgs
[1]
230 if overop
and helpmsgs
[2]:
232 helpmsg
+= "\n" + helpmsgs
[2]
234 helpmsg
= helpmsgs
[2]
235 for ligne
in helpmsg
.split("\n"):
236 serv
.privmsg(auteur
, ligne
.encode("utf-8"))
238 if auteur
in self
.ops
:
240 if message
[1] in self
.chanlist
:
241 serv
.privmsg(auteur
, "Je suis déjà sur %s" % (message
[1]))
243 serv
.join(message
[1])
244 self
.chanlist
.append(message
[1])
245 serv
.privmsg(auteur
, "Channels : " + " ".join(self
.chanlist
))
246 log(self
.serveur
, "priv", auteur
, " ".join(message
))
248 serv
.privmsg(auteur
, "Channels : " + " ".join(self
.chanlist
))
251 elif cmd
== u
"leave":
252 if auteur
in self
.ops
and len(message
) > 1:
253 if message
[1] in self
.chanlist
:
254 if not (message
[1] in self
.stay_channels
) or auteur
in self
.overops
:
255 self
.quitter(message
[1].encode("utf-8"), " ".join(message
[2:]))
256 self
.chanlist
.remove(message
[1])
257 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
259 serv
.privmsg(auteur
, "Non, je reste !")
260 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[failed]")
262 serv
.privmsg(auteur
, "Je ne suis pas sur %s" % (message
[1]))
266 if auteur
in self
.overops
:
268 if message
[1] in self
.stay_channels
:
269 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[failed]")
270 serv
.privmsg(auteur
, "Je stay déjà sur %s." % (message
[1]))
272 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
273 self
.stay_channels
.append(message
[1])
274 serv
.privmsg(auteur
, "Stay channels : " + " ".join(self
.stay_channels
))
276 serv
.privmsg(auteur
, "Stay channels : " + " ".join(self
.stay_channels
))
279 elif cmd
== u
"nostay":
280 if auteur
in self
.overops
:
282 if message
[1] in self
.stay_channels
:
283 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
284 self
.stay_channels
.remove(message
[1])
285 serv
.privmsg(auteur
, "Stay channels : " + " ".join(self
.stay_channels
))
287 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[failed]")
288 serv
.privmsg(auteur
, "Je ne stay pas sur %s." % (message
[1]))
292 if auteur
in self
.overops
:
293 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
297 elif cmd
== u
"crash":
298 if auteur
in self
.overops
:
299 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
300 self
.crash(auteur
, "priv")
303 elif cmd
== u
"reload":
304 if auteur
in self
.ops
:
305 self
.execute_something("reload", {"auteur" : auteur
}, place
=auteur
, auteur
=auteur
)
308 elif cmd
== u
"quiet":
309 if auteur
in self
.ops
:
311 if message
[1] in self
.quiet_channels
:
312 serv
.privmsg(auteur
, "Je me la ferme déjà sur %s" % (message
[1]))
313 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[failed]")
315 self
.quiet_channels
.append(message
[1])
316 serv
.privmsg(auteur
, "Quiet channels : " + " ".join(self
.quiet_channels
))
317 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
319 serv
.privmsg(auteur
, "Quiet channels : " + " ".join(self
.quiet_channels
))
322 elif cmd
== u
"noquiet":
323 if auteur
in self
.ops
:
325 if message
[1] in self
.quiet_channels
:
326 self
.quiet_channels
.remove(message
[1])
327 serv
.privmsg(auteur
, "Quiet channels : " + " ".join(self
.quiet_channels
))
328 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[successful]")
330 serv
.privmsg(auteur
, "Je ne me la ferme pas sur %s." % (message
[1]))
331 log(self
.serveur
, "priv", auteur
, " ".join(message
) + "[failed]")
335 if auteur
in self
.overops
and len(message
) > 2:
336 serv
.privmsg(message
[1].encode("utf-8"), (u
" ".join(message
[2:])).encode("utf-8"))
337 log(self
.serveur
, "priv", auteur
, " ".join(message
))
338 elif len(message
) <= 2:
339 serv
.privmsg(auteur
, "Syntaxe : SAY <channel> <message>")
343 if auteur
in self
.overops
and len(message
) > 2:
344 serv
.action(message
[1], " ".join(message
[2:]))
345 log(self
.serveur
, "priv", auteur
, " ".join(message
))
346 elif len(message
) <= 2:
347 serv
.privmsg(auteur
, "Syntaxe : DO <channel> <action>")
351 if auteur
in self
.overops
and len(message
) > 2:
352 serv
.kick(message
[1].encode("utf-8"), message
[2].encode("utf-8"), " ".join(message
[3:]).encode("utf-8"))
353 log(self
.serveur
, "priv", auteur
, " ".join(message
))
354 elif len(message
) <= 2:
355 serv
.privmsg(auteur
, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
359 if auteur
in self
.overops
:
360 serv
.privmsg(auteur
, " ".join(self
.ops
))
363 elif cmd
== u
"overops":
364 if auteur
in self
.overops
:
365 serv
.privmsg(auteur
, " ".join(self
.overops
))
368 elif cmd
== u
"dump" and auteur
in self
.ops
:
369 self
.dump(asked_by
=auteur
)
370 elif cmd
== u
"restore" and auteur
in self
.overops
:
371 self
.restore(asked_by
=auteur
)
375 serv
.privmsg(auteur
, "Je n'ai pas compris. Essayez HELP…")
377 def on_pubmsg(self
, serv
, ev
):
378 """À la réception d'un message sur un channel."""
379 if ignore_event(serv
, ev
):
381 auteur
= irclib
.nm_to_n(ev
.source())
383 message
= ev
.arguments()[0]
385 message
= bot_unicode(message
)
386 except errors
.UnicodeBotError
:
387 if config
.utf8_trigger
and not canal
in self
.quiet_channels
:
388 serv
.privmsg(canal
, (u
"%s: %s"% ( auteur
, random
.choice(config
.utf8_fail_answers
))).encode("utf-8"))
390 pour_moi
, message
= self
.pourmoi(serv
, message
)
391 if pour_moi
and message
.split()!=[]:
392 cmd
= message
.split()[0].lower()
394 args
= " ".join(message
.split()[1:])
397 if cmd
in [u
"meurs", u
"die", u
"crève"]:
398 if auteur
in self
.overops
:
399 log(self
.serveur
, canal
, auteur
, message
+ "[successful]")
402 serv
.privmsg(canal
,(u
"%s: %s"%(auteur
, random
.choice(config
.quit_fail_messages
))).encode("utf-8"))
403 log(self
.serveur
, canal
, auteur
, message
+ "[failed]")
404 elif cmd
== u
"reload":
405 if auteur
in self
.ops
:
406 self
.execute_something("reload", {"auteur" : auteur
}, place
=canal
, auteur
=auteur
)
407 elif cmd
== u
"crash":
408 if auteur
in self
.overops
:
409 self
.crash(auteur
, canal
)
410 elif cmd
in [u
"part", u
"leave", u
"dégage", u
"va-t-en"]:
411 if auteur
in self
.ops
and (not (canal
in self
.stay_channels
)
412 or auteur
in self
.overops
):
414 log(self
.serveur
, canal
, auteur
, message
+ "[successful]")
415 if canal
in self
.chanlist
:
416 self
.chanlist
.remove(canal
)
418 serv
.privmsg(canal
,(u
"%s: %s" % (auteur
, random
.choice(config
.leave_fail_messages
))).encode("utf-8"))
419 log(self
.serveur
, canal
, auteur
, message
+ "[failed]")
421 elif cmd
in [u
"ping"] and not canal
in self
.quiet_channels
:
422 serv
.privmsg(canal
, "%s: pong" % (auteur
))
423 elif cmd
in [u
"dump"]:
424 self
.dump(asked_by
=auteur
, asked_where
=canal
)
425 elif cmd
in [u
"restore"] and auteur
in self
.overops
:
426 self
.restore(asked_by
=auteur
, asked_where
=canal
)
427 elif cmd
in [u
"display", u
"link", u
"url"]:
428 self
.serv
.privmsg(canal
, "%s: %s" % (auteur
, config
.quote_display_url
.encode("utf-8")))
430 # Vu que ce bot est prévu pour parser des quotes il va falloir bosser ici
431 match
= self
.quote_pattern
.match(message
)
433 d
= match
.groupdict()
434 # On n'autorise pas les gens à déclarer le quoter
435 d
["quoter"] = auteur
.decode("utf-8")
436 if self
.quotedb
.store(**d
):
437 serv
.privmsg(canal
, (u
"%s: Ce sera retenu, répété, amplifié" % (auteur
,)).encode("utf-8"))
440 serv
.privmsg(canal
, (u
"%s: Je le savais déjà." % (auteur
,)).encode("utf-8"))
441 # Whou, attention, hack dégueu
442 # on enlève context- au début des !commands si il y est,
443 # et on passe à True le paramètre show_context pour s'en souvenir
445 if message
.startswith(u
"!context-"):
447 message
= u
"!" + message
[9:]
448 if message
.startswith(u
"!quote"):
449 if message
.strip() == u
"!quote":
450 q
= self
.quotedb
.random()
451 serv
.privmsg(canal
, q
.display(show_context
))
452 elif message
.startswith("!quote "):
453 author
= message
[7:].strip()
455 q
= self
.quotedb
.randomfrom(author
)
457 serv
.privmsg(canal
, (u
"Pas de quote de %s en mémoire." % author
).encode("utf-8"))
459 serv
.privmsg(canal
, q
.display(show_context
))
460 elif message
.startswith(u
"!author") or message
.startswith(u
"!from"):
461 words
= message
.split()
462 cmd
= words
[0].lstrip("!")
463 regexp
= any([cmd
.endswith(suffix
) for suffix
in config
.regex_suffixes
])
464 search
= u
" ".join(words
[1:])
465 authors
= self
.quotedb
.search_authors(search
, regexp
)
467 serv
.privmsg(canal
, "%s: Pas d'auteur correspondant à la recherche." % (auteur
,))
469 if cmd
.startswith("author"):
470 if len(authors
) > config
.search_max_authors
:
471 authors
= authors
[:config
.search_max_authors
+1] + ["+%s" % (len(authors
) - config
.search_max_authors
)]
472 serv
.privmsg(canal
, "%s: %s" % (auteur
, (u
", ".join(authors
)).encode("utf-8")))
473 elif cmd
.startswith("from"):
474 quotes
= sum([self
.quotedb
.quotesfrom(a
) for a
in authors
], [])
475 q
= random
.choice(quotes
)
476 serv
.privmsg(canal
, q
.display(show_context
))
477 elif message
.startswith(u
"!search"):
478 words
= message
.split()
479 cmd
= words
[0].lstrip("!")
480 regexp
= cmd
in ["search" + suffix
for suffix
in config
.regex_suffixes
]
481 search
= u
" ".join(words
[1:])
482 quotes
= self
.quotedb
.search(inquote
=search
, regexp
=regexp
)
483 # On recherche également sur le contexte si on est en !context-search
485 quotes
+= self
.quotedb
.search(place
=search
, regexp
=regexp
)
486 # Pour pas biaiser le choix aléatoire, on enlève les doublons
487 quotes
= list(set(quotes
))
489 q
= random
.choice(quotes
)
490 serv
.privmsg(canal
, q
.display(show_context
))
492 serv
.privmsg(canal
, "%s: Pas de quotes correspondant à la recherche." % (auteur
,))
494 def on_action(self
, serv
, ev
):
495 """À la réception d'une action."""
496 if ignore_event(serv
, ev
):
498 action
= ev
.arguments()[0]
499 auteur
= irclib
.nm_to_n(ev
.source())
500 channel
= ev
.target()
502 action
= bot_unicode(action
)
503 except errors
.UnicodeBotError
:
504 if config
.utf8_trigger
and not channel
in self
.quiet_channels
:
505 serv
.privmsg(channel
, (u
"%s: %s"%(auteur
,random
.choice(config
.utf8_fail_answers
))).encode("utf-8"))
509 def on_kick(self
, serv
, ev
):
510 """À la réception d'une action."""
511 auteur
= irclib
.nm_to_n(ev
.source())
512 channel
= ev
.target()
513 victime
= ev
.arguments()[0]
514 raison
= ev
.arguments()[1]
515 if victime
== self
.nick
:
516 log(self
.serveur
, ("%s kické de %s par %s (raison : %s)" % (victime
, channel
, auteur
, raison
)).decode("utf-8"))
521 def start_as_daemon(self
, outfile
):
522 sys
.stderr
= Logger(outfile
)
526 class Logger(object):
527 """Pour écrire ailleurs que sur stdout"""
528 def __init__(self
, filename
="parrot.full.log"):
529 self
.filename
= filename
531 def write(self
, message
):
532 f
= open(self
.filename
, "a")
537 """Exécution principale : lecture des paramètres et lancement du bot."""
538 if len(sys
.argv
) == 1:
539 print "Usage : parrot.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
540 print " --outfile sans --no-output ni --daemon n'a aucun effet"
542 serveur
= sys
.argv
[1]
543 if "--daemon" in sys
.argv
:
544 thisfile
= os
.path
.realpath(__file__
)
545 thisdirectory
= thisfile
.rsplit("/", 1)[0]
546 os
.chdir(thisdirectory
)
550 if "debug" in sys
.argv
or "--debug" in sys
.argv
:
554 if "--quiet" in sys
.argv
:
555 config
.debug_stdout
= False
557 "irc" : "irc.crans.org",
558 "crans" : "irc.crans.org",
559 "irc.crans.org" : "irc.crans.org"}
560 if "--no-output" in sys
.argv
or "--daemon" in sys
.argv
:
561 outfile
= "/var/log/bots/parrot.full.log"
564 if arg
[0].strip('-') in ["out", "outfile", "logfile"]:
566 sys
.stdout
= Logger(outfile
)
568 serveur
= serveurs
[serveur
]
570 print "Server Unknown : %s" % (serveur
)
572 parrot
= Parrot(serveur
,debug
)
573 # Si on reçoit un SIGHUP, on reload la config
574 def sighup_handler(signum
, frame
):
575 parrot
.execute_reload(auteur
="SIGHUP")
576 signal
.signal(signal
.SIGHUP
, sighup_handler
)
579 child_pid
= os
.fork()
582 parrot
.start_as_daemon(outfile
)
584 # on enregistre le pid de parrot
585 pidfile
= "/var/run/bots/parrot.pid"
588 if arg
[0].strip('-') in ["pidfile"]:
590 f
= open(pidfile
, "w")
591 f
.write("%s\n" % child_pid
)
596 if __name__
== "__main__":