Example #1
0
 def test_filter_regions(self):
     """
     [recommendation.filter.Region] Test a region filter on recommendation
     """
     rfilter = SimpleRegionFilter()
     recommendation = [random.random() for _ in range(len(ITEMS))]
     app_rec = [
         Item.get_item_by_id(aid + 1).external_id for aid, _ in sorted(
             enumerate(recommendation), key=lambda x: x[1], reverse=True)
     ]
     for u in USERS:
         user = User.get_user_by_external_id(u["external_id"])
         with self.assertNumQueries(0):
             result = rfilter(user, np.array(recommendation[:]))
         new_rec = [
             Item.get_item_by_id(aid + 1).external_id for aid, _ in sorted(
                 enumerate(result), key=lambda x: x[1], reverse=True)
         ]
         n = len(u["last_apps_region"])
         if n == 0:
             assert new_rec == app_rec, \
                 "Recommendation is not the same when not apps to filter(%s != %s)" % (new_rec, app_rec)
         else:
             for item in u["last_apps_region"]:
                 assert item in new_rec[0-n:], \
                     "Item %s for user %s is not in the last in recommendation %s. Items filtered %s." % \
                     (item, user, new_rec, list(u["last_apps_region"]))
Example #2
0
    def test_user_genres_in_recommendation_size_25(self):
        """
        [recommendation.api.GetRecommendation] At least 19 of the top genres in the size 25 recommendation
        """
        get_cache("default").clear()
        LogEntry.objects.all().delete()
        size = 25
        response = \
            self.client.get("/api/v2/recommend/%d/"
                            "00b65a359307654a7deee7c71a7563d2816d6b7e522377a66aaefe8848da5961/" % size)
        user_id = User.get_user_id_by_external_id("00b65a359307654a7deee7c71a7563d2816d6b7e522377a66aaefe8848da5961")

        user_genres = sorted(ItemGenre.genre_in(
            Item.get_item_by_id(item_id) for item_id in User.get_user_items(user_id)
        ).items(), key=lambda x: x[1], reverse=True)
        recommendation_genres = ItemGenre.genre_in(
            Item.get_item_by_external_id(item_eid) for item_eid in json.loads(response.content)["recommendations"]
        )
        measure = []
        for no, (genre, _) in enumerate(user_genres[:int(size)], start=1):
            if genre not in recommendation_genres:
                measure.append(no)
        assert len(measure) < 6, "Major genres failing by index: %s." \
                                 "\nUser %s" \
                                 "\nRecommendation %s" % (
            measure, user_genres, [ItemGenre.genre_in([Item.get_item_by_external_id(item)])
                                   for item in json.loads(response.content)["recommendations"]])
Example #3
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for language in LANGUAGES:
         Locale.objects.create(**language)
     for app in ITEMS:
         item = Item.objects.create(id=app["id"],
                                    name=app["name"],
                                    external_id=app["external_id"])
         for language in app["languages"]:
             l = Locale.objects.get(country_code=language)
             ItemLocale.objects.create(locale=l, item=item)
     for u in USERS:
         user = User.objects.create(id=u["id"],
                                    external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user,
                                      item=Item.get_item_by_external_id(i))
         for language in u["languages"]:
             l = Locale.objects.get(country_code=language)
             UserLocale.objects.create(locale=l, user=user)
     Item.load_to_cache()
     User.load_to_cache()
     Locale.load_to_cache()
Example #4
0
    def test_diversity_on_recommendation_25(self):
        """
        [recommendation.api.GetRecommendation] Test diversity for size 25 recommendation (at least 2/3 of user genres)
        """
        size = 25
        response = \
            self.client.get("/api/v2/recommend/%d/"
                            "00b65a359307654a7deee7c71a7563d2816d6b7e522377a66aaefe8848da5961/" % size)
        user_id = User.get_user_id_by_external_id("00b65a359307654a7deee7c71a7563d2816d6b7e522377a66aaefe8848da5961")
        user_genres = ItemGenre.genre_in(
            Item.get_item_by_id(item_id) for item_id in User.get_user_items(user_id)
        )
        recommendation_genres = ItemGenre.genre_in(
            Item.get_item_by_external_id(item_eid) for item_eid in json.loads(response.content)["recommendations"]
        )
        less, more = (user_genres, recommendation_genres) if len(user_genres) < len(recommendation_genres) else \
            (recommendation_genres, user_genres)
        measure = 0
        for genre in less:
            if genre in more:
                measure += 1

        assert measure > len(less)*2./3., \
            "Not sufficient genres in recommendation" \
            "(user: %d, recommendation: %d, similarity: %d)" % (len(user_genres), len(recommendation_genres), measure)
