quotes.py

   1 #!/usr/bin/env python
   2 # -*- encoding: utf-8 -*-
   3
   4 """ Gestion des quotes """
   5
   6 import datetime
   7 import time
   8 import re
   9 import json
  10 import random
  11
  12 import config
  13
  14 def get_now():
  15     """ Renvoie la date actuelle """
  16     return datetime.datetime(*time.localtime()[:6])
  17
  18 class Quote(object):
  19     """ Une citation """
  20     def __init__(self, author, content, timestamp=None):
  21         if timestamp is None:
  22             timestamp = get_now()
  23         elif isinstance(timestamp, basestring):
  24             timestamp = datetime.datetime(*time.strptime(timestamp, u"%Y-%m-%d_%H:%M:%S")[:6])
  25         self.author = author
  26         self.content = content
  27         self.timestamp = timestamp
  28
  29     def jsonize(self):
  30         d = {"author" : self.author, "content" : self.content,
  31              "timestamp" : self.timestamp.strftime(u"%F_%T")}
  32         return d
  33
  34     def __unicode__(self):
  35         """ Retourne la quote affichable """
  36         return config.quote_template % self.__dict__
  37     def __str__(self):
  38         return unicode(self).encode("utf-8")
  39
  40     def __eq__(self, otherquote):
  41         """ Vérifie si cette phrase n'a pas déjà été dite par la même personne.
  42             Indépendamment de la date. """
  43         return [self.author, self.content] == [otherquote.author, otherquote.content]
  44
  45 quote_matcher = re.compile(config.quote_regexp)
  46
  47 def parse(text, date=None):
  48     """ Parse le ``text`` et renvoie une quote ou None. """
  49     if date == None:
  50         date = get_now()
  51     get = quote_matcher.match(text)
  52     if not get is None:
  53         d = get.groupdict()
  54         return Quote(d["author"], d["content"], date)
  55
  56 def load_file(filename):
  57     """ Récupère les quotes depuis le fichier """
  58     with open(filename) as f:
  59         jsonquotes = json.load(f)
  60         quotes = [Quote(**q) for q in jsonquotes]
  61     return quotes
  62
  63 def save_file(quotes, filename):
  64     """ Enregistre les quotes dans le fichier """
  65     with open(filename, "w") as f:
  66         raws = [q.jsonize() for q in quotes]
  67         json.dump(raws, f)
  68
  69 class QuoteDB(object):
  70     """ Stocke et distribue des quotes. """
  71     def __init__(self):
  72         self.quotelist = []
  73
  74     def load(self):
  75         """ Charge le fichier de quotes dans la DB """
  76         self.quotelist = load_file(config.quote_file)
  77
  78     def save(self):
  79         """ Sauvegarde la DB dans le fichier de quotes """
  80         save_file(self.quotelist, config.quote_file)
  81
  82     def store(self, author, content, timestamp=None):
  83         """ Enregistre une nouvelle quote, sauf si elle existe déjà.
  84             Renvoie ``True`` si elle a été ajoutée, ``False`` si elle existait. """
  85         newquote = Quote(author, content, timestamp)
  86         if not newquote in self.quotelist:
  87             self.quotelist.append(newquote)
  88             return True
  89         return False
  90
  91     def __repr__(self):
  92         return repr(self.quotelist)
  93
  94     def random(self):
  95         """ Sort une quote aléatoire """
  96         return random.choice(self.quotelist)
  97     def randomfrom(self, author):
  98         """ Sort une quote aléatoire de ``author`` """
  99         return random.choice([q for q in self.quotelist if q.author == author])
 100
 101 def dump(quotedb, dump_file=None):
 102     """Pour exporter les quotes dans un format readable vers un fichier."""
 103     if dump_file is None:
 104         dump_file = config.quote_dump_file
 105     t = "\n".join(["%s %s" % (q.timestamp.strftime("%F_%T"), q) for q in quotedb.quotelist]) + "\n"
 106     with open(dump_file, "w") as f:
 107         f.write(t)
 108
 109 def restore(dump_file=None):
 110     """Crée un DB de quotes en parsant le contenu d'un fichier de dump."""
 111     if dump_file is None:
 112         dump_file = config.quote_dump_file
 113     with open(dump_file) as f:
 114         t = f.read()
 115     t = t.decode("utf-8") # Oui, ça peut fail, mais on ne doit alors pas continuer
 116     regex = re.compile(config.quote_regexp_with_timestamp)
 117     l = [m.groupdict() for m in regex.finditer(t)]
 118     # On instancie les quotes grâce aux dicos qui ont déjà la bonne tronche
 119     l = [Quote(**q) for q in l]
 120     newquotedb = QuoteDB()
 121     newquotedb.quotelist = l
 122     return newquotedb