def test_avarage_rating(session):
u0 = User(username='******', password='******')
u1 = User(username='******', password='******')
ex = Exercise(title='title1', description='desc0')
FUNRATING0 = 4
EFFECTIVERATING0 = 2
CLEARRATING0 = 1
AV0 = (FUNRATING0 + EFFECTIVERATING0 + CLEARRATING0) / 3.0
FUNRATING1 = 1
EFFECTIVERATING1 = 5
CLEARRATING1 = 3
AV1 = (FUNRATING1 + EFFECTIVERATING1 + CLEARRATING1) / 3.0
AV = (AV0 + AV1) / 2.0
session.add_all([u0, u1, ex])
session.commit()
rating0 = Rating(fun=FUNRATING0,
clear=CLEARRATING0,
effective=EFFECTIVERATING0,
exercise_id=ex.id,
user_id=u0.id)
rating1 = Rating(fun=FUNRATING1,
clear=CLEARRATING1,
effective=EFFECTIVERATING1,
exercise_id=ex.id,
user_id=u1.id)
session.add_all([rating0, rating1])
session.commit()
ex_id, avg_rating = session.query(Exercise.id, Exercise.avg_rating).first()
# ghetto way of ignoring the last bunch of decimal points. SQL
# rounds differently than python.
assert ex_id == ex.id and int(avg_rating * 1000) == int(AV * 1000)
def update_trueskill_by_match(match):
w_ratings = []
l_ratings = []
for p in match.winning_players:
mu, sigma = p.get_current_trueskill()
w_ratings.append(ts.Rating(mu, sigma))
for p in match.losing_players:
mu, sigma = p.get_current_trueskill()
l_ratings.append(ts.Rating(mu, sigma))
rating_groups = [w_ratings, l_ratings]
new_ratings = ts.rate(rating_groups, ranks=[0, 1])
players = match.winning_players + match.losing_players
new_ratings_flat = [item for sublist in new_ratings for item in sublist]
for player, rating in zip(players, new_ratings_flat):
r_m = Rating(
user=player,
match=match,
rating_type='trueskill_mu',
rating_value=rating.mu,
timestamp=match.timestamp,
)
r_s = Rating(
user=player,
match=match,
rating_type='trueskill_sigma',
rating_value=rating.sigma,
timestamp=match.timestamp,
)
db.session.add_all([r_m, r_s])
db.session.commit()
def seed_ratings():
demo1 = Rating(chef_id=Chef.query.get(1).id, rate=5)
demo2 = Rating(chef_id=Chef.query.get(2).id, rate=3)
db.session.add(demo1)
db.session.add(demo2)
db.session.commit()
def set_movie_watched(self, user_id, movie_id, set_watched=True):
self.logger.debug(
f"User with user_id={user_id} watched movie with movie_id={movie_id}"
)
if self.db.session.query(User).get(
user_id) is None or self.db.session.query(Movie).get(
movie_id) is None:
return None
if set_watched:
key = 'm' + str(movie_id) + "#avg"
avg_opt = self.redis_client.get(key)
implicit_rating = float(avg_opt.decode(
"utf-8")) if avg_opt is not None else self.default_rating
movie_rating = Rating(user_id=user_id,
movie_id=movie_id,
rating=implicit_rating,
is_implicit=True,
ts=datetime.now(tz=timezone.utc))
self.db.session.merge(movie_rating)
self.db.session.commit()
key = f"n_ratings_{user_id}"
self.redis_client.incr(key)
else:
self.delete_movie_rating(user_id, movie_id)
return set_watched
def set_movie_rating(self, user_id, movie_id, rating):
self.logger.debug(
f"User with user_id={user_id} rated with {rating} stars the movie with movie_id={movie_id}"
)
assert (0.5 <= rating <= 5.0)
rounded_rating = self.round_rating(rating)
if self.db.session.query(User).get(
user_id) is None or self.db.session.query(Movie).get(
movie_id) is None:
return None
movie_rating = Rating(user_id=user_id,
movie_id=movie_id,
rating=rounded_rating,
is_implicit=False,
ts=datetime.now(tz=timezone.utc))
self.db.session.merge(movie_rating)
self.db.session.commit()
key = f"n_ratings_{user_id}"
self.redis_client.incr(key)
return movie_rating
def fill_database(csv_content: str) -> None:
# load csv content to csv.reader
csv_file_obj = io.StringIO(csv_content)
reader = csv.reader(csv_file_obj, delimiter='\t')
# make 'cache' from all imdb_ids in local db
imdb_ids_query = db.session.query(Rating.imdb_id)
local_imdb_ids = set([_id for _id, in imdb_ids_query.all()])
# skip csv header
next(reader)
movie_ratings = []
for row in reader:
# check suck imdb_id already in local db
if row[0] in local_imdb_ids:
continue
# init object, collect them and fill db
movie_rating = Rating(
imdb_id=row[0],
rating=float(row[1]),
votes=int(row[2]),
)
movie_ratings.append(movie_rating)
if movie_ratings:
print(f'loading to db {len(movie_ratings)}')
db.session.bulk_save_objects(movie_ratings)
db.session.commit()
def on_post(self, req: falcon.Request, resp: falcon.Response, id: int):
"""
---
summary: Add rating for movie as logged in user
tags:
- Rating
parameters:
- in: body
schema: RatingSchema
consumes:
- application/json
produces:
- application/json
responses:
201:
description: Vote successful
401:
description: Unauthorized
422:
description: Input body formatting issue
"""
db = req.context["db"]
user = req.context["user"]
rating = req._deserialized["rating"]
user_rating = Rating(rating=rating, user=user, movie_id=id)
db.session.add(user_rating)
db.session.commit()
resp.status = falcon.HTTP_CREATED
resp.media = {"message": "rating saved"}
def rating(self, id):
x_forwarded_for = request.headers.getlist('X-Forwarded-For')
ip = x_forwarded_for[0] if x_forwarded_for else request.remote_addr
ip = ip.split(',')[0]
stars = request.form['stars']
r = Rating.query.filter_by(server_uuid=id, ip=ip).first()
if r is None:
try:
r = Rating()
r.server_uuid = id
r.ip = ip
r.stars = stars
db.session.add(r)
db.session.commit()
except:
import traceback
db.session.rollback()
traceback.print_exc()
return jsonify(message='success')
else:
r.stars = stars
db.session.commit()
return jsonify(message=r.stars)
def interact():
"""Handle interactions."""
# get POST form data
payload = json.loads(request.form["payload"])
# handle the Q question
if payload["callback_id"] == "q_ask":
response = payload["actions"][0]["value"]
user_slack_id = payload["user"]["id"]
slack_channel_id = payload["channel"]["id"]
# get user object, append rating
user = User.get_or_create(user_slack_id, slack_channel_id)
user.ratings.append(Rating(rating=response))
db.session.commit()
if response == "bad":
return "Ouch, sorry bud :slightly_frowning_face:"
elif response == "ok":
return "Ok! I got it."
elif response == "good":
return "Nice! :ok_hand:"
# otherwise do nothing
return "OK"
def movie_rating(id, user_id, rated):
# query from request info
movie = Movie.query.get(id)
if movie is None:
return create_response(400, "Movie is not exist")
rating = Rating.query.filter_by(movie_id=movie.id, user_id=user_id).first()
logger = Logger(user_id=user_id,
action_type_id=5,
movie_id=id,
rating=rated)
logger.create_log()
if rating is None:
r = Rating(rating=rated, user_id=user_id, movie_id=movie.id)
db.session.add(r)
else:
rating.rating = rated
rating.timestamp = datetime.datetime.utcnow()
db.session.add(rating)
db.session.flush()
new_rating = calc_rating(id)
movie.rating = new_rating
db.session.add(movie)
db.session.commit()
return create_response(200, "Rate film successfully")
def rate_teacher(teacherId):
user_id = current_user.id
rating = Rating.query.filter_by(user_id=user_id, teacher_id=teacherId).first()
if rating is not None:
flash('You have already rated this teacher!')
return redirect(url_for('view_teachers'))
form = RateTeacherForm()
if form.validate_on_submit():
dedication_score = form.dedication_score.data
leniency_score = form.leniency_score.data
marks_score = form.marks_score.data
teaching_score = form.teaching_score.data
friendliness_score = form.friendliness_score.data
rating = Rating(teacher_id=teacherId, user_id=current_user.id,
dedication_score=dedication_score,
leniency_score=leniency_score,
marks_score=marks_score,
teaching_score=teaching_score,
friendliness_score=friendliness_score)
if(update_score(teacherId, dedication_score, leniency_score, marks_score, teaching_score, friendliness_score)):
db.session.add(rating)
db.session.commit()
flash('Successfuly rated! Thank you for your contribution.')
return redirect(url_for('view_teachers'))
else:
flash(
'Unknown error. Sorry, please report the issue to the admin. Try again.')
return redirect(url_for(rate_teacher, teacherId=teacherId))
teacher = Teacher.query.filter_by(id=teacherId).first()
return render_template('rate_teacher.html', title="Rate Teacher", teacher=teacher, form=form)
def rate():
try:
data = request.json
rating_id = data.get('rating_id')
stars = data.get('stars')
description = data.get('description')
user_id = data.get('user_id')
bottle_id = data.get('bottle_id')
if stars and user_id and bottle_id:
if rating_id:
rating = Rating.query.filter_by(rating_id=rating_id).first()
rating.stars = stars
rating.description = description
else:
rating = Rating(stars=stars,
description=description,
user_id=user_id,
bottle_id=bottle_id)
db.session.add(rating)
db.session.commit()
return jsonify({'success': 'Rating added/edited.'})
else:
return jsonify({'error': 'Error: Missing parameters.'})
except:
return jsonify({'error': 'Error: Could not add rating.'})
def test_give_rating(session):
u0 = User(username='******', password='******')
u1 = User(username='******', password='******')
ex = Exercise(title='title1', description='desc0')
FUNRATING0 = 4
EFFECTIVERATING0 = 2
CLEARRATING0 = 1
session.add_all([u0, u1, ex])
session.commit()
rating = Rating(fun=FUNRATING0,
clear=CLEARRATING0,
effective=EFFECTIVERATING0,
exercise_id=ex.id,
user_id=u0.id)
session.add(rating)
session.commit()
ex_id, rating = session.query(Exercise.id, Rating.rating).\
join(Rating).\
filter(Rating.exercise_id == ex.id).\
first()
r = (FUNRATING0 + EFFECTIVERATING0 + CLEARRATING0) / 3.0
# ghetto way of ignoring the last bunch of decimal points. SQL
# rounds differently than python.
assert ex_id == ex.id and int(rating * 1000) == int(r * 1000)
def generate_ratings():
ratings = list()
# Iterate through each user
for user_id in range(1, NUMBER_OF_USERS + 1):
# Generate a random genre preference array
user_preferences = np.random.rand(NUMBER_OF_GENRES)
n = random.randint(MIN_NUMBER_OF_RATINGS, MAX_NUMBER_OF_RATINGS)
# Iterate over a random sample of n books
for book_id, (title, genres) in books_df.sample(n).iterrows():
book_genres = genres.split("|")
value = 0
for genre in book_genres:
value += user_preferences[GENRES.index(genre)]
# Convert to a half-decimal between 0 and 5
value = round(2 * (5 * value) / len(book_genres)) / 2
rating = Rating(book_id=book_id, user_id=user_id, value=value)
ratings.append(rating)
return ratings
def cocktails_rating():
if request.method == 'GET':
# Check if cocktails table isn't empty.
if Cocktail.query.first() is None:
return does_not_exist()
# If cocktail id in request body: return data for only one cocktail.
try:
cocktail_id = request.json['cocktail_id']
record = Cocktail.query.filter_by(id=cocktail_id).first()
if record is None:
return does_not_exist()
else:
response = make_response(
jsonify(cocktail_id=record.id,
cocktail_name=record.name,
pub_id=record.pub_id,
description=record.description), 200)
return response
except (KeyError, TypeError):
pass
# Show full rating.
cocktails_list = []
for cocktail in Cocktail.query.all():
sum_of_ratings = 0
for rating in cocktail.ratings:
sum_of_ratings += rating.rating
try:
avg = sum_of_ratings / len(cocktail.ratings)
except ZeroDivisionError:
avg = 0
cocktails_list.append({
'cocktail_id': cocktail.id,
'cocktail_name': cocktail.name,
'description': cocktail.description,
'average_rating': avg
})
response = make_response(jsonify(cocktails_list), 200)
return response
# To add new rating 'rating' and 'cocktail_id' in request body required.
elif request.method == 'POST':
if request.json is None:
return redirect(url_for('api.cocktails_rating'), 300)
try:
rating = request.json['rating']
cocktail_id = request.json['cocktail_id']
except (KeyError, ValueError):
return no_data()
if Cocktail.query.filter_by(id=cocktail_id).first() is None:
return does_not_exist
rate = Rating(cocktail_id=cocktail_id, rating=rating)
db.session.add(rate)
db.session.commit()
return redirect(url_for('api.cocktails_rating'), 300)
def create_rating(data):
new_rating = Rating(**data)
db.session.add(new_rating)
db.session.commit()
if new_rating is None:
raise RatingNotSaveException
return new_rating
def update_elo_by_match(match):
elo_change = get_match_elo_change(match)
for p in match.winning_players:
r = Rating(user=p,
match=match,
rating_type='elo',
rating_value=p.get_current_elo() + elo_change,
timestamp=match.timestamp)
db.session.add(r)
for p in match.losing_players:
r = Rating(user=p,
match=match,
rating_type='elo',
rating_value=p.get_current_elo() - elo_change,
timestamp=match.timestamp)
db.session.add(r)
db.session.commit()
def init_ratings(user, timestamp=None):
if timestamp is None:
timestamp = datetime.now()
r_elo = Rating(user=user,
rating_type='elo',
rating_value=1500,
timestamp=timestamp)
r_ts_m = Rating(user=user,
rating_type='trueskill_mu',
rating_value=25,
timestamp=timestamp)
r_ts_s = Rating(user=user,
rating_type='trueskill_sigma',
rating_value=8.333,
timestamp=timestamp)
db.session.add_all([r_elo, r_ts_m, r_ts_s])
db.session.commit()
def seed_ratings(filepath="../csv_data/user_ratings.csv"):
if os.path.exists(filepath):
df = pd.read_csv(filepath, index_col=0)
for index, row in df.iterrows():
# access data using column names which are required, print is not neccessary
# USERNAME,REST_ID,RESTAURANT,RATING
print(index, row['USERNAME'], row['REST_ID'], row['RATING'])
record = Rating(rest_id=row['REST_ID'], rating=row['RATING'], username=row['USERNAME'])
db.session.add(record)
# save every thing
db.session.commit()
def rate(request, snippet_id):
snippet = get_object_or_404(Snippet, pk=snippet_id)
if 'rating' not in request.GET or request.GET['rating'] not in ('1', '-1'):
return HttpResponseRedirect(snippet.get_absolute_url())
try:
rating = Rating.objects.get(user__pk=request.user.id, snippet__pk=snippet.id)
except Rating.DoesNotExist:
rating = Rating(user=request.user, snippet=snippet)
rating.rating = int(request.GET['rating'])
rating.save()
return HttpResponseRedirect(snippet.get_absolute_url())
def test_follow_posts(self):
# create four users
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
now = datetime.utcnow()
p1 = Rating(rate="post from john",
rater=u1,
timestamp=now + timedelta(seconds=1))
p2 = Rating(rate="post from susan",
rater=u2,
timestamp=now + timedelta(seconds=4))
p3 = Rating(rate="post from mary",
rater=u3,
timestamp=now + timedelta(seconds=3))
p4 = Rating(rate="post from david",
rater=u4,
timestamp=now + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u3) # susan follows mary
u3.follow(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def dat2base():
'''transefer dat to database'''
path = '../ml-latest-small/movies.csv'
count = 0
fp = open(path, 'r')
fp.readline()
regex = re.compile("(\d+),\"?(.+)\"?,(.+)")
for line in fp.readlines():
ilt = regex.search(line)
if ilt.group(2).endswith("\""):
movie = Movie(movie_id=ilt.group(1),
movie_name=ilt.group(2)[:-2],
movie_genres=ilt.group(3))
else:
movie = Movie(movie_id=ilt.group(1),
movie_name=ilt.group(2),
movie_genres=ilt.group(3))
db.session.add(movie)
count += 1
if count % 1000 == 0:
db.session.commit()
print("\r当前进度: {:.2f}%".format(count / 9126 * 100), end="")
db.session.commit()
path = '../ml-latest-small/ratings.csv'
count = 0
fp = open(path, 'r')
fp.readline()
for line in fp.readlines():
ilt = line.split(',')
rating = Rating(user_id=ilt[0], movie_id=ilt[1], rating=ilt[2])
count += 1
if count == 1000:
db.session.commit()
db.session.add(rating)
print("\r当前进度: {:.2f}%".format(count / 100005 * 100), end="")
db.session.commit()
path = '../ml-latest-small/ratings.csv'
count = 0
fp = open(path, 'r')
fp.readline()
for line in fp.readlines():
ilt = line.split(',')
if User.query.filter_by(user_id=ilt[0]).first() is not None:
continue
user = User(user_id=ilt[0], username='******' + str(ilt[0]))
count += 1
if count == 1000:
db.session.commit()
db.session.add(user)
print("\r当前进度: {:.2f}%".format(count / 100005 * 100), end="")
db.session.commit()
def add_rating(rating):
owner = User.objects.get(username__exact=rating['tripowner'])
rater = User.objects.get(username__exact=rating['rater'])
trip = Trip.objects.get(owner=owner, title=rating["triptitle"])
s = ""
try:
Rating.objects.get(owner=rater, trip=trip)
s = "Rating already exists"
except Rating.DoesNotExist:
r = Rating(owner=rater, trip=trip, score=int(rating['score']))
r.save()
s = "Rating created"
print(s)
def hello():
rate_updating = request.json['rating']
book = Book.query.filter_by(id=request.json['book']).first()
rating = Rating.query.filter_by(author=current_user, book=book).first()
if rating:
rating.score = rate_updating
else:
new_rating = Rating(author=current_user._get_current_object(),
book=book,
score=rate_updating)
db.session.add(new_rating)
db.session.commit()
db.session.commit()
return redirect(url_for('main.book', id=book.id))
def load_ratings(self):
"""
Loads in memory ratings database.
It ignores ratings described in ratings_to_exlude
"""
fname = os.path.join(self.db_dir, 'ratings.csv')
rt_list = []
with open(fname) as csvfile:
reader = csv.reader(csvfile, delimiter=',')
next(reader, None)
for row in reader:
rt = Rating(*row)
rt_list.append(rt)
self.ratings = tuple(rt_list)
def set_match_result(winner_song, loser_ids):
app.logger.info('Creating ratings...')
ratings = []
for loser_id in [i for i in map(int, loser_ids) if i != winner_song.id]:
loser_song = Song.query.get(loser_id)
app.logger.info('Rating: winner {} loser {}'.format(
winner_song.id, loser_song.id))
rating = Rating(winner_song, loser_song)
ratings.append(rating)
if ratings:
for rating in ratings:
db.session.add(rating)
db.session.commit()
app.logger.info('{} ratings'.format(len(ratings)))
return ratings
def test_rating(self):
movie_rating = Rating(
imdb_id='asdf123',
rating=5.0,
votes=1000,
)
db.session.add(movie_rating)
db.session.commit()
response_1 = urllib.request.urlopen(f'http://{self.API_URL}')
assert response_1.status == 400
response_2 = urllib.request.urlopen(
f'http://{self.API_URL}/?imdb_id=zcxv321')
assert response_2.status == 404
response_3 = urllib.request.urlopen(
f'http://{self.API_URL}/?imdb_id=asdf123')
assert response_3.status == 200
def add_rating(user_id):
user = User.query.get(user_id)
if user:
req_data = request.get_json()
err = rating_schema.validate(req_data)
if err:
return jsonify(err), 400
else:
rating_dat, err = rating_schema.load(req_data)
restaurant_id = rating_dat['restaurant_id']
restaurant = Restaurant.query.get(restaurant_id)
if restaurant:
rating_dat['user'] = user
rating_dat['restaurant'] = restaurant
del rating_dat['restaurant_id']
#ensure the user is not rating the same retaurant in less than a month
most_recent_rating = Rating.query.filter_by(
user=user, restaurant=restaurant).order_by(
Rating.date.desc()).first()
if most_recent_rating:
if (datetime.utcnow() -
most_recent_rating.date) < timedelta(days=30):
return jsonify({
'message':
'please wait longer than a month to rate the same restaurant'
}), 400
#if total score is 1.0 ensure there is a comment
rating = Rating(**rating_dat)
if rating.comment == '' and rating.totalscore == 1.0:
return jsonify(
{'message': 'please supply a comment for rating'}), 400
return db_add(rating, rating_schema)
else:
return jsonify({'message':
'restaurant could not be found'}), 404
else:
return jsonify({'message': 'user could not be found'}), 404
def movie_rating(id):
form = RatingForm()
movie = mg.db.movie.find_one({'_id': id})
form.uid.data = current_user.uid
form.mid.data = movie['lens_id']
form.name.data = movie['title']
if form.validate_on_submit() and request.method == 'POST':
Rating(uid=int(form.uid.data),
mid=int(form.mid.data),
name=form.name.data,
rating=float(form.rating.data),
title=form.title.data,
content=form.content.data).save()
recommender.add_ratings(
[[int(form.uid.data),
int(form.mid.data),
float(form.rating.data)]])
flash('rating recorded, retraining model...')
return redirect(url_for('main.movie_rating', id=id))
return render_template('rating.html', movie=movie, form=form)
def song_pg(song_id):
preview_url = song_df.loc[song_df.song_id==song_id,"Preview"].item()
iteration = session.get('iteration',None)
confidence = session.get('confidence', None)
if request.method == 'POST':
rating = int(request.form['rating'])
# get slider value
if iteration > 0: # slider only appears after 1st iteration
confidence = request.form['slider']
session['confidence'] = confidence
# save rating to database
user_id = session.get('user_id',None)
confidence = session.get('confidence', None)
rating_entry = Rating(user_id=user_id,rating=rating,song_id=song_id,iteration=iteration,confidence=confidence)
db.session.add(rating_entry)
db.session.commit()
# go to another song
return redirect(url_for('train_redirect'))
return render_template('song_pg.html', preview_url=preview_url, iteration=iteration,
confidence=confidence)