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