# 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
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__)
def get_config_logfile(serveur):
if blackit: # Il n'est pas exempté et matche la blacklist
return True
-def regex_join(liste, avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*"):
- """Fabrique une regexp à partir d'une liste d'éléments à matcher."""
- return avant + u"(" + u"|".join(liste) + u")" + apres
-
-def is_something(chain, regexp=None, matches=[], avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*",
- case_sensitive=False):
- """Vérifie si chain contient un des éléments de ``matches``.
- Si ``regexp`` est fournie, c'est simplement elle qui est testée"""
- if not case_sensitive:
- chain = chain.lower()
- if regexp == None:
- regexp = regex_join(matches, avant, apres)
- regexp = re.compile(regexp)
- o = regexp.match(chain)
- return o
-
-def regexp_compile():
- """Compilation des regexp à partir de la conf.
- Place les résultats dans le namespace de ``config``"""
- config.insult_regexp = regex_join(config.insultes, avant=u".*(?:^| |')")
- config.insult_regexp_compiled = re.compile(config.insult_regexp)
-
- config.not_insult_regexp = u".*pas %s%s" % (config.amplifier_regexp, config.insult_regexp)
- config.not_insult_regexp_compiled = re.compile(config.not_insult_regexp)
-
- config.compliment_regexp = regex_join(config.compliment_triggers, avant=u".*(?:^| |')")
- config.compliment_regexp_compiled = re.compile(config.compliment_regexp)
-
- config.perdu_regexp = regex_join(config.perdu)
- config.perdu_regexp_compiled = re.compile(config.perdu_regexp)
-
- config.tag_regexp = regex_join(config.tag_triggers)
- config.tag_regexp_compiled = re.compile(config.tag_regexp)
-
- config.gros_regexp = regex_join(config.gros)
- config.gros_regexp_compiled = re.compile(config.gros_regexp)
-
- config.tesla_regexp = regex_join(config.tesla_triggers, avant=u"^", apres="$")
- config.tesla_regexp_compiled = re.compile(config.tesla_regexp)
-
- config.merci_regexp = regex_join(config.merci_triggers)
- config.merci_regexp_compiled = re.compile(config.merci_regexp)
-
- config.tamere_regexp = regex_join(config.tamere_triggers)
- config.tamere_regexp_compiled = re.compile(config.tamere_regexp)
-
- config.bonjour_regexp = regex_join(config.bonjour_triggers, avant=u"^")
- config.bonjour_regexp_compiled = re.compile(config.bonjour_regexp)
-
- config.bonne_nuit_regexp = regex_join(config.bonne_nuit_triggers, avant=u"^")
- config.bonne_nuit_regexp_compiled = re.compile(config.bonne_nuit_regexp)
-
- config.pan_regexp = regex_join(config.pan_triggers, avant=".*", apres=".*")
- config.pan_regexp_compiled = re.compile(config.pan_regexp)
-
-
-regexp_compile()
-def is_insult(chain, debug=True):
- """Vérifie si ``chain`` contient une insulte."""
- return is_something(chain, config.insult_regexp_compiled)
-def is_not_insult(chain):
- """Vérifie si ``chain`` contient une insulte à la forme négative."""
- return is_something(chain, config.not_insult_regexp_compiled)
-def is_compliment(chain, debug=True):
- """Vérifie si ``chain`` contient un compliment."""
- return is_something(chain, config.compliment_regexp_compiled)
-def is_perdu(chain):
- """Vérifie si ``chain`` contient une raison de perdre."""
- return is_something(chain, config.perdu_regexp_compiled)
-def is_tag(chain):
- """Vérifie si ``chain`` demande de fermer sa gueule."""
- return is_something(chain, config.tag_regexp_compiled)
-def is_gros(chain):
- """Vérifie si ``chain`` traite de gros."""
- return is_something(chain, config.gros_regexp_compiled)
-def is_tesla(chain):
- """Vérifie si ``chain`` est un ping."""
- return is_something(chain, config.tesla_regexp_compiled)
-def is_merci(chain):
- """Vérifie si ``chain`` contient un remerciement."""
- return is_something(chain, config.merci_regexp_compiled)
-def is_tamere(chain):
- """Vérifie si ``chain`` traite ma mère."""
- return is_something(chain, config.tamere_regexp_compiled)
-def is_bad_action_trigger(chain,pseudo):
- """Vérifie si ``chain`` est une action méchante.
- On a besoin d'une regexp dynamique à cause du pseudo qui peut changer."""
- return is_something(chain, matches=config.bad_action_triggers, avant=u"^",
- apres="(?: [a-z]*ment)? %s($|\.| |,|;).*" % (pseudo))
-def is_good_action_trigger(chain,pseudo):
- """Vérifie si ``chain`` est une action gentille.
- On a besoin d'une regexp dynamique à cause du pseudo qui peut changer."""
- return is_something(chain, matches=config.good_action_triggers, avant=u"^",
- apres="(?: [a-z]*ment)? %s($|\.| |,|;).*" % (pseudo))
-def is_bonjour(chain):
- """Vérifie si ``chain`` contient un bonjour."""
- return is_something(chain, config.bonjour_regexp_compiled)
-def is_bonne_nuit(chain):
- """Vérifie si ``chain`` contient un bonne nuit."""
- return is_something(chain, config.bonne_nuit_regexp_compiled)
-def is_pan(chain):
- """Vérifie si ``chain`` contient un pan."""
- return is_something(chain, config.pan_regexp_compiled)
-
-def is_time(conf):
- """Vérifie si l'heure actuelle est entre les deux heures ``conf[0]`` et ``conf[1]``"""
- _, _, _, h, m, s, _, _, _ = time.localtime()
- return (conf[0], 0, 0) < (h, m, s) < (conf[1], 0, 0)
-def is_day():
- """Vérifie si on est le jour."""
- return is_time(config.daytime)
-def is_night():
- """Vérifie si on est la nuit."""
- return is_time(config.nighttime)
-
-
-class UnicodeBotError(Exception):
- """Erreur levée si quelqu'un fait du caca avec son encodage."""
- pass
-
-class CrashError(Exception):
- """Pour pouvoir faire crasher Basile, parce que ça a l'air drôle."""
- def __init__(self, msg=""):
- Exception.__init__(self, msg)
def bot_unicode(chain):
"""Essaye de décoder ``chain`` en UTF-8.
- Lève une py:class:`UnicodeBotError` en cas d'échec."""
+ Lève une py:class:`errors.UnicodeBotError` en cas d'échec."""
try:
return chain.decode("utf8")
except UnicodeDecodeError as exc:
- raise UnicodeBotError
+ raise errors.UnicodeBotError
class Basile(ircbot.SingleServerIRCBot):
self.ops = self.overops + config.ops
self.report_bugs_to = config.report_bugs_to
self.chanlist = config.chanlist
- self.identities = json.load(open(config.identities_file, "r"))
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"):
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))
+ 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."""
def execute_reload(self, auteur=None):
"""Recharge la config."""
reload(config)
- regexp_compile()
+ isit.regexp_compile()
if auteur in [None, "SIGHUP"]:
towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
for to in config.report_bugs_to:
else:
return True, u"Config reloaded"
- def crash(self, chan="nowhere", who="nobody"):
+ def crash(self, who="nobody", chan="nowhere"):
"""Fait crasher le bot."""
where = "en privé" if chan == "priv" else "sur le chan %s" % chan
- raise CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
+ raise errors.CrashError((u"Crash demandé par %s %s" % (who, where)).encode("utf-8"))
ACTIONS = {
"reload" : execute_reload,
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):
"""À l'arrivée sur le serveur."""
for report in self.report_bugs_to:
serv.privmsg(report, "Connection to NK2015 failed, invalid password ?")
+ def on_whoisregnick(self, serv, ev):
+ """Appelée sur une réponse à un whois au moment où ça dit "is a registered nick".
+ J'ai vérifié, "is a registered nick" ça inclu le fiat qu'il est identified correctement.
+
+ On stocke l'information comme quoi cette personne est registered, et quand c'était."""
+ pseudo, phrase = ev.arguments()
+ if phrase == 'is a registered nick':
+ # Le whois n'est plus "pending"
+ if self.users.pending_whois.has_key(pseudo):
+ self.users.pending_whois[pseudo][0] = "registered"
+ self.users.pending_whois[pseudo][3] = time.time()
+ _, askedwhy, askedby, _ = self.users.pending_whois[pseudo]
+ if askedwhy == "cmd WHOIS":
+ # Ce whois a été demandé par quelqu'un, on lui répond
+ self.serv.privmsg(askedby, "%s is a registered nick" % (pseudo,))
+
+ 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):
"""À la réception d'un message en privé."""
if ignore_event(serv, ev):
auteur = irclib.nm_to_n(ev.source())
try:
message = bot_unicode(message)
- except UnicodeBotError:
+ except errors.UnicodeBotError:
if config.utf8_trigger:
serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
return
helpmsg += "\n" + helpmsgs[2]
else:
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.encode("utf-8"))
elif cmd == u"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]["pseudo"].encode("utf8")))
+ 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.")
+ 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] = info
- json.dump(self.identities, open(config.identities_file,"w"))
+ 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)")
serv.privmsg(auteur, "Syntaxe : IDENTIFY [<username> <password>]")
elif cmd == u"drop":
if len(message) > 1:
- if self.identities.has_key(auteur):
+ if self.users.has(auteur):
+ idbde = self.users[auteur].idbde
password = " ".join(message[1:])
- success, _, _ = self.new_connection_NK(serv, self.identities[auteur], password)
+ success, _, _ = self.new_connection_NK(serv, "#%s" % idbde, password)
if success:
- del self.identities[auteur]
+ self.users.drop(idbde)
log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
- json.dump(self.identities, open(config.identities_file, "w"))
- serv.privmsg(auteur, "Identité oubliée.")
+ serv.privmsg(auteur, "Pseudo oublié.")
else:
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 <password>")
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]))
+ 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])
elif cmd == u"crash":
if auteur in self.overops:
log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
- self.crash("priv", auteur)
+ self.crash(auteur, "priv")
else:
notunderstood = True
elif cmd == u"reload":
notunderstood = True
elif cmd == u"say":
if auteur in self.overops and len(message) > 2:
- serv.privmsg(message[1], " ".join(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>")
notunderstood = True
elif cmd == u"solde":
if len(message) == 1:
- if self.identities.has_key(auteur):
- success, solde, pseudo = nk.get_solde(self.nk, self.identities[auteur]["idbde"], serv, auteur)
+ 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.")
+ 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.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
else:
notunderstood = True
if notunderstood:
message = ev.arguments()[0]
try:
message = bot_unicode(message)
- except UnicodeBotError:
+ 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
self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
elif cmd == u"crash":
if auteur in self.overops:
- self.crash(auteur, message)
+ 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):
serv.privmsg(canal, "%s: pong" % (auteur))
elif cmd in [u"solde", u"!solde", u"!coca"] or cmd.startswith("!"):
- if self.identities.has_key(auteur):
- idbde = self.identities[auteur]["idbde"]
+ 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, self.identities[auteur]["idbde"], serv, canal)
+ 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, self.identities[auteur]["idbde"], message[1:], serv, canal)
+ 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))
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):
+ 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")))
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:
+ 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)
+ 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:
+ 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)
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:
+ 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:
+ 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"))
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):
+ 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")))
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():
+ if isit.is_bonjour(message) and not canal in self.quiet_channels:
+ if isit.is_night():
answer = random.choice(config.night_answers)
- elif is_day():
+ 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:
+ 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 is_pan(message) and not canal in self.quiet_channels:
+ 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 [u"!pain au chocolat", u"!chocolatine"] and not canal in self.quiet_channels:
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) and not canal in self.quiet_channels:
+ 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"))
).format(mypseudo).lower(), message.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):
+ 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
channel = ev.target()
try:
action = bot_unicode(action)
- except UnicodeBotError:
+ 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
- if is_bad_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
+ 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)
serv.action(channel, l2[i - n1].format(auteur).encode("utf8"))
else:
serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
- if is_good_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
+ 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)
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))
+ 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
f.close()
def main():
- """Exécution principal : lecture des paramètres et lancement du bot."""
+ """Exécution principale : lecture des paramètres et lancement du bot."""
if len(sys.argv) == 1:
print "Usage : basile.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
print " --outfile sans --no-output ni --daemon n'a aucun effet"
projects / bots / basile.git / blobdiff