コード例 #1
0
    def add_films_to_special_basket_by_film_id(self, user, film_id):

        rating_basket_key = self.cache_key(cache.CACHE_USER_BASKET, user)
        special_rating_basket_key = self.cache_key(cache.CACHE_SPECIAL_USER_BASKET,
                user)
        rating_basket = cache.get(rating_basket_key) or set()
        special_rating_basket = cache.get(special_rating_basket_key) or set()
        new_basket = []

        related = self.get_related_film_ids(film_id)

        excluded = self.get_excluded_films()

        if related:
            new_basket = set(related) - excluded
            new_basket = set(list(new_basket)[:self.SPECIAL_BASKET_BONUS])

        if new_basket:
            # how many we leave from the previous basket
            left_number = self.SPECIAL_RATE_BASKET_SIZE - len(new_basket)
            basket_list = list(special_rating_basket)

            # we throw old films to normal basket
            rating_basket.update(set(basket_list[left_number:]))
            # we leave some old ones in special basket
            new_basket.update(set(basket_list[:left_number]))

            cache.set(rating_basket_key, rating_basket, cache.A_MONTH)
            cache.set(special_rating_basket_key, new_basket, cache.A_MONTH)
コード例 #2
0
ファイル: rating_helper.py プロジェクト: thuvh/filmmaster
    def get_from_tag_basket(cls, user, tag, number_of_films=1):

        basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)

        no_films_key = cache.Key("no_films_left_for_tag", user, tag)
        # indicates whether there are any films left to show to user
        no_films = cache.get(no_films_key)

        if not no_films:
            tag_basket = cache.get(basket_key) or dict()
            if len(tag_basket) < number_of_films:
                cls.refill_tag_basket(user, tag)
                tag_basket = cache.get(basket_key) or dict()

            result = sorted(tag_basket, key=tag_basket.get,
                    reverse=True)[:number_of_films]

            if not result:
                cache.set(no_films_key, True, cache.A_MONTH)
            else:
                for film_id in result:
                    tag_basket.pop(film_id)
                cache.set(basket_key, tag_basket, cache.A_MONTH)
                defer(cls.refill_tag_basket, user, tag)

            return result
        else:
            return []
コード例 #3
0
ファイル: rating_helper.py プロジェクト: thuvh/filmmaster
    def get_films_to_rate(cls, user, number_of_films=1, tag=None):

        if not tag:
            rating_basket_key = cache.Key(cache.CACHE_USER_BASKET, user)
            special_rating_basket_key = cache.Key(cache.CACHE_SPECIAL_USER_BASKET,
                    user)
            rating_basket = cache.get(rating_basket_key) or set()
            special_rating_basket = cache.get(special_rating_basket_key) or set()
            rating_basket.difference_update(special_rating_basket)
            if len(rating_basket) + len(special_rating_basket) < number_of_films:
                cls.refill_user_basket(user)
                rating_basket = cache.get(rating_basket_key) or set()
                rating_basket.difference_update(special_rating_basket)

            result = list(special_rating_basket) + list(rating_basket)
            result = result[:number_of_films]
            result_set = set(result)
            rating_basket.difference_update(result_set)
            special_rating_basket.difference_update(result_set)

            cache.set(rating_basket_key, rating_basket, cache.A_MONTH)
            cache.set(special_rating_basket_key,
                    special_rating_basket, cache.A_MONTH)
        else:
            result = cls.get_from_tag_basket(user, tag, number_of_films=number_of_films)

        films = list(Film.objects.filter(id__in=result).select_related())
        return films
コード例 #4
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def post(self, *args, **kw):
        key = cache.Key("questions_", self.request.unique_user)
        questions = cache.get(key)

        if "start" not in self.request.POST:
            self.check_answer(time.time())

        if not questions:
            return self.on_end_questions()

        question = questions.pop()
        if question:
            cache.delete(key) # delete cache for questions
            cache.set(key, questions) # set cache for questions-1
            key = cache.Key("answer_", self.request.unique_user)
            cache.set(key, question) # set cache for user answer

        context = self.get_context_data()
        context.update({
            'question': question or [],
            'tstamp': time.time(),
            'progress': (100-len(questions)*10),
            'answered': 10-len(questions)
        })
        return render(self.request, self.template_name, context )
