]> gitweb.pimeys.fr Git - bots/basile.git/commitdiff
Modularité : sortie des is_
authorVincent Le Gallic <legallic@crans.org>
Fri, 31 Jan 2014 00:26:47 +0000 (01:26 +0100)
committerVincent Le Gallic <legallic@crans.org>
Fri, 31 Jan 2014 00:26:47 +0000 (01:26 +0100)
basile.py
isit.py [new file with mode: 0644]

index 2fedf6ed76a4a0aa8dc9dfb3a644b892edd0dcc9..68c2bb35f3b47824de9806b570f8b813afc148f2 100755 (executable)
--- a/basile.py
+++ b/basile.py
@@ -25,6 +25,8 @@ 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
 
 # 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
@@ -66,122 +68,7 @@ def ignore_event(serv, ev):
             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()
-        apres = apres.lower()
-        avant = avant.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):
@@ -300,7 +187,7 @@ class Basile(ircbot.SingleServerIRCBot):
     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:
@@ -692,8 +579,8 @@ class Basile(ircbot.SingleServerIRCBot):
                     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")))
@@ -701,16 +588,16 @@ class Basile(ircbot.SingleServerIRCBot):
                     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)
@@ -718,11 +605,11 @@ class Basile(ircbot.SingleServerIRCBot):
                     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"))
@@ -731,7 +618,7 @@ class Basile(ircbot.SingleServerIRCBot):
                     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")))
@@ -765,18 +652,18 @@ class Basile(ircbot.SingleServerIRCBot):
                                        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:
@@ -799,7 +686,7 @@ class Basile(ircbot.SingleServerIRCBot):
                              ).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
@@ -824,7 +711,7 @@ class Basile(ircbot.SingleServerIRCBot):
             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)
@@ -832,7 +719,7 @@ class Basile(ircbot.SingleServerIRCBot):
                 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)
diff --git a/isit.py b/isit.py
new file mode 100644 (file)
index 0000000..d5264df
--- /dev/null
+++ b/isit.py
@@ -0,0 +1,125 @@
+#!/usr/bin/python
+# -*- coding:utf8 -*-
+
+""" Des fonctions utilitaire pour savoir si on est dans tel ou tel cas. """
+
+import re
+
+import config
+
+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()
+        apres = apres.lower()
+        avant = avant.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)
\ No newline at end of file