mygpo/directory/tags.py

   1 from collections import defaultdict, namedtuple
   2 from operator import itemgetter
   3 from datetime import datetime
   4 from random import choice
   5 from itertools import chain
   6
   7 from mygpo.core.models import Podcast
   8 from mygpo.decorators import query_if_required
   9 from mygpo.counter import Counter
  10 from mygpo.core.proxy import proxy_object
  11 from mygpo.directory.models import Category
  12 from mygpo.db.couchdb.podcast import podcasts_for_tag
  13 from mygpo.db.couchdb.directory import top_categories, category_for_tag
  14
  15
  16 class Tag(object):
  17
  18     def __init__(self, tag):
  19         self.tag = tag
  20
  21
  22     def get_podcasts(self):
  23         """ Returns the podcasts with the current tag.
  24
  25         Some podcasts might be returned twice """
  26
  27         return podcasts_for_tag(self.tag)
  28
  29
  30
  31 TagCloudEntry = namedtuple('TagCloudEntry', 'label weight')
  32
  33
  34 class Topics(object):
  35
  36     def __init__(self, total=100, num_cat=10, podcasts_per_cat=10):
  37         self.total = total
  38         self.num_cat = num_cat
  39         self.podcasts_per_cat = podcasts_per_cat
  40         self._categories = None
  41         self._tagcloud = None
  42
  43
  44     def _needs_query(self):
  45         return self._categories is None
  46
  47
  48     def _query(self):
  49         self._categories = []
  50         if self.num_cat > 0:
  51             self._categories = top_categories(0, self.num_cat, True)
  52
  53         self._tagcloud = []
  54         if self.total-self.num_cat > 0:
  55             self._tagcloud = top_categories(self.num_cat, self.total-self.num_cat, False)
  56
  57
  58     @property
  59     @query_if_required()
  60     def tagcloud(self):
  61         self._tagcloud.sort(key = lambda x: x.label.lower())
  62         return self._tagcloud
  63
  64
  65     @query_if_required()
  66     def max_weight(self):
  67         return max([e.get_weight() for e in self.tagcloud] + [0])
  68
  69     @query_if_required()
  70     def min_weight(self):
  71         return min([e.get_weight() for e in self.tagcloud])
  72
  73
  74     @property
  75     @query_if_required()
  76     def categories(self):
  77         return self._categories
  78
  79
  80     def _prepare_category(self, resp):
  81         category = Category.wrap(resp['doc'])
  82         category = proxy_object(category)
  83         category.podcasts = category.get_podcasts(0, self.podcasts_per_cat)
  84         return category
  85
  86
  87
  88 def update_category(podcast):
  89     all_tags = list(chain.from_iterable(s for s in podcast.tags.values()))
  90
  91     if not all_tags:
  92         return
  93
  94     random_tag = choice(all_tags)
  95
  96     category = category_for_tag(random_tag)
  97     if not category:
  98         category = Category(label=random_tag)
  99
 100     category.updated = datetime.utcnow()
 101
 102     category.podcasts = category.podcasts[:999]
 103
 104     # we don't need to CategoryEntry wrapper anymore
 105     if any(isinstance(x, dict) for x in category.podcasts):
 106         category.podcasts = filter(lambda x: isinstance(x, dict), category.podcasts)
 107         category.podcasts = [e['podcast'] for e in category.podcasts]
 108
 109     if podcast.get_id() in category.podcasts:
 110         category.podcasts.remove(podcast.get_id())
 111
 112     category.podcasts.insert(0, podcast.get_id())
 113     category.label = category.label.strip()
 114     category.save()