コード例 #5
0
ファイル: rating_helper.py プロジェクト: thuvh/filmmaster
    def refill_tag_basket(cls, user, tag):

        TAG_BASKET_SIZE = getattr(settings, 'TAG_BASKET_SIZE')
        MIN_TAG_BASKET_SIZE = getattr(settings, 'MIN_TAG_BASKET_SIZE')
        try:
            lang = user.get_profile().LANG
        except AttributeError:
            lang = 'en'

        basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)
        tag_basket = cache.get(basket_key) or dict()

        if len(tag_basket) < MIN_TAG_BASKET_SIZE:
            # get films with this tag
            films_dict = Film.get_film_ids_by_tag(tag, lang)
            # get films seen by user
            seen_films = Film.get_user_seen_films(user)

            # remove films seen by user
            films_dict = dict([(k,v) for k,v in films_dict.items() if k not in seen_films])
            # how many we want to refill
            to_refill = TAG_BASKET_SIZE - len(tag_basket)
            # reverse sort by popularity
            sorted_films = sorted(films_dict, key=films_dict.get, reverse=True)[:to_refill]
            refill_dict = dict([(fid, films_dict[fid]) for fid in sorted_films])

            tag_basket.update(refill_dict)
            cache.set(basket_key, tag_basket, cache.A_MONTH)
コード例 #6
0
ファイル: views.py プロジェクト: thuvh/filmmaster
    def checked_in_users(self):
        key = cache.Key("festival_participants", self.object)
        users = cache.get(key)
        if users is None:
            from django.db.models import Min

            # fetch user checked-in on festival screenings

            users = list(User.objects.filter(
                    screeningcheckin__screening__in=self.screening_set.get_screening_ids()
            ).annotate(Min('screeningcheckin__created_at')))
            for u in users:
                u.activity_date = u.screeningcheckin__created_at__min

            users = dict( (u.id, u) for u in users )

            # add users with activities tagged with festival tag
            users2 = User.objects.filter(
                user_activity__tagged_items__tag__name=self.object.tag.lower(),
                user_activity__LANG=settings.LANGUAGE_CODE,
                user_activity__created_at__gte=self.object.start_date,
                user_activity__created_at__lt=self.object.end_date + datetime.timedelta(days=1),
                profile__metacritic_name='',
            ).annotate(Min('user_activity__created_at'))

            for u in users2:
                u.activity_date = u.user_activity__created_at__min

                if not u.id in users or u.activity_date < users[u.id].activity_date:
                    users[u.id] = u

            users = sorted(users.values(), key=lambda u:u.activity_date)
            cache.set(key, users)
        return users
コード例 #7
0
def recompute_recommendations(user):
    engine.compute_user_features(user, save=True)

    key = cache_key("top_film_ids", MAX_RECOMMENDATIONS_NUMBER)
    film_ids = cache.get(key)
    if film_ids is None:
        film_ids = Film.objects.filter(popularity__gte=MIN_POPULARITY)
        film_ids = film_ids.with_poster().with_description().values_list(
            'id', flat=True)
        film_ids = film_ids.exclude(
            production_country_list__icontains='Poland').exclude(
                production_country_list__icontains='Polska')
        film_ids = film_ids.order_by(
            '-popularity')[:MAX_RECOMMENDATIONS_NUMBER]
        film_ids = list(film_ids)
        cache.set(key, film_ids)

    recommendations = [
        s
        for s in engine.compute_guess_score_for_films(user, film_ids).items()
        if s[1]
    ]
    recommendations = sorted(recommendations, key=lambda s: -s[1])

    return recommendations
コード例 #8
0
ファイル: rating_helper.py プロジェクト: thuvh/filmmaster
 def delete_from_tag_basket(cls, user, id, tag):
     basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)
     tag_basket = cache.get(basket_key) or dict()
     if id in tag_basket:
         tag_basket.pop(id)
     cache.set(basket_key, tag_basket, cache.A_MONTH)
     defer(cls.refill_tag_basket, user, tag)
コード例 #9
0
ファイル: regional_info.py プロジェクト: thuvh/filmmaster
def regional_info(context):
    """
        Display local info
    """

    slug_city = None
    slug_region = None

    request = context['request']
    user = request.user
    if user.is_authenticated():
        profile = user.get_profile()
        try:
            slug_city = slughifi(profile.location)
        except AttributeError:
            slug_city = None
            

    if not slug_city:
        try:
            city = request.city
        except AttributeError:
            city = None

        slug_city = city and slughifi(city) or None
        
    key = cache.Key(CACHE_REGIONAL_INFO, slug_city)
    regional_info_obj = cache.get(key)

    if regional_info_obj is None and slug_city is not None:
        regional_info_obj = get_regional_info_obj(slug_city)
        cache.set(key, regional_info_obj)
        
    return {'regional_info': regional_info_obj,}
コード例 #10
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_screening_set(self, past=False):
     key = cache.Key("festival_screening_set", self, past)
     screening_set = cache.get(key)
     if screening_set is None:
         screening_set = FestivalScreeningSet(self, past=past)
         cache.set(key, screening_set)
     return screening_set
