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 []
def rate(user, value, film_id=None, actor_id=None, director_id=None, type=1, overwrite=True, check_if_exists=False, redis_only=False, skip_activity=False, **kw): if not user.id and hasattr(user, 'store_to_db'): # temporary anonymouse user, store to db on first rating user.store_to_db() assert user.id if not redis_only or not settings.USE_REDIS: if not settings.USE_REDIS: ret = Rating.rate(user, value, film_id, actor_id, director_id, type, overwrite=overwrite, _skip_activity=skip_activity, **kw) else: defer(Rating.rate, user, value, film_id, actor_id, director_id, type, overwrite=overwrite, _skip_activity=skip_activity, **kw) if settings.USE_REDIS: ret = redis_intf.rate(user.id, value, film_id, actor_id, director_id, type, overwrite=overwrite, check_if_exists=check_if_exists) profile = user.get_profile() no_rec = profile.recommendations_status == profile.NO_RECOMMENDATIONS if settings.RECOMMENDATIONS_ENGINE == 'film20.new_recommendations.recommendations_engine': engine.compute_user_features(user) if no_rec: profile.recommendations_status = profile.FAST_RECOMMENDATIONS profile.save() else: if no_rec and len(get_user_ratings(user.id)) >= settings.RECOMMENDATIONS_MIN_VOTES_USER: engine.compute_user_features(user, True, initial=True) profile.recommendations_status = profile.FAST_RECOMMENDATIONS profile.save() return ret
def queue(users, label, extra_context=None, on_site=True, priority=PRIORITY_DEFAULT): """ Queue the notification in NoticeQueueBatch. This allows for large amounts of user notifications to be deferred to a seperate process running outside the webserver. """ if extra_context is None: extra_context = {} user_ids = [user.pk for user in users] key = lambda u: u[1] userids_w_lang = [(u.pk, get_notification_language(u, label)) for u in users] userids_w_lang = sorted(userids_w_lang, key=key) from itertools import groupby for lang, userids in groupby(userids_w_lang, key=key): ids = list(u[0] for u in userids) defer( _send_now, ids, label, extra_context, on_site, _routing_key="%s%s.notice" % (settings.CELERY_QUEUE_PREFIX, lang), )
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)
def compute_user_features(user, save=False, initial=False): if initial: profile = user.get_profile() no_recommendations = (profile.recommendations_status == profile.NO_RECOMMENDATIONS) if no_recommendations: profile.recommendations_status = profile.FAST_RECOMMENDATIONS_WAITING profile.save() from film20.core.deferred import defer defer(_compute_fast_recommendations, user, no_recommendations)
def fb_like(request): url = request.POST.get('url') content_type = request.POST.get('content_type') object_id = request.POST.get('object_id') if not (url and content_type and object_id): return HttpResponse(status=400) defer(LikeCounter.update, url, content_type, object_id) return HttpResponse('ok')
def fb_like(request): url = request.POST.get('url') content_type=request.POST.get('content_type') object_id = request.POST.get('object_id') if not (url and content_type and object_id): return HttpResponse(status=400) defer(LikeCounter.update, url, content_type, object_id) return HttpResponse('ok')
def send_notice(self, user, type, context): if getattr(settings, 'NOTIFICATION_QUEUE_ALL', False): from film20.core.deferred import defer key = '%s%s.notice.%s.%s' % ( settings.CELERY_QUEUE_PREFIX, settings.LANGUAGE_CODE, self.name, type.label ) logger.debug('notice %r to %s queued to send via %s', type.label, user, self.name) defer(self._send_notice_impl, user, type, context, _routing_key=key) else: try: self._send_notice_impl(user, type, context) except Exception, e: pass
def send_notice(self, user, type, context, now=False): if getattr(settings, 'NOTIFICATION_QUEUE_ALL', False) and not now: from film20.core.deferred import defer key = '%s%s.notice.%s.%s' % (settings.CELERY_QUEUE_PREFIX, settings.LANGUAGE_CODE, self.name, type.label) logger.debug('notice %r to %s queued to send via %s', type.label, user, self.name) defer(self._send_notice_impl, user, type, context, _routing_key=key) else: try: self._send_notice_impl(user, type, context) except Exception, e: pass
def delete_film_from_baskets_by_id(self, user, film_id): # delete from tag baskets for tag in self.BASKETS_TAGS_LIST: self.delete_from_tag_basket(user, film_id, tag) defer(self.refill_tag_baskets, user, self.BASKETS_TAGS_LIST) # delete from regular basket rating_basket_key = self.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 = self.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)
def compute_fast_recommendations(user_id, send_notice=True): from recom_helper import RecomHelper from film20.core.models import Recommendation from film20.showtimes.showtimes_helper import get_films from film20.showtimes.models import Channel from film20.showtimes.utils import get_today from itertools import chain import pytz helper = RecomHelper() user = User.objects.get(pk=user_id) profile = user.get_profile() for r in helper.get_ranking()[:settings.FAST_RECOMMENDATIONS_NUMBER_OF_TOP_FILMS]: count_guessed_rate(user, r.film) profile.recommendations_status = profile.FAST_RECOMMENDATIONS profile.save() from film20.core.deferred import defer defer(compute_fast_recommendations_phase2, user_id, send_notice)
def compute_fast_recommendations(user_id, send_notice=True): from recom_helper import RecomHelper from film20.core.models import Recommendation from film20.showtimes.showtimes_helper import get_films from film20.showtimes.models import Channel from film20.showtimes.utils import get_today from itertools import chain import pytz helper = RecomHelper() user = User.objects.get(pk=user_id) profile = user.get_profile() for r in helper.get_ranking()[: settings.FAST_RECOMMENDATIONS_NUMBER_OF_TOP_FILMS]: count_guessed_rate(user, r.film) profile.recommendations_status = profile.FAST_RECOMMENDATIONS profile.save() from film20.core.deferred import defer defer(compute_fast_recommendations_phase2, user_id, send_notice)
def post_save(cls, sender, instance, *args, **kw): from film20.import_ratings.import_ratings_helper import import_ratings defer(import_ratings)
def recompute_recommendations(user): if user.id: routing_key = "%s%s.recommendations" % (settings.CELERY_QUEUE_PREFIX, settings.LANGUAGE_CODE) defer(vue.recompute_recommendations, user, _routing_key=routing_key)
def post_commit(cls, sender, instance, created, *args, **kw): if created: from film20.core.deferred import defer defer(instance._sync_with_fb, instance.id)