]> gitweb.pimeys.fr Git - bots/basile.git/blob - basile.py
Message d'erreur venant de NK2015 en unicode
[bots/basile.git] / basile.py
1 #!/usr/bin/python
2 # -*- coding:utf8 -*-
3
4 # Codé par 20-100 (commencé le 23/04/12)
5
6 """ Un bot IRC destiné à s'interfacer avec la Note Kfet 2015 """
7
8 import threading
9 import random
10 import time
11 import json
12 import re
13 import os
14 import signal
15 import sys
16
17 # Oui, j'ai recodé ma version d'irclib pour pouvoir rattrapper les SIGHUP
18 sys.path.insert(0, "/home/vincent/scripts/python-myirclib")
19 import irclib
20 import ircbot
21
22 from commands import getstatusoutput as ex
23
24 #: Config de basile
25 import config
26 #: Module responsable du dialogue avec la NoteKfet2015
27 import nk
28
29 # la partie qui réfère au fichier lui-même est mieux ici
30 # sinon on réfère la config et pas le fichier lui-même
31 import os
32 config.thisfile = os.path.realpath(__file__)
33
34 def get_config_logfile(serveur):
35 """Renvoie le nom du fichier de log en fonction du ``serveur`` et de la config."""
36 serveurs = {"acoeur.crans.org" : "acoeur",
37 "irc.crans.org" : "crans"}
38 return config.logfile_template % (serveurs[serveur],)
39
40 def get_filesize():
41 """Récupère la taille de ce fichier."""
42 return ex("ls -s %s" % (config.thisfile))[1].split()[0]
43
44 def log(serveur, channel, auteur=None, message=None):
45 """Enregistre une ligne de log."""
46 if auteur == message == None:
47 # alors c'est que c'est pas un channel mais juste une ligne de log
48 chain = u"%s %s" % (time.strftime("%F %T"), channel)
49 else:
50 chain = u"%s [%s:%s] %s" % (time.strftime("%F %T"), channel, auteur, message)
51 f = open(get_config_logfile(serveur), "a")
52 f.write((chain + u"\n").encode("utf-8"))
53 f.close()
54 if config.debug_stdout:
55 print chain
56
57 def regex_join(liste, avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*"):
58 """Fabrique une regexp à partir d'une liste d'éléments à matcher."""
59 return avant + u"(" + u"|".join(liste) + u")" + apres
60
61 def is_something(chain, regexp=None, matches=[], avant=u".*(?:^| )", apres=u"(?:$|\.| |,|;).*",
62 case_sensitive=False):
63 """Vérifie si chain contient un des éléments de ``matches``.
64 Si ``regexp`` est fournie, c'est simplement elle qui est testée"""
65 if case_sensitive:
66 chain = chain.lower()
67 if regexp == None:
68 regexp = regex_join(matches, avant, apres)
69 regexp = re.compile(regexp)
70 o = regexp.match(chain)
71 return o
72
73 def regexp_compile():
74 """Compilation des regexp à partir de la conf.
75 Place les résultats dans le namespace de ``config``"""
76 config.insult_regexp = regex_join(config.insultes, avant=u".*(?:^| |')")
77 config.insult_regexp_compiled = re.compile(config.insult_regexp)
78
79 config.not_insult_regexp = u".*pas %s%s" % (config.amplifier_regexp, config.insult_regexp)
80 config.not_insult_regexp_compiled = re.compile(config.not_insult_regexp)
81
82 config.compliment_regexp = regex_join(config.compliment_triggers, avant=u".*(?:^| |')")
83 config.compliment_regexp_compiled = re.compile(config.compliment_regexp)
84
85 config.perdu_regexp = regex_join(config.perdu)
86 config.perdu_regexp_compiled = re.compile(config.perdu_regexp)
87
88 config.tag_regexp = regex_join(config.tag_triggers)
89 config.tag_regexp_compiled = re.compile(config.tag_regexp)
90
91 config.gros_regexp = regex_join(config.gros)
92 config.gros_regexp_compiled = re.compile(config.gros_regexp)
93
94 config.tesla_regexp = regex_join(config.tesla_triggers, avant=u"^", apres="$")
95 config.tesla_regexp_compiled = re.compile(config.tesla_regexp)
96
97 config.merci_regexp = regex_join(config.merci_triggers)
98 config.merci_regexp_compiled = re.compile(config.merci_regexp)
99
100 config.tamere_regexp = regex_join(config.tamere_triggers)
101 config.tamere_regexp_compiled = re.compile(config.tamere_regexp)
102
103 config.bonjour_regexp = regex_join(config.bonjour_triggers, avant=u"^")
104 config.bonjour_regexp_compiled = re.compile(config.bonjour_regexp)
105
106 config.bonne_nuit_regexp = regex_join(config.bonne_nuit_triggers, avant=u"^")
107 config.bonne_nuit_regexp_compiled = re.compile(config.bonne_nuit_regexp)
108
109 config.pan_regexp = regex_join(config.pan_triggers, avant=".*", apres=".*")
110 config.pan_regexp_compiled = re.compile(config.pan_regexp)
111
112
113 regexp_compile()
114 def is_insult(chain, debug=True):
115 """Vérifie si ``chain`` contient une insulte."""
116 return is_something(chain, config.insult_regexp_compiled)
117 def is_not_insult(chain):
118 """Vérifie si ``chain`` contient une insulte à la forme négative."""
119 return is_something(chain, config.not_insult_regexp_compiled)
120 def is_compliment(chain, debug=True):
121 """Vérifie si ``chain`` contient un compliment."""
122 return is_something(chain, config.compliment_regexp_compiled)
123 def is_perdu(chain):
124 """Vérifie si ``chain`` contient une raison de perdre."""
125 return is_something(chain, config.perdu_regexp_compiled)
126 def is_tag(chain):
127 """Vérifie si ``chain`` demande de fermer sa gueule."""
128 return is_something(chain, config.tag_regexp_compiled)
129 def is_gros(chain):
130 """Vérifie si ``chain`` traite de gros."""
131 return is_something(chain, config.gros_regexp_compiled)
132 def is_tesla(chain):
133 """Vérifie si ``chain`` est un ping."""
134 return is_something(chain, config.tesla_regexp_compiled)
135 def is_merci(chain):
136 """Vérifie si ``chain`` contient un remerciement."""
137 return is_something(chain, config.merci_regexp_compiled)
138 def is_tamere(chain):
139 """Vérifie si ``chain`` traite ma mère."""
140 return is_something(chain, config.tamere_regexp_compiled)
141 def is_bad_action_trigger(chain,pseudo):
142 """Vérifie si ``chain`` est une action méchante.
143 On a besoin d'une regexp dynamique à cause du pseudo qui peut changer."""
144 return is_something(chain, matches=config.bad_action_triggers, avant=u"^",
145 apres="(?: [a-z]*ment)? %s($|\.| |,|;).*" % (pseudo))
146 def is_good_action_trigger(chain,pseudo):
147 """Vérifie si ``chain`` est une action gentille.
148 On a besoin d'une regexp dynamique à cause du pseudo qui peut changer."""
149 return is_something(chain, matches=config.good_action_triggers, avant=u"^",
150 apres="(?: [a-z]*ment)? %s($|\.| |,|;).*" % (pseudo))
151 def is_bonjour(chain):
152 """Vérifie si ``chain`` contient un bonjour."""
153 return is_something(chain, config.bonjour_regexp_compiled)
154 def is_bonne_nuit(chain):
155 """Vérifie si ``chain`` contient un bonne nuit."""
156 return is_something(chain, config.bonne_nuit_regexp_compiled)
157 def is_pan(chain):
158 """Vérifie si ``chain`` contient un pan."""
159 return is_something(chain, config.pan_regexp_compiled)
160
161 def is_time(conf):
162 """Vérifie si l'heure actuelle est entre les deux heures ``conf[0]`` et ``conf[1]``"""
163 _, _, _, h, m, s, _, _, _ = time.localtime()
164 return (conf[0], 0, 0) < (h, m, s) < (conf[1], 0, 0)
165 def is_day():
166 """Vérifie si on est le jour."""
167 return is_time(config.daytime)
168 def is_night():
169 """Vérifie si on est la nuit."""
170 return is_time(config.nighttime)
171
172
173 class UnicodeBotError(Exception):
174 """Erreur levée si quelqu'un fait du caca avec son encodage."""
175 pass
176
177 class CrashError(Exception):
178 """Pour pouvoir faire crasher Basile, parce que ça a l'air drôle."""
179 def __init__(self, msg=""):
180 Exception.__init__(self, msg)
181
182 def bot_unicode(chain):
183 """Essaye de décoder ``chain`` en UTF-8.
184 Lève une py:class:`UnicodeBotError` en cas d'échec."""
185 try:
186 return chain.decode("utf8")
187 except UnicodeDecodeError as exc:
188 raise UnicodeBotError
189
190
191 class Basile(ircbot.SingleServerIRCBot):
192 """Classe principale : définition du bot Basile."""
193 def __init__(self, serveur, debug=False):
194 temporary_pseudo = config.irc_pseudo + str(random.randrange(10000,100000))
195 ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
196 temporary_pseudo, "Basile, le bot irc. [Codé par 20-100]", 10)
197 self.debug = debug
198 self.serveur = serveur
199 self.overops = config.overops
200 self.ops = self.overops + config.ops
201 self.report_bugs_to = config.report_bugs_to
202 self.chanlist = config.chanlist
203 self.identities = json.load(open(config.identities_file, "r"))
204 self.stay_channels = config.stay_channels
205 self.quiet_channels = config.quiet_channels
206 self.last_perdu = 0
207
208 ### Communication NK
209 def new_connection_NK(self, serv, username, password, typ="bdd"):
210 """Renvoie (``True``, <une socket ouverte et authentifiée sur la NoteKfet2015>)
211 ou bien (``False``, None)"""
212 try:
213 login_result, sock = nk.login(username, password, typ)
214 info, retcode, errmsg = login_result["msg"], login_result["retcode"], login_result["errmsg"]
215 except nk.NKRefused as exc:
216 for report in self.report_bugs_to:
217 serv.privmsg(report, "Le Serveur NK2015 est down.")
218 return (False, None, None)
219 except nk.NKHelloFailed as exc:
220 for report in self.report_bugs_to:
221 serv.privmsg(report,
222 "La version du protocole utilisée n'est pas supportée par le serveur NK2015.")
223 return (False, None, None)
224 except nk.NKUnknownError as exc:
225 erreurs = ["Une fucking erreur inconnue s'est produite"]
226 erreurs += str(exc).split("\n")
227 for report in self.report_bugs_to:
228 for err in erreurs:
229 serv.privmsg(report, err)
230 return (False, None, None)
231 except Exception as exc:
232 # Exception qui ne vient pas de la communication avec le serveur NK2015
233 log(self.serveur, "Erreur dans new_connection_NK\n" + str(exc))
234 return (False, None, None)
235 if retcode == 0:
236 return (True, info, sock)
237 else:
238 return (False, None, None)
239
240 ### Utilitaires
241 def _getnick(self):
242 """Récuère le nick effectif du bot sur le serveur."""
243 return self.serv.get_nickname()
244 nick = property(_getnick)
245
246 def give_me_my_pseudo(self, serv):
247 """Récupère le pseudo auprès de NickServ."""
248 serv.privmsg("NickServ", "RECOVER %s %s" % (config.irc_pseudo, config.irc_password))
249 serv.privmsg("NickServ", "RELEASE %s %s" % (config.irc_pseudo, config.irc_password))
250 time.sleep(0.3)
251 serv.nick(config.irc_pseudo)
252
253 def pourmoi(self, serv, message):
254 """Renvoie (False, lemessage) ou (True, le message amputé de "pseudo: ")"""
255 pseudo = self.nick
256 pseudo = pseudo.decode("utf-8")
257 size = len(pseudo)
258 if message[:size] == pseudo and len(message) > size and message[size] == ":":
259 return (True, message[size+1:].lstrip(" "))
260 else:
261 return (False, message)
262
263 ### Exécution d'actions
264 def lost(self, serv, channel, forced=False):
265 """Réaction à un trigger de perdu.
266 Annonce "J'ai perdu" sur le channel si on n'a pas perdu depuis un certain temps."""
267 if self.last_perdu + config.time_between_perdu < time.time() or forced:
268 if not channel in self.quiet_channels or forced:
269 serv.privmsg(channel, "J'ai perdu !")
270 self.last_perdu=time.time()
271 delay=config.time_between_perdu_trigger
272 delta=config.time_between_perdu_trigger_delta
273 serv.execute_delayed(random.randrange(delay-delta,delay+delta),self.lost,(serv,channel))
274
275 def quitter(self, chan, leave_message=None):
276 """Quitter un channel avec un message customisable."""
277 if leave_message == None:
278 leave_message = random.choice(config.leave_messages)
279 self.serv.part(chan, message=leave_message.encode("utf8"))
280
281 def mourir(self):
282 """Se déconnecter du serveur IRC avec un message customisable."""
283 quit_message = random.choice(config.quit_messages)
284 self.die(msg=quit_message.encode("utf8"))
285
286 def execute_reload(self, auteur=None):
287 """Recharge la config."""
288 reload(config)
289 regexp_compile()
290 if auteur in [None, "SIGHUP"]:
291 towrite = "Config reloaded" + " (SIGHUP received)" * (auteur == "SIGHUP")
292 for to in config.report_bugs_to:
293 self.serv.privmsg(to, towrite)
294 log(self.serveur, towrite)
295 return True, None
296 else:
297 return True, u"Config reloaded"
298
299 def crash(self, chan="nowhere", who="nobody"):
300 """Fait crasher le bot."""
301 where = "en privé" if chan == "priv" else "sur le chan %s" % chan
302 raise CrashError("Crash demandé par %s %s" % (who, where))
303
304 ACTIONS = {
305 "reload" : execute_reload,
306 }
307
308 def execute_something(self, something, params, place=None, auteur=None):
309 """Exécute une action et répond son résultat à ``auteur``
310 sur un chan ou en privé en fonction de ``place``"""
311 action = self.ACTIONS[something]
312 success, message = action(self, **params)
313 if message:
314 if irclib.is_channel(place):
315 message = "%s: %s" % (auteur, message.encode("utf-8"))
316 self.serv.privmsg(place, message)
317 log(self.serveur, place, auteur, something + "%r" % params + ("[successful]" if success else "[failed]"))
318
319 ### Surcharge des events du Bot
320 def on_welcome(self, serv, ev):
321 """À l'arrivée sur le serveur."""
322 self.serv = serv # ça serv ira :)
323 self.give_me_my_pseudo(serv)
324 serv.privmsg("NickServ", "IDENTIFY %s" % (config.irc_password))
325 log(self.serveur, "Connected")
326 if self.debug:
327 self.chanlist = ["#bot"]
328 for c in self.chanlist:
329 log(self.serveur, "JOIN %s" % (c))
330 serv.join(c)
331 # on ouvre la connexion note de Basile, special user
332 self.nk = self.new_connection_NK(serv, config.note_pseudo, config.note_password, "special")[2]
333 if self.nk == None:
334 for report in self.report_bugs_to:
335 serv.privmsg(report, "Connection to NK2015 failed, invalid password ?")
336
337 def on_privmsg(self, serv, ev):
338 """À la réception d'un message en privé."""
339 message = ev.arguments()[0]
340 auteur = irclib.nm_to_n(ev.source())
341 try:
342 message = bot_unicode(message)
343 except UnicodeBotError:
344 if config.utf8_trigger:
345 serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
346 return
347 message = message.split()
348 cmd = message[0].lower()
349 notunderstood = False
350 if cmd == u"help":
351 op,overop=auteur in self.ops, auteur in self.overops
352 if len(message)==1:
353 helpmsg = config.helpmsg_default
354 if op:
355 helpmsg += config.helpmsg_ops
356 if overop:
357 helpmsg += config.helpmsg_overops
358 else:
359 helpmsgs = config.helpdico.get(message[1].lower(), ["Commande inconnue.", None, None])
360 helpmsg = helpmsgs[0]
361 if op and helpmsgs[1]:
362 if helpmsg:
363 helpmsg += "\n" + helpmsgs[1]
364 else:
365 helpmsg = helpmsgs[1]
366 if overop and helpmsgs[2]:
367 if helpmsg:
368 helpmsg += "\n" + helpmsgs[2]
369 else:
370 helpmsg = helpmsgs[2]
371 for ligne in helpmsg.split("\n"):
372 serv.privmsg(auteur, ligne.encode("utf-8"))
373 elif cmd == u"identify":
374 if len(message) == 1:
375 if self.identities.has_key(auteur):
376 serv.privmsg(auteur, "Je vous connais sous le pseudo note %s." % (
377 self.identities[auteur]["pseudo"].encode("utf8")))
378 else:
379 serv.privmsg(auteur, "Je ne connais pas votre pseudo note.")
380 elif len(message) >= 3:
381 username, password = message[1], " ".join(message[2:])
382 success, info, _ = self.new_connection_NK(serv, username, password)
383 if success:
384 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
385 serv.privmsg(auteur, "Identité enregistrée.")
386 self.identities[auteur] = info
387 json.dump(self.identities, open(config.identities_file,"w"))
388 else:
389 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
390 serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)")
391 else:
392 serv.privmsg(auteur, "Syntaxe : IDENTIFY [<username> <password>]")
393 elif cmd == u"drop":
394 if len(message) > 1:
395 if self.identities.has_key(auteur):
396 password = " ".join(message[1:])
397 success, _, _ = self.new_connection_NK(serv, self.identities[auteur], password)
398 if success:
399 del self.identities[auteur]
400 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
401 json.dump(self.identities, open(config.identities_file, "w"))
402 serv.privmsg(auteur, "Identité oubliée.")
403 else:
404 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
405 serv.privmsg(auteur, "Mot de passe invalide. (ou serveur down)")
406 else:
407 serv.privmsg(auteur, "Je ne connais pas ton pseudo note.")
408 else:
409 serv.privmsg(auteur, "Syntaxe : DROP <password>")
410 elif cmd == u"join":
411 if auteur in self.ops:
412 if len(message) > 1:
413 if message[1] in self.chanlist:
414 serv.privmsg(auteur, "Je suis déjà sur %s" % (message[1]))
415 else:
416 serv.join(message[1])
417 self.chanlist.append(message[1])
418 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
419 log(self.serveur, "priv", auteur, " ".join(message))
420 else:
421 serv.privmsg(auteur, "Channels : " + " ".join(self.chanlist))
422 else:
423 notunderstood = True
424 elif cmd == u"leave":
425 if auteur in self.ops and len(message) > 1:
426 if message[1] in self.chanlist:
427 if not (message[1] in self.stay_channels) or auteur in self.overops:
428 self.quitter(message[1], " ".join(message[2:]))
429 self.chanlist.remove(message[1])
430 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
431 else:
432 serv.privmsg(auteur, "Non, je reste !")
433 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
434 else:
435 serv.privmsg(auteur, "Je ne suis pas sur %s" % (message[1]))
436 else:
437 notunderstood = True
438 elif cmd == u"stay":
439 if auteur in self.overops:
440 if len(message) > 1:
441 if message[1] in self.stay_channels:
442 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
443 serv.privmsg(auteur, "Je stay déjà sur %s." % (message[1]))
444 else:
445 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
446 self.stay_channels.append(message[1])
447 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
448 else:
449 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
450 else:
451 notunderstood = True
452 elif cmd == u"nostay":
453 if auteur in self.overops:
454 if len(message) > 1:
455 if message[1] in self.stay_channels:
456 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
457 self.stay_channels.remove(message[1])
458 serv.privmsg(auteur, "Stay channels : " + " ".join(self.stay_channels))
459 else:
460 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
461 serv.privmsg(auteur, "Je ne stay pas sur %s." % (message[1]))
462 else:
463 notunderstood = True
464 elif cmd == u"die":
465 if auteur in self.overops:
466 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
467 self.mourir()
468 else:
469 notunderstood = True
470 elif cmd == u"crash":
471 if auteur in self.overops:
472 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
473 self.crash("priv", auteur)
474 else:
475 notunderstood = True
476 elif cmd == u"reload":
477 if auteur in self.ops:
478 self.execute_something("reload", {"auteur" : auteur}, place=auteur, auteur=auteur)
479 else:
480 notunderstood = True
481 elif cmd == u"reconnect":
482 if auteur in self.ops:
483 try:
484 self.nk = self.new_connection_NK(serv, config.note_pseudo,
485 config.note_password, "special")[2]
486 except Exception as exc:
487 self.nk = None
488 log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc))
489 if self.nk != None:
490 serv.privmsg(auteur, "%s: done" % (auteur))
491 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
492 else:
493 serv.privmsg(auteur, "%s: failed" % (auteur))
494 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
495 for report in self.report_bugs_to:
496 serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?")
497 else:
498 notunderstood = True
499 elif cmd == u"quiet":
500 if auteur in self.ops:
501 if len(message) > 1:
502 if message[1] in self.quiet_channels:
503 serv.privmsg(auteur, "Je me la ferme déjà sur %s" % (message[1]))
504 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
505 else:
506 self.quiet_channels.append(message[1])
507 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
508 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
509 else:
510 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
511 else:
512 notunderstood = True
513 elif cmd == u"noquiet":
514 if auteur in self.ops:
515 if len(message) > 1:
516 if message[1] in self.quiet_channels:
517 self.quiet_channels.remove(message[1])
518 serv.privmsg(auteur, "Quiet channels : " + " ".join(self.quiet_channels))
519 log(self.serveur, "priv", auteur, " ".join(message) + "[successful]")
520 else:
521 serv.privmsg(auteur, "Je ne me la ferme pas sur %s." % (message[1]))
522 log(self.serveur, "priv", auteur, " ".join(message) + "[failed]")
523 else:
524 notunderstood = True
525 elif cmd == u"say":
526 if auteur in self.overops and len(message) > 2:
527 serv.privmsg(message[1], " ".join(message[2:]))
528 log(self.serveur, "priv", auteur, " ".join(message))
529 elif len(message) <= 2:
530 serv.privmsg(auteur, "Syntaxe : SAY <channel> <message>")
531 else:
532 notunderstood = True
533 elif cmd == u"do":
534 if auteur in self.overops and len(message) > 2:
535 serv.action(message[1], " ".join(message[2:]))
536 log(self.serveur, "priv", auteur, " ".join(message))
537 elif len(message) <= 2:
538 serv.privmsg(auteur, "Syntaxe : DO <channel> <action>")
539 else:
540 notunderstood = True
541 elif cmd == u"kick":
542 if auteur in self.overops and len(message) > 2:
543 serv.kick(message[1], message[2], " ".join(message[3:]))
544 log(self.serveur, "priv", auteur, " ".join(message))
545 elif len(message) <= 2:
546 serv.privmsg(auteur, "Syntaxe : KICK <channel> <pseudo> [<raison>]")
547 else:
548 notunderstood = True
549 elif cmd == u"lost":
550 if auteur in self.ops and len(message) > 1:
551 serv.privmsg(message[1], "J'ai perdu !")
552 log(self.serveur, "priv", auteur, " ".join(message))
553 elif len(message) <= 1:
554 serv.privmsg(auteur, "Syntaxe : LOST <channel>")
555 else:
556 notunderstood = True
557 elif cmd == u"solde":
558 if len(message) == 1:
559 if self.identities.has_key(auteur):
560 success, solde, pseudo = nk.get_solde(self.nk, self.identities[auteur]["idbde"], serv, auteur)
561 if success:
562 serv.privmsg(auteur, "%.2f (%s)" % (solde/100.0, pseudo.encode("utf8")))
563 log(self.serveur, "priv", auteur, " ".join(message) + ("[successful]" if success else "[failed]"))
564 else:
565 serv.privmsg(canal, "Je ne connais pas ton pseudo note.")
566 elif cmd == u"ops":
567 if auteur in self.overops:
568 serv.privmsg(auteur, " ".join(self.ops))
569 else:
570 notunderstood = True
571 elif cmd == u"overops":
572 if auteur in self.overops:
573 serv.privmsg(auteur, " ".join(self.overops))
574 else:
575 notunderstood = True
576 else:
577 notunderstood = True
578 if notunderstood:
579 serv.privmsg(auteur, "Je n'ai pas compris. Essayez HELP…")
580
581 def on_pubmsg(self, serv, ev):
582 """À la réception d'un message sur un channel."""
583 auteur = irclib.nm_to_n(ev.source())
584 canal = ev.target()
585 message = ev.arguments()[0]
586 try:
587 message = bot_unicode(message)
588 except UnicodeBotError:
589 if config.utf8_trigger and not canal in self.quiet_channels:
590 serv.privmsg(canal, (u"%s: %s"% ( auteur, random.choice(config.utf8_fail_answers))).encode("utf8"))
591 return
592 pour_moi, message = self.pourmoi(serv, message)
593 if pour_moi and message.split()!=[]:
594 cmd = message.split()[0].lower()
595 try:
596 args = " ".join(message.split()[1:])
597 except:
598 args = ""
599 if cmd in [u"meurs", u"die", u"crève"]:
600 if auteur in self.overops:
601 log(self.serveur, canal, auteur, message + "[successful]")
602 self.mourir()
603 else:
604 serv.privmsg(canal,(u"%s: %s"%(auteur, random.choice(config.quit_fail_messages))).encode("utf8"))
605 log(self.serveur, canal, auteur, message + "[failed]")
606 elif cmd == u"reload":
607 if auteur in self.ops:
608 self.execute_something("reload", {"auteur" : auteur}, place=canal, auteur=auteur)
609 elif cmd == u"crash":
610 if auteur in self.overops:
611 self.crash(auteur, message)
612 elif cmd in [u"part", u"leave", u"dégage", u"va-t-en", u"tut'tiresailleurs,c'estmesgalets"]:
613 if auteur in self.ops and (not (canal in self.stay_channels)
614 or auteur in self.overops):
615 self.quitter(canal)
616 log(self.serveur, canal, auteur, message + "[successful]")
617 if canal in self.chanlist:
618 self.chanlist.remove(canal)
619 else:
620 serv.privmsg(canal,(u"%s: %s" % (auteur, random.choice(config.leave_fail_messages))).encode("utf8"))
621 log(self.serveur, canal, auteur, message + "[failed]")
622
623 elif cmd == u"reconnect":
624 if auteur in self.ops:
625 try:
626 self.nk = self.new_connection_NK(serv, config.note_pseudo,
627 config.note_password, "special")[2]
628 except Exception as exc:
629 self.nk = None
630 log(self.serveur, 'Erreur dans on_pubmsg/"cmd in ["reconnect"]\n' + str(exc))
631 if self.nk != None:
632 serv.privmsg(canal, "%s: done" % (auteur))
633 log(self.serveur, canal, auteur, message + "[successful]")
634 else:
635 serv.privmsg(canal, "%s: failed" % (auteur))
636 log(self.serveur, canal, auteur, message + "[failed]")
637 for report in self.report_bugs_to:
638 serv.privmsg(report, "Connection to NK2015 failed, invalid password ? Server dead ?")
639 else:
640 serv.privmsg(canal, "%s: %s" % (auteur, random.choice(config.pas_programme_pour_tobeir).encode("utf8")))
641 log(self.serveur, canal, auteur, message + "[failed]")
642
643 elif cmd in [u"deviens", u"pseudo"]:
644 if auteur in self.ops:
645 become = args
646 serv.nick(become)
647 log(self.serveur, canal, auteur, message + "[successful]")
648
649 if cmd in [u"meur", u"meurt", u"meurre", u"meurres"] and not canal in self.quiet_channels:
650 serv.privmsg(canal, '%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)' % (auteur))
651 elif cmd in [u"ping"] and not canal in self.quiet_channels:
652 serv.privmsg(canal, "%s: pong" % (auteur))
653
654 elif cmd in [u"solde", u"!solde", u"!coca"] or cmd.startswith("!"):
655 if self.identities.has_key(auteur):
656 idbde = self.identities[auteur]["idbde"]
657 if cmd in [u"solde", u"!solde"]:
658 success, solde, pseudo = nk.get_solde(self.nk, self.identities[auteur]["idbde"], serv, canal)
659 if success:
660 serv.privmsg(canal, "%s: %s (%s)" % (auteur, float(solde)/100, pseudo.encode("utf8")))
661 elif cmd in [u"!coca"] or cmd.startswith("!"):
662 success = nk.consomme(self.nk, self.identities[auteur]["idbde"], message[1:], serv, canal)
663 log(self.serveur, canal, auteur, message + ("[successful]" if success else "[failed]"))
664 else:
665 serv.privmsg(canal, "%s: Je ne connais pas votre pseudo note." % (auteur))
666 log(self.serveur, canal, auteur, message + "[unknown]")
667 elif (re.match("!?(pain au chocolat|chocolatine)", message.lower())
668 and not canal in self.quiet_channels):
669 serv.action(canal, "sert un pain au chocolat à %s" % (auteur))
670 elif re.match("!?manzana",message.lower()) and not canal in self.quiet_channels:
671 if auteur in config.manzana:
672 serv.action(canal, "sert une bouteille de manzana à %s" % (auteur))
673 elif auteur in config.manzana_bis:
674 serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur))
675 else:
676 serv.action(canal, "sert un verre de manzana à %s" % (auteur))
677 if is_insult(message) and not canal in self.quiet_channels:
678 if is_not_insult(message):
679 answer = random.choice(config.compliment_answers)
680 for ligne in answer.split("\n"):
681 serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
682 else:
683 answer = random.choice(config.insultes_answers)
684 for ligne in answer.split("\n"):
685 serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
686 elif is_compliment(message) and not canal in self.quiet_channels:
687 answer = random.choice(config.compliment_answers)
688 for ligne in answer.split("\n"):
689 serv.privmsg(canal, "%s: %s" % (auteur,ligne.encode("utf8")))
690 gros_match = is_gros(message)
691 if gros_match and not canal in self.quiet_channels:
692 taille = get_filesize()
693 answer = u"Mais non, je ne suis pas %s, %sKo tout au plus…" % (gros_match.groups()[0], taille)
694 serv.privmsg(canal, "%s: %s"%(auteur, answer.encode("utf8")))
695 if is_tesla(message) and not canal in self.quiet_channels:
696 l1, l2 = config.tesla_answers, config.tesla_actions
697 n1, n2 = len(l1), len(l2)
698 i = random.randrange(n1 + n2)
699 if i >= n1:
700 serv.action(canal, l2[i - n1].encode("utf8"))
701 else:
702 serv.privmsg(canal, "%s: %s" % (auteur, l1[i].encode("utf8")))
703 if is_tamere(message) and not canal in self.quiet_channels:
704 answer = random.choice(config.tamere_answers)
705 for ligne in answer.split("\n"):
706 serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8")))
707 if is_tag(message) and not canal in self.quiet_channels:
708 if auteur in self.ops:
709 action = random.choice(config.tag_actions)
710 serv.action(canal, action.encode("utf8"))
711 self.quiet_channels.append(canal)
712 else:
713 answer = random.choice(config.tag_answers)
714 for ligne in answer.split("\n"):
715 serv.privmsg(canal, "%s: %s" % (auteur, ligne.encode("utf8")))
716 if is_merci(message):
717 answer = random.choice(config.merci_answers)
718 for ligne in answer.split("\n"):
719 serv.privmsg(canal, "%s: %s"%(auteur, ligne.encode("utf8")))
720 out = re.match(ur"^([A-Z[]|\\|[0-9]+|(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+)(?:| \?| !)$", message.upper())
721 if re.match("ma bite dans ton oreille", message) and not canal in self.quiet_channels:
722 serv.privmsg(canal, "%s: Seul un olasd peut imiter un olasd dans un de ses grands jours !" % (auteur))
723 if out and not canal in self.quiet_channels:
724 out = out.groups()[0]
725 try:
726 iout = int(out)
727 serv.privmsg(canal, "%s: %s !" % (auteur, iout + 1))
728 if iout == 2147483647:
729 serv.privmsg(canal, "%s: Ciel, un maxint ! Heureusement que je suis en python…" % (auteur))
730 return
731 if iout + 1 > 1000 and random.randrange(4) == 0:
732 serv.privmsg(canal, "%s: Vous savez, moi et les chiffres…" % (auteur))
733 return
734 except Exception as exc:
735 pass
736 if re.match("[A-Y]", out):
737 alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
738 serv.privmsg(canal, "%s: %s !"%(auteur, alphabet[alphabet.index(out) + 1]))
739 elif out == "Z":
740 serv.privmsg(canal, "%s: Je ne vous remercie pas, j'ai l'air idiot ainsi… [ ?" % (auteur))
741 elif out in "[\\":
742 serv.privmsg(canal, "%s: Nous devrions nous en tenir là, ça va finir par poser des problèmes…" % (auteur))
743 elif re.match(ur"(¹|²|³|⁴|⁵|⁶|⁷|⁸|⁹|⁰)+", out):
744 def translate(mess):
745 return "".join([{u"⁰¹²³⁴⁵⁶⁷⁸⁹0123456789"[i]:u"0123456789⁰¹²³⁴⁵⁶⁷⁸⁹"[i]
746 for i in range(20)}[j]
747 for j in mess])
748 out = int(translate(out))
749 serv.privmsg(canal,"%s: %s !" % (auteur, translate(str(out + 1)).encode("utf8")))
750 if is_bonjour(message) and not canal in self.quiet_channels:
751 if is_night():
752 answer = random.choice(config.night_answers)
753 elif is_day():
754 answer = random.choice(config.bonjour_answers)
755 else:
756 answer = random.choice(config.bonsoir_answers)
757 serv.privmsg(canal, answer.format(auteur).encode("utf8"))
758 if is_bonne_nuit(message) and not canal in self.quiet_channels:
759 answer = random.choice(config.bonne_nuit_answers)
760 serv.privmsg(canal, answer.format(auteur).encode("utf8"))
761 if is_pan(message) and not canal in self.quiet_channels:
762 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))
763 else:
764 if message in [u"!pain au chocolat", u"!chocolatine"] and not canal in self.quiet_channels:
765 serv.action(canal, "sert un pain au chocolat à %s" % (auteur))
766 if message in [u"!manzana"] and not canal in self.quiet_channels:
767 if auteur in config.manzana:
768 serv.action(canal, "sert une bouteille de manzana à %s" % (auteur))
769 elif auteur in config.manzana_bis:
770 serv.action(canal, "sert un grand verre de jus de pomme à %s : tout le monde sait qu'il ne boit pas." % (auteur))
771 else:
772 serv.action(canal, "sert un verre de manzana à %s" % (auteur))
773 if re.match(u'^ *(.|§|!|/|/|:|)(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)).encode("utf8"))
777 if not canal in self.quiet_channels:
778 mypseudo = self.nick
779 if re.match((u"^(" + u"|".join(config.bonjour_triggers)
780 + ur")( {}| all| tout le monde| (à )?tous)(\.| ?!)?$"
781 ).format(mypseudo).lower(), message.strip().lower()):
782 answer = random.choice(config.bonjour_answers)
783 serv.privmsg(canal, answer.format(auteur).encode("utf8"))
784 if (is_perdu(message) and not canal in self.quiet_channels):
785 # proba de perdre sur trigger :
786 # avant 30min (enfin, config) : 0
787 # ensuite, +25%/30min, linéairement
788 deltat = time.time() - self.last_perdu
789 barre = (deltat - config.time_between_perdu)/(2*3600.0)
790 if random.uniform(0, 1) < barre:
791 serv.privmsg(canal, "%s: J'ai perdu !" % (auteur))
792 self.last_perdu = time.time()
793
794 def on_action(self, serv, ev):
795 """À la réception d'une action."""
796 action = ev.arguments()[0]
797 auteur = irclib.nm_to_n(ev.source())
798 channel = ev.target()
799 try:
800 action = bot_unicode(action)
801 except UnicodeBotError:
802 if config.utf8_trigger and not channel in self.quiet_channels:
803 serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
804 return
805 mypseudo = self.nick
806
807 if is_bad_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
808 l1, l2 = config.bad_action_answers, config.bad_action_actions
809 n1, n2 = len(l1), len(l2)
810 i = random.randrange(n1 + n2)
811 if i >= n1:
812 serv.action(channel, l2[i - n1].format(auteur).encode("utf8"))
813 else:
814 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
815 if is_good_action_trigger(action, mypseudo) and not channel in self.quiet_channels:
816 l1, l2 = config.good_action_answers, config.good_action_actions
817 n1, n2 = len(l1), len(l2)
818 i = random.randrange(n1 + n2)
819 if i >= n1:
820 serv.action(channel, l2[i-n1].format(auteur).encode("utf8"))
821 else:
822 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
823
824 def on_kick(self, serv, ev):
825 """À la réception d'une action."""
826 auteur = irclib.nm_to_n(ev.source())
827 channel = ev.target()
828 victime = ev.arguments()[0]
829 raison = ev.arguments()[1]
830 if victime == self.nick:
831 log(self.serveur, "%s kické de %s par %s (raison : %s)" % (victime, channel, auteur, raison))
832 time.sleep(2)
833 serv.join(channel)
834 l1, l2 = config.kick_answers, config.kick_actions
835 n1, n2 = len(l1), len(l2)
836 i = random.randrange(n1 + n2)
837 if i >= n1:
838 serv.action(channel, l2[i-n1].format(auteur).encode("utf8"))
839 else:
840 serv.privmsg(channel, l1[i].format(auteur).encode("utf8"))
841
842 ### .fork trick
843 def start_as_daemon(self, outfile):
844 sys.stderr = Logger(outfile)
845 self.start()
846
847
848 class Logger(object):
849 """Pour écrire ailleurs que sur stdout"""
850 def __init__(self, filename="basile.full.log"):
851 self.filename = filename
852
853 def write(self, message):
854 f = open(self.filename, "a")
855 f.write(message)
856 f.close()
857
858 def main():
859 """Exécution principal : lecture des paramètres et lancement du bot."""
860 if len(sys.argv) == 1:
861 print "Usage : basile.py <serveur> [--debug] [--no-output] [--daemon [--pidfile]] [--outfile]"
862 print " --outfile sans --no-output ni --daemon n'a aucun effet"
863 exit(1)
864 serveur = sys.argv[1]
865 if "--daemon" in sys.argv:
866 thisfile = os.path.realpath(__file__)
867 thisdirectory = thisfile.rsplit("/", 1)[0]
868 os.chdir(thisdirectory)
869 daemon = True
870 else:
871 daemon = False
872 if "debug" in sys.argv or "--debug" in sys.argv:
873 debug = True
874 else:
875 debug = False
876 if "--quiet" in sys.argv:
877 config.debug_stdout = False
878 serveurs = {"a♡" : "acoeur.crans.org",
879 "acoeur" : "acoeur.crans.org",
880 "acoeur.crans.org" : "acoeur.crans.org",
881 "irc" : "irc.crans.org",
882 "crans" : "irc.crans.org",
883 "irc.crans.org" : "irc.crans.org"}
884 if "--no-output" in sys.argv or "--daemon" in sys.argv:
885 outfile = "/var/log/bots/basile.full.log"
886 for arg in sys.argv:
887 arg = arg.split("=")
888 if arg[0].strip('-') in ["out", "outfile", "logfile"]:
889 outfile = arg[1]
890 sys.stdout = Logger(outfile)
891 try:
892 serveur = serveurs[serveur]
893 except KeyError:
894 print "Server Unknown : %s" % (serveur)
895 exit(404)
896 basile = Basile(serveur,debug)
897 # Si on reçoit un SIGHUP, on reload la config
898 def sighup_handler(signum, frame):
899 basile.execute_reload(auteur="SIGHUP")
900 signal.signal(signal.SIGHUP, sighup_handler)
901 # Daemonization
902 if daemon:
903 child_pid = os.fork()
904 if child_pid == 0:
905 os.setsid()
906 basile.start_as_daemon(outfile)
907 else:
908 # on enregistre le pid de basile
909 pidfile = "/var/run/bots/basile.pid"
910 for arg in sys.argv:
911 arg = arg.split("=")
912 if arg[0].strip('-') in ["pidfile"]:
913 pidfile = arg[1]
914 f = open(pidfile, "w")
915 f.write("%s\n" % child_pid)
916 f.close()
917 else:
918 basile.start()
919
920 if __name__ == "__main__":
921 main()