コード例 #11
0
ファイル: utils.py プロジェクト: manlan2/filmaster
def get_country_and_tz_by_lat_lng(lat, lng):
    key = cache.Key('country_tz', lat, lng)
    data = cache.get(key)
    if data is None:
        data = _get_country_and_tz_by_lat_lng(lat, lng)
        cache.set(key, data)
    return data
コード例 #12
0
ファイル: regional_info.py プロジェクト: manlan2/filmaster
def regional_info(context):
    """
        Display local info
    """

    slug_city = None
    slug_region = None

    request = context['request']
    user = request.user
    if user.is_authenticated():
        profile = user.get_profile()
        try:
            slug_city = slughifi(profile.location)
        except AttributeError:
            slug_city = None

    if not slug_city:
        try:
            city = request.city
        except AttributeError:
            city = None

        slug_city = city and slughifi(city) or None

    key = cache.Key(CACHE_REGIONAL_INFO, slug_city)
    regional_info_obj = cache.get(key)

    if regional_info_obj is None and slug_city is not None:
        regional_info_obj = get_regional_info_obj(slug_city)
        cache.set(key, regional_info_obj)

    return {
        'regional_info': regional_info_obj,
    }
コード例 #13
0
ファイル: utils.py プロジェクト: thuvh/filmmaster
def get_country_and_tz_by_lat_lng(lat, lng):
    key = cache.Key('country_tz', lat, lng)
    data = cache.get(key)
    if data is None:
        data = _get_country_and_tz_by_lat_lng(lat, lng)
        cache.set(key, data)
    return data
コード例 #14
0
ファイル: widgets.py プロジェクト: thuvh/filmmaster
def latest_ratings():
    """
        Widget for main page (for unregistered users)
        displaying X random ratings by Filmaster users.
    """

    key = cache.Key("latest_ratings")
    ratings = cache.get(key)

    NUMBER_OF_LATEST_RATINGS = getattr(settings,
            'NUMBER_OF_LATEST_RATINGS', 10)
    NUMBER_OF_RATINGS_AT_MAIN_PAGE = getattr(settings,
            'NUMBER_OF_RATINGS_AT_MAIN_PAGE', 4)

    if not ratings:
        ratings = UserActivity.objects.all_ratings().\
                order_by('-created_at')[:NUMBER_OF_LATEST_RATINGS]
        cache.set(key, ratings, cache.A_DAY)

    try:
        ratings = random.sample(ratings, NUMBER_OF_RATINGS_AT_MAIN_PAGE)
    except ValueError:
        ratings = ratings[:NUMBER_OF_RATINGS_AT_MAIN_PAGE]

    return {'activities': ratings, }
コード例 #15
0
    def get_films_to_rate(self, number_of_films=1, tag=None):
        key = cache.Key("vue_rater_user_films", self.user)
        user_films = cache.get(key)
        if user_films is None:
            user_films = vue.get_ordered_known_film_ids()
            if self.SHUFFLE_BLOCK_SIZE:
                shuffled = []
                while user_films:
                    block = user_films[:self.SHUFFLE_BLOCK_SIZE]
                    user_films = user_films[self.SHUFFLE_BLOCK_SIZE:]
                    random.shuffle(block)
                    shuffled.extend(block)
                user_films = shuffled
            cache.set(key, user_films)

        excluded = self.get_excluded_films()

        out = []
        for film_id in user_films:
            if film_id not in excluded:
                out.append(film_id)
            if len(out) >= number_of_films:
                break
        out = [Film.get(id=id) for id in out]
        return out
コード例 #16
0
    def get_films_to_rate(self, number_of_films=1, tag=None):
        key = cache.Key("vue_rater_user_films", self.user)
        user_films = cache.get(key)
        if user_films is None:
            user_films = vue.get_ordered_known_film_ids()
            if self.SHUFFLE_BLOCK_SIZE:
                shuffled = []
                while user_films:
                    block = user_films[:self.SHUFFLE_BLOCK_SIZE]
                    user_films = user_films[self.SHUFFLE_BLOCK_SIZE:]
                    random.shuffle(block)
                    shuffled.extend(block)
                user_films = shuffled
            cache.set(key, user_films)

        excluded = self.get_excluded_films()

        out = []
        for film_id in user_films:
            if film_id not in excluded:
                out.append(film_id)
            if len(out) >= number_of_films:
                break
        out = [Film.get(id=id) for id in out]
        return out
