mygpo/directory/tags.py

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