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")