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