]> gitweb.pimeys.fr Git - today.git/blob - today.py
[server] On ne prend pas trop de place dans les messages de début.
[today.git] / today.py
1 #!/usr/bin/python
2 # -*- encoding: utf-8 -*-
3
4 """ Codé par 20-100
5 script qui affiche des trucs à penser, des J-n des conneries
6 or that kind of stuff"""
7
8 import time, datetime
9 import re
10 import os
11 import sys
12 import subprocess
13 import json
14 os.chdir('/home/vincent/scripts/today/')
15
16
17 class Config(object):
18 """Configuration (pas de couleurs si on n'output pas dans un terminal"""
19 def __init__(self, color=True):
20 self.endcolor = u"\e[0m"
21 self.blue = u"\e[1;36m"
22 self.red = u"\e[1;31m"
23 self.green = u"\e[1;32m"
24 if not color:
25 self.nocolor()
26 #: Faut-il contacter le serveur distant
27 self.do_remote = True
28 #: Serveur distant où aller récupérer les checks
29 self.distant_server = "pimeys"
30 #: path de today-server.py sur le serveur distant
31 self.path_today_server = "/home/vincent/scripts/today/today_server.py"
32 #: Fichier contenant les anniversaires
33 self.birthdays_file = "birthdays.txt"
34 #: Fichier contenant les évènements à venir
35 self.timers_file = "timers.txt"
36 #: Fichier contenant les fêtes à souhaiter
37 self.saints_file = "saints.json"
38 #: Fichier contenant les ids des derniers trucs vus/lus
39 self.last_seen_file = "lasts"
40 #: Fichier contenant le timestamp de dernière exécution
41 self.lasttime_file = ".lasttime"
42 #: Fichier contenant un booléen mémorisant si il y a quelquechose dans le today du jour et qu'il n'a pas encore été regardé
43 self.something_file = ".something"
44
45 def nocolor(self):
46 """Passe en mode sans couleur."""
47 self.endcolor = self.blue = self.red = self.green = u""
48
49 if "--color" in sys.argv:
50 sys.argv.remove("--color")
51 color = True
52 elif sys.stdout.isatty():
53 color = True
54 else:
55 color = False
56
57 config = Config(color=color)
58
59 def print_date(timestamp=None,color=True):
60 """Afficher la date"""
61 if timestamp == None:
62 timestamp = time.time()
63 return time.strftime(" "*30 + config.blue+"%d/%m/%Y %H:%M:%S"+config.endcolor + "\n",
64 time.localtime(timestamp))
65
66 def add_title(titre, texte):
67 """Ajoute un titre à la partie si il y a quelque chose dedans"""
68 if texte:
69 texte = u" %s%s :%s\n" % (config.green, titre, config.endcolor) + texte + "\n"
70 return texte
71
72 def get_now():
73 """Obtenir la date actuelle sous le bon format"""
74 timestamp = time.time()
75 now = datetime.datetime(*time.localtime(timestamp)[:7])
76 return now
77
78 def get_last_seen():
79 """Récupère la liste des derniers trucs vus/lus"""
80 with open(config.last_seen_file) as f:
81 return json.loads(f.read())
82
83 def is_int(a):
84 try:
85 int(a)
86 return True
87 except ValueError:
88 return False
89
90 def update_last_seen(newdict):
91 """Met à jour un des derniers trucs vus/lus"""
92 if not all([is_int(v) or (v == "last") for v in newdict.values()]):
93 raise ValueError("Donner un entier ou last")
94 # Il est possible qu'on ait mis "last" quelque part
95 if "last" in newdict.values():
96 # il faut alors récupérer les derniers pour convertir "last" en <last_id>
97 lasts_published = get_whatsup()
98 for key in [k for (k, v) in newdict.items() if v == "last"]:
99 newdict[key] = lasts_published[key]
100 # On convertit les chaînes en entier (pour les <last_id> il leur arrive rien)
101 newdict = {k: int(v) for (k,v) in newdict.items()}
102 lasts_seen = get_last_seen()
103 lasts_seen.update(newdict)
104 with open(config.last_seen_file, "w") as f:
105 f.write(json.dumps(lasts_seen))
106
107 def parse_datefile(namefile):
108 """Ouvre et parse un fichier avec des lignes de la forme
109 jj/mm/aaaa Truc
110 """
111 with open(namefile) as f:
112 rawdata = [l.strip().decode("utf8") for l in f.readlines()[1:] if not l.strip().startswith("#") and not l.strip() == '']
113 data = []
114 for l in rawdata:
115 date, truc = l.split("\t",1)
116 date = datetime.datetime(*time.strptime(date, "%d/%m/%Y")[:7])
117 data.append([date, truc])
118 return data
119
120
121 def get_timers():
122 """Obtenir la liste des évènements à venir (J-n)"""
123 now = get_now()
124 data = parse_datefile(config.timers_file)
125 timers = []
126 for [date, event] in data:
127 delta = date - now + datetime.timedelta(1)
128 if delta > datetime.timedelta(0):
129 timers.append([event,delta.days])
130 eventsize = max([0]+[len(l[0]) for l in timers])
131 timers = u"\n".join([(u"%%-%ss J-%%s" % eventsize) % (event, timer) for event,timer in timers])
132 timers = add_title(u"Timers", timers)
133 return timers
134
135 def get_birthdays(*search):
136 """Obtenir la liste des anniversaires à venir,
137 ou la liste des anniversaires correspondants à une recherche"""
138 now = get_now()
139 liste = parse_datefile(config.birthdays_file)
140 birthdays = []
141 if len(search) == 0:
142 # Simple demande d'anniversaires courants
143 for date, nom in liste:
144 thisyeardate = datetime.datetime(now.year, date.month, date.day)
145 delta = thisyeardate - now + datetime.timedelta(1)
146 if delta > datetime.timedelta(0):
147 age = now.year - date.year
148 if abs(delta) < datetime.timedelta(1):
149 birthdays.append([config.red, u"%s a %s ans AUJOURD'HUI !" % (nom, age), 0, config.endcolor])
150 elif delta < datetime.timedelta(7):
151 birthdays.append([config.red, u"%s va avoir %s ans" % (nom, age), -delta.days, config.endcolor])
152 elif delta < datetime.timedelta(14):
153 birthdays.append([u"", u"%s va avoir %s ans" % (nom, age), -delta.days, u""])
154 elif datetime.timedelta(30-4) < delta < datetime.timedelta(30+4):
155 birthdays.append([u"", u"%s va avoir %s ans" % (nom, age), -delta.days, u""])
156 else:
157 # Recherche spécifique
158 search = [i.lower() for i in search]
159 tous = ("--all" in search)
160 for date, nom in liste:
161 if tous or any([term.lower() in nom.lower() for term in search]):
162 thisyeardate = datetime.datetime(now.year, date.month, date.day)
163 delta = thisyeardate - now + datetime.timedelta(1)
164 age = now.year - date.year
165 if delta.days<0:
166 birthdays.append([u"", u"%s a eu %s ans" % (nom, age), -delta.days, ""])
167 else:
168 birthdays.append([u"", u"%s va avoir %s ans" % (nom, age), -delta.days, ""])
169 birthdays.sort(lambda x,y: -cmp(x[2], y[2]))
170 eventsize = max([0]+[len(l[1]) for l in birthdays])
171 template = (u"%%s%%-%ss J%%+d%%s" % eventsize)
172 birthdays = u"\n".join([template % tuple(tup) for tup in birthdays])
173 birthdays = add_title(u"Anniversaires", birthdays)
174 return birthdays
175
176 def _parse_saint(s):
177 """Renvoie la liste des fêtes contenue dans un jour"""
178 l = s.split(",")
179 if l == [""]:
180 l = []
181 ll = []
182 for st in l:
183 if st[0] == "&":
184 ll.append(["St ", st[1:]])
185 elif st[0] == "!":
186 ll.append(["Ste ", st[1:]])
187 return ll
188
189 def _get_firstnames():
190 """Récupère la liste des noms des gens connus"""
191 birthdays = parse_datefile(config.birthdays_file)
192 firstnames = [b[1].split()[0] for b in birthdays]
193 return firstnames
194
195 def get_saints():
196 """Renvoie la liste des fêtes à souhaiter aujourd'hui et demain"""
197 sourcesaints = json.load(open(config.saints_file))
198 now = get_now()
199 saints = {}
200 saints["today"] = _parse_saint(sourcesaints[now.month - 1][now.day - 1])
201 nbdays = len(sourcesaints[now.month - 1])
202 if now.day == nbdays: # il faut regarder le mois suivant
203 if now.month == 12: # il faut regarder l'année suivante
204 saints["tomorrow"] = _parse_saint(sourcesaints[0][0])
205 else:
206 saints["tomorrow"] = _parse_saint(sourcesaints[now.month][0])
207 else:
208 saints["tomorrow"] = _parse_saint(sourcesaints[now.month - 1][now.day])
209 firstnames = _get_firstnames()
210 towish = {"today" : [], "tomorrow" : []}
211 for day in ["today", "tomorrow"]:
212 ssaints = saints[day]
213 for (sexe, saint) in ssaints:
214 if any([firstname.lower() in saint.lower().split() for firstname in firstnames]):
215 towish[day].append(sexe + saint)
216 ttowish = []
217 if towish["today"]:
218 ttowish.append(u"Aujourd'hui :\n" + "\n".join(towish["today"]))
219 if towish["tomorrow"]:
220 ttowish.append(u"Demain :\n" + "\n".join(towish["tomorrow"]))
221 saints = "\n".join(ttowish)
222 saints = add_title(u"Fêtes à souhaiter", saints)
223 return saints
224
225 def check_birthdays():
226 """Compte combien il y a d'anniversaires à afficher"""
227 birthdays = get_birthdays()
228 if birthdays:
229 n = birthdays.count(u"\n") - 1
230 else:
231 n = 0
232 return n
233
234 def check_saints():
235 """Compte combien il y a de fêtes à afficher"""
236 saints = get_saints()
237 return len(re.findall("\nSt", saints))
238
239 def format_quotes(liste):
240 """Formate les quotes de dicos à texte"""
241 t = (u"\n" + u"_"*80 + u"\n").join([u"%(id)s (%(date)s)\n%(quote)s" % q for q in liste])
242 return t
243
244 def get_dtc(*args):
245 """Récupère les quotes DTC non lues"""
246 if len(args) == 0:
247 last_dtc = get_last_seen().get("dtc", 0)
248 cmd = "~/bin/dtc %s + --json" % (last_dtc+1,)
249 elif len(args) == 1:
250 cmd = "~/bin/dtc %s --json" % args[0]
251 elif len(args) == 2:
252 cmd = "~/bin/dtc %s %s --json" % (args[0], args[1])
253 else:
254 return None
255 proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
256 out, err = proc.communicate()
257 out += err
258 quotes = json.loads(out)
259 if quotes:
260 last_id = max([q["id"] for q in quotes])
261 update_last_seen({"dtc" : last_id})
262 textquotes = format_quotes(quotes)
263 return textquotes
264
265 def update_xkcd(newid):
266 update_last_seen({"xkcd" : newid})
267
268 def update_xantah(newid):
269 update_last_seen({"xantah" : newid})
270
271 def update_visiteur(newid):
272 update_last_seen({"visiteur" : newid})
273
274 def update_noob(newid):
275 update_last_seen({"noob" : newid})
276
277 def update_warpzone(newid):
278 update_last_seen({"warpzone" : newid})
279
280 def update_hugo(newid):
281 update_last_seen({"hugo" : newid})
282
283 def update_norman(newid):
284 update_last_seen({"norman" : newid})
285
286 def update_cyprien(newid):
287 update_last_seen({"cyprien" : newid})
288
289 def update_grenier(newid):
290 update_last_seen({"grenier" : newid})
291
292 def update_jl8(newid):
293 update_last_seen({"dc" : newid})
294
295
296 THINGS = {
297 "dtc" : u"Quotes DTC",
298 "xkcd" : u"Épisodes de XKCD",
299 "xantah" : u"Épisodes de La Légende de Xantah",
300 "visiteur" : u"Épisodes du Visiteur du Futur",
301 "noob" : u"Épisodes de NOOB",
302 "warpzone" : u"Épisodes de WARPZONE PROJECT",
303 "hugo" : u"Vidéos de Hugo Tout Seul",
304 "norman" : u"Vidéos de Norman",
305 "cyprien" : u"Vidéos de Cyprien",
306 "grenier" : u"Épisodes du joueur du grenier",
307 "dc" : u"Épisodes de la BD youngDC",
308
309 "birthdays" : u"Anniversaires à souhaiter",
310 "saints" : u"Fêtes à souhaiter",
311 }
312
313 def get_whatsup():
314 """Récuère sur le serveur les derniers trucs."""
315 cmd = "%s whatsup" % (config.path_today_server,)
316 proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd], stdout=subprocess.PIPE)
317 out, err = proc.communicate()
318 news = json.loads(out)
319 return news
320
321 def check_all():
322 """Vérifie si il y a des derniers trucs non lus/vus."""
323 news = get_whatsup()
324 seen = get_last_seen()
325 news["birthdays"] = check_birthdays()
326 news["saints"] = check_saints()
327 checks = []
328 for (thing, comm) in THINGS.iteritems():
329 n = news[thing] - seen.get(thing, 0)
330 if type(n) != int:
331 print n
332 elif n > 0:
333 checks.append("%s : %s (last : %s)" % (comm, n, news[thing]))
334 checks = u"\n".join(checks)
335 checks = add_title(u"Checks", checks)
336 return checks
337
338 def get_everything():
339 """Récupère toutes les infos."""
340 work = [action() for (keyword, action) in AUTOMATED_ACTIONS.iteritems()
341 if (config.do_remote or not keyword in REMOTE_ACTIONS)]
342 chain = u"\n\n".join([result for result in work if result])
343 return chain
344
345 def _is_there_something_in_today():
346 """Teste si il y a des choses non lue dans le today"""
347 return open(config.something_file, "r").read() == "True"
348
349 def _there_is_something_in_today(something):
350 """Met à jour le something"""
351 f = open(config.something_file, "w")
352 f.write(str(bool(something)))
353 f.close()
354
355 def _get_lasttime():
356 """Récupère la dernière fois que today a été exécuté"""
357 if os.path.isfile(config.lasttime_file):
358 lasttime = open(config.lasttime_file, "r").read()
359 else:
360 lasttime = 0
361 lasttime = datetime.datetime(*time.localtime(float(lasttime))[:7])
362 return lasttime
363
364 def _update_lasttime(when):
365 """Met à jour le timestamp de dernière exécution de today"""
366 f = open(config.lasttime_file, "w")
367 f.write(str(time.mktime(when.timetuple())))
368 f.close()
369
370 def ping():
371 """Dit juste si il y a quelque chose à voir.
372 La première exécution de la journée peut être lente parce qu'elle va bosser avant de répondre.
373 """
374 now = get_now()
375 lasttime = _get_lasttime()
376 if (lasttime.date() < now.date()):
377 # On a changé de jour
378 _update_lasttime(now)
379 something = get_everything()
380 _there_is_something_in_today(something)
381 if something:
382 return u"You have something in %stoday%s" % (config.red, config.endcolor)
383 else:
384 return u"Nothing in today"
385 else:
386 if _is_there_something_in_today():
387 return u"You have something in %stoday%s" % (config.red, config.endcolor)
388
389 def affiche():
390 """Action par défaut, affiche toutes les infos."""
391 out = print_date()
392 out += get_everything()
393 _there_is_something_in_today(False)
394 return out
395
396 def initialize():
397 """Crée les fichiers (vides) nécessaires au fonctionnement du script"""
398 files = [config.birthdays_file, config.timers_file, config.saints_file,
399 config.last_seen_file]
400 contents = [u"# Anniversaires\n#jj/mm/aaaa Prénom Nom\n",
401 u"# Évènements à venir\n#jj/mm/aaaa Évènement\n",
402 json.dumps([[""]*31]*12).decode(),
403 u"{}"]
404 for ifile in range(len(files)):
405 namefile = files[ifile]
406 if os.path.isfile(namefile):
407 print (u"%s exists, skipping." % (namefile,)).encode("utf-8")
408 else:
409 f = open(namefile, "w")
410 f.write(contents[ifile].encode("utf-8"))
411 f.close()
412
413 def sync():
414 """Synchronise les last_seen avec le serveur distant qui en garde une copie,
415 le maximum de chaque truc vu est gardé des deux côtés."""
416 lasts = get_last_seen()
417 cmd = "%s sync" % (config.path_today_server,)
418 proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd],
419 stdin = subprocess.PIPE, stdout=subprocess.PIPE,
420 close_fds = True)
421 lasts_raw = json.dumps(lasts)
422 proc.stdin.write(lasts_raw)
423 proc.stdin.close()
424 out = proc.stdout.read()
425 newdict = json.loads(out)
426 update_last_seen(newdict)
427 print (u"Nouvel état : %r" % newdict).encode("utf-8")
428
429
430
431 #: Les actions effectuées lors d'un appel sans paramètres
432 AUTOMATED_ACTIONS = {
433 "timers" : get_timers,
434 "birth" : get_birthdays,
435 "saints" : get_saints,
436 "check" : check_all,
437 }
438
439 #: Les actions qu'on peut effectuer en rajoutant des paramètres
440 OTHER_ACTIONS = {
441 "xkcd" : update_xkcd,
442 "xantah" : update_xantah,
443 "visiteur" : update_visiteur,
444 "noob" : update_noob,
445 "warpzone" : update_warpzone,
446 "hugo" : update_hugo,
447 "norman" : update_norman,
448 "cyprien" : update_cyprien,
449 "grenier" : update_grenier,
450 "dc" : update_jl8,
451
452 "dtc" : get_dtc,
453 "ping" : ping,
454 "show" : affiche,
455 "sync" : sync,
456
457 "init" : initialize,
458 }
459
460 #: Les actions qui nécessitent un accès au serveur distant
461 REMOTE_ACTIONS = ["check", "sync"]
462
463 #: Toutes les actions
464 ACTIONS = dict(AUTOMATED_ACTIONS)
465 ACTIONS.update(OTHER_ACTIONS)
466
467 ACTIONS[None] = affiche # action par défaut
468
469 if __name__ == "__main__":
470 import sys
471 if "--no-color" in sys.argv:
472 config.nocolor()
473 sys.argv.remove("--no-color")
474 if "--no-remote" in sys.argv:
475 config.do_remote = False
476 sys.argv.remove("--no-remote")
477 if len(sys.argv) == 1:
478 # Juste un today
479 output = ACTIONS[None]()
480 else:
481 commande = sys.argv[1]
482 args = [s.decode("utf-8") for s in sys.argv[2:]]
483 output = ACTIONS[commande](*args)
484 if output:
485 print output.encode("utf-8")