Ejemplo n.º 1
0
    def get_newest_episodes(self, max_date, max_per_podcast=5):
        """ Returns the newest episodes of all subscribed podcasts

        Only max_per_podcast episodes per podcast are loaded. Episodes with
        release dates above max_date are discarded.

        This method returns a generator that produces the newest episodes.

        The number of required DB queries is equal to the number of (distinct)
        podcasts of all consumed episodes (max: number of subscribed podcasts),
        plus a constant number of initial queries (when the first episode is
        consumed). """

        cmp_key = lambda episode: episode.released or datetime(2000, 01, 01)

        podcasts = list(self.get_subscribed_podcasts())
        podcasts = filter(lambda p: p.latest_episode_timestamp, podcasts)
        podcasts = sorted(podcasts, key=lambda p: p.latest_episode_timestamp,
                        reverse=True)

        podcast_dict = dict((p.get_id(), p) for p in podcasts)

        # contains the un-yielded episodes, newest first
        episodes = []

        for podcast in podcasts:

            yielded_episodes = 0

            for episode in episodes:
                # determine for which episodes there won't be a new episodes
                # that is newer; those can be yielded
                if episode.released > podcast.latest_episode_timestamp:
                    p = podcast_dict.get(episode.podcast, None)
                    yield proxy_object(episode, podcast=p)
                    yielded_episodes += 1
                else:
                    break

            # remove the episodes that have been yielded before
            episodes = episodes[yielded_episodes:]

            # fetch and merge episodes for the next podcast
            from mygpo.db.couchdb.episode import episodes_for_podcast
            new_episodes = episodes_for_podcast(podcast, since=1,
                        until=max_date, descending=True, limit=max_per_podcast)
            episodes = sorted(episodes+new_episodes, key=cmp_key, reverse=True)


        # yield the remaining episodes
        for episode in episodes:
            podcast = podcast_dict.get(episode.podcast, None)
            yield proxy_object(episode, podcast=podcast)
Ejemplo n.º 2
0
 def _prepare_list(self, l):
     podcasts = Podcast.get_multi(l.podcasts[:self.podcasts_per_topic])
     user = User.get(l.user)
     l = proxy_object(l)
     l.podcasts = podcasts
     l.username = user.username
     l.cls = "PodcastList"
     return l
Ejemplo n.º 3
0
Archivo: views.py Proyecto: fk-lx/mygpo
    def get_random_list(self, podcasts_per_list=5):
        random_list = next(random_podcastlists(), None)
        list_owner = None
        if random_list:
            random_list = proxy_object(random_list)
            random_list.more_podcasts = max(0, len(random_list.podcasts) - podcasts_per_list)
            random_list.podcasts = podcasts_by_id(random_list.podcasts[:podcasts_per_list])
            random_list.user = get_user_by_id(random_list.user)

        yield random_list
Ejemplo n.º 4
0
def podcasts_for_states(podcast_states):
    """ returns the podcasts corresponding to the podcast states """

    podcast_ids = [state.podcast for state in podcast_states]
    podcasts = podcasts_to_dict(podcast_ids)

    for state in podcast_states:
        podcast = proxy_object(podcasts[state.podcast], url=state.ref_url)
        podcasts[state.podcast] = podcast

    return podcasts.values()
Ejemplo n.º 5
0
    def get_subscribed_podcasts(self, public=None):
        """ Returns all subscribed podcasts for the user

        The attribute "url" contains the URL that was used when subscribing to
        the podcast """

        from mygpo.db.couchdb.podcast_state import get_subscribed_podcast_states_by_user
        states = get_subscribed_podcast_states_by_user(self, public)
        podcast_ids = [state.podcast for state in states]
        podcasts = podcasts_to_dict(podcast_ids)

        for state in states:
            podcast = podcasts.get(state.podcast, None)
            if podcast is None:
                continue

            podcast = proxy_object(podcast, url=state.ref_url)
            podcasts[state.podcast] = podcast

        return set(podcasts.values())