コード例 #17
0
ファイル: widgets.py プロジェクト: thuvh/filmmaster
def latest_checkins():
    """
        Widget for main page (for unregistered users) displaying X
        random check-ins by Filmaster users.
    """
    key = cache.Key("latest-checkins")
    latest = cache.get(key)

    NUMBER_OF_LATEST_CHECKINS = getattr(settings,
            'NUMBER_OF_LATEST_CHECKINS', 10)
    NUMBER_OF_CHECKINS_AT_MAIN_PAGE = getattr(settings,
            'NUMBER_OF_CHECKINS_AT_MAIN_PAGE', 4)

    if not latest:

        now = datetime.now()
        ago = now - timedelta(hours=3)
        checkins = UserActivity.objects.all_checkins().order_by('-created_at')

        latest = list(checkins.filter(created_at__gte=ago)[:NUMBER_OF_LATEST_CHECKINS])
        if len(latest) < NUMBER_OF_CHECKINS_AT_MAIN_PAGE:
            latest = list(checkins)[:NUMBER_OF_LATEST_CHECKINS]

        cache.set(key, latest, cache.CACHE_HOUR * 3)

    try:
        latest = random.sample(latest, NUMBER_OF_CHECKINS_AT_MAIN_PAGE)
    except ValueError:
        latest = latest[:NUMBER_OF_CHECKINS_AT_MAIN_PAGE]

    return {'activities': latest, }
コード例 #18
0
ファイル: models.py プロジェクト: yangjiandong/filmaster
 def get_screening_set(self, past=False):
     key = cache.Key("festival_screening_set", self, past)
     screening_set = cache.get(key)
     if screening_set is None:
         screening_set = FestivalScreeningSet(self, past=past)
         cache.set(key, screening_set)
     return screening_set
コード例 #19
0
ファイル: widgets.py プロジェクト: manlan2/filmaster
def latest_checkins():
    """
        Widget for main page (for unregistered users) displaying X
        random check-ins by Filmaster users.
    """
    key = cache.Key("latest-checkins")
    latest = cache.get(key)

    NUMBER_OF_LATEST_CHECKINS = getattr(settings, 'NUMBER_OF_LATEST_CHECKINS',
                                        10)
    NUMBER_OF_CHECKINS_AT_MAIN_PAGE = getattr(
        settings, 'NUMBER_OF_CHECKINS_AT_MAIN_PAGE', 4)

    if not latest:

        now = datetime.now()
        ago = now - timedelta(hours=3)
        checkins = UserActivity.objects.all_checkins().order_by('-created_at')

        latest = list(
            checkins.filter(created_at__gte=ago)[:NUMBER_OF_LATEST_CHECKINS])
        if len(latest) < NUMBER_OF_CHECKINS_AT_MAIN_PAGE:
            latest = list(checkins)[:NUMBER_OF_LATEST_CHECKINS]

        cache.set(key, latest, cache.CACHE_HOUR * 3)

    try:
        latest = random.sample(latest, NUMBER_OF_CHECKINS_AT_MAIN_PAGE)
    except ValueError:
        latest = latest[:NUMBER_OF_CHECKINS_AT_MAIN_PAGE]

    return {
        'activities': latest,
    }
コード例 #20
0
ファイル: widgets.py プロジェクト: manlan2/filmaster
def latest_ratings():
    """
        Widget for main page (for unregistered users)
        displaying X random ratings by Filmaster users.
    """

    key = cache.Key("latest_ratings")
    ratings = cache.get(key)

    NUMBER_OF_LATEST_RATINGS = getattr(settings, 'NUMBER_OF_LATEST_RATINGS',
                                       10)
    NUMBER_OF_RATINGS_AT_MAIN_PAGE = getattr(settings,
                                             'NUMBER_OF_RATINGS_AT_MAIN_PAGE',
                                             4)

    if not ratings:
        ratings = UserActivity.objects.all_ratings().\
                order_by('-created_at')[:NUMBER_OF_LATEST_RATINGS]
        cache.set(key, ratings, cache.A_DAY)

    try:
        ratings = random.sample(ratings, NUMBER_OF_RATINGS_AT_MAIN_PAGE)
    except ValueError:
        ratings = ratings[:NUMBER_OF_RATINGS_AT_MAIN_PAGE]

    return {
        'activities': ratings,
    }
コード例 #21
0
def count_guessed_rate(user, film):
    ratings = Rating.get_user_ratings(user)
    logger.info("counting guessed rate for film %d", film.id)

    if len(ratings) < MIN_USER_RATES:
        return None

    average_rate, average_weight = AVERAGE_RATE, AVERAGE_WEIGHT

    film_weight = 0.0
    film_rate = film.average_score() or 0.0
    film_rate = float(film_rate)

    if film_rate:
        film_weight = FILM_WEIGHT * pow(
                float(film.number_of_votes() / FILM_RELIABILITY_BAR), 0.3)

    user_rate = sum(ratings.values()) / len(ratings)
    user_weight = USER_WEIGHT * (len(ratings) / USER_RELIABILITY_BAR) ** 0.3

