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 quote_matcher = re.compile(config.quote_regexp, flags=re.UNICODE)
  15 quote_matcher_with_timestamp = re.compile(config.quote_regexp_with_timestamp, flags=re.UNICODE)
  16 spaces_matcher = re.compile(u"\s", flags=re.U)
  17
  18 def get_now():
  19     """ Renvoie la date actuelle """
  20     return datetime.datetime(*time.localtime()[:6])
  21
  22 def sanitize_author(raw):
  23     """Proprifie l'auteur : enlève les espaces insécables."""
  24     return spaces_matcher.sub(u" ", raw)
  25
  26 class Quote(object):
  27     """ Une citation """
  28     def __init__(self, author, content, timestamp=None):
  29         if timestamp is None:
  30             timestamp = get_now()
  31         elif isinstance(timestamp, basestring):
  32             timestamp = datetime.datetime(*time.strptime(timestamp, u"%Y-%m-%d_%H:%M:%S")[:6])
  33         self.author = sanitize_author(author)
  34         self.content = content
  35         self.timestamp = timestamp
  36
  37     def jsonize(self):
  38         d = {"author" : self.author, "content" : self.content,
  39              "timestamp" : self.timestamp.strftime(u"%F_%T")}
  40         return d
  41
  42     def __unicode__(self):
  43         """ Retourne la quote affichable """
  44         return config.quote_template % self.__dict__
  45     def __str__(self):
  46         return unicode(self).encode("utf-8")
  47
  48     def __eq__(self, otherquote):
  49         """ Vérifie si cette phrase n'a pas déjà été dite par la même personne.
  50             Indépendamment de la date et de la casse. """
  51         return [self.author.lower(), self.content.lower()] == [otherquote.author.lower(), otherquote.content.lower()]
  52
  53
  54 def parse(text, date=None):
  55     """ Parse le ``text`` et renvoie une quote ou None. """
  56     if date == None:
  57         date = get_now()
  58     get = quote_matcher.match(text)
  59     if not get is None:
  60         d = get.groupdict()
  61         return Quote(d["author"], d["content"], date)
  62
  63 def load_file(filename):
  64     """ Récupère les quotes depuis le fichier """
  65     with open(filename) as f:
  66         jsonquotes = json.load(f)
  67         quotes = [Quote(**q) for q in jsonquotes]
  68     return quotes
  69
  70 def save_file(quotes, filename):
  71     """ Enregistre les quotes dans le fichier """
  72     with open(filename, "w") as f:
  73         raws = [q.jsonize() for q in quotes]
  74         json.dump(raws, f)
  75
  76 class QuoteDB(object):
  77     """ Stocke et distribue des quotes. """
  78     def __init__(self):
  79         self.quotelist = []
  80
  81     def load(self):
  82         """ Charge le fichier de quotes dans la DB """
  83         self.quotelist = load_file(config.quote_file)
  84
  85     def save(self):
  86         """ Sauvegarde la DB dans le fichier de quotes """
  87         save_file(self.quotelist, config.quote_file)
  88
  89     def store(self, author, content, timestamp=None):
  90         """ Enregistre une nouvelle quote, sauf si elle existe déjà.
  91             Renvoie ``True`` si elle a été ajoutée, ``False`` si elle existait. """
  92         newquote = Quote(author, content, timestamp)
  93         if not newquote in self.quotelist:
  94             self.quotelist.append(newquote)
  95             return True
  96         return False
  97
  98     def __repr__(self):
  99         return repr(self.quotelist)
 100
 101     def random(self):
 102         """ Sort une quote aléatoire """
 103         return random.choice(self.quotelist)
 104     def quotesfrom(self, author):
 105         """ Sort toutes les quotes de ``author`` """
 106         return [q for q in self.quotelist if q.author == author]
 107     def randomfrom(self, author):
 108         """ Sort une quote aléatoire de ``author`` """
 109         return random.choice(self.quotesfrom(author))
 110
 111     def search(self, inquote=None, author=None, regexp=False):
 112         """Fait une recherche dans les quotes."""
 113         if regexp:
 114             if inquote is None:
 115                 inquote = ".*"
 116             if author is None:
 117                 author = ".*"
 118             qreg = re.compile(inquote, flags=re.UNICODE)
 119             areg = re.compile(author, flags=re.UNICODE)
 120             l = [q for q in self.quotelist if qreg.match(q.content) and areg.match(q.author)]
 121         else:
 122             if inquote is None:
 123                 inquote = ""
 124             if author is None:
 125                 author = ""
 126             l = [q for q in self.quotelist if inquote in q.content and author in q.author]
 127         return l
 128
 129     def search_authors(self, author=None, regexp=False):
 130         """Renvoie la liste des auteurs contenant ``author`` ou qui matchent la regexp."""
 131         if regexp:
 132             if author is None:
 133                 author = ".*"
 134             areg = re.compile(author, flags=re.UNICODE)
 135             l = list(set([q.author for q in self.quotelist if areg.match(q.author)]))
 136         else:
 137             if author is None:
 138                 author = ""
 139             l = list(set([q.author for q in self.quotelist if author in q.author]))
 140         return l
 141
 142 def dump(quotedb, dump_file=None):
 143     """Pour exporter les quotes dans un format readable vers un fichier."""
 144     if dump_file is None:
 145         dump_file = config.quote_dump_file
 146     t = "\n".join(["%s %s" % (q.timestamp.strftime("%F_%T"), q) for q in quotedb.quotelist]) + "\n"
 147     with open(dump_file, "w") as f:
 148         f.write(t)
 149
 150 def restore(dump_file=None):
 151     """Crée un DB de quotes en parsant le contenu d'un fichier de dump."""
 152     if dump_file is None:
 153         dump_file = config.quote_dump_file
 154     with open(dump_file) as f:
 155         t = f.read()
 156     t = t.decode("utf-8") # Oui, ça peut fail, mais on ne doit alors pas continuer
 157     l = [m.groupdict() for m in quote_matcher_with_timestamp.finditer(t)]
 158     # On instancie les quotes grâce aux dicos qui ont déjà la bonne tronche
 159     l = [Quote(**q) for q in l]
 160     newquotedb = QuoteDB()
 161     newquotedb.quotelist = l
 162     return newquotedb