X-Git-Url: http://gitweb.pimeys.fr/?p=bots%2Fbasile.git;a=blobdiff_plain;f=basile.py;h=ad22ab649f74ded43ca500733377546a6cc20634;hp=011dc56a18699f04d7eee861cfb2c73b189c0bd5;hb=HEAD;hpb=7ce8b7c5ed4cec336c94e9c5d4f358cd5917fa65 diff --git a/basile.py b/basile.py index 011dc56..ad22ab6 100755 --- a/basile.py +++ b/basile.py @@ -3,842 +3,870 @@ # Codé par 20-100 (commencé le 23/04/12) -# Un bot IRC qui, un jour, s'interfacera avec la Note Kfet 2015 +""" Un bot IRC destiné à s'interfacer avec la Note Kfet 2015 """ -import irclib -import ircbot import threading import random import time -import socket, ssl, json -import pickle +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 +# On veut réagir sur la partie du whois qui dit qu'un nick est registered +irclib.numeric_events['307'] = "whoisregnick" +import ircbot + from commands import getstatusoutput as ex -# on récupère la config -import config_basile as config +#: Config de basile +import config +#: Module responsable du dialogue avec la NoteKfet2015 +import nk +#: Module de réponse aux questions de base +import isit +#: Module définissant les erreurs +import errors +#: Module de gestion des utilisateurs +import users # la partie qui réfère au fichier lui-même est mieux ici # sinon on réfère la config et pas le fichier lui-même -import os -config.thisfile= os.path.realpath( __file__ ) +config.thisfile = os.path.realpath(__file__) def get_config_logfile(serveur): - serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"} - return config.logfile_template%(serveurs[serveur]) + """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config.""" + serveurs = {"acoeur.crans.org" : "acoeur", + "irc.crans.org" : "crans"} + return config.logfile_template % (serveurs[serveur],) def get_filesize(): - return ex("ls -s %s"%(config.thisfile))[1].split()[0] - -class NKError(Exception): - def __init__(self,msg): - Exception.__init__(self) - self.msg=msg - def __str__(self): - return str(self.msg) - def __unicode__(self): - return unicode(self.msg) - -class NKRefused(NKError): - pass - -class NKHelloFailed(NKError): - pass - -class NKUnknownError(NKError): - pass + """Récupère la taille de ce fichier.""" + return ex("ls -s %s" % (config.thisfile))[1].split()[0] -def log(serveur,channel,auteur=None,message=None): - f=open(get_config_logfile(serveur),"a") - if auteur==message==None: +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="%s %s"%(time.strftime("%F %T"),channel) + chain = u"%s %s" % (time.strftime("%F %T"), channel) else: - chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message) - f.write(chain+"\n") - if config.debug_stdout: - print chain + 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 connect_NK(): - sock=socket.socket() - try: - # On établit la connexion sur port 4242 - sock.connect(("127.0.0.1",4242)) - # On passe en SSL - sock=ssl.wrap_socket(sock,ca_certs='../keys/ca_.crt') - # On fait un hello - sock.write('hello "Basile"') - # On récupère la réponse du hello - out=sock.read() - out=json.loads(out) - except Exception as exc: - # Si on a foiré quelque part, c'est que le serveur est down - raise NKRefused(str(exc)) - if out["retcode"]==0: - return sock - elif out["retcode"]==11: - raise NKHelloFailed(out["errmsg"]) - else: - raise NKUnknownError(out["errmsg"]) - -def login_NK(username,password,typ="bdd"): - sock=connect_NK() - if typ=="special": # ça c'est pour Basile lui-même - masque='["note"]' - elif typ=="bdd": - masque='[["all"],["all"],false]' - try: - # Basile a un compte special user - commande='login [%s,%s,"%s",%s]'%(json.dumps(username),json.dumps(password),typ,masque) - sock.write(commande) - out=sock.read() - except Exception as exc: - # Si on a foiré quelque part, c'est que le serveur est down - raise NKRefused(str(exc)) - # On vérifie ensuite que le login - return json.loads(out),sock - - -def is_something(chain,matches,avant=u".*(?:^| )",apres=u"(?:$|\.| |,|;).*",case_sensitive=False,debug=False): - if case_sensitive: - chain=unicode(chain,"utf8") - else: - chain=unicode(chain,"utf8").lower() - allmatches="("+"|".join(matches)+")" - reg=(avant+allmatches+apres).lower() - o=re.match(reg,chain) - return o - -def is_insult(chain,debug=True): - return is_something(chain,config.insultes,avant=".*(?:^| |')") -def is_not_insult(chain): - chain=unicode(chain,"utf8") - insult_regexp=u"("+u"|".join(config.insultes)+u")" - middle_regexp=u"(une? (?:(?:putain|enfoiré) d(?:e |'))*|)(?:| super )(?: (?:gros|petit|grand|énorme) |)" - reg=".*pas %s%s.*"%(middle_regexp,insult_regexp) - if re.match(reg,chain): - return True - else: - return False -def is_compliment(chain,debug=True): - return is_something(chain,config.compliment_triggers,avant=".*(?:^| |')") -def is_perdu(chain): - return is_something(chain,config.perdu) -def is_tag(chain): - return is_something(chain,config.tag_triggers) -def is_gros(chain): - return is_something(chain,config.gros) -def is_tesla(chain): - return is_something(chain,config.tesla_triggers,avant=u"^",apres=u"$",debug=True) -def is_merci(chain): - return is_something(chain,config.merci_triggers) -def is_tamere(chain): - return is_something(chain,config.tamere_triggers) -def is_bad_action_trigger(chain,pseudo): - return is_something(chain,config.bad_action_triggers,avant=u"^", - apres="(?: [a-z]*ment)? %s($|\.| |,|;).*"%(pseudo)) -def is_good_action_trigger(chain,pseudo): - return is_something(chain,config.good_action_triggers,avant=u"^", - apres="(?: [a-z]*ment)? %s($|\.| |,|;).*"%(pseudo)) -def is_bonjour(chain): - return is_something(chain,config.bonjour_triggers,avant=u"^") -def is_bonne_nuit(chain): - return is_something(chain,config.bonne_nuit_triggers,avant=u"^") -def is_pan(chain): - return re.match(u"^(pan|bim|bang)( .*)?$",unicode(chain,"utf8").lower().strip()) +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 is_time(conf): - _,_,_,h,m,s,_,_,_=time.localtime() - return (conf[0],0,0)<(h,m,s)<(conf[1],0,0) -def is_day(): - return is_time(config.daytime) -def is_night(): - return is_time(config.nighttime) - -class UnicodeBotError(Exception): - pass def bot_unicode(chain): + """Essaye de décoder ``chain`` en UTF-8. + Lève une py:class:`errors.UnicodeBotError` en cas d'échec.""" try: - unicode(chain,"utf8") + return chain.decode("utf8") except UnicodeDecodeError as exc: - raise UnicodeBotError + raise errors.UnicodeBotError + class Basile(ircbot.SingleServerIRCBot): - def __init__(self,serveur,debug=False): - temporary_pseudo=config.irc_pseudo+str(random.randrange(10000,100000)) + """Classe principale : définition du bot Basile.""" + def __init__(self, serveur, debug=False): + temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000)) ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)], - temporary_pseudo,"Basile, le bot irc.[Codé par 20-100, fouettez-le]", 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.identities=pickle.load(open("identities.pickle","r")) - self.stay_channels=config.stay_channels - self.quiet_channels=config.quiet_channels - self.last_perdu=0 - - - def new_connection_NK(self,serv,username,password,typ="bdd"): + temporary_pseudo, "Basile, 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 + # On charge la base de données d'utilisateurs + self.users = users.UserDB() + self.users.load() + + ### Communication NK + def new_connection_NK(self, serv, username, password, typ="bdd"): + """Renvoie (``True``, ) + ou bien (``False``, None)""" try: - login_result,sock=login_NK(username,password,typ) - droits,retcode,errmsg=login_result["msg"],login_result["retcode"],login_result["errmsg"] - except NKRefused as exc: + login_result, sock = nk.login(username, password, typ) + info, retcode, errmsg = login_result["msg"], login_result["retcode"], login_result["errmsg"] + except nk.NKRefused as exc: for report in self.report_bugs_to: - serv.privmsg(report,"Le Serveur NK2015 est down.") - return (False,None) - except NKHelloFailed as exc: + serv.privmsg(report, "Le Serveur NK2015 est down.") + return (False, None, None) + except nk.NKHelloFailed as exc: for report in self.report_bugs_to: serv.privmsg(report, - "La version du site utilisée n'est pas supportée par le serveur NK2015.") - return (False,None) - except NKUnknownError as exc: - erreurs=["Une fucking erreur inconnue s'est produite"] - erreurs+=str(exc).split("\n") + "La version du protocole utilisée n'est pas supportée par le serveur NK2015.") + return (False, None, None) + except nk.NKUnknownError as exc: + erreurs = ["Une fucking erreur inconnue s'est produite"] + erreurs += str(exc).split("\n") for report in self.report_bugs_to: for err in erreurs: - serv.privmsg(report,err) - return (False,None) + serv.privmsg(report, err) + return (False, None, None) except Exception as exc: # Exception qui ne vient pas de la communication avec le serveur NK2015 - log(self.serveur,"Erreur dans new_connection_NK\n"+str(exc)) - return (False,None) - if retcode==0: - return (True,sock) + log(self.serveur, "Erreur dans new_connection_NK\n" + str(exc)) + return (False, None, None) + if retcode == 0: + return (True, info, sock) else: - return (False,None) - - def give_me_my_pseudo(self,serv): - serv.privmsg("NickServ","RECOVER %s %s"%(config.irc_pseudo,config.irc_password)) - serv.privmsg("NickServ","RELEASE %s %s"%(config.irc_pseudo,config.irc_password)) + return (False, None, None) + + ### 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 lost(self, serv, channel, forced=False): + """Réaction à un trigger de perdu. + Annonce "J'ai perdu" sur le channel si on n'a pas perdu depuis un certain temps.""" + if self.last_perdu + config.time_between_perdu < time.time() or forced: + if not channel in self.quiet_channels or forced: + serv.privmsg(channel, "J'ai perdu !") + self.last_perdu = time.time() + delay = config.time_between_perdu_trigger + delta = config.time_between_perdu_trigger_delta + serv.execute_delayed(random.randrange(delay - delta, delay + delta), self.lost, (serv, channel)) + + 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]")) + + def whois(self, pseudo, askedwhy, askedby): + """Demande un whois sur ``pseudo``. La réponse sera handled par une autre fonction.""" + self.users.pending_whois[pseudo] = ["pending", askedwhy, askedby, None] + self.serv.whois([pseudo]) + + ### Surcharge des events du Bot def on_welcome(self, serv, ev): - self.serv=serv # ça serv ira :) + """À 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") + serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password)) + log(self.serveur, "Connected") if self.debug: - self.chanlist=["#bot"] - else: - serv.privmsg("ChanServ", "INVITE #note-dev") + self.chanlist = ["#bot"] for c in self.chanlist: - log(self.serveur,"JOIN %s"%(c)) + log(self.serveur, "JOIN %s" % (c)) serv.join(c) # on ouvre la connexion note de Basile, special user - self.nk=self.new_connection_NK(serv,config.note_pseudo,config.note_password,"special")[1] - if self.nk==None: + self.nk = self.new_connection_NK(serv, config.note_pseudo, config.note_password, "special")[2] + if self.nk == None: for report in self.report_bugs_to: - serv.privmsg(report,"Connection to NK2015 failed, invalid password ?") + serv.privmsg(report, "Connection to NK2015 failed, invalid password ?") - def lost(self,serv,channel,forced=False): - if self.last_perdu+config.time_between_perdusize and message[size]==":": - return (True,message[size+1:].lstrip(" ")) - else: - return (False,message) + def on_endofwhois(self, serv, ev): + """Si on arrive à la fin du whois, on va voir si on n'a pas reçu "is a registered nick" + c'est que le pseudo n'est pas identifié. """ + pseudo = ev.arguments()[0] + # On laisse le temps au bot de souffler un coup + serv.execute_delayed(config.whois_timeout, self.fail_whoisregnick, (pseudo,)) + def fail_whoisregnick(self, pseudo): + """Maintenant qu'on a laissé quelques secondes au bot pour gérer les affaires courantes, + on considère que le pseudo n'est pas registered. """ + # Attention, parce qu'il se pourrait qu'on n'ait pas sollicité ce whois + # et que donc pending_whois n'ai pas été peuplé en conséquence + if self.users.pending_whois.has_key(pseudo): + status, askedwhy, askedby, _ = self.users.pending_whois[pseudo] + if status == "pending": + # Si le status est encore pending, on n'a pas eu de réponse positive, donc elle est négative + self.users.pending_whois[pseudo] = "notregistered" + if askedwhy == "cmd WHOIS": + self.serv.privmsg(askedby, "%s is NOT a registered nick" % (pseudo,)) + def on_privmsg(self, serv, ev): - message=ev.arguments()[0] + """À 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: - test=bot_unicode(message) - except UnicodeBotError: + 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=="help": - helpdico={"help":["""HELP - Affiche de l'aide sur la commande""",None,None], -"identify": ["""IDENTIFY - Vérifie le mot de passe et me permet de savoir à l'avenir quel est votre pseudo note kfet. - Sans paramètre, je vous précise sous quel pseudo je vous connais.""",None,None], -"drop":["""DROP - Vérifie le mot de passe et me fait d'oublier votre pseudo note kfet.""",None,None], -"solde": ["""SOLDE - Affiche votre solde, si je connais votre pseudo note kfet.""", - """SOLDE - Affiche le solde de la personne désignée (par son pseudo note).""",None], - "join": [None, """JOIN - Me fait rejoindre le channel""",None], - "leave": [None,"""LEAVE - Me fait quitter le channel (sauf s'il est dans ma stay_list).""",None], - "quiet": [None,"""QUIET - Me rend silencieux sur le channel.""",None], - "noquiet": [None,"""NOQUIET - Me rend la parole sur le channel.""",None], - "lost": [None,"""LOST - Me fait perdre sur le channel.""",None], - "reconnect": [None,"""RECONNECT - Établit à nouveau la connexion avec le serveur NK2015""",None], - "say": [None,None,"""SAY - Me fait parler sur le channel."""], - "do": [None,None,"""DO - Me fait faitre une action (/me) sur le channel."""], - "stay": [None,None,"""STAY - Ajoute le channel à ma stay_list."""], - "nostay": [None,None,"""NOSTAY - Retire le channel de ma stay_list."""], - "ops": [None,None,"""OPS - Affiche la liste des ops."""], - "overops": [None,None,"""OVEROPS - Affiche la liste des overops."""], - "kick": [None,None,"""KICK [] - Kicke du channel (Il faut bien entendu que j'y sois op)."""], - "die": [None,None,"""DIE - Me déconnecte du serveur IRC."""] - } - helpmsg_default="Liste des commandes disponibles :\nHELP IDENTIFY DROP SOLDE" - helpmsg_ops=" JOIN LEAVE QUIET NOQUIET LOST RECONNECT" - helpmsg_overops=" SAY DO STAY NOSTAY OPS OVEROPS KICK DIE" + 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=helpmsg_default + helpmsg = config.helpmsg_default if op: - helpmsg+=helpmsg_ops + helpmsg += config.helpmsg_ops if overop: - helpmsg+=helpmsg_overops + helpmsg += config.helpmsg_overops else: - helpmsgs=helpdico.get(message[1].lower(),["Commande inconnue.",None,None]) - helpmsg=helpmsgs[0] + 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] + helpmsg += "\n" + helpmsgs[1] else: - helpmsg=helpmsgs[1] + helpmsg = helpmsgs[1] if overop and helpmsgs[2]: if helpmsg: - helpmsg+="\n"+helpmsgs[2] + helpmsg += "\n" + helpmsgs[2] else: - helpmsg=helpmsgs[2] + helpmsg = helpmsgs[2] + if not helpmsg: # Un non-op a demandé de l'aide sur une commande dont il n'est pas censé connaître l'existence + helpmsg = "Commande inacessible." for ligne in helpmsg.split("\n"): - serv.privmsg(auteur,ligne) - elif cmd=="identify": - if len(message)==1: - if self.identities.has_key(auteur): - serv.privmsg(auteur,"Je vous connais sous le pseudo note %s."%( - self.identities[auteur].encode("utf8"))) + serv.privmsg(auteur, ligne.encode("utf-8")) + elif cmd == u"identify": + if len(message) == 1: + if self.users.has(auteur): + infos = self.users[auteur].get_infos(self.nk, serv, auteur) + serv.privmsg(auteur, (u"Vous avez le compte note n°%(idbde)s, pseudo : %(pseudo)s." % infos + ).encode("utf8")) else: - serv.privmsg(auteur,"Je ne connais pas votre pseudo note.") - elif len(message)>=3: - username,password=message[1],unicode(" ".join(message[2:]),"utf8") - success,_=self.new_connection_NK(serv,username,password) + serv.privmsg(auteur, "Je ne connais pas votre note.") + elif len(message) >= 3: + username, password = message[1], " ".join(message[2:]) + success, info, _ = self.new_connection_NK(serv, username, password) if success: - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") - serv.privmsg(auteur,"Identité enregistrée.") - self.identities[auteur]=username - pickle.dump(Xself.identities,open("identities.pickle","w")) + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") + self.users.add(auteur, info["idbde"]) + serv.privmsg(auteur, "Pseudo enregistré.") else: - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") - serv.privmsg(auteur,"Mot de passe invalide. (ou serveur down)") + log(self.serveur, "priv", auteur, " ".join(message) + "[failed]") + serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)") else: - serv.privmsg(auteur,u"Syntaxe : IDENTIFY [ ]") - elif cmd=="drop": - if len(message)>1: - if self.identities.has_key(auteur): - password=" ".join(message[1:]) - success,_=self.new_connection_NK(serv,self.identities[auteur],password) + serv.privmsg(auteur, "Syntaxe : IDENTIFY [ ]") + elif cmd == u"drop": + if len(message) > 1: + if self.users.has(auteur): + idbde = self.users[auteur].idbde + password = " ".join(message[1:]) + success, _, _ = self.new_connection_NK(serv, "#%s" % idbde, password) if success: - del self.identities[auteur] - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") - pickle.dump(self.identities,open("identities.pickle","w")) - serv.privmsg(auteur,"Identité oubliée.") + self.users.drop(idbde) + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") + serv.privmsg(auteur, "Pseudo oublié.") else: - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") - serv.privmsg(auteur,"Mot de passe invalide. (ou serveur down)") + log(self.serveur, "priv", auteur, " ".join(message) + "[failed]") + serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)") else: - serv.privmsg(auteur,"Je ne connais pas ton pseudo note.") + serv.privmsg(auteur, "Je ne connais pas votre note.") else: - serv.privmsg(auteur,"Syntaxe : DROP ") - elif cmd=="join": + serv.privmsg(auteur, "Syntaxe : DROP ") + elif cmd == u"join": if auteur in self.ops: - if len(message)>1: + if len(message) > 1: if message[1] in self.chanlist: - serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1])) + serv.privmsg(auteur, (u"Je suis déjà sur %s" % (message[1])).encode("utf-8")) else: serv.join(message[1]) self.chanlist.append(message[1]) - serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist)) - log(self.serveur,"priv",auteur," ".join(message)) + serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist)) + log(self.serveur, "priv", auteur, " ".join(message)) else: - serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist)) + serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist)) else: - notunderstood=True - elif cmd=="leave": - if auteur in self.ops and len(message)>1: + 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]," ".join(message[2:])) + self.quitter(message[1].encode("utf-8"), " ".join(message[2:])) self.chanlist.remove(message[1]) - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") else: - serv.privmsg(auteur,"Non, je reste !") - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") + 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])) + serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1])) else: - notunderstood=True - elif cmd=="stay": + notunderstood = True + elif cmd == u"stay": if auteur in self.overops: - if len(message)>1: + 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])) + 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]") + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") self.stay_channels.append(message[1]) - serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels)) + serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels)) else: - serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels)) + serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels)) else: - notunderstood=True - elif cmd=="nostay": + notunderstood = True + elif cmd == u"nostay": if auteur in self.overops: - if len(message)>1: + if len(message) > 1: if message[1] in self.stay_channels: - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") self.stay_channels.remove(message[1]) - serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels)) + 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])) - + log(self.serveur, "priv", auteur, " ".join(message) + "[failed]") + serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1])) else: - notunderstood=True - elif cmd=="die": + notunderstood = True + elif cmd == u"die": if auteur in self.overops: - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") self.mourir() else: - notunderstood=True - elif cmd=="reconnect": + 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"reconnect": if auteur in self.ops: try: - self.nk=self.new_connection_NK(serv,config.note_pseudo, - config.note_password,"special")[1] + self.nk = self.new_connection_NK(serv, config.note_pseudo, + config.note_password, "special")[2] except Exception as exc: - self.nk=None - log(self.serveur,"""Erreur dans on_pubmsg/"cmd in ["reconnect"]\n"""+str(exc)) - if self.nk!=None: - serv.privmsg(auteur,"%s: done"%(auteur)) - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") + self.nk = None + log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc)) + if self.nk != None: + serv.privmsg(auteur, "%s: done" % (auteur)) + log(self.serveur, "priv", auteur, " ".join(message) + "[successful]") else: - serv.privmsg(auteur,"%s: failed"%(auteur)) - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") + serv.privmsg(auteur, "%s: failed" % (auteur)) + log(self.serveur, "priv", auteur, " ".join(message) + "[failed]") for report in self.report_bugs_to: - serv.privmsg(report,"Connection to NK2015 failed, invalid password ? Server dead ?") + serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?") else: - notunderstood=True - elif cmd=="quiet": + notunderstood = True + elif cmd == u"quiet": if auteur in self.ops: - if len(message)>1: + 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]") + 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]") + 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)) + serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels)) else: - notunderstood=True - elif cmd=="noquiet": + notunderstood = True + elif cmd == u"noquiet": if auteur in self.ops: - if len(message)>1: + 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]") + 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]") + 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=="say": - if auteur in self.overops and len(message)>2: - serv.privmsg(message[1]," ".join(message[2:])) - log(self.serveur,"priv",auteur," ".join(message)) - elif len(message)<=2: - serv.privmsg(auteur,"Syntaxe : SAY ") + 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 ") else: - notunderstood=True - elif cmd=="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 ") + 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 ") else: - notunderstood=True - elif cmd=="kick": - if auteur in self.overops and len(message)>2: - serv.kick(message[1],message[2]," ".join(message[3:])) - log(self.serveur,"priv",auteur," ".join(message)) - elif len(message)<=2: - serv.privmsg(auteur,"Syntaxe : KICK []") + 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 []") else: - notunderstood=True - elif cmd=="lost": - if auteur in self.ops and len(message)>1: - serv.privmsg(message[1],"J'ai perdu !") - log(self.serveur,"priv",auteur," ".join(message)) - elif len(message)<=1: - serv.privmsg(auteur,"Syntaxe : LOST ") + notunderstood = True + elif cmd == u"lost": + if auteur in self.ops and len(message) > 1: + serv.privmsg(message[1], "J'ai perdu !") + log(self.serveur, "priv", auteur, " ".join(message)) + elif len(message) <= 1: + serv.privmsg(auteur, "Syntaxe : LOST ") else: - notunderstood=True - elif cmd=="solde": - if len(message)==1: - if self.identities.has_key(auteur): - try: - self.nk.write('search ["x",["pseudo"],%s]'%(json.dumps(self.identities[auteur]))) - ret=json.loads(self.nk.read()) - solde=ret["msg"][0]["solde"] - pseudo=ret["msg"][0]["pseudo"] - except Exception as exc: - print exc - serv.privmsg(auteur,"failed") - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") - return - serv.privmsg(auteur,"%s (%s)"%(float(solde)/100,pseudo.encode("utf8"))) - log(self.serveur,"priv",auteur," ".join(message)+"[successful]") + notunderstood = True + elif cmd == u"solde": + if len(message) == 1: + if self.users.has(auteur): + success, solde, pseudo = nk.get_solde(self.nk, self.users[auteur].idbde, serv, auteur) + if success: + serv.privmsg(auteur, "%.2f (%s)" % (solde/100.0, pseudo.encode("utf8"))) + log(self.serveur, "priv", auteur, " ".join(message) + ("[successful]" if success else "[failed]")) else: - serv.privmsg(canal,"Je ne connais pas ton pseudo note.") - elif auteur in self.ops: - try: - self.nk.write('search ["x",["pseudo"],%s]'%(json.dumps(message[1]))) - ret=json.loads(self.nk.read()) - solde=ret["msg"][0]["solde"] - pseudo=ret["msg"][0]["pseudo"] - except Exception as exc: - serv.privmsg(auteur,"failed") - log(self.serveur,"priv",auteur," ".join(message)+"[failed]") - return - serv.privmsg(auteur,"%s (%s)"%(float(solde)/100,pseudo.encode("utf8"))) - elif cmd=="ops": + serv.privmsg(auteur, "Je ne connais pas votre note.") + elif cmd == u"ops": if auteur in self.overops: - serv.privmsg(auteur," ".join(self.ops)) + serv.privmsg(auteur, " ".join(self.ops)) else: - notunderstood=True - elif cmd=="overops": + notunderstood = True + elif cmd == u"overops": if auteur in self.overops: - serv.privmsg(auteur," ".join(self.overops)) + serv.privmsg(auteur, " ".join(self.overops)) + else: + notunderstood = True + elif cmd == u"whois": + if auteur in self.ops and len(message) > 1: + self.whois(message[1], askedwhy="cmd WHOIS", askedby=auteur) else: - notunderstood=True + notunderstood = True else: - notunderstood=True + notunderstood = True if notunderstood: - serv.privmsg(auteur,"Je n'ai pas compris. Essayez HELP…") + 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: - test=bot_unicode(message) - except UnicodeBotError: + 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")) + serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8")) return - pour_moi,message=self.pourmoi(serv,message) + pour_moi, message = self.pourmoi(serv, message) if pour_moi and message.split()!=[]: - cmd=message.split()[0].lower() + cmd = message.split()[0].lower() try: - args=" ".join(message.split()[1:]) + args = " ".join(message.split()[1:]) except: - args="" - if cmd in ["meurs","die","crève"]: + args = "" + if cmd in [u"meurs", u"die", u"crève"]: if auteur in self.overops: - log(self.serveur,canal,auteur,message+"[successful]") + log(self.serveur, canal, auteur, message + "[successful]") self.mourir() else: - serv.privmsg(canal,("%s: %s"%(auteur,random.choice(config.quit_fail_messages))).encode("utf8")) - log(self.serveur,canal,auteur,message+"[failed]") - - elif cmd in ["part","leave","dégage","va-t-en","tut'tiresailleurs,c'estmesgalets"]: + 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", u"tut'tiresailleurs,c'estmesgalets"]: 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]") + log(self.serveur, canal, auteur, message + "[successful]") if canal in self.chanlist: self.chanlist.remove(canal) else: - serv.privmsg(canal,("%s: %s"%(auteur,random.choice(config.leave_fail_messages))).encode("utf8")) - log(self.serveur,canal,auteur,message+"[failed]") + 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 ["reconnect"]: + elif cmd == u"reconnect": if auteur in self.ops: try: - self.nk=self.new_connection_NK(serv,config.note_pseudo, - config.note_password,"special")[1] + self.nk = self.new_connection_NK(serv, config.note_pseudo, + config.note_password, "special")[2] except Exception as exc: - self.nk=None - log(self.serveur,"""Erreur dans on_pubmsg/"cmd in ["reconnect"]\n"""+str(exc)) - if self.nk!=None: - serv.privmsg(canal,"%s: done"%(auteur)) - log(self.serveur,canal,auteur,message+"[successful]") + self.nk = None + log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc)) + if self.nk != None: + serv.privmsg(canal, "%s: done" % (auteur)) + log(self.serveur, canal, auteur, message + "[successful]") else: - serv.privmsg(canal,"%s: failed"%(auteur)) - log(self.serveur,canal,auteur,message+"[failed]") + serv.privmsg(canal, "%s: failed" % (auteur)) + log(self.serveur, canal, auteur, message + "[failed]") for report in self.report_bugs_to: - serv.privmsg(report,"Connection to NK2015 failed, invalid password ? Server dead ?") + serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?") else: - serv.privmsg(canal,"%s: %s"%(auteur,random.choice(config.pas_programme_pour_tobeir).encode("utf8"))) - log(self.serveur,canal,auteur,message+"[failed]") + serv.privmsg(canal, "%s: %s" % (auteur, random.choice(config.pas_programme_pour_tobeir).encode("utf8"))) + log(self.serveur, canal, auteur, message + "[failed]") - elif cmd in ["deviens","pseudo"]: + elif cmd in [u"deviens", u"pseudo"]: if auteur in self.ops: - become=args + become = args serv.nick(become) - log(self.serveur,canal,auteur,message+"[successful]") + log(self.serveur, canal, auteur, message + "[successful]") - if cmd in ["meur", "meurt","meurre","meurres"] and not canal in self.quiet_channels: - serv.privmsg(canal,'%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)'%(auteur)) - elif cmd in ["ping"] and not canal in self.quiet_channels: - serv.privmsg(canal,"%s: pong"%(auteur)) + if cmd in [u"meur", u"meurt", u"meurre", u"meurres"] and not canal in self.quiet_channels: + serv.privmsg(canal, '%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)' % (auteur)) + elif cmd in [u"ping"] and not canal in self.quiet_channels: + serv.privmsg(canal, "%s: pong" % (auteur)) - elif cmd in ["solde","!solde"]: - if self.identities.has_key(auteur): - pseudo=self.identities[auteur] - try: - self.nk.write('search ["x",["pseudo"],%s]'%(json.dumps(pseudo))) - ret=json.loads(self.nk.read()) - solde=ret["msg"][0]["solde"] - pseudo=ret["msg"][0]["pseudo"] - except Exception as exc: - serv.privmsg(canal,"%s: failed"%(auteur)) - log(self.serveur,canal,auteur,message+"[failed]") - else: - serv.privmsg(canal,"%s: %s (%s)"%(auteur,float(solde)/100,pseudo.encode("utf8"))) - log(self.serveur,canal,auteur,message+"[successful]") + elif cmd in [u"solde", u"!solde", u"!coca"] or cmd.startswith("!"): + if self.users.has(auteur): + idbde = self.users[auteur].idbde + if cmd in [u"solde", u"!solde"]: + success, solde, pseudo = nk.get_solde(self.nk, idbde, serv, canal) + if success: + serv.privmsg(canal, "%s: %s (%s)" % (auteur, float(solde)/100, pseudo.encode("utf8"))) + elif cmd in [u"!coca"] or cmd.startswith("!"): + success = nk.consomme(self.nk, idbde, message[1:], serv, canal) + log(self.serveur, canal, auteur, message + ("[successful]" if success else "[failed]")) else: - serv.privmsg(canal,"%s: Je ne connais pas votre pseudo note."%(auteur)) - log(self.serveur,canal,auteur,message+"[unknown]") - elif (re.match("!?(pain au chocolat|chocolatine)",message.lower()) + serv.privmsg(canal, "%s: Je ne connais pas votre pseudo note." % (auteur)) + log(self.serveur, canal, auteur, message + "[unknown]") + elif (re.match("(pain au chocolat|chocolatine)", message.lower()) and not canal in self.quiet_channels): - serv.action(canal,"sert un pain au chocolat à %s"%(auteur)) - elif re.match("!?manzana",message.lower()) and not canal in self.quiet_channels: + serv.action(canal, "sert un pain au chocolat à %s" % (auteur)) + elif re.match("manzana",message.lower()) and not canal in self.quiet_channels: if auteur in config.manzana: - serv.action(canal,"sert une bouteille de manzana à %s"%(auteur)) + serv.action(canal, "sert une bouteille de manzana à %s" % (auteur)) elif auteur in config.manzana_bis: - serv.action(canal,"sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas."%(auteur)) + serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur)) else: - serv.action(canal,"sert un verre de manzana à %s"%(auteur)) - if is_insult(message) and not canal in self.quiet_channels: - if is_not_insult(message): - answer=random.choice(config.compliment_answers) + serv.action(canal, "sert un verre de manzana à %s" % (auteur)) + if isit.is_insult(message) and not canal in self.quiet_channels: + if isit.is_not_insult(message): + answer = random.choice(config.compliment_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) + serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8"))) else: - answer=random.choice(config.insultes_answers) + answer = random.choice(config.insultes_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) - elif is_compliment(message) and not canal in self.quiet_channels: - answer=random.choice(config.compliment_answers) + serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8"))) + elif isit.is_compliment(message) and not canal in self.quiet_channels: + answer = random.choice(config.compliment_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) - gros_match=is_gros(message) + serv.privmsg(canal, "%s: %s" % (auteur,ligne.encode("utf8"))) + gros_match = isit.is_gros(message) if gros_match and not canal in self.quiet_channels: - taille=get_filesize() - answer=u"Mais non, je ne suis pas %s, %sKo tout au plus…"%(gros_match.groups()[0],taille) - serv.privmsg(canal,"%s: %s"%(auteur,answer.encode("utf8"))) - if is_tesla(message) and not canal in self.quiet_channels: - l1,l2=config.tesla_answers,config.tesla_actions - n1,n2=len(l1),len(l2) - i=random.randrange(n1+n2) - if i>=n1: - serv.action(canal,l2[i-n1].encode("utf8")) + taille = get_filesize() + answer = u"Mais non, je ne suis pas %s, %sKo tout au plus…" % (gros_match.groups()[0], taille) + serv.privmsg(canal, "%s: %s"%(auteur, answer.encode("utf8"))) + if isit.is_tesla(message) and not canal in self.quiet_channels: + l1, l2 = config.tesla_answers, config.tesla_actions + n1, n2 = len(l1), len(l2) + i = random.randrange(n1 + n2) + if i >= n1: + serv.action(canal, l2[i - n1].encode("utf8")) else: - serv.privmsg(canal,"%s: %s"%(auteur,l1[i].encode("utf8"))) - if is_tamere(message) and not canal in self.quiet_channels: - answer=random.choice(config.tamere_answers) + serv.privmsg(canal, "%s: %s" % (auteur, l1[i].encode("utf8"))) + if isit.is_tamere(message) and not canal in self.quiet_channels: + answer = random.choice(config.tamere_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) - if is_tag(message) and not canal in self.quiet_channels: + serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8"))) + if isit.is_tag(message) and not canal in self.quiet_channels: if auteur in self.ops: - action=random.choice(config.tag_actions) - serv.action(canal,action.encode("utf8")) + action = random.choice(config.tag_actions) + serv.action(canal, action.encode("utf8")) self.quiet_channels.append(canal) else: - answer=random.choice(config.tag_answers) + answer = random.choice(config.tag_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) - if is_merci(message): - answer=random.choice(config.merci_answers) + serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8"))) + if isit.is_merci(message): + answer = random.choice(config.merci_answers) for ligne in answer.split("\n"): - serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8"))) - out=re.match(ur"^([A-Z[]|\\|[0-9]+|(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+)(?:| \?| !)$", - unicode(message.upper(),"utf8")) - if re.match("ma bite dans ton oreille",message) and not canal in self.quiet_channels: - serv.privmsg(canal,"%s: Seul un olasd peut imiter un olasd dans un de ses grands jours !"%(auteur)) + serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8"))) + out = re.match(ur"^([A-Z[]|\\|[0-9]+|(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+)(?:| \?| !)$", message.upper()) + if re.match("ma bite dans ton oreille", message) and not canal in self.quiet_channels: + serv.privmsg(canal, "%s: Seul un olasd peut imiter un olasd dans un de ses grands jours !" % (auteur)) if out and not canal in self.quiet_channels: - out=out.groups()[0] + out = out.groups()[0] try: - out=int(out) - serv.privmsg(canal,"%s: %s !"%(auteur,out+1)) - if out==2147483647: - serv.privmsg(canal,"%s: Ciel, un maxint ! Heureusement que je suis en python…"%(auteur)) + iout = int(out) + serv.privmsg(canal, "%s: %s !" % (auteur, iout + 1)) + if iout == 2147483647: + serv.privmsg(canal, "%s: Ciel, un maxint ! Heureusement que je suis en python…" % (auteur)) return - if out+1>1000 and random.randrange(4)==0: - serv.privmsg(canal,"%s: Vous savez, moi et les chiffres…"%(auteur)) + if iout + 1 > 1000 and random.randrange(4) == 0: + serv.privmsg(canal, "%s: Vous savez, moi et les chiffres…" % (auteur)) return except Exception as exc: pass - if re.match("[A-Y]",out): - alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ" - serv.privmsg(canal,"%s: %s !"%(auteur,alphabet[alphabet.index(out)+1])) - elif out=="Z": - serv.privmsg(canal,"%s: Je ne vous remercie pas, j'ai l'air idiot ainsi… [ ?"%(auteur)) + if re.match("[A-Y]", out): + alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + serv.privmsg(canal, "%s: %s !"%(auteur, alphabet[alphabet.index(out) + 1])) + elif out == "Z": + serv.privmsg(canal, "%s: Je ne vous remercie pas, j'ai l'air idiot ainsi… [ ?" % (auteur)) elif out in "[\\": - serv.privmsg(canal,"%s: Nous devrions nous en tenir là, ça va finir par poser des problèmes…"%(auteur)) - elif re.match(ur"(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+",out): + serv.privmsg(canal, "%s: Nous devrions nous en tenir là, ça va finir par poser des problèmes…" % (auteur)) + elif re.match(ur"(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+", out): def translate(mess): return "".join([{u"⁰¹²³⁴⁵⁶⁷⁸⁹0123456789"[i]:u"0123456789⁰¹²³⁴⁵⁶⁷⁸⁹"[i] for i in range(20)}[j] for j in mess]) - out=int(translate(out)) - serv.privmsg(canal,"%s: %s !"%(auteur,translate(str(out+1)).encode("utf8"))) - if is_bonjour(message) and not canal in self.quiet_channels: - if is_night(): - answer=random.choice(config.night_answers) - elif is_day(): - answer=random.choice(config.bonjour_answers) + out = int(translate(out)) + serv.privmsg(canal,"%s: %s !" % (auteur, translate(str(out + 1)).encode("utf8"))) + if isit.is_bonjour(message) and not canal in self.quiet_channels: + if isit.is_night(): + answer = random.choice(config.night_answers) + elif isit.is_day(): + answer = random.choice(config.bonjour_answers) else: - answer=random.choice(config.bonsoir_answers) - serv.privmsg(canal,answer.format(auteur).encode("utf8")) - if is_bonne_nuit(message) and not canal in self.quiet_channels: - answer=random.choice(config.bonne_nuit_answers) - serv.privmsg(canal,answer.format(auteur).encode("utf8")) - if is_pan(message) and not canal in self.quiet_channels: - serv.privmsg(canal,"%s: ce n'est pas sur moi qu'il faut tirer, même si je sais que j'attire l'œil !"%(auteur)) + answer = random.choice(config.bonsoir_answers) + serv.privmsg(canal, answer.format(auteur).encode("utf8")) + if isit.is_bonne_nuit(message) and not canal in self.quiet_channels: + answer = random.choice(config.bonne_nuit_answers) + serv.privmsg(canal, answer.format(auteur).encode("utf8")) + if isit.is_pan(message) and not canal in self.quiet_channels: + serv.privmsg(canal, "%s: ce n'est pas sur moi qu'il faut tirer, même si je sais que j'attire l'œil !" % (auteur)) else: - if message in ["!pain au chocolat","!chocolatine"] and not canal in self.quiet_channels: - serv.action(canal,"sert un pain au chocolat à %s"%(auteur)) - if message in ["!manzana"] and not canal in self.quiet_channels: + if message in [u"!pain au chocolat", u"!chocolatine"] and not canal in self.quiet_channels: + serv.action(canal, "sert un pain au chocolat à %s" % (auteur)) + if message in [u"!manzana"] and not canal in self.quiet_channels: if auteur in config.manzana: - serv.action(canal,"sert une bouteille de manzana à %s"%(auteur)) + serv.action(canal, "sert une bouteille de manzana à %s" % (auteur)) elif auteur in config.manzana_bis: - serv.action(canal,"sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas."%(auteur)) + serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur)) else: - serv.action(canal,"sert un verre de manzana à %s"%(auteur)) - if re.match(u'^ *(.|§|!|/|/|:|)(w|b) [0-9]+$',message.decode("utf8")) and not canal in self.quiet_channels: - failanswers=config.buffer_fail_answers - answer=random.choice(failanswers) - serv.privmsg(canal,("%s: %s"%(auteur,answer)).encode("utf8")) + serv.action(canal, "sert un verre de manzana à %s" % (auteur)) + if re.match(config.buffer_fail_regexp, message, flags=re.UNICODE) and not canal in self.quiet_channels: + failanswers = config.buffer_fail_answers + answer = random.choice(failanswers) + serv.privmsg(canal, ("%s: %s"%(auteur,answer)).encode("utf8")) if not canal in self.quiet_channels: - mypseudo=self.nick - if re.match((u"^("+u"|".join(config.bonjour_triggers) - +ur")( {}| all| tout le monde| (à )?tous)(\.| ?!)?$" - ).format(mypseudo).lower(), message.decode("utf8").strip().lower()): - answer=random.choice(config.bonjour_answers) - serv.privmsg(canal,answer.format(auteur).encode("utf8")) - if (is_perdu(message) and not canal in self.quiet_channels): + mypseudo = self.nick + if re.match((u"^(" + u"|".join(config.bonjour_triggers) + + ur")( {}| all| tout le monde| (à )?tous)(\.| ?!)?$" + ).format(mypseudo).lower(), message.strip().lower()): + answer = random.choice(config.bonjour_answers) + serv.privmsg(canal, answer.format(auteur).encode("utf8")) + if (isit.is_perdu(message) and not canal in self.quiet_channels): # proba de perdre sur trigger : # avant 30min (enfin, config) : 0 # ensuite, +25%/30min, linéairement - deltat=time.time()-self.last_perdu - barre=(deltat-config.time_between_perdu)/(2*3600.0) - if random.uniform(0,1)=n1: - serv.action(channel,l2[i-n1].format(auteur).encode("utf8")) + if isit.is_bad_action_trigger(action, mypseudo) and not channel in self.quiet_channels: + l1, l2 = config.bad_action_answers, config.bad_action_actions + n1, n2 = len(l1), len(l2) + i = random.randrange(n1 + n2) + if i >= n1: + serv.action(channel, l2[i - n1].format(auteur).encode("utf8")) else: - serv.privmsg(channel,l1[i].format(auteur).format(auteur).encode("utf8")) - if is_good_action_trigger(action,mypseudo) and not channel in self.quiet_channels: - l1,l2=config.good_action_answers,config.good_action_actions - n1,n2=len(l1),len(l2) - i=random.randrange(n1+n2) - if i>=n1: - serv.action(channel,l2[i-n1].format(auteur).format(auteur).encode("utf8")) + serv.privmsg(channel, l1[i].format(auteur).encode("utf8")) + if isit.is_good_action_trigger(action, mypseudo) and not channel in self.quiet_channels: + l1, l2 = config.good_action_answers, config.good_action_actions + n1, n2 = len(l1), len(l2) + i = random.randrange(n1 + n2) + if i >= n1: + serv.action(channel, l2[i-n1].format(auteur).encode("utf8")) else: - serv.privmsg(channel,l1[i].format(auteur).format(auteur).encode("utf8")) + serv.privmsg(channel, l1[i].format(auteur).encode("utf8")) - def on_kick(self,serv,ev): + 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,"%s kické de %s par %s (raison : %s)" %(victime,channel,auteur,raison)) + if victime == self.nick: + log(self.serveur, ("%s kické de %s par %s (raison : %s)" % (victime, channel, auteur, raison)).decode("utf-8")) time.sleep(2) serv.join(channel) - l1,l2=config.kick_answers,config.kick_actions - n1,n2=len(l1),len(l2) - i=random.randrange(n1+n2) - if i>=n1: - serv.action(channel,l2[i-n1].format(auteur).encode("utf8")) + l1, l2 = config.kick_answers, config.kick_actions + n1, n2 = len(l1), len(l2) + i = random.randrange(n1 + n2) + if i >= n1: + serv.action(channel, l2[i-n1].format(auteur).encode("utf8")) else: - serv.privmsg(channel,l1[i].format(auteur).encode("utf8")) + serv.privmsg(channel, l1[i].format(auteur).encode("utf8")) - def quitter(self,chan,leave_message=None): - if leave_message==None: - leave_message=random.choice(config.leave_messages) - self.serv.part(chan,message=leave_message.encode("utf8")) + ### .fork trick + def start_as_daemon(self, outfile): + sys.stderr = Logger(outfile) + self.start() - def mourir(self): - quit_message=random.choice(config.quit_messages) - self.die(msg=quit_message.encode("utf8")) - - def _getnick(self): - return self.serv.get_nickname() - nick=property(_getnick) +class Logger(object): + """Pour écrire ailleurs que sur stdout""" + def __init__(self, filename="basile.full.log"): + self.filename = filename -if __name__=="__main__": - import sys - if len(sys.argv)==1: - print "Usage : basile.py [--debug]" + 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 : basile.py [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]" + print " --outfile sans --no-output ni --daemon n'a aucun effet" exit(1) - serveur=sys.argv[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 + debug = True else: - debug=False + debug = False if "--quiet" in sys.argv: - config.debug_stdout=False - serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org", - "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org"} + config.debug_stdout = False + serveurs = {"a♡" : "acoeur.crans.org", + "acoeur" : "acoeur.crans.org", + "acoeur.crans.org" : "acoeur.crans.org", + "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/basile.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] + serveur = serveurs[serveur] except KeyError: - print "Server Unknown : %s"%(serveur) + print "Server Unknown : %s" % (serveur) exit(404) - basile=Basile(serveur,debug) - basile.start() + basile = Basile(serveur,debug) + # Si on reçoit un SIGHUP, on reload la config + def sighup_handler(signum, frame): + basile.execute_reload(auteur="SIGHUP") + signal.signal(signal.SIGHUP, sighup_handler) + # Daemonization + if daemon: + child_pid = os.fork() + if child_pid == 0: + os.setsid() + basile.start_as_daemon(outfile) + else: + # on enregistre le pid de basile + pidfile = "/var/run/bots/basile.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: + basile.start() + +if __name__ == "__main__": + main()