#    film_ids = ratings.keys()
#    scores = dict(FilmComparator.objects.filter(
#            main_film=film, compared_film__id__in=film_ids).\
#            values_list('compared_film', 'score'))

    key = cache.Key("compared_films", film.id)
    scores = cache.get(key)
    if scores is None:
        query = FilmComparator.objects.filter(main_film=film).values_list(
                    'compared_film', 'score')
        scores = dict((f, float(s)) for (f, s) in query)
        cache.set(key, scores)


    sum_weights = 0.0
    sum_rate = 0.0
    for film_id, rating in ratings.items():
        if film_id in scores:
            weight = float(scores[film_id])
            sum_weights += weight
            sum_rate += float(rating) * weight

    sum_rate += film_weight * film_rate + user_weight * user_rate
    sum_rate += average_weight * average_rate
    sum_weights += film_weight + user_weight + average_weight
    recommendation = None
    if sum_weights > 0.0 and sum_rate >= 0.0:
        score = Decimal(str(sum_rate / sum_weights))
        if score <= 10:
            recommendation, created = Recommendation.objects.get_or_create(
                user=user, 
                film=film,
                defaults=dict(guess_rating_alg2=score),
            )
            if not created:
                recommendation.guess_rating_alg2 = score
                recommendation.save()
    # transaction.commit()
    return recommendation
コード例 #22
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_open_festivals(self):
     key = cache.Key("open_festivals")
     festivals = cache.get(key)
     if festivals is None:
         festivals = Festival.objects.filter(event_status=self.STATUS_OPEN)
         festivals = list(festivals)
         cache.set(key, festivals)
     return festivals
コード例 #23
0
ファイル: fragments.py プロジェクト: thuvh/filmmaster
    def get_fragments( self ):
        key = cache.Key( "fragments-set-%s" % self.key )
        fragments = cache.get( key )
        if fragments is None:
            fragments = Fragment.objects.filter( key=self.key )
            cache.set( key, fragments, cache.A_MONTH )

        return fragments
コード例 #24
0
 def __init__(self, queryset, page_size):
     self.queryset = queryset.order_by('id')
     key = cache.Key("sitemap_paginator", str(self.queryset.query))
     self.ids = cache.get(key)
     if self.ids is None:
         self.ids = list(self.queryset.values_list('id', flat=True))[::page_size]
         cache.set(key, self.ids)
     self.num_pages = len(self.ids)
コード例 #25
0
ファイル: fragments.py プロジェクト: manlan2/filmaster
    def get_fragments(self):
        key = cache.Key("fragments-set-%s" % self.key)
        fragments = cache.get(key)
        if fragments is None:
            fragments = Fragment.objects.filter(key=self.key)
            cache.set(key, fragments, cache.A_MONTH)

        return fragments
コード例 #26
0
ファイル: models.py プロジェクト: yangjiandong/filmaster
 def get_open_festivals(self):
     key = cache.Key("open_festivals")
     festivals = cache.get(key)
     if festivals is None:
         festivals = Festival.objects.filter(event_status = self.STATUS_OPEN)
         festivals = list(festivals)
         cache.set(key, festivals)
     return festivals
コード例 #27
0
 def get_related_film_ids(self, film_id):
     key = self.cache_key("rater_related_films", film_id)
     related = cache.get(key)
     if related is None:
         film = Film.objects.get(id=film_id)
         related = list(film.get_related_films().values_list('id', flat=True)[:self.NUMBER_OF_FILMS_RELATED])
         cache.set(key, related)
     return related
コード例 #28
0
ファイル: rating_helper.py プロジェクト: thuvh/filmmaster
    def delete_film_from_baskets_by_id(cls, user, film_id):
        # delete from tag baskets
        for tag in settings.BASKETS_TAGS_LIST:
            cls.delete_from_tag_basket(user, film_id, tag)

        # delete from regular basket
        rating_basket_key = cache.Key(cache.CACHE_USER_BASKET, user)
        rating_basket = cache.get(rating_basket_key) or set()
        rating_basket.discard(film_id)
        cache.set(rating_basket_key, rating_basket, cache.A_MONTH)

        # delete from special basket
        special_rating_basket_key = cache.Key(cache.CACHE_SPECIAL_USER_BASKET,
                user)
        special_rating_basket = cache.get(special_rating_basket_key) or set()
        special_rating_basket.discard(film_id)
        cache.set(special_rating_basket_key, special_rating_basket, cache.A_MONTH)