Example #5
0
 def test_owned_items(self):
     """
     [recommendation.models.User] Test owned items
     """
     for u in USERS:
         user = User.get_user_by_external_id(u["external_id"])
         for i in u["items"]:
             ivent = Inventory.objects.get(item=user.all_items[Item.get_item_by_external_id(i).pk], user=user)
             ivent.is_dropped = True
             ivent.save()
             assert Item.get_item_by_external_id(i).pk not in user.owned_items, \
                 "Item %s is in user %s owned items" % (i, user.external_id)
             ivent = Inventory.objects.get(item=user.all_items[Item.get_item_by_external_id(i).pk], user=user)
             ivent.is_dropped = False
             ivent.save()
Example #6
0
 def test_recommendation_update_user(self):
     """
     [recommendation.api.GetUserItems] Test update user items
     """
     response = self.client.put(
         "/api/v2/user-items/00504e6196ab5fa37ae7450dad99d031a80c50ef4b762c15151a2e4e92c64e0b/",
         '{"user_items": ["504343", "413346"]}',
         content_type="application/json"
     )
     sleep(0.8)
     user = User.get_user_by_external_id("00504e6196ab5fa37ae7450dad99d031a80c50ef4b762c15151a2e4e92c64e0b")
     assert response.status_code == 200, "Request failed. Status code %d." % response.status_code
     assert len(user.owned_items) == 2, "Owned items should be 3(%d)" % len(user.owned_items)
     assert Item.get_item_by_external_id("504343").pk in user.owned_items, "New item not in owned items"
     assert Item.get_item_by_external_id("413346").pk in user.owned_items, "New item not in owned items"
Example #7
0
    def get(self, request, user_external_id):
        """
        Get the users owned items. It receives an extra set of GET parameters. The offset and the items.

        The ´´offset´´ represents the amount of items to pass before start sending results.
        The ´´items´´ represents the amount of items to show.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A list of app external ids of the user owned (items that are in database with reference to this
         user and the dropped date set to null).
        """
        offset = int(request.GET.get("offset", 0))  # Offset of items
        number_of_items = int(request.GET.get("items",
                                              0))  # Number of items to present
        limit = (offset + number_of_items) or None
        user = User.get_user_by_external_id(user_external_id)
        try:
            items = [{
                "external_id": Item.get_item_external_id_by_id(item_id),
                "is_dropped": is_dropped
            } for item_id, is_dropped in User.get_user_items(user.pk).items()
                     [offset:limit]]
        except KeyError:
            return self.format_response(self.NOT_FOUND_ERROR_MESSAGE,
                                        status=NOT_FOUND_ERROR)

        data = {"user": user_external_id, "items": items}
        return self.format_response(data)
Example #8
0
    def get(self, request, user_external_id):
        """
        Get the users owned items. It receives an extra set of GET parameters. The offset and the items.

        The ´´offset´´ represents the amount of items to pass before start sending results.
        The ´´items´´ represents the amount of items to show.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A list of app external ids of the user owned (items that are in database with reference to this
         user and the dropped date set to null).
        """
        offset = int(request.GET.get("offset", 0))  # Offset of items
        number_of_items = int(request.GET.get("items", 0))  # Number of items to present
        limit = (offset+number_of_items) or None
        user = User.get_user_by_external_id(user_external_id)
        try:
            items = [
                {
                    "external_id": Item.get_item_external_id_by_id(item_id),
                    "is_dropped": is_dropped
                } for item_id, is_dropped in User.get_user_items(user.pk).items()[offset:limit]
            ]
        except KeyError:
            return self.format_response(self.NOT_FOUND_ERROR_MESSAGE, status=NOT_FOUND_ERROR)

        data = {"user": user_external_id, "items": items}
        return self.format_response(data)
