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)