コード例 #29
0
ファイル: models.py プロジェクト: yangjiandong/filmaster
 def get_films(self):
     key = cache.Key("festival_films", self)
     films = cache.get(key)
     if films is None:
         films = Film.objects.tagged(self.tag.lower())
         films = list(films[:1000])
         Film.update_ranking(films)
         cache.set(key, films)
     return films
コード例 #30
0
ファイル: models.py プロジェクト: yangjiandong/filmaster
 def get_theaters(self):
     key = cache.Key("festival_theaters", self)
     theaters = cache.get(key)
     if theaters is None:
         from film20.tagging.models import TaggedItem
         channels = self.theaters.all()
         theaters = list(Channel.objects.theaters().filter(id__in=channels))
         cache.set(key, theaters)
     return theaters
コード例 #31
0
 def __init__(self, queryset, page_size):
     self.queryset = queryset.order_by('id')
     key = cache.Key("sitemap_paginator", str(self.queryset.query))
     self.ids = cache.get(key)
     if self.ids is None:
         self.ids = list(self.queryset.values_list('id',
                                                   flat=True))[::page_size]
         cache.set(key, self.ids)
     self.num_pages = len(self.ids)
コード例 #32
0
 def get_unliked_film_ids(cls, user):
     if not user.id:
         return ()
     key = cache.Key("unliked_recommendations", user.id)
     ret = cache.get(key)
     if ret is None:
         ret = cls.objects.filter(user=user, vote=0).values_list('film_id', flat=True)
         cache.set(key, ret)
     return ret
コード例 #33
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_theaters(self):
     key = cache.Key("festival_theaters", self)
     theaters = cache.get(key)
     if theaters is None:
         from film20.tagging.models import TaggedItem
         channels = self.theaters.all()
         theaters = list(Channel.objects.theaters().filter(id__in=channels))
         cache.set(key, theaters)
     return theaters
コード例 #34
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_films(self):
     key = cache.Key("festival_films", self)
     films = cache.get(key)
     if films is None:
         films = Film.objects.tagged(self.tag.lower())
         films = list(films[:1000])
         Film.update_ranking(films)
         cache.set(key, films)
     return films
コード例 #35
0
ファイル: email_backend.py プロジェクト: thuvh/filmmaster
 def get_user(self, user_id):
     key = cache.Key("user", user_id)
     user = settings.CACHED_USERS and cache.get(key) or None
     if not user:
         try:
             user = super(CachedModelBackend, self).get_user(user_id)
             cache.set(key, user)
         except User.DoesNotExist, e:
             pass
コード例 #36
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def matching_film_ids(self, include_ids, exclude_ids):
     key = cache.Key("features_film_ids", include_ids, exclude_ids)
     film_ids = cache.get(key)
     if film_ids is None:
         film_ids = Film.objects.filter(features__type__in=include_ids)
         if exclude_ids:
             film_ids = film_ids.exclude(features__type__in=exclude_ids)
         film_ids = set(film_ids.values_list('id', flat=True))
         cache.set(key, film_ids)
     return film_ids
コード例 #37
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_unliked_film_ids(cls, user):
     if not user.id:
         return ()
     key = cache.Key("unliked_recommendations", user.id)
     ret = cache.get(key)
     if ret is None:
         ret = cls.objects.filter(user=user, vote=0).values_list('film_id',
                                                                 flat=True)
         cache.set(key, ret)
     return ret
コード例 #38
0
 def get_user(self, user_id):
     key = cache.Key("user", user_id)
     user = settings.CACHED_USERS and cache.get(key) or None
     if not user:
         try:
             user = super(CachedModelBackend, self).get_user(user_id)
             if settings.CACHED_USERS:
                 cache.set(key, user)
         except User.DoesNotExist, e:
             pass