Example #9
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     path = resource_filename(recommendation.__name__, "/")
     fill.FillTool({"items": True, "--mozilla": True, "prod": True}).load()
     fill.FillTool({"users": True, "--mozilla": True, "<path>": path+"data/user"}).load()
     modelcrafter.main("train", "popularity")
     modelcrafter.main("train", "tensorcofi")
     # Load user and items
     Item.load_to_cache()
     User.load_to_cache()
     # Load main models
     Popularity.load_to_cache()
     TensorCoFi.load_to_cache()
     cls.client = Client()
Example #10
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     logger = LogEvent(LogEvent.RECOMMEND)
     for app in ITEMS:
         Item.objects.create(**app)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
         for _ in range(3):
             recommendation = [Item.get_item_by_external_id(i).pk
                               for i in ("10001", "10002", "10003", "10004", "98766")]
             shuffle(recommendation)
             logger(lambda user: recommendation)(user=user)
     time.sleep(1.)
Example #11
0
 def test_get_item_by_external_id(self):
     """
     [recommendation.models.Item] Test queries by external id made by getting items and check integrity of that items
     """
     with self.assertNumQueries(0):
         for app in ITEMS:
             item = Item.get_item_by_external_id(app["external_id"])
             assert isinstance(item, Item), "Cached item is not instance of Item."
             assert item.name == app["name"], "Name of the app is not correct"
Example #12
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for region in REGIONS:
         Region.objects.create(**region)
     for app in ITEMS:
         item = Item.objects.create(id=app["id"], name=app["name"], external_id=app["external_id"])
         for region in app["regions"]:
             ItemRegion.objects.create(region=Region.objects.get(slug=region), item=item)
     for u in USERS:
         user = User.objects.create(id=u["id"], external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
         UserRegion.objects.create(region=Region.objects.get(slug=u["region"]), user=user)
     Item.load_to_cache()
     User.load_to_cache()
     Region.load_to_cache()
Example #13
0
 def test_user_items(self):
     """
     [recommendation.models.User] Test user items
     """
     for u in USERS:
         user = User.get_user_by_external_id(u["external_id"])
         for i in u["items"]:
             assert Item.get_item_by_external_id(i).pk in user.all_items, \
                 "Item %s is not in user %s" % (i, user.external_id)
Example #14
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for app in ITEMS:
         Item.objects.create(**app)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
Example #15
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for app in ITEMS:
         Item.objects.create(**app)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
Example #16
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     logger = LogEvent(LogEvent.RECOMMEND)
     for app in ITEMS:
         Item.objects.create(**app)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user,
                                      item=Item.get_item_by_external_id(i))
         for _ in range(3):
             recommendation = [
                 Item.get_item_by_external_id(i).pk
                 for i in ("10001", "10002", "10003", "10004", "98766")
             ]
             shuffle(recommendation)
             logger(lambda user: recommendation)(user=user)
     time.sleep(1.)
Example #17
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for language in LANGUAGES:
         Locale.objects.create(**language)
     for app in ITEMS:
         item = Item.objects.create(id=app["id"], name=app["name"], external_id=app["external_id"])
         for language in app["languages"]:
             l = Locale.objects.get(country_code=language)
             ItemLocale.objects.create(locale=l, item=item)
     for u in USERS:
         user = User.objects.create(id=u["id"], external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
         for language in u["languages"]:
             l = Locale.objects.get(country_code=language)
             UserLocale.objects.create(locale=l, user=user)
     Item.load_to_cache()
     User.load_to_cache()
     Locale.load_to_cache()
Example #18
0
 def test_click_logging(self):
     """
     [recommendation.decorator.SimpleLogger] Test if a clicked item is logged
     """
     logger = LogEvent(LogEvent.CLICK)
     user = User.get_user_by_external_id("joaonrb")
     logger(lambda uid, iid: None)(user, Item.get_item_by_external_id("10004"))
     time.sleep(1.)
     logs = list(LogEntry.objects.filter(user=user, type=logger.CLICK))
     assert len(logs) == 1, "Number of register is not correct %s" % logs
     assert "10004" == logs[0].item.external_id, \
         "The item in log is incorrect(1004 != %s)" % logs[0].item.external_id
Example #19
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     cls.df = pd.read_csv(resource_filename(testfm.__name__, "data/movielenshead.dat"), sep="::", header=None,
                          names=["user", "item", "rating", "date", "title"])
     for i, app in enumerate(ITEMS, start=1):
         Item.objects.create(pk=(i*2), **app)
     for i, u in enumerate(USERS, start=1):
         user = User.objects.create(pk=(i*2), external_id=u["external_id"])
         for item in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(item))
