basile.py

   1 #!/usr/bin/python
   2 # -*- coding:utf8 -*-
   3
   4 # Codé par 20-100 le 23/04/12
   5
   6 # Un test de bot irc, parce que c'est cool
   7
   8 import irclib
   9 import ircbot
  10 import threading
  11 import random
  12 import time
  13 import socket, ssl, json
  14 import pickle
  15 import re
  16 import os
  17 from commands import getstatusoutput as ex
  18
  19 import sys
  20 config_debug_stdout=True
  21 if "--quiet" in sys.argv:
  22     config_debug_stdout=False
  23
  24 config_irc_password="NK2015BasileB0t"
  25 config_irc_pseudo="Basile"
  26 config_chanlist=["#bot","#flood"]
  27 config_stay_channels=["#bot","#flood"]
  28 config_quiet_channels=[]
  29 config_note_pseudo="Basile"
  30 config_note_password="NK2015BasileB0tr4nd0omp4assword]6_+{#]78{"
  31 config_logfile_template="basile.%s.log"
  32 def get_config_logfile(serveur):
  33     serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"}
  34     return config_logfile_template%(serveurs[serveur])
  35 config_overops=["[20-100]","[20-100]_"]
  36 config_ops=["PEB","Nit"]
  37 config_report_bugs_to=["[20-100]"]
  38
  39 config_insultes=[u"conna(rd|sse)",u"pute",u"con(|ne)",u"enf(oiré|lure)",
  40 u"sal(op(|e(|rie)|ard)|aud)",u"p(e|')tite bite",u"imbécile",u"idiot",u"stupid(|e)",u"débile",u"crétin",
  41 u"pétasse",u"enculé",u"chagasse",u"cagole",u"abruti",u"ahuri",u"analphabète",u"andouille",
  42 u"atardé",u"avorton",u"bachibouzouk",u"(balais|brosse) (de|à) chiotte(|s)",
  43 u"batard",u"blaireau",u"bouffon",u"branque",u"bouseux",u"branleur",u"catin",u"chacal",
  44 u"charogne",u"chiant(|e)",u"chieur",u"cochon",u"coprophage",u"couillon",u"crapule",u"crevard",
  45 u"cruche",u"cuistre",u"ducon",u"décérébré",
  46 u"emmerdeur",u"feignasse",u"fainéant",u"fourbe",u"freluquet",u"frigide",
  47 u"garce",u"glandu",u"gogol",u"goujat",u"gourdasse",u"gredin",u"gringalet",u"grognasse",
  48 u"naze",u"truie",u"iconoclaste",
  49 u"peigne(-|)cul",u"ignare",u"illétré",u"lèche(|-)cul",u"malotru",u"motherfucker",u"nabot",u"nigaud",
  50 u"nul",u"escroc",u"pouffiasse",u"pourriture",u"raclure",u"relou",u"sagouin",u"putain",
  51 u"péripatéticienne"]
  52 config_insultes_answers=[u"toi-même",
  53 u"Oh non ! Quelle insulte ! Je crois que je ne m'en reléverai jamais…\nAh si, ça y est.",
  54 u"J'entends comme un vague murmure, tu disais ?",
  55 u"Je vais prendre ça pour un compliment.",
  56 u"Tu sais, pour toi c'est peut-être une insulte, mais pour moi ce n'est qu'une suite de 0 et de 1…",
  57 u"Si tu allais voir sur un autre chan si j'y suis ?",
  58 u"Permets-moi de te retourner le compliment.",
  59 u"Mais je ne te permets pas !"]
  60
  61 config_gros=[u"gros"]
  62
  63 config_buffer_fail_answers=["haha !","You type like you drive","encore un effort ;)"]
  64
  65 config_premier_groupe_terminaisons=u"(e|es|ons|ez|ent|er(|ai|as|a|ons|ez|ont)|(|er)(ais|ait|ions|iez|aient)|(a(i|s|)|â(mes|tes|t)|èrent)|ass(e(|s|nt)|i(ons|ez))|é(|s|e|es))"
  66 config_regexp_etre=u"(être|suis|e(s|t)|so(mmes|nt)|êtes|(ét|ser)(ai(s|t|ent)|i(ons|ent)|)|ser(ai|as|a|ons|ez|ont)|so(i(s|t|ent)|y(ons|ez))|f(u(s|t|rent)|û(mes|tes|t))|fuss(e(|s|nt)|i(ons|ez))|étant)"
  67 config_regexp_etre_avec_c=u"c'(e(s|st)|étai(t|ent))"
  68 config_regexp_faire=u"fais"
  69 config_perdu=[u"perd(|s|ons|ez|ent|r(e|ai|as|a|ons|ez|ont)|(|r)(ais|ait|ions|iez|aient))"
  70 u"perd(i(s|t|rent)|î(mes|tes|t))", # oui, j'ai inclus qu'il perdît
  71 u"perdiss(e(|s|nt)|i(ons|ez))",
  72 u"perdu(|s|e|es)",u"perdant(|s|e|es)",u"perte(|s)",
  73
  74 u"(gagn|trouv)"+config_premier_groupe_terminaisons,u"gagnant(|s|e|es)",u"gain(|s)",
  75
  76 u"trouvant",u"trouvaille(|s)",
  77
  78 u"victoire(|s)",u"vaincu(|s|e|es)",
  79 u"loose",u"lost",u"looser(|s)",u"win(|ner)(|s)",
  80 u"jeu(|x)",u"game(|s)"]
  81 config_time_between_perdu_trigger=3600*3 #temps moyen pour perdre en l'absence de trigger
  82 config_time_between_perdu_trigger_delta = 30*60 #marge autorisée autour de ^^^
  83 config_time_between_perdu=30*60 #temps pendant lequel on ne peut pas perdre
  84
  85 config_tag=[u"t(|a)g",u"ta gueule",u"la ferme",u"ferme( |-)la",u"tais-toi",u"chut"]
  86 config_tag_actions=[u"se tait",u"ferme sa gueule",u"se la ferme",u"la ferme"]
  87 config_tag_answers=[u"J'me tais si j'veux !",
  88 u"Je t'entends pas :°",
  89 u"Héhé, try again",
  90 u"Non, j'ai pas envie",
  91 u"Peut-être quand toi tu la fermeras, et encore…"]
  92
  93 config_tesla=[u"t('|u )es là \?",u"\?",u"plop \?",u"plouf \?"]
  94 config_tesla_answers=[u"Oui, je suis là",u"Oui ?",u"En quoi puis-je me rendre utile ?"]
  95 config_tesla_actions=[u"est là",u"attend des instructions",u"is alive"]
  96
  97 config_compliment=[u"gentil",u"cool",u"sympa"]
  98 config_compliment_answers=[u"Merci, c'est gentil :)",u"Je te retourne le compliment",u"C'est gentil ça."]
  99
 100 config_merci=[u"merci",u"remercie",u"thx",u"thank(|s)"]
 101 config_merci_answers=[u"Mais de rien.",u"À ton service ;)",u"Quand tu veux ^^",
 102 u"Tout le plaisir est pour moi."]
 103
 104 config_tamere=[u"ta mère"]
 105 config_tamere_answers=[u"Laisse ma mère en dehors de ça !",
 106 u"Tu veux qu'on parle de ta soœur ?",
 107 u"Et la tienne ?",
 108 u"Ce que fait ma mère c'est comme ce que tu fais avec ta bite, ça nous regarde pas…",
 109 u"♩ J'ai vu ta mère sur chat rouleeeeeeette ♫"
 110 u"On avait dit \"pas les mamans\""]
 111
 112 config_action_trigger=[u"(frappe|cogne|tape)(| sur)",u"démolit",u"vomit sur",u"slap(|s)"]
 113 config_action_answers=[u"Hey ! Mais qu'est-ce que j'ai fait ?",
 114 u"Pourquoi moi ?",
 115 u"Mais euh…",
 116 u"Mais j'ai rien demandé moi !"]
 117 config_action_actions=[u"prend de la distance, par précaution…",u"part en courant"]
 118
 119 config_bonjour=[u"(s|)(a|'|)lu(t|)",u"hello",u"plop",u"plip",u"pr(ou|ü)t",u"bonjour",u"bonsoir"]
 120 config_bonjour_answers=[u"Salut {}",u"Hello {} :)",u"Bonjour {}",u"Hello {}",u"{}: hello",u"{}: bonjour"]
 121
 122
 123 config_thisfile= os.path.realpath( __file__ )
 124 def get_filesize():
 125     return ex("ls -s %s"%(config_thisfile))[1].split()[0]
 126
 127 class NKError(Exception):
 128     def __init__(self,msg):
 129         Exception.__init__(self)
 130         self.msg=msg
 131     def __str__(self):
 132         return str(self.msg)
 133     def __unicode__(self):
 134         return unicode(self.msg)
 135
 136 class NKRefused(NKError):
 137     pass
 138
 139 class NKHelloFailed(NKError):
 140     pass
 141
 142 class NKUnknownError(NKError):
 143     pass
 144
 145 def log(serveur,channel,auteur=None,message=None):
 146     f=open(get_config_logfile(serveur),"a")
 147     if auteur==message==None:
 148         # alors c'est que c'est pas un channel mais juste une ligne de log
 149         chain="%s %s"%(time.strftime("%F %T"),channel)
 150     else:
 151         chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message)
 152     f.write(chain+"\n")
 153     if config_debug_stdout:
 154         print chain
 155     f.close()
 156
 157 def connect_NK():
 158     sock=socket.socket()
 159     try:
 160         # On établit la connexion sur port 4242
 161         sock.connect(("127.0.0.1",4242))
 162         # On passe en SSL
 163         sock=ssl.wrap_socket(sock,ca_certs='../keys/ca_.crt')
 164         # On fait un hello
 165         sock.write('hello "Basile"')
 166         # On récupère la réponse du hello
 167         out=sock.read()
 168         out=json.loads(out)
 169     except Exception as exc:
 170         # Si on a foiré quelque part, c'est que le serveur est down
 171         raise NKRefused(str(exc))
 172     if out["retcode"]==0:
 173         return sock
 174     elif out["retcode"]==11:
 175         raise NKHelloFailed(out["errmsg"])
 176     else:
 177         raise NKUnknownError(out["errmsg"])
 178
 179 def login_NK(username,password,typ="bdd"):
 180     sock=connect_NK()
 181     if typ=="special": # ça c'est pour Basile lui-même
 182         masque='["note"]'
 183     elif typ=="bdd":
 184         masque='[["all"],["all"],false]'
 185     try:
 186         # Basile a un compte special user
 187         commande='login [%s,%s,"%s",%s]'%(json.dumps(username),json.dumps(password),typ,masque)
 188         sock.write(commande)
 189         out=sock.read()
 190     except Exception as exc:
 191         # Si on a foiré quelque part, c'est que le serveur est down
 192         raise NKRefused(str(exc))
 193     # On vérifie ensuite que le login
 194     return json.loads(out),sock
 195
 196
 197 def is_something(chain,matches,avant=u".*(^| )",apres=u"($|\.| |,|;).*",case_sensitive=False,debug=False):
 198     if case_sensitive:
 199         chain=unicode(chain,"utf8")
 200     else:
 201         chain=unicode(chain,"utf8").lower()
 202     allmatches="("+"|".join(matches)+")"
 203     reg=(avant+allmatches+apres).lower()
 204     if re.match(reg,chain):
 205         return True
 206     return False
 207
 208 def is_insult(chain,debug=True):
 209     return is_something(chain,config_insultes,avant=".*(^| |')")
 210 def is_not_insult(chain):
 211     chain=unicode(chain,"utf8")
 212     insult_regexp=u"("+u"|".join(config_insultes)+u")"
 213     middle_regexp=u"(un(|e) ((putain|enfoiré) d(e |'))*|)(| super )( (gros|petit|grand|énorme) |)"
 214     reg=".*pas %s%s.*"%(middle_regexp,insult_regexp)
 215     if re.match(reg,chain):
 216         return True
 217     else:
 218         return False
 219 def is_perdu(chain):
 220     return is_something(chain,config_perdu)
 221 def is_tag(chain):
 222     return is_something(chain,config_tag)
 223 def is_gros(chain):
 224     return is_something(chain,config_gros)
 225 def is_tesla(chain):
 226     return is_something(chain,config_tesla,avant=u"^",apres=u"$",debug=True)
 227 def is_merci(chain):
 228     return is_something(chain,config_merci)
 229 def is_tamere(chain):
 230     return is_something(chain,config_tamere)
 231 def is_action_trigger(chain,pseudo):
 232     return is_something(chain,config_action_trigger,avant=u"^",apres=" %s($|\.| |,|;).*"%(pseudo))
 233 def is_pan(chain):
 234     return re.match(u"^(pan|bim|bang)$",unicode(chain,"utf8").lower().strip())
 235
 236
 237
 238 class UnicodeBotError(Exception):
 239     pass
 240 def bot_unicode(chain):
 241     try:
 242         unicode(chain,"utf8")
 243     except UnicodeDecodeError as exc:
 244         raise UnicodeBotError
 245
 246 class Basile(ircbot.SingleServerIRCBot):
 247     def __init__(self,serveur,debug=False):
 248         temporary_pseudo=config_irc_pseudo+str(random.randrange(10000,100000))
 249         ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
 250                               temporary_pseudo,"Basile, le bot irc.[Codé par 20-100, fouettez-le]", 10)
 251         self.debug=debug
 252         self.serveur=serveur
 253         self.overops=config_overops
 254         self.ops=self.overops+config_ops
 255         self.report_bugs_to=config_report_bugs_to
 256         self.chanlist=config_chanlist
 257         self.sockets={}
 258         self.identities=pickle.load(open("identities.pickle","r"))
 259         self.stay_channels=config_stay_channels
 260         self.quiet_channels=config_quiet_channels
 261         self.last_perdu=0
 262
 263
 264     def new_connection_NK(self,serv,username,password,typ="bdd"):
 265         try:
 266             login_result,sock=login_NK(username,password,typ)
 267             droits,retcode,errmsg=login_result["msg"],login_result["retcode"],login_result["errmsg"]
 268         except NKRefused as exc:
 269             for report in self.report_bugs_to:
 270                 serv.privmsg(report,"Le Serveur NK2015 est down.")
 271             return (False,None)
 272         except NKHelloFailed as exc:
 273             for report in self.report_bugs_to:
 274                 serv.privmsg(report,
 275                              "La version du site utilisée n'est pas supportée par le serveur NK2015.")
 276             return (False,None)
 277         except NKUnknownError as exc:
 278             erreurs=["Une fucking erreur inconnue s'est produite"]
 279             erreurs+=str(exc).split("\n")
 280             for report in self.report_bugs_to:
 281                 for err in erreurs:
 282                     serv.privmsg(report,err)
 283             return (False,None)
 284         except Exception as exc:
 285             # Exception qui ne vient pas de la communication avec le serveur NK2015
 286             log(self.serveur,"Erreur dans new_connection_NK\n"+str(exc))
 287             return (False,None)
 288         if retcode==0:
 289             return (True,sock)
 290         else:
 291             return (False,None)
 292
 293     def give_me_my_pseudo(self,serv):
 294         serv.privmsg("NickServ","RECOVER %s %s"%(config_irc_pseudo,config_irc_password))
 295         serv.privmsg("NickServ","RELEASE %s %s"%(config_irc_pseudo,config_irc_password))
 296         time.sleep(0.3)
 297         serv.nick(config_irc_pseudo)
 298
 299     def on_welcome(self, serv, ev):
 300         self.give_me_my_pseudo(serv)
 301         serv.privmsg("NickServ","identify %s"%(config_irc_password))
 302         log(self.serveur,"Connected")
 303         if self.debug:
 304             self.chanlist=["#bot"]
 305         for c in self.chanlist:
 306             log(self.serveur,"JOIN %s"%(c))
 307             serv.join(c)
 308         # on ouvre la connexion note de Basile, special user
 309         self.nk=self.new_connection_NK(serv,config_note_pseudo,config_note_password,"special")[1]
 310         if self.nk==None:
 311             for report in self.report_bugs_to:
 312                 serv.privmsg(report,"Connection to NK2015 failed, invalid password ?")
 313
 314     def lost(self,serv,channel,forced=False):
 315         if self.last_perdu+config_time_between_perdu<time.time() or forced:
 316             if not channel in self.quiet_channels or forced:
 317                 serv.privmsg(channel,"J'ai perdu !")
 318             self.last_perdu=time.time()
 319             delay=config_time_between_perdu_trigger
 320             delta=config_time_between_perdu_trigger_delta
 321             serv.execute_delayed(random.randrange(delay-delta,delay+delta),self.lost,(serv,channel))
 322
 323     def try_tamere(self,serv,channel,auteur,message):
 324         """Essaye de trigger un ta mère"""
 325         #pas à chaque fois quand même
 326         if random.randrange(4)==0:
 327             debuts=u"("+config_regexp_etre+u"|"+config_regexp_etre_avec_c+u")"
 328             adjectifs={u"bon(|ne|s|nes)":u"bonne",
 329                        u"baisable(|s)":u"baisable",
 330                        u"faisable(|s)":u"faisable",
 331                        u"pas ch(ère(|s)|er(|s))":u"pas chère",
 332                        u"facile(|s)":u"facile",
 333                        u"chaud(|e|s|es)":u"chaude",
 334                        u"gratuit(|e|s|es)":u"gratuite",
 335                        u"payant(|e|s|es)":u"payante",
 336                        u"ouvert(|e|s|es)":u"ouverte",
 337                        u"open":u"open",
 338                        u"plein(|s|es)":u"pleine",
 339                        u"bien plein(|e|s|es)":u"bien pleine",
 340                        u"innocent(|e|s|es)":u"innocente"}
 341             adj_reg=u"(?P<adjectif>"+u"|".join(adjectifs.keys())+u")"
 342             reg=u".*(^| |')"+debuts+u" "+adj_reg+u"($|,|;|\.| ).*"
 343             matched=re.match(reg,message)
 344             if matched:
 345                 # il faut repasser l'adjectif au féminin singulier
 346                 found=matched.groupdict()["adjectif"]
 347                 for adj in adjectifs.keys():
 348                     if re.match(adj,found):
 349                         adjectif=adjectifs[adj]
 350                         break
 351                 serv.privmsg(channel,(u"%s: c'est ta mère qui est %s !"%(auteur,adjectif)).encode("utf8"))
 352             elif random.randrange(5)==0:
 353                 # deuxième type de trigger, mais moins probable
 354                 matched=re.match(adj_reg,message)
 355                 if matched:
 356                     found=matched.groupdict()["adjectif"]
 357                     for adj in adjectifs.keys():
 358                         if re.match(adj,found):
 359                             adjectif=adjectifs[adj]
 360                             break
 361                     fille=random.choice([u"mère",u"soœur"])
 362                     serv.privmsg(channel,(u"%s: et ta %s, elle est %s ?"%
 363                                                (auteur,fille,adjectif)).encode("utf8"))
 364                 else:
 365                     # troisième type de trigger
 366                     cpgt=config_premier_groupe_terminaisons
 367                     verbes={u"tourn"+cpgt:u"tourne",
 368                             u"balad"+cpgt+u" sur le trottoir":u"se balade sur le trottoir",
 369                             u"prom(e|è)n"+cpgt+" sur le trottoir":u"se promène sur le trottoir",
 370                             u"_srqhbkjjn":""}
 371                     vb_reg=u".*(^| )(?P<verbe>"+"|".join(verbes.keys())+")( |,|;|\.|$)"
 372                     matched=re.match(vb_reg,message)
 373                     if matched:
 374                         found=matched.groupdict()["verbe"]
 375                         for vb in verbes.keys():
 376                             if re.match(vb,found):
 377                                 verbe=verbes[vb]
 378                                 break
 379                         fille=random.choice([u"mère",u"soœur"])
 380                         serv.privmsg(channel,(u"%s: et ta %s, elle %s ?"%
 381                                                (auteur,fille,verbe)).encode("utf8"))
 382     def pourmoi(self, serv, message):
 383         """renvoie (False,lemessage) ou (True, le message amputé de "pseudo: ")"""
 384         pseudo=serv.get_nickname()
 385         size=len(pseudo)
 386         if message[:size]==pseudo and len(message)>size and message[size]==":":
 387             return (True,message[size+1:].lstrip(" "))
 388         else:
 389             return (False,message)
 390
 391     def on_privmsg(self, serv, ev):
 392         message=ev.arguments()[0]
 393         auteur = irclib.nm_to_n(ev.source())
 394         try:
 395             test=bot_unicode(message)
 396         except UnicodeBotError:
 397             serv.privmsg(auteur,
 398               "Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…")
 399             return
 400         message=message.split()
 401         cmd=message[0].lower()
 402         notunderstood=False
 403         if cmd=="connect":
 404             if not len(message) in [2,3]:
 405                 serv.privmsg(auteur,"Syntaxe : CONNECT [<username>] <password>")
 406                 return
 407             username=auteur
 408             if len(message)>2:
 409                 username=(message[1])
 410                 password=" ".join(message[2:])
 411             else:
 412                 password=" ".join(message[1:])
 413             success,sock=self.new_connection_NK(serv,username,password)
 414             if success:
 415                 self.sockets[username]=sock
 416                 serv.privmsg(auteur,"Connection successful")
 417                 log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 418             else:
 419                 serv.privmsg(auteur,"Connection failed")
 420                 log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 421
 422         elif cmd=="help":
 423             helpdico={"connect": """CONNECT [<username>] <password>
 424  Ouvre une connexion au serveur NoteKfet.
 425  Si <username> n'est pas précisé, j'utiliserais l'identité sous laquelle je te connais, ou, à défaut, ton pseudo.""",
 426 "identify": """IDENTIFY <username> <password>
 427  Vérifie le mot de passe et me permet de savoir à l'avenir quel est ton pseudo note kfet.
 428  Sans paramètre, je réponds sous quel pseudo je te connais.""",
 429 "drop":"""DROP <password>
 430  Vérifie le mot de passe et me fait d'oublier ton pseudo note kfet."""}
 431             helpmsg_default="""Liste des commandes :
 432  HELP       Affiche de l'aide sur une commande.
 433  CONNECT    Ouvre une connection au serveur Note Kfet.
 434  IDENTIFY   Me permet de savoir qui tu es sur la note kfet.
 435  DROP       Me fait oublier ton identité."""
 436             helpmsg_ops="""
 437  JOIN       Faire rejoindre un chan
 438  LEAVE      Faire quitter un chan
 439  QUIET      Se taire sur un chan
 440  NOQUIET    Opposé de QUIET
 441  LOST       Perdre sur un chan"""
 442             helpmsg_overops="""
 443  SAY        Fais envoyer un message sur un chan ou à une personne
 444  STAY       Ignorera les prochains LEAVE pour un chan
 445  NOSTAY     Opposé de STAY
 446  DIE        Mourir"""
 447             if len(message)==1:
 448                 helpmsg=helpmsg_default
 449                 if auteur in self.ops:
 450                     helpmsg+=helpmsg_ops
 451                 if auteur in self.overops:
 452                     helpmsg+=helpmsg_overops
 453             else:
 454                 helpmsg=helpdico.get(message[1].lower(),"Commande inconnue.")
 455             for ligne in helpmsg.split("\n"):
 456                 serv.privmsg(auteur,ligne)
 457         elif cmd=="identify":
 458             if len(message)==1:
 459                 if self.identities.has_key(auteur):
 460                     serv.privmsg(auteur,"Je te connais sous le pseudo note %s."%(
 461                                      self.identities[auteur].encode("utf8")))
 462                 else:
 463                     serv.privmsg(auteur,"Je ne connais pas ton pseudo note.")
 464             elif len(message)>=3:
 465                 username,password=message[1],unicode(" ".join(message[2:]),"utf8")
 466                 success,_=self.new_connection_NK(serv,username,password)
 467                 if success:
 468                     log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 469                     serv.privmsg(auteur,"Identité enregistrée.")
 470                     self.identities[auteur]=username
 471                     pickle.dump(self.identities,open("identities.pickle","w"))
 472                 else:
 473                     log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 474                     serv.privmsg(auteur,"Mot de passe invalide. (ou serveur down)")
 475             else:
 476                 serv.privmsg(auteur,u"Syntaxe : IDENTIFY [<username> <password>]")
 477         elif cmd=="drop":
 478             if len(message)>1:
 479                 if self.identities.has_key(auteur):
 480                     password=" ".join(message[1:])
 481                     success,_=self.new_connection_NK(serv,self.identities[auteur],password)
 482                     if success:
 483                         del self.identities[auteur]
 484                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 485                         pickle.dump(self.identities,open("identities.pickle","w"))
 486                         serv.privmsg(auteur,"Identité oubliée.")
 487                     else:
 488                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 489                         serv.privmsg(auteur,"Mot de passe invalide. (ou serveur down)")
 490                 else:
 491                     serv.privmsg(auteur,"Je ne connais pas ton pseudo note.")
 492             else:
 493                 serv.privmsg(auteur,"Syntaxe : DROP <password>")
 494         elif cmd=="join":
 495             if auteur in self.ops:
 496                 if len(message)>1:
 497                     if message[1] in self.chanlist:
 498                         serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1]))
 499                     else:
 500                         serv.join(message[1])
 501                         self.chanlist.append(message[1])
 502                         serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 503                         log(self.serveur,"priv",auteur," ".join(message))
 504                 else:
 505                     serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 506             else:
 507                 notunderstood=True
 508         elif cmd=="leave":
 509             if auteur in self.ops and len(message)>1:
 510                 if message[1] in self.chanlist:
 511                     if not (message[1] in self.stay_channels) or auteur in self.overops:
 512                         serv.part(message[1])
 513                         self.chanlist.remove(message[1])
 514                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 515                     else:
 516                         serv.privmsg(auteur,"Non, je reste !")
 517                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 518                 else:
 519                     serv.privmsg(auteur,"Je ne suis pas sur %s"%(message[1]))
 520             else:
 521                 notunderstood=True
 522         elif cmd=="stay":
 523             if auteur in self.overops:
 524                 if len(message)>1:
 525                     if message[1] in self.stay_channels:
 526                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 527                         serv.privmsg(auteur,"Je stay déjà sur %s."%(message[1]))
 528                     else:
 529                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 530                         self.stay_channels.append(message[1])
 531                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 532                 else:
 533                     serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 534             else:
 535                 notunderstood=True
 536         elif cmd=="nostay":
 537             if auteur in self.overops:
 538                 if len(message)>1:
 539                     if message[1] in self.stay_channels:
 540                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 541                         self.stay_channels.remove(message[1])
 542                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 543                     else:
 544                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 545                         serv.privmsg(auteur,"Je ne stay pas sur %s."%(message[1]))
 546
 547             else:
 548                 notunderstood=True
 549         elif cmd=="die":
 550             if auteur in self.overops:
 551                 log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 552                 self.die()
 553             else:
 554                 notunderstood=True
 555         elif cmd=="quiet":
 556             if auteur in self.ops:
 557                 if len(message)>1:
 558                     if message[1] in self.quiet_channels:
 559                         serv.privmsg(auteur,"Je me la ferme déjà sur %s"%(message[1]))
 560                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 561                     else:
 562                         self.quiet_channels.append(message[1])
 563                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 564                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 565                 else:
 566                     serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 567             else:
 568                 notunderstood=True
 569         elif cmd=="noquiet":
 570             if auteur in self.ops:
 571                 if len(message)>1:
 572                     if message[1] in self.quiet_channels:
 573                         self.quiet_channels.remove(message[1])
 574                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 575                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 576                     else:
 577                         serv.privmsg(auteur,"Je ne me la ferme pas sur %s."%(message[1]))
 578                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 579             else:
 580                 notunderstood=True
 581         elif cmd=="say":
 582             if auteur in self.overops and len(message)>2:
 583                 serv.privmsg(message[1]," ".join(message[2:]))
 584                 log(self.serveur,"priv",auteur," ".join(message))
 585             elif len(message)<=2:
 586                 serv.privmsg(auteur,"Syntaxe : SAY <channel> <message>")
 587             else:
 588                 notunderstood=True
 589         elif cmd=="lost":
 590             if auteur in self.ops and len(message)>1:
 591                 serv.privmsg(message[1],"J'ai perdu !")
 592                 log(self.serveur,"priv",auteur," ".join(message))
 593             elif len(message)<=1:
 594                 serv.privmsg(auteur,"Syntaxe : LOST <channel>")
 595             else:
 596                 notunderstood=True
 597         else:
 598             notunderstood=True
 599         if notunderstood:
 600             serv.privmsg(auteur,"Je n'ai pas compris. Essaye HELP…")
 601
 602     def on_pubmsg(self, serv, ev):
 603         auteur = irclib.nm_to_n(ev.source())
 604         canal = ev.target()
 605         message = ev.arguments()[0]
 606         try:
 607             test=bot_unicode(message)
 608         except UnicodeBotError:
 609             if not canal in self.quiet_channels:
 610                 serv.privmsg(canal,
 611                   "%s: Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…"%(auteur))
 612                 return
 613         pour_moi,message=self.pourmoi(serv,message)
 614         if pour_moi and message.split()!=[]:
 615             cmd=message.split()[0].lower()
 616             try:
 617                 args=" ".join(message.split()[1:])
 618             except:
 619                 args=""
 620             if cmd in ["meurs","die","crève"]:
 621                 if auteur in self.overops:
 622                     log(self.serveur,canal,auteur,message+"[successful]")
 623                     self.die()
 624                 else:
 625                     serv.privmsg(canal,"%s: crève !"%(auteur))
 626                     log(self.serveur,canal,auteur,message+"[failed]")
 627
 628             elif cmd in ["part","leave","dégage"]:
 629                 if auteur in self.ops and (not (canal in self.stay_channels)
 630                                            or auteur in self.overops):
 631                     serv.part(canal,message="Éjecté par %s"%(auteur))
 632                     log(self.serveur,canal,auteur,message+"[successful]")
 633                 else:
 634                     serv.privmsg(canal,"%s: Non, je reste !"%(auteur))
 635                     log(self.serveur,canal,auteur,message+"[failed]")
 636
 637             elif cmd in ["reconnect"]:
 638                 if auteur in self.ops:
 639                     try:
 640                         self.nk=self.new_connection_NK(serv,config_note_pseudo,
 641                                               config_note_password,"special")[1]
 642                     except Exception as exc:
 643                         self.nk=None
 644                         log(self.serveur,"""Erreur dans on_pubmsg/"cmd in ["reconnect"]\n"""+str(exc))
 645                     if self.nk!=None:
 646                         serv.privmsg(canal,"%s: done"%(auteur))
 647                         log(self.serveur,canal,auteur,message+"[successful]")
 648                     else:
 649                         serv.privmsg(canal,"%s: failed"%(auteur))
 650                         log(self.serveur,canal,auteur,message+"[failed]")
 651                         for report in self.report_bugs_to:
 652                             serv.privmsg(report,"Connection to NK2015 failed, invalid password ?")
 653                 else:
 654                     serv.privmsg(canal,"%s: crève !"%(auteur))
 655                     log(self.serveur,canal,auteur,message+"[failed]")
 656
 657             elif cmd in ["deviens","pseudo"]:
 658                 if auteur in self.ops:
 659                     become=args
 660                     serv.nick(become)
 661                     log(self.serveur,canal,auteur,message+"[successful]")
 662
 663             elif cmd in ["coucou"] and not canal in self.quiet_channels:
 664                 serv.privmsg(canal,"%s: coucou"%(auteur))
 665             elif cmd in ["ping"] and not canal in self.quiet_channels:
 666                 serv.privmsg(canal,"%s: pong"%(auteur))
 667
 668             elif cmd in ["solde","!solde"]:
 669                 if self.identities.has_key(auteur):
 670                     pseudo=self.identities[auteur]
 671                     try:
 672                         self.nk.write('search ["x",["pseudo"],%s]'%(json.dumps(pseudo)))
 673                         ret=json.loads(self.nk.read())
 674                         solde=ret["msg"][0]["solde"]
 675                         pseudo=ret["msg"][0]["pseudo"]
 676                     except Exception as exc:
 677                         serv.privmsg(canal,"%s: failed"%(auteur))
 678                         log(self.serveur,canal,auteur,message+"[failed]")
 679                     else:
 680                         serv.privmsg(canal,"%s: %s (%s)"%(auteur,float(solde)/100,pseudo.encode("utf8")))
 681                         log(self.serveur,canal,auteur,message+"[successful]")
 682                 else:
 683                     serv.privmsg(canal,"%s: Je ne connais pas ton pseudo note."%(auteur))
 684                     log(self.serveur,canal,auteur,message+"[unknown]")
 685             elif (re.match("!?(pain au chocolat|chocolatine)",message.lower())
 686                  and not canal in self.quiet_channels):
 687                 serv.action(canal,"sert un pain au chocolat à %s"%(auteur))
 688             elif re.match("!?manzana",message.lower()) and not canal in self.quiet_channels:
 689                 if auteur=="[20-100]":
 690                     serv.action(canal,"sert une bouteille de manzana à %s"%(auteur))
 691                 else:
 692                     serv.action(canal,"sert un verre de manzana à %s"%(auteur))
 693             if is_insult(message) and not canal in self.quiet_channels:
 694                 if is_not_insult(message):
 695                     answer=random.choice(config_compliment_answers)
 696                     for ligne in answer.split("\n"):
 697                         serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 698                 else:
 699                     answer=random.choice(config_insultes_answers)
 700                     for ligne in answer.split("\n"):
 701                         serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 702             if is_gros(message) and not canal in self.quiet_channels:
 703                 taille=get_filesize()
 704                 answer=u"Mais non, je ne suis pas gros, %sKo tout au plus…"%(taille)
 705                 serv.privmsg(canal,"%s: %s"%(auteur,answer.encode("utf8")))
 706             if is_tesla(message) and not canal in self.quiet_channels:
 707                 l1,l2=config_tesla_answers,config_tesla_actions
 708                 n1,n2=len(l1),len(l2)
 709                 i=random.randrange(n1+n2)
 710                 if i>=n1:
 711                     serv.action(canal,l2[i-n1])
 712                 else:
 713                     serv.privmsg(canal,"%s: %s"%(auteur,l1[i].encode("utf8")))
 714             if is_tamere(message) and not canal in self.quiet_channels:
 715                 answer=random.choice(config_tamere_answers)
 716                 for ligne in answer.split("\n"):
 717                     serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 718             if is_tag(message) and not canal in self.quiet_channels:
 719                 if auteur in self.ops:
 720                     action=random.choice(config_tag_actions)
 721                     serv.action(canal,action.encode("utf8"))
 722                     self.quiet_channels.append(canal)
 723                 else:
 724                     answer=random.choice(config_tag_answers)
 725                     for ligne in answer.split("\n"):
 726                         serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 727             if is_merci(message):
 728                 answer=random.choice(config_merci_answers)
 729                 for ligne in answer.split("\n"):
 730                     serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 731             out=re.match(u"^([A-Z[]|\\|[0-9]+|(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+)(?:| \?| !)$",
 732                          unicode(message.upper(),"utf8"))
 733             if out and not canal in self.quiet_channels:
 734                 out=out.groups()[0]
 735                 try:
 736                     out=int(out)
 737                     serv.privmsg(canal,"%s: %s !"%(auteur,out+1))
 738                     if out+1>1000 and random.randrange(4)==0:
 739                         serv.privmsg(canal,"%s: Tu sais, je peux continuer longtemps comme ça…"%(auteur))
 740                     if out==2147483647:
 741                         serv.privmsg(canal,"%s: Tu croyais m'avoir sur le maxint ? J'suis en python mon vieux, 'va falloir trouver mieux…"%(auteur))
 742                     return
 743                 except Exception as exc:
 744                     pass
 745                 if re.match("[A-Y]",out):
 746                     alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 747                     serv.privmsg(canal,"%s: %s !"%(auteur,alphabet[alphabet.index(out)+1]))
 748                 elif out=="Z":
 749                     serv.privmsg(canal,"%s: pfff, j'ai l'air malin maintenant… [ ?"%(auteur))
 750                 elif out in "[\\":
 751                     serv.privmsg(canal,"%s: nan mais il faut qu'on arrête, ça va finir par poser des problèmes…"%(auteur))
 752                 elif re.match(r"(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+",out):
 753                     def translate(mess):
 754                         return "".join([{u"⁰¹²³⁴⁵⁶⁷⁸⁹0123456789"[i]:u"0123456789⁰¹²³⁴⁵⁶⁷⁸⁹"[i]
 755                                         for i in range(20)}[j]
 756                                        for j in mess])
 757                     out=int(translate(out))
 758                     serv.privmsg(canal,"%s: %s !"%(auteur,translate(str(out+1)).encode("utf8")))
 759             if (not canal in self.quiet_channels
 760                 and re.match((u"^("+"|".join(config_bonjour)+").*").lower(),message.lower()) ):
 761                 answer=random.choice(config_bonjour_answers)
 762                 serv.privmsg(canal,answer.format(auteur).encode("utf8"))
 763             if is_pan(message):
 764                 serv.privmsg(canal,"%s: c'est pas sur moi qu'il faut tirer !"%(auteur))
 765         else:
 766             if message in ["!pain au chocolat","!chocolatine"] and not canal in self.quiet_channels:
 767                 serv.action(canal,"sert un pain au chocolat à %s"%(auteur))
 768             if message in ["!manzana"] and not canal in self.quiet_channels:
 769                 if auteur=="[20-100]":
 770                     serv.action(canal,"sert une bouteille de manzana à %s"%(auteur))
 771                 else:
 772                     serv.action(canal,"sert un verre de manzana à %s"%(auteur))
 773             if re.match('^(.|§|:|)(w|b) [0-9]+$',message) and not canal in self.quiet_channels:
 774                 failanswers=config_buffer_fail_answers
 775                 answer=random.choice(failanswers)
 776                 serv.privmsg(canal,"%s: %s"%(auteur,answer))
 777             if not canal in self.quiet_channels:
 778                 self.try_tamere(serv,canal,auteur,message)
 779                 mypseudo=serv.get_nickname()
 780                 if re.match((u"^("+u"|".join(config_bonjour)
 781                                   +u")( {}| all| tout le monde|(|à) tous)(\.|( |)!|)$"
 782                              ).format(mypseudo).lower(), message.strip().lower()):
 783                     answer=random.choice(config_bonjour_answers)
 784                     serv.privmsg(canal,answer.format(auteur).encode("utf8"))
 785         if (is_perdu(message) and not canal in self.quiet_channels):
 786             # proba de perdre sur trigger :
 787             #  avant 30min (enfin, config) : 0
 788             #  ensuite, +25%/30min, linéairement
 789             deltat=time.time()-self.last_perdu
 790             barre=(deltat-config_time_between_perdu)/(2*3600.0)
 791             if random.uniform(0,1)<barre:
 792                 serv.privmsg(canal,"%s: J'ai perdu !"%(auteur))
 793                 self.last_perdu=time.time()
 794
 795     def on_action(self, serv, ev):
 796         action = ev.arguments()[0]
 797         auteur = irclib.nm_to_n(ev.source())
 798         channel = ev.target()
 799         mypseudo=serv.get_nickname()
 800         if is_action_trigger(action,mypseudo):
 801             l1,l2=config_action_answers,config_action_actions
 802             n1,n2=len(l1),len(l2)
 803             i=random.randrange(n1+n2)
 804             if i>=n1:
 805                 serv.action(channel,l2[i-n1])
 806             else:
 807                 serv.privmsg(channel,"%s: %s"%(auteur,l1[i].encode("utf8")))
 808
 809 if __name__=="__main__":
 810     import sys
 811     if len(sys.argv)==1:
 812         print "Usage : basile.py <serveur> [--debug]"
 813         exit(1)
 814     serveur=sys.argv[1]
 815     if "debug" in sys.argv or "--debug" in sys.argv:
 816         debug=True
 817     else:
 818         debug=False
 819     serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org",
 820               "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org"}
 821     try:
 822         serveur=serveurs[serveur]
 823     except KeyError:
 824         print "Server Unknown : %s"%(serveur)
 825         exit(404)
 826     basile=Basile(serveur,debug)
 827     basile.start()