Ejemplo n.º 6
0
    def get_newest_episodes(self, max_date, num_episodes, max_per_podcast=5):
        """ Returns the newest episodes for a set of podcasts """

        podcast_key = lambda p: p.latest_episode_timestamp

        podcasts = filter(lambda p: p.latest_episode_timestamp, self.podcasts)
        podcasts = sorted(podcasts, key=podcast_key, reverse=True)

        # we need at most num_episodes podcasts
        podcasts = podcasts[:num_episodes]

        podcast_dict = dict((p.get_id(), p) for p in podcasts)

        links = [(p.latest_episode_timestamp, lazy_call(episodes_for_podcast,
                    p, since=1, until=max_date, descending=True,
                    limit=max_per_podcast) ) for p in podcasts]

        episodes = sorted_chain(links, lambda e: e.released, reverse=True)

        for episode in islice(episodes, num_episodes):
            p = podcast_dict.get(episode.podcast, None)
            yield proxy_object(episode, podcast=p)
Ejemplo n.º 7
0
Archivo: views.py Proyecto: fk-lx/mygpo
def list_show(request, plist, owner):

    is_own = owner == request.user
    site = RequestSite(request)

    plist = proxy_object(plist)

    podcasts = list(podcasts_groups_by_id(plist.podcasts))
    plist.podcasts = podcasts

    max_subscribers = max([p.subscriber_count() for p in podcasts] + [0])

    thing = plist.get_flattr_thing(site.domain, owner.username)
    flattr = Flattr(owner, site.domain, request.is_secure())
    flattr_autosubmit = flattr.get_autosubmit_url(thing)

    return render(request, 'list.html', {
            'podcastlist': plist,
            'max_subscribers': max_subscribers,
            'owner': owner,
            'flattr_autosubmit': flattr_autosubmit,
            'domain': site.domain,
            'is_own': is_own,
        })
Ejemplo n.º 8
0
Archivo: views.py Proyecto: Mic92/mygpo
def list_show(request, plist, owner):

    is_own = owner == request.user

    plist = proxy_object(plist)

    podcasts = list(Podcast.get_multi(plist.podcasts))
    plist.podcasts = podcasts

    max_subscribers = max([p.subscriber_count() for p in podcasts] + [0])

    site = RequestSite(request)

    return render(
        request,
        "list.html",
        {
            "podcastlist": plist,
            "max_subscribers": max_subscribers,
            "owner": owner,
            "domain": site.domain,
            "is_own": is_own,
        },
    )
Ejemplo n.º 9
0
Archivo: views.py Proyecto: fk-lx/mygpo
 def annotate_episode(episode):
     listener_count = listeners.get(episode._id, None)
     return proxy_object(episode, listeners=listener_count)
Ejemplo n.º 10
0
Archivo: views.py Proyecto: fk-lx/mygpo
 def _prepare_list(l):
     user = get_user_by_id(l.user)
     l = proxy_object(l)
     l.username = user.username if user else ''
     return l
Ejemplo n.º 11
0
Archivo: tags.py Proyecto: fk-lx/mygpo
 def _prepare_category(self, resp):
     category = Category.wrap(resp['doc'])
     category = proxy_object(category)
     category.podcasts = category.get_podcasts(0, self.podcasts_per_cat)
     return category
Ejemplo n.º 12
0
Archivo: utils.py Proyecto: fk-lx/mygpo
 def set_podcast(episode):
     episode = proxy_object(episode)
     episode.podcast = podcasts.get(episode.podcast, None)
     return episode
Ejemplo n.º 13
0
 def _prepare_category(self, category):
     category = proxy_object(category)
     category.podcasts = category.get_podcasts(0, self.podcasts_per_topic)
     category.cls = "Category"
     return category
Ejemplo n.º 14
0
def _annotate_episode(listeners, episode_actions, episode):
    listener_count = listeners.pop(episode._id, None)
    action         = episode_actions.pop(episode._id, None)
    return proxy_object(episode, listeners=listener_count, action=action)
Ejemplo n.º 15
0
 def _set_objects(h):
     dev = user.get_device(h.device)
     return proxy_object(h, device=dev)
Ejemplo n.º 16
0
Archivo: views.py Proyecto: Mic92/mygpo
 def _prepare_list(l):
     user = User.get(l.user)
     l = proxy_object(l)
     l.username = user.username
     return l
Ejemplo n.º 17
0
 def _set_objects(h):
     #TODO: optimize by indexing devices by id
     dev = request.user.get_device(h.device)
     return proxy_object(h, device=dev)