コード例 #39
0
def count_guessed_rate(user, film):
    ratings = Rating.get_user_ratings(user)
    logger.info("counting guessed rate for film %d", film.id)

    if len(ratings) < MIN_USER_RATES:
        return None

    average_rate, average_weight = AVERAGE_RATE, AVERAGE_WEIGHT

    film_weight = 0.0
    film_rate = film.average_score() or 0.0
    film_rate = float(film_rate)

    if film_rate:
        film_weight = FILM_WEIGHT * pow(float(film.number_of_votes() / FILM_RELIABILITY_BAR), 0.3)

    user_rate = sum(ratings.values()) / len(ratings)
    user_weight = USER_WEIGHT * (len(ratings) / USER_RELIABILITY_BAR) ** 0.3

    #    film_ids = ratings.keys()
    #    scores = dict(FilmComparator.objects.filter(
    #            main_film=film, compared_film__id__in=film_ids).\
    #            values_list('compared_film', 'score'))

    key = cache.Key("compared_films", film.id)
    scores = cache.get(key)
    if scores is None:
        query = FilmComparator.objects.filter(main_film=film).values_list("compared_film", "score")
        scores = dict((f, float(s)) for (f, s) in query)
        cache.set(key, scores)

    sum_weights = 0.0
    sum_rate = 0.0
    for film_id, rating in ratings.items():
        if film_id in scores:
            weight = float(scores[film_id])
            sum_weights += weight
            sum_rate += float(rating) * weight

    sum_rate += film_weight * film_rate + user_weight * user_rate
    sum_rate += average_weight * average_rate
    sum_weights += film_weight + user_weight + average_weight
    recommendation = None
    if sum_weights > 0.0 and sum_rate >= 0.0:
        score = Decimal(str(sum_rate / sum_weights))
        if score <= 10:
            recommendation, created = Recommendation.objects.get_or_create(
                user=user, film=film, defaults=dict(guess_rating_alg2=score)
            )
            if not created:
                recommendation.guess_rating_alg2 = score
                recommendation.save()
    # transaction.commit()
    return recommendation
コード例 #40
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def check_answer(self, serv_tstamp):
        question_key = cache.Key("answer_", self.request.unique_user)
        question = cache.get(question_key)

        if question:
            answer = question.get('answer', '')
            choice = int(self.request.POST.get('choice', 0))
            user_tstamp = float(self.request.POST.get('tstamp'))
            if answer == choice:
                self.count_points(user_tstamp, serv_tstamp)
        cache.delete(question_key)
コード例 #41
0
def get_vue_film_ids(skip_cache=False):
    key = cache_key("vue_film_ids")
    ids = cache.get(key)
    if not skip_cache and ids is not None:
        return ids
    ids = Film.objects.tagged('vue2012').values_list('id', flat=True)
    if len(ids) < 50:
        ids = Film.objects.all().order_by('-popularity').values_list('id', flat=True)[:150]
    ids = set(ids)
    cache.set(key, ids)
    return ids
コード例 #42
0
def compute_guess_score_for_all_films(user):
    if not hasattr(user, '_guess_score'):
        key = cache.Key("guess_score", user.id)
        user._guess_score = cache.get(key)
        if user._guess_score is None:
            from film20.core.models import Recommendation
            items = Recommendation.objects.filter(user=user.id)
            items = items.values_list('film_id', 'guess_rating_alg2')
            user._guess_score = dict((r[0], float(r[1])) for r in items)
        cache.set(key, user._guess_score)
    return user._guess_score
コード例 #43
0
def get_vue_film_ids(skip_cache=False):
    key = cache_key("vue_film_ids")
    ids = cache.get(key)
    if not skip_cache and ids is not None:
        return ids
    ids = Film.objects.tagged('vue2012').values_list('id', flat=True)
    if len(ids) < 50:
        ids = Film.objects.all().order_by('-popularity').values_list(
            'id', flat=True)[:150]
    ids = set(ids)
    cache.set(key, ids)
    return ids
コード例 #44
0
ファイル: handlers.py プロジェクト: manlan2/filmaster
 def to_recommend_ids(self, request):
     tag = request.GET.get('tag')
     key = cache.Key('saas_to_recommend_ids', tag)
     film_ids = cache.get(key)
     if film_ids is None:
         if tag:
             film_ids = Film.objects.tagged(tag)
         else:
             film_ids = Film.objects.filter(popularity__gt=20)
         film_ids = list(film_ids.values_list('id', flat=True))
         cache.set(key, film_ids)
     return film_ids
コード例 #45
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def count_points(self, user_tstamp, serv_tstamp):
        quiz_points_key = cache.Key("points_", self.request.unique_user)
        quiz_points = cache.get(quiz_points_key)
        cache.delete(quiz_points_key)

        if not quiz_points:
            quiz_points = 0

        tdelta = serv_tstamp - user_tstamp
        tdelta = int(round(tdelta))

        quiz_points += settings.FBAPP.get('points').get('seconds').get(tdelta, 0)
        cache.set(quiz_points_key, quiz_points)
        return quiz_points
コード例 #46
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def add_points(self):
        quiz_points_key = cache.Key("points_", self.request.unique_user)
        quiz_points = cache.get(quiz_points_key)

        contest = self.get_contest()
        participant = ContestParticipation.objects.get(user=self.request.unique_user, contest=contest)

        if participant.state == ContestParticipation.STATE_TICKET:
            participant.quiz_count = quiz_points
            participant.score += quiz_points
            participant.state = ContestParticipation.STATE_QUIZ
            participant.save()
        cache.delete(quiz_points_key)
        return participant.score