Example #20
0
 def test_acquire_logging(self):
     """
     [recommendation.decorator.SimpleLogger] Test if a acquired item is logged
     """
     logger = LogEvent(LogEvent.ACQUIRE)
     user = User.get_user_by_external_id("joaonrb")
     logger(lambda uid, iid: None)(user,
                                   Item.get_item_by_external_id("10004"))
     time.sleep(1.)
     logs = list(LogEntry.objects.filter(user=user, type=logger.ACQUIRE))
     assert len(logs) == 1, "Number of register is not correct %s" % logs
     assert "10004" == logs[0].item.external_id, \
         "The item in log is incorrect(1004 != %s)" % logs[0].item.external_id
Example #21
0
    def test_reranker_diversity(self):
        """
        [recommendation.diversity.ReRanker] Test a diversity re-ranker on recommendation
        """
        diversity = SimpleDiversityReRanker()
        recommendation = [Item.get_item_by_external_id(i).pk for i in ("10001", "10002", "10003", "10004", "98766")]
        shuffle(recommendation)
        for u in USERS:
            user = User.get_user_by_external_id(u["external_id"])
            with self.assertNumQueries(0):
                result = diversity(user=user, recommendation=recommendation[:], size=5)

            new_rec = [aid+1 for aid, _ in sorted(enumerate(result), key=lambda x: x[1], reverse=True)]
            assert len(result) == len(ITEMS), "Recommendation size changed (%d != %s)" % (len(new_rec), len(ITEMS))
Example #22
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for app in ITEMS:
         Item.objects.create(**app)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
     TensorCoFi.train_from_db()
     Popularity.train_from_db()
     TensorCoFi.load_to_cache()
     Popularity.load_to_cache()
Example #23
0
 def test_filter_regions(self):
     """
     [recommendation.filter.Region] Test a region filter on recommendation
     """
     rfilter = SimpleRegionFilter()
     recommendation = [random.random() for _ in range(len(ITEMS))]
     app_rec = [Item.get_item_by_id(aid+1).external_id
                for aid, _ in sorted(enumerate(recommendation), key=lambda x: x[1], reverse=True)]
     for u in USERS:
         user = User.get_user_by_external_id(u["external_id"])
         with self.assertNumQueries(0):
             result = rfilter(user, np.array(recommendation[:]))
         new_rec = [Item.get_item_by_id(aid+1).external_id
                    for aid, _ in sorted(enumerate(result), key=lambda x: x[1], reverse=True)]
         n = len(u["last_apps_region"])
         if n == 0:
             assert new_rec == app_rec, \
                 "Recommendation is not the same when not apps to filter(%s != %s)" % (new_rec, app_rec)
         else:
             for item in u["last_apps_region"]:
                 assert item in new_rec[0-n:], \
                     "Item %s for user %s is not in the last in recommendation %s. Items filtered %s." % \
                     (item, user, new_rec, list(u["last_apps_region"]))
Example #24
0
    def get_external_id_recommendations(self, user, n=10):
        """
        Returns the recommendations with a list of external_is's

        :param user: Same parameters that get_app_significance
        :param n:
        :return: Item external id list
        """
        try:
            user = User.get_user_by_external_id(user)
        except IndexError:
            logging.info("User %s not exist. Is going to be created")
            user = User.objects.create(external_id=user)
        result = self.get_recommendation(user=user, n=n)
        return [Item.get_item_external_id_by_id(r) for r in result]
Example #25
0
 def test_recommendation_acquire_new_item(self):
     """
     [recommendation.api.GetUserItems] Test acquire new item
     """
     user = User.get_user_by_external_id("00504e6196ab5fa37ae7450dad99d031a80c50ef4b762c15151a2e4e92c64e0b")
     items = user.owned_items
     response = self.client.post(
         "/api/v2/user-items/00504e6196ab5fa37ae7450dad99d031a80c50ef4b762c15151a2e4e92c64e0b/",
         {"item_to_acquire": "504343"}
     )
     sleep(0.8)
     assert response.status_code == 200, "Request failed. Status code %d." % response.status_code
     assert len(user.owned_items) == len(items)+1, "Owned items should be %d(%d)" % (len(items)+1,
                                                                                     len(user.owned_items))
     assert Item.get_item_by_external_id("504343").pk in user.owned_items.keys(), "New item not in owned items"
