--- /dev/null
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+""" Configuration de Basile """
+
+#: Faut-il débuguer sur la sortie standard par défaut ?
+debug_stdout = True
+
+## La config irc-related
+#: Mot de passe NickServ. TODO : le mettre dans un secrets.py
+irc_password = "1iuh0HiJKWjuE"
+#: Pseudo IRC
+irc_pseudo = "Parrot"
+#: Liste des channels à rejoindre
+chanlist = ["#bot", "#flood"]
+#: Liste des channels à ne pas quitter
+stay_channels = ["#bot", "#flood"]
+#: Liste des channels où se taire
+quiet_channels = []
+
+#: Le template des noms de fichier de log
+logfile_template = "parrot.%s.log"
+
+#: Les OVEROPs, tous les droits sur le bot
+overops=["[20-100]","[20-100]_c"]
+#: Les OPs, moins de droits que les OVEROPs
+ops=[]
+#: À qui s'adresser (par IRC) quand le bot rencontre une erreur
+report_bugs_to=["[20-100]"]
+
+#: config UTF8-fail
+utf8_fail_answers = [u"« Encodings : you need to stop the pain » ~ Ned Batchelder"]
+#: Doit-on râler en cas de fial d'UTF-8
+utf8_trigger = True
+
+#: config "tais-toi"
+tag_triggers = [u"t(|a)g", u"ta gueule", u"la ferme", u"ferme( |-)la", u"tais-toi", u"chut", u"tu fais trop de bruit", u"tu parles trop"]
+tag_actions = [u"ne citera plus"]
+tag_answers = [
+u"« Un grand pouvoir implique de grandes responsabilités » ~ Oncle Ben.",
+]
+
+#: config on m'a demandé de mourir/partir
+quit_messages = [u"« » ~ "]
+leave_messages = quit_messages
+
+quit_fail_messages = [u" « » ~ "]
+leave_fail_messages = quit_fail_messages
+
+#: Aide sur les commandes
+helpdico = {
+"help" : [u"""HELP <commande>
+ Affiche de l'aide sur la commande""", None, None],
+
+"join" : [None, u"""JOIN <channel>
+ Me fait rejoindre le channel""", None],
+
+"leave" : [None, u"""LEAVE <channel>
+ Me fait quitter le channel (sauf s'il est dans ma stay_list).""", None],
+
+"quiet" : [None, u"""QUIET <channel>
+ Me rend silencieux sur le channel.""", None],
+
+"noquiet" : [None, u"""NOQUIET <channel>
+ Me rend la parole sur le channel.""", None],
+
+"lost" : [None, u"""LOST <channel>
+ Me fait perdre sur le channel.""", None],
+
+"reload" : [None, u"""RELOAD
+ Recharge la configuration.""", None],
+
+"say" : [None, None, u"""SAY <channel> <message>
+ Me fait parler sur le channel."""],
+
+"do" : [None, None, u"""DO <channel> <action>
+ Me fait faitre une action (/me) sur le channel."""],
+
+"stay" : [None, None, u"""STAY <channel>
+ Ajoute le channel à ma stay_list."""],
+
+"nostay" : [None, None, u"""NOSTAY <channel>
+ Retire le channel de ma stay_list."""],
+
+"ops" : [None, None, u"""OPS
+ Affiche la liste des ops."""],
+
+"overops" : [None, None, u"""OVEROPS
+ Affiche la liste des overops."""],
+
+"kick" : [None, None, u"""KICK <channel> <pseudo> [<raison>]
+ Kicke <pseudo> du channel (Il faut bien entendu que j'y sois op)."""],
+
+"die" : [None, None, u"""DIE
+ Me déconnecte du serveur IRC."""],
+
+"crash" : [None, None, u"""CRASH
+ Me fait crasher"""]
+ }
+
+#: Message d'aide par défaut
+helpmsg_default = u"Liste des commandes disponibles :\nHELP"
+#: Message d'aide par défaut à ajouter pour les OPs
+helpmsg_ops = u" JOIN LEAVE QUIET NOQUIET RELOAD"
+#: Message d'aide par défaut à ajouter pour les OVEROPs
+helpmsg_overops = u" SAY DO STAY NOSTAY OPS OVEROPS KICK DIE CRASH"
+
+#: Liste de paires de masques ``[black, exceptlist]`` : on blacklistera ce qui match ``black``
+#: et aucun élément de ``exceptlist``
+blacklisted_masks = [("Flo!*@*", [])]
--- /dev/null
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+""" Un bot IRC qui enregistre et ressort des citations """
+
+import threading
+import random
+import time
+import json
+import re
+import os
+import signal
+import sys
+
+# Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
+sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
+import irclib
+import ircbot
+
+from commands import getstatusoutput as ex
+
+#: Config du bot
+import config
+#: Module définissant les erreurs
+import errors
+
+
+def get_config_logfile(serveur):
+ """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
+ serveurs = {"irc.crans.org" : "crans"}
+ return config.logfile_template % (serveurs[serveur],)
+
+def log(serveur, channel, auteur=None, message=None):
+ """Enregistre une ligne de log."""
+ if auteur == message == None:
+ # alors c'est que c'est pas un channel mais juste une ligne de log
+ chain = u"%s %s" % (time.strftime("%F %T"), channel)
+ else:
+ chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
+ f = open(get_config_logfile(serveur), "a")
+ f.write((chain + u"\n").encode("utf-8"))
+ f.close()
+ if config.debug_stdout:
+ print chain.encode("utf-8")
+
+def ignore_event(serv, ev):
+ """Retourne ``True`` si il faut ignorer cet évènement."""
+ for (blackmask, exceptlist) in config.blacklisted_masks:
+ usermask = ev.source()
+ blackit = bool(irclib.mask_matches(usermask, blackmask))
+ exceptit = any([bool(irclib.mask_matches(usermask, exceptmask)) for exceptmask in exceptlist])
+ if exceptit: # Il est exempté
+ return False
+ else:
+ if blackit: # Il n'est pas exempté et matche la blacklist
+ return True
+
+
+def bot_unicode(chain):
+ """Essaye de décoder ``chain`` en UTF-8.
+ Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
+ try:
+ return chain.decode("utf8")
+ except UnicodeDecodeError as exc:
+ raise errors.UnicodeBotError
+
+
+class Parrot(ircbot.SingleServerIRCBot):
+ """Classe principale : définition du bot."""
+ def __init__(self, serveur, debug=False):
+ temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
+ ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
+ temporary_pseudo, "Parrot, le bot irc. [Codé par 20-100]", 10)
+ self.debug = debug
+ self.serveur = serveur
+ self.overops = config.overops
+ self.ops = self.overops + config.ops
+ self.report_bugs_to = config.report_bugs_to
+ self.chanlist = config.chanlist
+ self.stay_channels = config.stay_channels
+ self.quiet_channels = config.quiet_channels
+ self.last_perdu = 0
+
+ ### Utilitaires
+ def _getnick(self):
+ """Récuère le nick effectif du bot sur le serveur."""
+ return self.serv.get_nickname()
+ nick = property(_getnick)
+
+ def give_me_my_pseudo(self, serv):
+ """Récupère le pseudo auprès de NickServ."""
+ serv.privmsg("NickServ", "RECOVER %s %s" % (config.irc_pseudo, config.irc_password))
+ serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
+ time.sleep(0.3)
+ serv.nick(config.irc_pseudo)
+
+ def pourmoi(self, serv, message):
+ """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
+ pseudo = self.nick
+ pseudo = pseudo.decode("utf-8")
+ size = len(pseudo)
+ if message[:size] == pseudo and len(message) > size and message[size] == ":":
+ return (True, message[size+1:].lstrip(" "))
+ else:
+ return (False, message)
+
+ ### Exécution d'actions
+ def quitter(self, chan, leave_message=None):
+ """Quitter un channel avec un message customisable."""
+ if leave_message == None:
+ leave_message = random.choice(config.leave_messages)
+ self.serv.part(chan, message=leave_message.encode("utf8"))
+
+ def mourir(self):
+ """Se déconnecter du serveur IRC avec un message customisable."""
+ quit_message = random.choice(config.quit_messages)
+ self.die(msg=quit_message.encode("utf8"))
+
+ def execute_reload(self, auteur=None):
+ """Recharge la config."""
+ reload(config)
+ isit.regexp_compile()
+ if auteur in [None, "SIGHUP"]:
+ towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
+ for to in config.report_bugs_to:
+ self.serv.privmsg(to, towrite)
+ log(self.serveur, towrite)
+ return True, None
+ else:
+ return True, u"Config reloaded"
+
+ def crash(self, who="nobody", chan="nowhere"):
+ """Fait crasher le bot."""
+ where = "en privé" if chan == "priv" else "sur le chan %s" % chan
+ raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
+
+ ACTIONS = {
+ "reload" : execute_reload,
+ }
+
+ def execute_something(self, something, params, place=None, auteur=None):
+ """Exécute une action et répond son résultat à ``auteur``
+ sur un chan ou en privé en fonction de ``place``"""
+ action = self.ACTIONS[something]
+ success, message = action(self, **params)
+ if message:
+ if irclib.is_channel(place):
+ message = "%s: %s" % (auteur, message.encode("utf-8"))
+ self.serv.privmsg(place, message)
+ log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
+
+ ### Gestion des quotes
+
+
+ ### Surcharge des events du Bot
+ def on_welcome(self, serv, ev):
+ """À l'arrivée sur le serveur."""
+ self.serv = serv # ça serv ira :)
+ self.give_me_my_pseudo(serv)
+ serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
+ log(self.serveur, "Connected")
+ if self.debug:
+ self.chanlist = ["#bot"]
+ for c in self.chanlist:
+ log(self.serveur, "JOIN %s" % (c))
+ serv.join(c)
+
+ def on_privmsg(self, serv, ev):
+ """À la réception d'un message en privé."""
+ if ignore_event(serv, ev):
+ return
+ message = ev.arguments()[0]
+ auteur = irclib.nm_to_n(ev.source())
+ try:
+ message = bot_unicode(message)
+ except errors.UnicodeBotError:
+ if config.utf8_trigger:
+ serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
+ return
+ message = message.split()
+ cmd = message[0].lower()
+ notunderstood = False
+ if cmd == u"help":
+ op,overop=auteur in self.ops, auteur in self.overops
+ if len(message)==1:
+ helpmsg = config.helpmsg_default
+ if op:
+ helpmsg += config.helpmsg_ops
+ if overop:
+ helpmsg += config.helpmsg_overops
+ else:
+ helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
+ helpmsg = helpmsgs[0]
+ if op and helpmsgs[1]:
+ if helpmsg:
+ helpmsg += "\n" + helpmsgs[1]
+ else:
+ helpmsg = helpmsgs[1]
+ if overop and helpmsgs[2]:
+ if helpmsg:
+ helpmsg += "\n" + helpmsgs[2]
+ else:
+ helpmsg = helpmsgs[2]
+ for ligne in helpmsg.split("\n"):
+ serv.privmsg(auteur, ligne.encode("utf-8"))
+ elif cmd == u"join":
+ if auteur in self.ops:
+ if len(message) > 1:
+ if message[1] in self.chanlist:
+ serv.privmsg(auteur, "Je suis déjà sur %s" % (message[1]))
+ else:
+ serv.join(message[1])
+ self.chanlist.append(message[1])
+ serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
+ log(self.serveur, "priv", auteur, " ".join(message))
+ else:
+ serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
+ else:
+ notunderstood = True
+ elif cmd == u"leave":
+ if auteur in self.ops and len(message) > 1:
+ if message[1] in self.chanlist:
+ if not (message[1] in self.stay_channels) or auteur in self.overops:
+ self.quitter(message[1].encode("utf-8"), " ".join(message[2:]))
+ self.chanlist.remove(message[1])
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ else:
+ serv.privmsg(auteur, "Non, je reste !")
+ log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+ else:
+ serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
+ else:
+ notunderstood = True
+ elif cmd == u"stay":
+ if auteur in self.overops:
+ if len(message) > 1:
+ if message[1] in self.stay_channels:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+ serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
+ else:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ self.stay_channels.append(message[1])
+ serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+ else:
+ serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+ else:
+ notunderstood = True
+ elif cmd == u"nostay":
+ if auteur in self.overops:
+ if len(message) > 1:
+ if message[1] in self.stay_channels:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ self.stay_channels.remove(message[1])
+ serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
+ else:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+ serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
+ else:
+ notunderstood = True
+ elif cmd == u"die":
+ if auteur in self.overops:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ self.mourir()
+ else:
+ notunderstood = True
+ elif cmd == u"crash":
+ if auteur in self.overops:
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ self.crash(auteur, "priv")
+ else:
+ notunderstood = True
+ elif cmd == u"reload":
+ if auteur in self.ops:
+ self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
+ else:
+ notunderstood = True
+ elif cmd == u"quiet":
+ if auteur in self.ops:
+ if len(message) > 1:
+ if message[1] in self.quiet_channels:
+ serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
+ log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+ else:
+ self.quiet_channels.append(message[1])
+ serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ else:
+ serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+ else:
+ notunderstood = True
+ elif cmd == u"noquiet":
+ if auteur in self.ops:
+ if len(message) > 1:
+ if message[1] in self.quiet_channels:
+ self.quiet_channels.remove(message[1])
+ serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
+ log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
+ else:
+ serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
+ log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
+ else:
+ notunderstood = True
+ elif cmd == u"say":
+ if auteur in self.overops and len(message) > 2:
+ serv.privmsg(message[1].encode("utf-8"), (u" ".join(message[2:])).encode("utf-8"))
+ log(self.serveur, "priv", auteur, " ".join(message))
+ elif len(message) <= 2:
+ serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
+ else:
+ notunderstood = True
+ elif cmd == u"do":
+ if auteur in self.overops and len(message) > 2:
+ serv.action(message[1], " ".join(message[2:]))
+ log(self.serveur, "priv", auteur, " ".join(message))
+ elif len(message) <= 2:
+ serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
+ else:
+ notunderstood = True
+ elif cmd == u"kick":
+ if auteur in self.overops and len(message) > 2:
+ serv.kick(message[1].encode("utf-8"), message[2].encode("utf-8"), " ".join(message[3:]).encode("utf-8"))
+ log(self.serveur, "priv", auteur, " ".join(message))
+ elif len(message) <= 2:
+ serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
+ else:
+ notunderstood = True
+ elif cmd == u"ops":
+ if auteur in self.overops:
+ serv.privmsg(auteur, " ".join(self.ops))
+ else:
+ notunderstood = True
+ elif cmd == u"overops":
+ if auteur in self.overops:
+ serv.privmsg(auteur, " ".join(self.overops))
+ else:
+ notunderstood = True
+ else:
+ notunderstood = True
+ if notunderstood:
+ serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
+
+ def on_pubmsg(self, serv, ev):
+ """À la réception d'un message sur un channel."""
+ if ignore_event(serv, ev):
+ return
+ auteur = irclib.nm_to_n(ev.source())
+ canal = ev.target()
+ message = ev.arguments()[0]
+ try:
+ message = bot_unicode(message)
+ except errors.UnicodeBotError:
+ if config.utf8_trigger and not canal in self.quiet_channels:
+ serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
+ return
+ pour_moi, message = self.pourmoi(serv, message)
+ if pour_moi and message.split()!=[]:
+ cmd = message.split()[0].lower()
+ try:
+ args = " ".join(message.split()[1:])
+ except:
+ args = ""
+ if cmd in [u"meurs", u"die", u"crève"]:
+ if auteur in self.overops:
+ log(self.serveur, canal, auteur, message + "[successful]")
+ self.mourir()
+ else:
+ serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
+ log(self.serveur, canal, auteur, message + "[failed]")
+ elif cmd == u"reload":
+ if auteur in self.ops:
+ self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
+ elif cmd == u"crash":
+ if auteur in self.overops:
+ self.crash(auteur, canal)
+ elif cmd in [u"part", u"leave", u"dégage", u"va-t-en"]:
+ if auteur in self.ops and (not (canal in self.stay_channels)
+ or auteur in self.overops):
+ self.quitter(canal)
+ log(self.serveur, canal, auteur, message + "[successful]")
+ if canal in self.chanlist:
+ self.chanlist.remove(canal)
+ else:
+ serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
+ log(self.serveur, canal, auteur, message + "[failed]")
+
+ elif cmd in [u"ping"] and not canal in self.quiet_channels:
+ serv.privmsg(canal, "%s: pong" % (auteur))
+ else:
+ # Vu que ce bot est prévu pour parser des quotes il va falloir bosser ici
+ pass
+
+ def on_action(self, serv, ev):
+ """À la réception d'une action."""
+ if ignore_event(serv, ev):
+ return
+ action = ev.arguments()[0]
+ auteur = irclib.nm_to_n(ev.source())
+ channel = ev.target()
+ try:
+ action = bot_unicode(action)
+ except errors.UnicodeBotError:
+ if config.utf8_trigger and not channel in self.quiet_channels:
+ serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
+ return
+ mypseudo = self.nick
+
+ def on_kick(self, serv, ev):
+ """À la réception d'une action."""
+ auteur = irclib.nm_to_n(ev.source())
+ channel = ev.target()
+ victime = ev.arguments()[0]
+ raison = ev.arguments()[1]
+ if victime == self.nick:
+ log(self.serveur, u"%s kické de %s par %s (raison : %s)" % (victime, channel.decode("utf-8"), auteur, raison))
+ time.sleep(2)
+ serv.join(channel)
+
+ ### .fork trick
+ def start_as_daemon(self, outfile):
+ sys.stderr = Logger(outfile)
+ self.start()
+
+
+class Logger(object):
+ """Pour écrire ailleurs que sur stdout"""
+ def __init__(self, filename="parrot.full.log"):
+ self.filename = filename
+
+ def write(self, message):
+ f = open(self.filename, "a")
+ f.write(message)
+ f.close()
+
+def main():
+ """Exécution principale : lecture des paramètres et lancement du bot."""
+ if len(sys.argv) == 1:
+ print "Usage : parrot.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
+ print " --outfile sans --no-output ni --daemon n'a aucun effet"
+ exit(1)
+ serveur = sys.argv[1]
+ if "--daemon" in sys.argv:
+ thisfile = os.path.realpath(__file__)
+ thisdirectory = thisfile.rsplit("/", 1)[0]
+ os.chdir(thisdirectory)
+ daemon = True
+ else:
+ daemon = False
+ if "debug" in sys.argv or "--debug" in sys.argv:
+ debug = True
+ else:
+ debug = False
+ if "--quiet" in sys.argv:
+ config.debug_stdout = False
+ serveurs = {
+ "irc" : "irc.crans.org",
+ "crans" : "irc.crans.org",
+ "irc.crans.org" : "irc.crans.org"}
+ if "--no-output" in sys.argv or "--daemon" in sys.argv:
+ outfile = "/var/log/bots/parrot.full.log"
+ for arg in sys.argv:
+ arg = arg.split("=")
+ if arg[0].strip('-') in ["out", "outfile", "logfile"]:
+ outfile = arg[1]
+ sys.stdout = Logger(outfile)
+ try:
+ serveur = serveurs[serveur]
+ except KeyError:
+ print "Server Unknown : %s" % (serveur)
+ exit(404)
+ parrot = Parrot(serveur,debug)
+ # Si on reçoit un SIGHUP, on reload la config
+ def sighup_handler(signum, frame):
+ parrot.execute_reload(auteur="SIGHUP")
+ signal.signal(signal.SIGHUP, sighup_handler)
+ # Daemonization
+ if daemon:
+ child_pid = os.fork()
+ if child_pid == 0:
+ os.setsid()
+ parrot.start_as_daemon(outfile)
+ else:
+ # on enregistre le pid de parrot
+ pidfile = "/var/run/bots/parror.pid"
+ for arg in sys.argv:
+ arg = arg.split("=")
+ if arg[0].strip('-') in ["pidfile"]:
+ pidfile = arg[1]
+ f = open(pidfile, "w")
+ f.write("%s\n" % child_pid)
+ f.close()
+ else:
+ parrot.start()
+
+if __name__ == "__main__":
+ main()
projects / bots / parrot.git / commitdiff