コード例 #47
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def get(self, *args, **kw):
        context = self.get_context_data()

        contest = self.get_contest()
        participant = ContestParticipation.objects.get(user=self.request.unique_user, contest=contest)
        if participant.state >= ContestParticipation.STATE_QUIZ:
            return http.HttpResponseRedirect(self.get_next_step())

        key = cache.Key("questions_", self.request.unique_user)
        questions = cache.get(key)
        if not questions:
            questions = self.quiz_mixer()        
            cache.set(key, questions)
        return render(self.request, self.on_start, context)
コード例 #48
0
ファイル: views.py プロジェクト: manlan2/filmaster
    def get_contest( self ):
        contest_key = cache.Key("contest")
        contest = cache.get(contest_key)
        if not contest:
            try:
                contest = Contest.objects.get(state=Contest.STATE_OPEN)
            except Contest.DoesNotExist:
                contest = Contest.objects.all().order_by('-final_date')[0]

            if contest.final_date < datetime.date.today():
                contest.state = Contest.STATE_CLOSED
                contest.save()
                contest = Contest.objects.get(id=contest.id)
            cache.set(contest_key, contest)
        return contest
コード例 #49
0
ファイル: models.py プロジェクト: manlan2/filmaster
 def get_screenings_for(self, date):
     key = cache.Key("festival_screenings", self, date)
     screenings = cache.get(key)
     if screenings is None:
         channels = self.theaters.all()
         films = Film.objects.tagged(self.tag.lower())
         screenings = Screening.objects.filter(
             channel__in=channels,
             utc_time__gte=date,
             utc_time__lt=date + timedelta(days=1),
             film__film__in=films,
         ).order_by('utc_time')
         screenings = screenings.select_related('film', 'film__film',
                                                'channel')
         screenings = list(screenings)
         cache.set(key, screenings)
     return screenings
コード例 #50
0
def filmaster_recommends():
    """
        A widget displaying HTML from a selected flat page.
        Define this page in settings.py to FLATPAGE_FILMASTER_RECOMMENDS
    """
    key = cache.Key(FLATPAGE_FILMASTER_RECOMMENDS)

    flat_page = cache.get(key)

    if flat_page is None:
        try:
            flat_page = FlatPage.objects.get(url=FLATPAGE_FILMASTER_RECOMMENDS)
        except FlatPage.DoesNotExist:
            flat_page = False
        cache.set(key, flat_page, cache.A_DAY)

    return {'flat_page': flat_page}
コード例 #51
0
ファイル: widgets.py プロジェクト: manlan2/filmaster
def main_page_activity_list(context):
    """
        Widget for main page (for not logged in users)
        Displays list of recent activities on Filmaster.
    """

    key = cache.Key("main_page_activities_displayed")

    displayed_activities = cache.get(key)
    if not displayed_activities:
        uahelper = UserActivityHelper()
        displayed_activities = uahelper.main_page_featured_activities()
        cache.set(key, displayed_activities, cache.CACHE_HOUR)

    return {
        'activities': displayed_activities,
        'request': context.get('request'),
    }
コード例 #52
0
ファイル: fbconnect.py プロジェクト: manlan2/filmaster
def invite_box(context):
    request = context['request']
    assoc = None
    friends = []
    if request.user.is_authenticated():
        try:
            assoc = FBAssociation.objects.select_related('fb_user').get(
                user=request.user)
            if assoc.fb_user_id:
                key = cache.Key("some_fb_friends", assoc.fb_user_id)
                friends = cache.get(key)
                if friends is None:
                    friends = assoc.fb_user.friends
                    friends = list(
                        friends.exclude(
                            fbassociation__isnull=False).order_by('?')[0:100])
                    cache.set(key, friends)
        except FBAssociation.DoesNotExist, e:
            pass
コード例 #53
0
def get_similar_films(skip_cache=False):
    """
    returns dict(film_id, set(similar_films))
    """

    key = cache_key("similar_films")
    ret = cache.get(key)
    if not skip_cache and ret is not None:
        return ret

    q = SimilarFilm.objects.all()
    q = q.exclude(film_a__production_country_list__icontains='Poland').exclude(
        film_a__production_country_list__icontains='Polska')
    gr = itertools.groupby(q.order_by('film_b'), key=lambda s: s.film_b_id)
    d = dict((id, set(f.film_a_id for f in items)) for (id, items) in gr)

    cache.set(key, d)

    return d