or that kind of stuff"""
import time, datetime
+import re
import os
import sys
import subprocess
os.chdir('/home/vincent/scripts/today/')
-class Config(object):
- """Configuration (pas de couleurs si on n'output pas dans un terminal"""
- def __init__(self, color=True):
- if color:
- self.endcolor = u"\e[0m"
- self.blue = u"\e[1;36m"
- self.red = u"\e[1;31m"
- self.green = u"\e[1;32m"
- else:
- self.endcolor=self.blue=self.red=self.green=""
- #: Serveur distant où aller récupérer les checks
- self.distant_server = "pimeys"
- #: path de today-server.py sur le serveur distant
- self.path_today_server = "/home/vincent/scripts/today/today_server.py"
- #: Fichier contenant les anniversaires
- self.birthdays_file = "birthdays.txt"
- #: Fichier contenant les évènements à venir
- self.timers_file = "timers.txt"
- #: Fichier contenant les fêtes à souhaiter
- self.saints_file = "saints.txt"
- #: Fichier contenant les ids des derniers trucs vus/lus
- self.last_seen_file = "lasts"
- #: Fichier contenant le timestamp de dernière exécution
- self.lasttime_file = ".lasttime"
- #: 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é
- self.something_file = ".something"
+# Import de la configuration
+import config
if "--color" in sys.argv:
sys.argv.remove("--color")
else:
color = False
-config = Config(color=color)
+config = config.Config(color=color)
def print_date(timestamp=None,color=True):
"""Afficher la date"""
"""Récupère la liste des derniers trucs vus/lus"""
with open(config.last_seen_file) as f:
return json.loads(f.read())
-
-def update_last_seen(newdict):
+
+def is_int(a):
+ try:
+ int(a)
+ return True
+ except ValueError:
+ return False
+
+def update_last_seen(newdict, lasts_seen=None):
"""Met à jour un des derniers trucs vus/lus"""
- lasts = get_last_seen()
- lasts.update(newdict)
+ if not all([is_int(v) or (v == "last") for v in newdict.values()]):
+ raise ValueError("Donner un entier ou last")
+ # Il est possible qu'on ait mis "last" quelque part
+ if "last" in newdict.values():
+ # il faut alors récupérer les derniers pour convertir "last" en <last_id>
+ lasts_published = get_whatsup()
+ for key in [k for (k, v) in newdict.items() if v == "last"]:
+ newdict[key] = lasts_published[key]
+ # On convertit les chaînes en entier (pour les <last_id> il leur arrive rien)
+ newdict = {k: int(v) for (k,v) in newdict.items()}
+ if lasts_seen is None:
+ lasts_seen = get_last_seen()
+ lasts_seen.update(newdict)
with open(config.last_seen_file, "w") as f:
- f.write(json.dumps(lasts))
+ f.write(json.dumps(lasts_seen))
+ return ", ".join(["last %s to %s" % (id, n) for (id, n) in newdict.items()])
def parse_datefile(namefile):
"""Ouvre et parse un fichier avec des lignes de la forme
timers = add_title(u"Timers", timers)
return timers
-def exists(l):
- """Renvoie True si au moins un élément de l est vrai"""
- for i in l:
- if i:
- return True
- return False
-
def get_birthdays(*search):
"""Obtenir la liste des anniversaires à venir,
ou la liste des anniversaires correspondants à une recherche"""
birthdays.append([config.red, u"%s a %s ans AUJOURD'HUI !" % (nom, age), 0, config.endcolor])
elif delta < datetime.timedelta(7):
birthdays.append([config.red, u"%s va avoir %s ans" % (nom, age), -delta.days, config.endcolor])
- elif delta < datetime.timedelta(14):
- birthdays.append([u"", u"%s va avoir %s ans" % (nom, age), -delta.days, u""])
- elif datetime.timedelta(30-4) < delta < datetime.timedelta(30+4):
+ elif delta < datetime.timedelta(30):
birthdays.append([u"", u"%s va avoir %s ans" % (nom, age), -delta.days, u""])
else:
# Recherche spécifique
search = [i.lower() for i in search]
tous = ("--all" in search)
for date, nom in liste:
- if tous or exists([term.lower() in nom.lower() for term in search]):
+ if tous or any([term.lower() in nom.lower() for term in search]):
thisyeardate = datetime.datetime(now.year, date.month, date.day)
delta = thisyeardate - now + datetime.timedelta(1)
age = now.year - date.year
birthdays = add_title(u"Anniversaires", birthdays)
return birthdays
+def _parse_saint(s):
+ """Renvoie la liste des fêtes contenue dans un jour"""
+ l = s.split(",")
+ if l == [""]:
+ l = []
+ ll = []
+ for st in l:
+ if st[0] == "&":
+ ll.append(["St ", st[1:]])
+ elif st[0] == "!":
+ ll.append(["Ste ", st[1:]])
+ return ll
+
+def _get_firstnames():
+ """Récupère la liste des noms des gens connus"""
+ birthdays = parse_datefile(config.birthdays_file)
+ firstnames = [b[1].split()[0] for b in birthdays]
+ return firstnames
+
+def get_saints():
+ """Renvoie la liste des fêtes à souhaiter aujourd'hui et demain"""
+ sourcesaints = json.load(open(config.saints_file))
+ now = get_now()
+ saints = {}
+ saints["today"] = _parse_saint(sourcesaints[now.month - 1][now.day - 1])
+ nbdays = len(sourcesaints[now.month - 1])
+ if now.day == nbdays: # il faut regarder le mois suivant
+ if now.month == 12: # il faut regarder l'année suivante
+ saints["tomorrow"] = _parse_saint(sourcesaints[0][0])
+ else:
+ saints["tomorrow"] = _parse_saint(sourcesaints[now.month][0])
+ else:
+ saints["tomorrow"] = _parse_saint(sourcesaints[now.month - 1][now.day])
+ firstnames = _get_firstnames()
+ towish = {"today" : [], "tomorrow" : []}
+ for day in ["today", "tomorrow"]:
+ ssaints = saints[day]
+ for (sexe, saint) in ssaints:
+ if any([firstname.lower() in saint.lower().split() for firstname in firstnames]):
+ towish[day].append(sexe + saint)
+ ttowish = []
+ if towish["today"]:
+ ttowish.append(u"Aujourd'hui :\n" + "\n".join(towish["today"]))
+ if towish["tomorrow"]:
+ ttowish.append(u"Demain :\n" + "\n".join(towish["tomorrow"]))
+ saints = "\n".join(ttowish)
+ saints = add_title(u"Fêtes à souhaiter", saints)
+ return saints
+
def check_birthdays():
"""Compte combien il y a d'anniversaires à afficher"""
birthdays = get_birthdays()
n = 0
return n
+def check_saints():
+ """Compte combien il y a de fêtes à afficher"""
+ saints = get_saints()
+ return len(re.findall("\nSt", saints))
+
def format_quotes(liste):
"""Formate les quotes de dicos à texte"""
t = (u"\n" + u"_"*80 + u"\n").join([u"%(id)s (%(date)s)\n%(quote)s" % q for q in liste])
cmd = "~/bin/dtc %s %s --json" % (args[0], args[1])
else:
return None
- proc = subprocess.Popen(["ssh", config.distant_server, cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = proc.communicate()
out += err
quotes = json.loads(out)
textquotes = format_quotes(quotes)
return textquotes
-def update_xkcd(newid):
- update_last_seen({"xkcd" : int(newid)})
-
-def update_xantah(newid):
- update_last_seen({"xantah" : int(newid)})
-def update_visiteur(newid):
- update_last_seen({"visiteur" : int(newid)})
-
-THINGS = {
- "dtc" : u"Quotes DTC",
- "xkcd" : u"Épisodes de XKCD",
- "xantah" : u"Épisodes de La Légende de Xantah",
- "visiteur" : u"Épisodes du Visiteur du Futur",
-
- "birthdays" : u"Anniversaires à souhaiter",
- }
-
-def check_all():
- """Vérifie si il y a des derniers trucs non lus/vus."""
+def get_whatsup():
+ """Récupère sur le serveur les derniers trucs."""
cmd = "%s whatsup" % (config.path_today_server,)
- proc = subprocess.Popen(["ssh", config.distant_server, cmd], stdout=subprocess.PIPE)
+ proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd], stdout=subprocess.PIPE)
out, err = proc.communicate()
news = json.loads(out)
+ return news
+
+def check_all():
+ """Vérifie si il y a des derniers trucs non lus/vus."""
+ news = get_whatsup()
seen = get_last_seen()
- news["birthdays"] = check_birthdays()
checks = []
- for (thing, comm) in THINGS.iteritems():
- n = news[thing] - seen.get(thing, 0)
+ length = max([len(thing) for thing in news.keys()])
+ for (thing, lastid) in news.items():
+ n = lastid - seen.get(thing, 0)
if type(n) != int:
print n
elif n > 0:
- checks.append("%s : %s" % (comm, n))
+ checks.append("%s :%s%s (last : %s)" % (thing, " " *(length + 1 - len(thing)), n, news[thing]))
checks = u"\n".join(checks)
checks = add_title(u"Checks", checks)
return checks
def get_everything():
- """Récupère toutes les infos"""
- work = [action() for action in AUTOMATED_ACTIONS.values()]
+ """Récupère toutes les infos."""
+ work = [action() for (keyword, action) in AUTOMATED_ACTIONS.iteritems()
+ if (config.do_remote or not keyword in REMOTE_ACTIONS)]
chain = u"\n\n".join([result for result in work if result])
return chain
def ping():
"""Dit juste si il y a quelque chose à voir.
- La première exécution de la journée peut être lente parce qu'elle va bosser avnt de répondre."""
+ La première exécution de la journée peut être lente parce qu'elle va bosser avant de répondre.
+ """
now = get_now()
lasttime = _get_lasttime()
if (lasttime.date() < now.date()):
return u"You have something in %stoday%s" % (config.red, config.endcolor)
def affiche():
- """Action par défaut, affiche toutes les infos"""
+ """Action par défaut, affiche toutes les infos."""
out = print_date()
out += get_everything()
_there_is_something_in_today(False)
config.last_seen_file]
contents = [u"# Anniversaires\n#jj/mm/aaaa Prénom Nom\n",
u"# Évènements à venir\n#jj/mm/aaaa Évènement\n",
- u"# Fêtes\n#jj/mm/aaaa Saint\n",
+ json.dumps([[""]*31]*12).decode(),
u"{}"]
for ifile in range(len(files)):
namefile = files[ifile]
if os.path.isfile(namefile):
- print "%s exists, skipping." % (namefile,)
+ print (u"%s exists, skipping." % (namefile,)).encode("utf-8")
else:
f = open(namefile, "w")
f.write(contents[ifile].encode("utf-8"))
le maximum de chaque truc vu est gardé des deux côtés."""
lasts = get_last_seen()
cmd = "%s sync" % (config.path_today_server,)
- proc = subprocess.Popen(["ssh", config.distant_server, cmd],
+ proc = subprocess.Popen(["ssh", "-4", config.distant_server, cmd],
stdin = subprocess.PIPE, stdout=subprocess.PIPE,
close_fds = True)
lasts_raw = json.dumps(lasts)
out = proc.stdout.read()
newdict = json.loads(out)
update_last_seen(newdict)
- print u"Nouvel état : %r" % newdict
+ print (u"Nouvel état : %r" % newdict).encode("utf-8")
AUTOMATED_ACTIONS = {
"timers" : get_timers,
"birth" : get_birthdays,
+ "saints" : get_saints,
"check" : check_all,
}
#: Les actions qu'on peut effectuer en rajoutant des paramètres
OTHER_ACTIONS = {
- "xkcd" : update_xkcd,
- "xantah" : update_xantah,
- "visiteur" : update_visiteur,
-
"dtc" : get_dtc,
"ping" : ping,
"show" : affiche,
"init" : initialize,
}
+#: Les actions qui nécessitent un accès au serveur distant
+REMOTE_ACTIONS = ["check", "sync"]
+
#: Toutes les actions
ACTIONS = dict(AUTOMATED_ACTIONS)
ACTIONS.update(OTHER_ACTIONS)
if __name__ == "__main__":
import sys
if "--no-color" in sys.argv:
- config.endcolor, config.red, config.blue = u"", u"", u""
+ config.nocolor()
+ sys.argv.remove("--no-color")
+ if "--no-remote" in sys.argv:
+ config.do_remote = False
+ sys.argv.remove("--no-remote")
+ output = None
if len(sys.argv) == 1:
# Juste un today
output = ACTIONS[None]()
else:
commande = sys.argv[1]
- args = sys.argv[2:]
- output = ACTIONS[commande](*args)
+ args = [s.decode("utf-8") for s in sys.argv[2:]]
+ if commande in ACTIONS:
+ output = ACTIONS[commande](*args)
+ else:
+ # on tente un update
+ lasts_seen = get_last_seen()
+ if not commande in lasts_seen:
+ print "Attention : n'existait pas avant."
+ output = update_last_seen({commande : args[0]}, lasts_seen)
if output:
- print output
+ print output.encode("utf-8")
projects / today.git / blobdiff