Example #26
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for region in REGIONS:
         Region.objects.create(**region)
     for app in ITEMS:
         item = Item.objects.create(id=app["id"],
                                    name=app["name"],
                                    external_id=app["external_id"])
         for region in app["regions"]:
             ItemRegion.objects.create(
                 region=Region.objects.get(slug=region), item=item)
     for u in USERS:
         user = User.objects.create(id=u["id"],
                                    external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user,
                                      item=Item.get_item_by_external_id(i))
         UserRegion.objects.create(
             region=Region.objects.get(slug=u["region"]), user=user)
     Item.load_to_cache()
     User.load_to_cache()
     Region.load_to_cache()
Example #27
0
 def test_recommendation_logging(self):
     """
     [recommendation.decorator.SimpleLogger] Test if a recommendation is logged
     """
     logger = LogEvent(LogEvent.RECOMMEND)
     user = User.get_user_by_external_id("joaonrb")
     recommendation = [Item.get_item_by_external_id(i).pk for i in ("10001", "10002", "10003", "10004", "98766")]
     recommendation = logger(lambda user: recommendation)(user=user)
     time.sleep(1.)
     logs = list(LogEntry.objects.filter(user=user, type=logger.RECOMMEND).order_by("value"))
     assert len(logs) == 5, "Number of register is not correct %s" % logs
     logs_iter = iter(logs)
     for i, item in enumerate(recommendation, start=1):
         log = logs_iter.next()
         assert item == log.item.pk, "The item in position %d is not the same that in recommendation " \
                                     "(%s != %s)" % (i, item, log.item.external_id)
         assert i == log.value, "The item in position %d do not have the right value. (%d)" % (i, log.value)
Example #28
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for genre in GENRES:
         Genre.objects.create(**genre)
     for app in ITEMS:
         item = Item.objects.create(name=app["name"], external_id=app["external_id"])
         for genre in app["genres"]:
             g = Genre.objects.get(name=genre)
             ItemGenre.objects.create(item=item, type=g)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user, item=Item.get_item_by_external_id(i))
     Genre.load_to_cache()
     ItemGenre.load_to_cache()
Example #29
0
    def delete(self, request, user_external_id):
        """
        removes an old item in the user installed apps. It should have a special POST parameter (besides the csrf token
        or other token needed to the connection) that is item_to_acquire.

        The ´´item_to_remove´´ is the item external id that is supposed to be removed in the user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            item_id = request.DATA["item_to_remove"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS, status=FORMAT_ERROR)

        self.remove_item(User.get_user_by_external_id(user_external_id), Item.get_item_by_external_id(item_id))
        return self.format_response(SUCCESS_MESSAGE)
Example #30
0
 def setup_class(cls, *args, **kwargs):
     """
     Put elements in db
     """
     for genre in GENRES:
         Genre.objects.create(**genre)
     for app in ITEMS:
         item = Item.objects.create(name=app["name"],
                                    external_id=app["external_id"])
         for genre in app["genres"]:
             g = Genre.objects.get(name=genre)
             ItemGenre.objects.create(item=item, type=g)
     for u in USERS:
         user = User.objects.create(external_id=u["external_id"])
         for i in u["items"]:
             Inventory.objects.create(user=user,
                                      item=Item.get_item_by_external_id(i))
     Genre.load_to_cache()
     ItemGenre.load_to_cache()
Example #31
0
    def post(self, request, user_external_id):
        """
        Inserts a new item in the user owned items. It should have a special POST parameter (besides the csrf token or
        other token needed to the connection - to development and presentation purposes the csrf was disabled) that is
        item_to_acquire.

        The ´´item_to_acquire´´ is the item external id that is supposed to be in the user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            item_id = request.POST["item_to_acquire"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS, status=FORMAT_ERROR)

        self.insert_acquisition(User.get_user_by_external_id(user_external_id), Item.get_item_by_external_id(item_id))
        return self.format_response(SUCCESS_MESSAGE)
