def get_rec():
"get_rec"
rec_request_list = request.args.get('rec_request_list')
for_who = request.args.get('for_who')
if not for_who:
return jsonify({})
try:
rec_request_list = rec_request_list.split(",")
except:
return jsonify({})
resp = {}
i = 0
movie_to_exclude = TrailerSeen.query.filter_by(seen_by=for_who)
imdb_to_exclude = []
for m in movie_to_exclude:
imdb_to_exclude.append(m.imdb_id)
for req in rec_request_list:
rec_type = rec_types.get(req, "RANDOM")
table_to_use = get_table('all_table')()
table_to_use = table_to_use[~table_to_use["IMDB_ID"].
isin(Series(imdb_to_exclude))]
t = rec_router.get(rec_type, random_rec.random_rec)(table_to_use)
t
i += 1
resp.update({i: t})
return jsonify(resp)
def pers_rec(user_id,num_of_rec,num_of_skip,pers_type):
movies_seen=trailer_seen.TrailerSeen.query.filter_by(seen_by=user_id)
movies_to_exclude = []
for r in movies_seen:
movies_to_exclude.append(r.imdb_id)
pers_user = personality.Personality.query.filter_by(user_id=user_id).first().TIPI_TO_OCEAN()
final_array = []
if pers_type == "users":
pers_others = personality.Personality.query.filter(personality.Personality.user_id != user_id)
for pers_other in pers_others:
d = get_distance(pers_user, pers_other.TIPI_TO_OCEAN())
movies_seen=trailer_seen.TrailerSeen.query.filter_by(seen_by=pers_other.user_id, is_skipped=0)
for r in movies_seen:
# problem when multiple users rated the same movie, it should prob aggregate the score
final_array.append((r.imdb_id, float((1/d) * float(r.rate)), r.rate))
else:
for row in movie_pers.itertuples():
d = get_distance(pers_user, [row.openness, row.conscientiousness, row.extraversion, row.agreeableness, row.emotional_range])
final_array.append((row.IMDB_ID, 1/d, d))
dtype = [('IMDB_ID', 'S10'), ('PREDICTED_VOTE', float), ('IMDB_VOTES', int)]
numpy_final = numpy.array(final_array, dtype=dtype)
numpy_final = numpy.sort(numpy_final, order=['PREDICTED_VOTE'])
numpy_final = numpy_final[::-1]
all_table = get_table("all_table")()
all_table = all_table[~all_table["IMDB_ID"].isin(Series(movies_to_exclude))]
all_table.reset_index(drop=True, inplace=True)
final = {}
safe_iter = 0
while (len(final) < num_of_rec) and (safe_iter < 20) and len(numpy_final) > (safe_iter + num_of_skip):
rec = numpy_final[safe_iter + num_of_skip]
movie = all_table[all_table["IMDB_ID"] == rec[0]].copy()
if len(movie.index):
movie.reset_index(drop=True, inplace=True)
movie = movie.iloc[0]
movie["REC_TYPE"] = "PERS"
movie["PREDICTED_VOTE"]=rec[1]
z = movie.to_json()
safe_iter += 1
final.update({len(final): z})
else:
safe_iter += 1
return final
def movies_rated_by():
user_id = request.args.get('user_id')
limit = request.args.get('limit')
show_skipped = request.args.get('show_skipped')
try:
limit = int(limit)
except:
limit = 5
try:
show_skipped = int(show_skipped)
except:
show_skipped = 0
if show_skipped:
rated_by_user = TrailerSeen.query.filter_by(seen_by=user_id).limit(
int(limit))
else:
rated_by_user = TrailerSeen.query.filter_by(seen_by=user_id,
is_skipped=0).limit(
int(limit))
resp = {}
for rate in rated_by_user:
imdb_id = rate.imdb_id
rate = rate.rate
all_movie = get_table("all_table")()
movie = all_movie[all_movie["IMDB_ID"] == imdb_id]
print movie
print imdb_id
movie.loc["user_rate"] = rate
movie.reset_index(drop=True, inplace=True)
t = movie.iloc[0]
m_j = t.to_json()
resp.update({len(resp): m_j})
return jsonify(resp)
def video_deep_rec(user_id, num_of_rec):
rated_by_user = trailer_seen.TrailerSeen.query.filter_by(seen_by=user_id,
is_skipped=0)
movies_seen = trailer_seen.TrailerSeen.query.filter_by(seen_by=user_id)
rated_imdb = {}
movies_to_exclude = []
for r in rated_by_user:
rated_imdb.update({r.imdb_id: r.rate})
for r in movies_seen:
movies_to_exclude.append(r.imdb_id)
final_array = []
i = 0
for row in video_deep_sim.itertuples():
num = float(0)
den = float(0)
i += 1
neigh_splitted = row[3].split(",")
for j in neigh_splitted:
imdb_sim = j.split(":")
imdb = imdb_sim[0]
if rated_imdb.get(imdb, None):
num += float(rated_imdb.get(imdb)) * float(imdb_sim[1])
den += float(imdb_sim[1])
if den == 0:
final_v = float(0)
else:
final_v = float(num / den)
if not final_v:
final_v = float(0)
final_array.append((row[1], final_v, row[2]))
dtype = [('IMDB_ID', 'S10'), ('PREDICTED_VOTE', float),
('IMDB_VOTES', int)]
numpy_final = numpy.array(final_array, dtype=dtype)
numpy_final = numpy.sort(numpy_final, order=['PREDICTED_VOTE'])
numpy_final = numpy_final[::-1]
all_table = get_table("all_table")()
all_table = all_table[~all_table["IMDB_ID"].isin(Series(movies_to_exclude)
)]
all_table.reset_index(drop=True, inplace=True)
final = {}
safe_iter = 0
while (len(final) < num_of_rec) and (safe_iter < 20):
rec = numpy_final[safe_iter]
movie = all_table[all_table["IMDB_ID"] == rec[0]].copy()
if len(movie.index):
movie.reset_index(drop=True, inplace=True)
movie = movie.iloc[0]
movie["REC_TYPE"] = "AUDIO"
movie["PREDICTED_VOTE"] = rec[1]
z = movie.to_json()
safe_iter += 1
final.update({len(final): z})
else:
safe_iter += 1
return final
def get_movies():
num_movies = request.args.get('num_of_movies')
genre = request.args.get('genre')
order_by = request.args.get('order_by')
years = request.args.get('years')
requested_by = request.args.get('requested_by')
f1 = request.args.get('f1')
f2 = request.args.get('f2')
f4 = request.args.get('f4')
f6 = request.args.get('f6')
f1_c = feature_converter.get(f1)
f2_c = feature_converter.get(f2)
f4_c = feature_converter.get(f4)
f6_c = feature_converter.get(f6)
# filter by genre
if genre in genres_list:
tmp_table = get_table_by_genre(genre)()
else:
tmp_table = get_table("all_table")()
# years
if not years:
return jsonify({})
# filter by years
try:
int(years)
except:
years = None
if years:
years_complete = []
for i in range(0, 10):
years_complete.append(int(years) + i)
years_series = Series(years_complete)
tmp_table = tmp_table[tmp_table['YEAR'].isin(years_series)]
tmp_table.reset_index(drop=True, inplace=True)
len(tmp_table.index)
# filter by features
if f1 != "ALL":
tmp_table = tmp_table[(tmp_table["f1"] > f1_c[0])
& (tmp_table["f1"] < f1_c[1])]
if f2 != "ALL":
tmp_table = tmp_table[(tmp_table["f2"] > f2_c[0])
& (tmp_table["f2"] < f2_c[1])]
if f4 != "ALL":
tmp_table = tmp_table[(tmp_table["f4"] > f4_c[0])
& (tmp_table["f4"] < f4_c[1])]
if f6 != "ALL":
tmp_table = tmp_table[(tmp_table["f6"] > f6_c[0])
& (tmp_table["f6"] < f6_c[1])]
movies = {}
try:
num_movies = int(num_movies)
except:
num_movies = 10
tmp_table = tmp_table.sort_values(by=["IMDB_VOTES"], ascending=[0])
# len(tmp_table.index)
# tmp_table.head()
movies_selected = tmp_table.iloc[:num_movies]
movies_selected.reset_index(drop=True, inplace=True)
# movies_selected.head()
rated_by_user = TrailerSeen.query.filter_by(seen_by=requested_by,
is_skipped=0)
rated_by_user_imdbid = []
for rate in rated_by_user:
rated_by_user_imdbid.append(rate.imdb_id)
# "LEN!!!"
# len(movies_selected.index)
for i, r in movies_selected.iterrows():
if r["IMDB_ID"] in rated_by_user_imdbid:
r["IS_ALREADY_VOTED"] = True
# "already voted"
else:
r["IS_ALREADY_VOTED"] = False
# "NOT already voted"
m_j = r.to_json()
# m_j
movies.update({len(movies): m_j})
return jsonify(movies)