Example #32
0
    def delete(self, request, user_external_id):
        """
        removes an old item in the user installed apps. It should have a special POST parameter (besides the csrf token
        or other token needed to the connection) that is item_to_acquire.

        The ´´item_to_remove´´ is the item external id that is supposed to be removed in the user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            item_id = request.DATA["item_to_remove"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS,
                                        status=FORMAT_ERROR)

        self.remove_item(User.get_user_by_external_id(user_external_id),
                         Item.get_item_by_external_id(item_id))
        return self.format_response(SUCCESS_MESSAGE)
Example #33
0
    def post(self, request, user_external_id):
        """
        Inserts a new item in the user owned items. It should have a special POST parameter (besides the csrf token or
        other token needed to the connection - to development and presentation purposes the csrf was disabled) that is
        item_to_acquire.

        The ´´item_to_acquire´´ is the item external id that is supposed to be in the user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            item_id = request.POST["item_to_acquire"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS,
                                        status=FORMAT_ERROR)

        self.insert_acquisition(User.get_user_by_external_id(user_external_id),
                                Item.get_item_by_external_id(item_id))
        return self.format_response(SUCCESS_MESSAGE)
Example #34
0
    def put(self, request, user_external_id):
        """
        Replaces all the user items with the list of given items.
        It should have a PUT body parameter items_to_acquire (besides the csrf token or
        other token needed to the connection - to development and presentation purposes the csrf was disabled) that is.

        The ´´items_to_acquire´´ is the list of items external ids that will become a new user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            items_ids = request.DATA["user_items"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS, status=FORMAT_ERROR)
        try:
            user = User.get_user_by_external_id(user_external_id)
        except User.DoesNotExist:
            user = User.objects.create(external_id=user_external_id)
        items = [Item.get_item_by_external_id(iid) for iid in items_ids]
        self.update_user_items(user, items)
        return self.format_response(SUCCESS_MESSAGE)
Example #35
0
 def test_recommendation_logging(self):
     """
     [recommendation.decorator.SimpleLogger] Test if a recommendation is logged
     """
     logger = LogEvent(LogEvent.RECOMMEND)
     user = User.get_user_by_external_id("joaonrb")
     recommendation = [
         Item.get_item_by_external_id(i).pk
         for i in ("10001", "10002", "10003", "10004", "98766")
     ]
     recommendation = logger(lambda user: recommendation)(user=user)
     time.sleep(1.)
     logs = list(
         LogEntry.objects.filter(user=user,
                                 type=logger.RECOMMEND).order_by("value"))
     assert len(logs) == 5, "Number of register is not correct %s" % logs
     logs_iter = iter(logs)
     for i, item in enumerate(recommendation, start=1):
         log = logs_iter.next()
         assert item == log.item.pk, "The item in position %d is not the same that in recommendation " \
                                     "(%s != %s)" % (i, item, log.item.external_id)
         assert i == log.value, "The item in position %d do not have the right value. (%d)" % (
             i, log.value)
Example #36
0
    def test_reranker_diversity_no_redundancy(self):
        """
        [recommendation.diversity.ReRanker] Test a diversity re-ranker on recommendation for non redundancy and loss
        """
        diversity = SimpleDiversityReRanker()
        recommendation = [
            Item.get_item_by_external_id(i).pk
            for i in ("10001", "10002", "10003", "10004", "98766")
        ]
        shuffle(recommendation)
        for u in USERS:
            user = User.get_user_by_external_id(u["external_id"])
            with self.assertNumQueries(0):
                result = diversity(user=user,
                                   recommendation=recommendation[:],
                                   size=5)

            new_rec = [
                aid + 1 for aid, _ in sorted(
                    enumerate(result), key=lambda x: x[1], reverse=True)
            ]
            assert len(set(result)) == len(
                ITEMS), "Recommendation size changed (%d != %s)" % (
                    len(new_rec), len(ITEMS))
Example #37
0
    def put(self, request, user_external_id):
        """
        Replaces all the user items with the list of given items.
        It should have a PUT body parameter items_to_acquire (besides the csrf token or
        other token needed to the connection - to development and presentation purposes the csrf was disabled) that is.

        The ´´items_to_acquire´´ is the list of items external ids that will become a new user inventory.

        :param request: The HTTP request.
        :param user_external_id: The user external id that are making the request.
        :return: A success response if the input was successful =p
        """
        try:
            items_ids = request.DATA["user_items"]
        except KeyError:
            return self.format_response(PARAMETERS_IN_MISS,
                                        status=FORMAT_ERROR)
        try:
            user = User.get_user_by_external_id(user_external_id)
        except User.DoesNotExist:
            user = User.objects.create(external_id=user_external_id)
        items = [Item.get_item_by_external_id(iid) for iid in items_ids]
        self.update_user_items(user, items)
        return self.format_response(SUCCESS_MESSAGE)
Example #38
0
 def get_item_locales(item_id):
     return set([
         pk[0] for pk in Item.get_item_by_id(
             item_id).locales.all().values_list("locale_id")
     ])
Example #39
0
    def fill_db_with_items(self, objects):
        """
        Put items in db
        """
        objs = []
        for obj in objects:
            if self.item_file_identifier_field in obj:
                obj[self.item_field] = str(obj[self.item_field])
                objs.append(obj)
        objects = objs
        json_items = {json_item[self.item_field]: json_item for json_item in objects}  # Map items for easy treatment

        items = {item.external_id: item for item in Item.objects.filter(external_id__in=json_items.keys())}
        new_items = {}
        categories = set([])
        locales = set([])
        regions = {}
        with click.progressbar(json_items.items(), label="Loading items") as bar:
            for item_eid, json_item in bar:
                if item_eid not in items:
                    try:
                        name = json_item["name"][json_item["default_locale"]]
                    except (KeyError, TypeError):
                        name = json_item.get("name", "NO NAME")
                    except UnicodeEncodeError as e:
                        logging.error(e)
                        name = "NO NAME"
                    new_items[item_eid] = Item(external_id=item_eid, name=name)

                # In case of json[self.item_genres_field] = None
                json_categories = json_item.get(self.item_genres_field, None) or ()
                if isinstance(json_categories, basestring):
                    categories.add(json_categories)
                else:
                    categories = categories.union(json_item[self.item_genres_field])

                # In case of json[self.item_locales_field] = None
                json_locales = json_item.get(self.item_locales_field, None) or ()
                if isinstance(json_locales, basestring):
                    locales.add(json_locales)
                else:
                    locales = locales.union(json_locales)
                for region in json_item.get("regions", None) or ():
                    try:
                        regions[region["name"]]["items"].append(item_eid)
                    except KeyError:
                        regions[region["name"]] = {"slug": region["slug"], "items": [item_eid]}
        #logging.debug("Items ready to be saved")
        Item.objects.bulk_create(new_items.values())
        #logging.debug("%d new items saved with bulk_create" % len(new_items))

        items.update({item.external_id: item for item in Item.objects.filter(external_id__in=json_items.keys())})

        assert len(items) == len(objects), \
            "Size of items and size of objects are different (%d != %d)" % (len(items), len(objects))

        if "recommendation.diversity" in settings.INSTALLED_APPS:
            #logging.debug("Preparing genres")
            db_categories = self.get_genres(categories)
            self.fill_item_genre(objects, items, db_categories)
            #logging.debug("Genres loaded")

        if "recommendation.language" in settings.INSTALLED_APPS:
            #logging.debug("Preparing languages")
            db_locales = self.get_locales(locales)
            db_regions = self.get_regions(regions)
            self.fill_item_locale(objects, items, db_locales)
            self.fill_item_region(regions, items, db_regions)
Example #40
0
 def get_item_locales(item_id):
     return set([pk[0] for pk in Item.get_item_by_id(item_id).locales.all().values_list("locale_id")])
Example #41
0
Ths is an example of use. the recommendation loads most of trivial info to cache and work with cache directly for
performance improvement.
"""

from django.core.wsgi import get_wsgi_application

application = get_wsgi_application()

from threading import Thread
from django.conf import settings
from recommendation.models import Item, User, TensorCoFi, Popularity


def load_rest():
    User.load_to_cache()

    # Load main models
    Popularity.load_to_cache()
    TensorCoFi.load_to_cache()
    if "recommendation.language" in settings.INSTALLED_APPS:
        from recommendation.language.models import Region
        Region.load_to_cache()
    if "recommendation.diversity" in settings.INSTALLED_APPS:
        from recommendation.diversity.models import ItemGenre, Genre
        Genre.load_to_cache()
        ItemGenre.load_to_cache()


# Load user and items
Item.load_to_cache()
Thread(target=load_rest).start()