From ac6d69c1f9e7e84f66fa65edc195e1a19e0f1a98 Mon Sep 17 00:00:00 2001 From: Jessica Date: Thu, 30 Mar 2023 19:09:00 -0600 Subject: [PATCH 1/3] Go dammitgit --- play_tester.py | 14 +- tests/test_wave_01.py | 37 +++--- tests/test_wave_02.py | 10 +- tests/test_wave_03.py | 15 ++- tests/test_wave_04.py | 6 +- tests/test_wave_05.py | 20 ++- viewing_party/party.py | 290 ++++++++++++++++++++++++++++++++++++++++- 7 files changed, 351 insertions(+), 41 deletions(-) diff --git a/play_tester.py b/play_tester.py index 9e2aecf48..9a3f0f9e9 100644 --- a/play_tester.py +++ b/play_tester.py @@ -9,14 +9,20 @@ pp = pprint.PrettyPrinter(indent=4) # play testing section -print("\n-----Wave 01 test data-----") -pp.pprint(HORROR_1) -pp.pprint(FANTASY_1) -pp.pprint(FANTASY_2) +# print("\n-----Wave 01 test data-----") +# pp.pprint(HORROR_1) +# pp.pprint(FANTASY_1) +# pp.pprint(FANTASY_2) # print("\n-----Wave 02 user_data-----") # pp.pprint(clean_wave_2_data()) + # Arrange +janes_data = clean_wave_2_data() + +average = get_watched_avg_rating(janes_data) +print(f"{average = }") +print(f"{average=}") #print("\n-----Wave 03 user_data-----") #pp.pprint(clean_wave_3_data()) diff --git a/tests/test_wave_01.py b/tests/test_wave_01.py index 669efee6a..a9b67f967 100644 --- a/tests/test_wave_01.py +++ b/tests/test_wave_01.py @@ -4,7 +4,7 @@ from viewing_party.party import * from tests.test_constants import * -@pytest.mark.skip() +# @pytest.mark.skip() def test_create_successful_movie(): # Arrange movie_title = MOVIE_TITLE_1 @@ -19,7 +19,7 @@ def test_create_successful_movie(): assert new_movie["genre"] == GENRE_1 assert new_movie["rating"] == pytest.approx(RATING_1) -@pytest.mark.skip() +# @pytest.mark.skip() def test_create_no_title_movie(): # Arrange movie_title = None @@ -32,7 +32,7 @@ def test_create_no_title_movie(): # Assert assert new_movie is None -@pytest.mark.skip() +# @pytest.mark.skip() def test_create_no_genre_movie(): # Arrange movie_title = "Title A" @@ -45,7 +45,7 @@ def test_create_no_genre_movie(): # Assert assert new_movie is None -@pytest.mark.skip() +# @pytest.mark.skip() def test_create_no_rating_movie(): # Arrange movie_title = "Title A" @@ -58,7 +58,7 @@ def test_create_no_rating_movie(): # Assert assert new_movie is None -@pytest.mark.skip() +# @pytest.mark.skip() def test_adds_movie_to_user_watched(): # Arrange movie = { @@ -79,7 +79,7 @@ def test_adds_movie_to_user_watched(): assert updated_data["watched"][0]["genre"] == GENRE_1 assert updated_data["watched"][0]["rating"] == RATING_1 -@pytest.mark.skip() +# @pytest.mark.skip() def test_adds_movie_to_non_empty_user_watched(): # Arrange movie = { @@ -99,7 +99,7 @@ def test_adds_movie_to_non_empty_user_watched(): assert movie in updated_data["watched"] assert FANTASY_2 in updated_data["watched"] -@pytest.mark.skip() +# @pytest.mark.skip() def test_adds_movie_to_user_watchlist(): # Arrange movie = { @@ -120,7 +120,7 @@ def test_adds_movie_to_user_watchlist(): assert updated_data["watchlist"][0]["genre"] == GENRE_1 assert updated_data["watchlist"][0]["rating"] == RATING_1 -@pytest.mark.skip() +# @pytest.mark.skip() def test_adds_movie_to_non_empty_user_watchlist(): # Arrange movie = { @@ -140,7 +140,7 @@ def test_adds_movie_to_non_empty_user_watchlist(): assert movie in updated_data["watchlist"] assert FANTASY_2 in updated_data["watchlist"] -@pytest.mark.skip() +# @pytest.mark.skip() def test_moves_movie_from_watchlist_to_empty_watched(): # Arrange janes_data = { @@ -158,13 +158,16 @@ def test_moves_movie_from_watchlist_to_empty_watched(): # Assert assert len(updated_data["watchlist"]) == 0 assert len(updated_data["watched"]) == 1 - - raise Exception("Test needs to be completed.") + assert updated_data["watched"][0]["title"] == MOVIE_TITLE_1 + assert updated_data["watched"][0]["genre"] == GENRE_1 + assert updated_data["watched"][0]["rating"] == RATING_1 + + # raise Exception("Test needs to be completed.") # ******************************************************************************************* # ****** Add assertions here to test that the correct movie was added to "watched" ********** # ******************************************************************************************* -@pytest.mark.skip() +# @pytest.mark.skip() def test_moves_movie_from_watchlist_to_watched(): # Arrange movie_to_watch = HORROR_1 @@ -182,13 +185,17 @@ def test_moves_movie_from_watchlist_to_watched(): # Assert assert len(updated_data["watchlist"]) == 1 assert len(updated_data["watched"]) == 2 - - raise Exception("Test needs to be completed.") + + assert movie_to_watch not in updated_data["watchlist"] + assert movie_to_watch in updated_data["watched"] + assert FANTASY_2 in updated_data["watched"] + + # raise Exception("Test needs to be completed.") # ******************************************************************************************* # ****** Add assertions here to test that the correct movie was added to "watched" ********** # ******************************************************************************************* -@pytest.mark.skip() +# @pytest.mark.skip() def test_does_nothing_if_movie_not_in_watchlist(): # Arrange movie_to_watch = HORROR_1 diff --git a/tests/test_wave_02.py b/tests/test_wave_02.py index 19f045c79..64b62729d 100644 --- a/tests/test_wave_02.py +++ b/tests/test_wave_02.py @@ -2,7 +2,7 @@ from viewing_party.party import * from tests.test_constants import * -@pytest.mark.skip() +# @pytest.mark.skip() def test_calculates_watched_average_rating(): # Arrange janes_data = clean_wave_2_data() @@ -14,7 +14,7 @@ def test_calculates_watched_average_rating(): assert average == pytest.approx(3.58333) assert janes_data == clean_wave_2_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_empty_watched_average_rating_is_zero(): # Arrange janes_data = { @@ -27,7 +27,7 @@ def test_empty_watched_average_rating_is_zero(): # Assert assert average == pytest.approx(0.0) -@pytest.mark.skip() +# @pytest.mark.skip() def test_most_watched_genre(): # Arrange janes_data = clean_wave_2_data() @@ -39,7 +39,7 @@ def test_most_watched_genre(): assert popular_genre == "Fantasy" assert janes_data == clean_wave_2_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_most_watched_genre_order_mixed(): # Arrange janes_data = clean_wave_2b_data() @@ -51,7 +51,7 @@ def test_most_watched_genre_order_mixed(): assert popular_genre == "Fantasy" assert janes_data == clean_wave_2b_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_genre_is_None_if_empty_watched(): # Arrange janes_data = { diff --git a/tests/test_wave_03.py b/tests/test_wave_03.py index 046429360..aa534ceaf 100644 --- a/tests/test_wave_03.py +++ b/tests/test_wave_03.py @@ -2,7 +2,7 @@ from viewing_party.party import * from tests.test_constants import * -@pytest.mark.skip() +# @pytest.mark.skip() def test_my_unique_movies(): # Arrange amandas_data = clean_wave_3_data() @@ -16,7 +16,7 @@ def test_my_unique_movies(): assert INTRIGUE_2 in amandas_unique_movies assert amandas_data == clean_wave_3_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_my_not_unique_movies(): # Arrange amandas_data = clean_wave_3_data() @@ -28,7 +28,7 @@ def test_my_not_unique_movies(): # Assert assert len(amandas_unique_movies) == 0 -@pytest.mark.skip() +# @pytest.mark.skip() def test_friends_unique_movies(): # Arrange amandas_data = clean_wave_3_data() @@ -43,7 +43,7 @@ def test_friends_unique_movies(): assert FANTASY_4 in friends_unique_movies assert amandas_data == clean_wave_3_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_friends_unique_movies_not_duplicated(): # Arrange amandas_data = clean_wave_3_data() @@ -54,13 +54,16 @@ def test_friends_unique_movies_not_duplicated(): # Assert assert len(friends_unique_movies) == 3 + assert FANTASY_1 in friends_unique_movies + assert INTRIGUE_3 in friends_unique_movies - raise Exception("Test needs to be completed.") + + # raise Exception("Test needs to be completed.") # ************************************************************************************************* # ****** Add assertions here to test that the correct movies are in friends_unique_movies ********** # ************************************************************************************************** -@pytest.mark.skip() +# @pytest.mark.skip() def test_friends_not_unique_movies(): # Arrange amandas_data = { diff --git a/tests/test_wave_04.py b/tests/test_wave_04.py index 499669077..0b0b3c7e2 100644 --- a/tests/test_wave_04.py +++ b/tests/test_wave_04.py @@ -2,7 +2,7 @@ from viewing_party.party import * from tests.test_constants import * -@pytest.mark.skip() +# @pytest.mark.skip() def test_get_available_friend_rec(): # Arrange amandas_data = clean_wave_4_data() @@ -16,7 +16,7 @@ def test_get_available_friend_rec(): assert FANTASY_4b in recommendations assert amandas_data == clean_wave_4_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_no_available_friend_recs(): # Arrange amandas_data = { @@ -38,7 +38,7 @@ def test_no_available_friend_recs(): # Assert assert len(recommendations) == 0 -@pytest.mark.skip() +# @pytest.mark.skip() def test_no_available_friend_recs_watched_all(): # Arrange amandas_data = { diff --git a/tests/test_wave_05.py b/tests/test_wave_05.py index b2ba9ad33..765298bdf 100644 --- a/tests/test_wave_05.py +++ b/tests/test_wave_05.py @@ -2,7 +2,7 @@ from viewing_party.party import * from tests.test_constants import * -@pytest.mark.skip() +# @pytest.mark.skip() def test_new_genre_rec(): # Arrange sonyas_data = clean_wave_5_data() @@ -17,7 +17,7 @@ def test_new_genre_rec(): assert FANTASY_4b in recommendations assert sonyas_data == clean_wave_5_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_new_genre_rec_from_empty_watched(): # Arrange sonyas_data = { @@ -38,7 +38,7 @@ def test_new_genre_rec_from_empty_watched(): # Assert assert len(recommendations) == 0 -@pytest.mark.skip() +# @pytest.mark.skip() def test_new_genre_rec_from_empty_friends(): # Arrange sonyas_data = { @@ -53,12 +53,18 @@ def test_new_genre_rec_from_empty_friends(): ] } - raise Exception("Test needs to be completed.") + # Act + new_genre_rec = get_new_rec_by_genre(sonyas_data) + + # Assert + assert new_genre_rec is None + + # raise Exception("Test needs to be completed.") # ********************************************************************* # ****** Complete the Act and Assert Portions of these tests ********** # ********************************************************************* -@pytest.mark.skip() +# @pytest.mark.skip() def test_unique_rec_from_favorites(): # Arrange sonyas_data = clean_wave_5_data() @@ -72,7 +78,7 @@ def test_unique_rec_from_favorites(): assert INTRIGUE_2b in recommendations assert sonyas_data == clean_wave_5_data() -@pytest.mark.skip() +# @pytest.mark.skip() def test_unique_from_empty_favorites(): # Arrange sonyas_data = { @@ -94,7 +100,7 @@ def test_unique_from_empty_favorites(): # Assert assert len(recommendations) == 0 -@pytest.mark.skip() +# @pytest.mark.skip() def test_new_rec_from_empty_friends(): # Arrange sonyas_data = { diff --git a/viewing_party/party.py b/viewing_party/party.py index 6d34a6b5f..a9af6d35a 100644 --- a/viewing_party/party.py +++ b/viewing_party/party.py @@ -1,23 +1,311 @@ # ------------- WAVE 1 -------------------- def create_movie(title, genre, rating): - pass + + if not (title and genre and rating): + return None + else: + movie = { "title" : title, + "genre" : genre, + "rating" : rating} + return movie + +def add_to_watched(user_data, movie): + + user_data["watched"].append(movie) + return user_data + +def add_to_watchlist(user_data, movie): + + user_data["watchlist"].append(movie) + return user_data + + +def watch_movie(user_data, title): + + for movie in user_data["watchlist"]: + if movie["title"] == title: + user_data["watchlist"].remove(movie) + user_data["watched"].append(movie) + break + + return user_data # ----------------------------------------- # ------------- WAVE 2 -------------------- # ----------------------------------------- +user_data = { + "watched" : [{ + "title": "Movie 4", + "genre": "Fantasy", + "rating": 4.8 + }, + { + "title": "Movie 5", + "genre": "SF", + "rating": 4.0 + }, + { + "title": "Movie 6", + "genre": "Horror", + "rating": 4.0 + }, + { + "title": "Movie 7", + "genre": "Fantasy", + "rating": 3.0 + }, + { + "title": "Movie 8", + "genre": "SF", + "rating": 4.8 + }, + { + "title": "Movie 9", + "genre": "SF", + "rating": 4.4 + }, + { + "title": "Movie 10", + "genre": "SF", + "rating": 4.0 + }, + { + "title": "Movie 11", + "genre": "SF", + "rating": 4.1 + } + ], + "watchlist" : [{ + "title": "Movie 1", + "genre": "SF", + "rating": 4.0 + }, + { + "title": "Movie 2", + "genre": "SF", + "rating": 5.0 + }, + { + "title": "Movie 3", + "genre": "SF", + "rating": 4.0 + }] +} + +def get_watched_avg_rating(user_data): + + if not user_data["watched"]: + return 0.0 + else: + total_rating = sum(movie["rating"] for movie in user_data["watched"]) + # return total_rating / len(user_data["watched"]) + test = total_rating / len(user_data["watched"]) + print(f"average {test = }") + return test + +get_watched_avg_rating(user_data) + +def get_most_watched_genre(user_data): + + if not user_data["watched"]: + return None + + genre_count = {} + for movie in user_data["watched"]: + genre = movie["genre"] + if genre in genre_count: + genre_count[genre] += 1 + else: + genre_count[genre] = 1 + # return max(genre_count, key=lambda genre: genre_count[genre]) + # values = None + # test = max(genre_count, key=genre_count.get("genre", values)) + test = max(genre_count, key=genre_count.get) + print(f"most {test = }") + return test + +get_most_watched_genre(user_data) # ----------------------------------------- # ------------- WAVE 3 -------------------- # ----------------------------------------- +# Wave 3 +# Create a function named get_unique_watched. This function should... +# take one parameter: user_data +# the value of user_data will be a dictionary with a "watched" list of movie dictionaries, and a "friends" +# This represents that the user has a list of watched movies and a list of friends +# The value of "friends" is a list +# Each item in "friends" is a dictionary. This dictionary has a key "watched", which has a list of movie dictionaries. +# Each movie dictionary has a "title". +# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies the user has watched, but none of their friends have watched. +# Return a list of dictionaries, that represents a list of movies +# Create a function named get_friends_unique_watched. This function should... +# take one parameter: user_data +# the value of user_data will be a dictionary with a "watched" list of movie dictionaries, and a "friends" +# This represents that the user has a list of watched movies and a list of friends +# The value of "friends" is a list +# Each item in "friends" is a dictionary. This dictionary has a key "watched", which has a list of movie dictionaries. +# Each movie dictionary has a "title". +# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies at least one of the user's friends have watched, but the user has not watched. +# Return a list of dictionaries, that represents a list of movies + +# For get_unique_watched: + +# Get the list of movies that the user has watched. +# Create an empty set to hold the titles of all the movies that the user's friends have watched. +# For each friend in the user's "friends" list: +# For each movie that the friend has watched: +# Add the movie title to the set of movies that the user's friends have watched. +# Create an empty list to hold the movies that the user has watched but none of their friends have watched. +# For each movie that the user has watched: +# If the title of the movie is not in the set of movies that the user's friends have watched: +# Add the movie to the list of movies that the user has watched but none of their friends have watched. +# Return the list of movies. + +def get_unique_watched(user_data): + user_movies = set([movie['title'] for movie in user_data['watched']]) + friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) + unique_movies = user_movies.difference(friends_movies) + return [{'title': movie} for movie in unique_movies] + + +# For get_friends_unique_watched: + +# Get the list of movies that the user has watched. +# Create an empty set to hold the titles of all the movies that the user's friends have watched. +# For each friend in the user's "friends" list: +# For each movie that the friend has watched: +# Add the movie title to the set of movies that the user's friends have watched. +# Create an empty list to hold the movies that at least one of the user's friends has watched but the user has not watched. +# For each movie that the user's friends have watched: +# If the title of the movie is not in the list of movies that the user has watched: +# If the title of the movie is not already in the list of movies that at least one of the user's friends have watched: +# Add the movie to the list of movies that at least one of the user's friends have watched but the user has not watched. +# Return the list of movies. + +def get_friends_unique_watched(user_data): + user_movies = set([movie['title'] for movie in user_data['watched']]) + friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) + unique_movies = friends_movies.difference(user_movies) + return [{'title': movie} for movie in unique_movies] # ----------------------------------------- # ------------- WAVE 4 -------------------- # ----------------------------------------- +user_data = { + "watched": [ + {"title": "fury", "genre": "action", "rating": 4.5, "host": "amazon"}, + {"title": "love", "genre": "romance", "rating": 4, "host": "netflix"} + ], + "subscriptions": ["netflix", "amazon", "hulu"], + "friends": [ + { + "name": "Amy", + "watched": [ + {"title": "love", "genre": "romance", "rating": 3, "host": "netflix"}, + {"title": "stars", "genre": "fantasy", "rating": 3, "host": "amazon"}, + {"title": "horror movie", "genre": "horror", "rating": 5, "host": "hulu"} + ] + }, + { + "name": "Matt", + "watched": [ + {"title": "fury", "genre": "action", "rating": 4, "host": "amazon"}, + {"title": "silly", "genre": "comedy", "rating": 3, "host": "disney+"} + ] + }, + { + "name": "Will", + "watched": [ + {"title": "fury", "genre": "action", "rating": 4.5, "host": "amazon"}, + {"title": "love", "genre": "romance", "rating": 3.5, "host": "netflix"}, + {"title": "stars", "genre": "fantasy", "rating": 3, "host": "amazon"} + ] + } + ] +} + +def get_available_recs(user_data): + recommendations = [] + friend_list = user_data["friends"] + user_watched_list = user_data["watched"] + sub_list = user_data["subscriptions"] + for friend in friend_list: + for movie in friend["watched"]: + if movie["host"] in sub_list and movie not in user_watched_list: + #1. works but adds duplicates, add something here to prevent that + #2.OR use wave 3 has a helper function? either works! + recommendations.append(movie) + return recommendations + +# get_available_recs(user_data) +# Wave 4 +# Create a function named get_available_recs. This function should... +# take one parameter: user_data +# user_data will have a field "subscriptions". The value of "subscriptions" is a list of strings +# This represents the names of streaming services that the user has access to +# Each friend in "friends" has a watched list. Each movie in the watched list has a "host", which is a string that says what streaming service it's hosted on +# Determine a list of recommended movies. A movie should be added to this list if and only if: +# The user has not watched it +# At least one of the user's friends has watched +# The "host" of the movie is a service that is in the user's "subscriptions" +# Return the list of recommended movies + +# iterate over FRIENDS: +# check to see if any of their movies != movies in watched +# if their movies are NOT in watched (True) +# check to see if the value to host is in SUBS? +# add those movies to recommended movies +# return recommended movies + + +# For each friend f in the friends list: +# For each movie m in the watched list of friend f: +# If the user has not watched the movie m +# and the movie m is hosted on a streaming service that is in the user's subscriptions list: +# Check if the movie m is already in the recs list. If not, add it to the recs list +# Return the recs list + + # ----------------------------------------- # ------------- WAVE 5 -------------------- # ----------------------------------------- +# Wave 5 +# Create a function named get_new_rec_by_genre. This function should... +# take one parameter: user_data +# Consider the user's most frequently watched genre. Then, determine a list of recommended movies. A movie should be added to this list if and only if: +# The user has not watched it +# At least one of the user's friends has watched +# The "genre" of the movie is the same as the user's most frequent genre +# Return the list of recommended movies +# Create a function named get_rec_from_favorites. This function should... +# take one parameter: user_data +# user_data will have a field "favorites". The value of "favorites" is a list of movie dictionaries +# This represents the user's favorite movies +# Determine a list of recommended movies. A movie should be added to this list if and only if: +# The movie is in the user's "favorites" +# None of the user's friends have watched it +# Return the list of recommended movies + +def get_new_rec_by_genre(user_data): + + + + + available_recs = [] + user_watchlist = get_unique_watched(user_data) + + # for i in range(len(user_data["favorites"])): + # if user_data["favorites"][i] in user_watchlist: + # available_recs.append(user_data["favorites"][i]) + # return available_recs + return user_watchlist + + + + From 5d4123a3084db814508754b10b7abb46be29c91a Mon Sep 17 00:00:00 2001 From: Jessica Date: Fri, 31 Mar 2023 10:13:25 -0600 Subject: [PATCH 2/3] all waves but dirty --- play_tester.py | 17 ++- tests/test_wave_03.py | 1 - tests/test_wave_05.py | 4 +- viewing_party/party.py | 294 ++++++++++++++++++----------------------- 4 files changed, 141 insertions(+), 175 deletions(-) diff --git a/play_tester.py b/play_tester.py index 9a3f0f9e9..3e5e6dc38 100644 --- a/play_tester.py +++ b/play_tester.py @@ -16,15 +16,16 @@ # print("\n-----Wave 02 user_data-----") # pp.pprint(clean_wave_2_data()) - # Arrange -janes_data = clean_wave_2_data() +# # Arrange +# janes_data = clean_wave_2_data() +# average = get_watched_avg_rating(janes_data) + +# print(f"{average = }") +# print(f"{average=}") -average = get_watched_avg_rating(janes_data) -print(f"{average = }") -print(f"{average=}") #print("\n-----Wave 03 user_data-----") -#pp.pprint(clean_wave_3_data()) +pp.pprint(clean_wave_3_data()) # Wave 04 user data #print("\n-----Wave 04 user_data-----") @@ -32,4 +33,6 @@ # Wave 05 user data #print("\n-----Wave 05 user_data-----") -#pp.pprint(clean_wave_5_data()) +pp.pprint(clean_wave_5_data()) + +get_rec_from_favorites(clean_wave_5_data()) \ No newline at end of file diff --git a/tests/test_wave_03.py b/tests/test_wave_03.py index aa534ceaf..ae25a9814 100644 --- a/tests/test_wave_03.py +++ b/tests/test_wave_03.py @@ -54,7 +54,6 @@ def test_friends_unique_movies_not_duplicated(): # Assert assert len(friends_unique_movies) == 3 - assert FANTASY_1 in friends_unique_movies assert INTRIGUE_3 in friends_unique_movies diff --git a/tests/test_wave_05.py b/tests/test_wave_05.py index 765298bdf..13475bef8 100644 --- a/tests/test_wave_05.py +++ b/tests/test_wave_05.py @@ -57,7 +57,9 @@ def test_new_genre_rec_from_empty_friends(): new_genre_rec = get_new_rec_by_genre(sonyas_data) # Assert - assert new_genre_rec is None + # assert new_genre_rec is None + # assert len(new_genre_rec) == 0 + assert new_genre_rec == [] # raise Exception("Test needs to be completed.") # ********************************************************************* diff --git a/viewing_party/party.py b/viewing_party/party.py index a9af6d35a..2c5462b61 100644 --- a/viewing_party/party.py +++ b/viewing_party/party.py @@ -35,65 +35,6 @@ def watch_movie(user_data, title): # ------------- WAVE 2 -------------------- # ----------------------------------------- -user_data = { - "watched" : [{ - "title": "Movie 4", - "genre": "Fantasy", - "rating": 4.8 - }, - { - "title": "Movie 5", - "genre": "SF", - "rating": 4.0 - }, - { - "title": "Movie 6", - "genre": "Horror", - "rating": 4.0 - }, - { - "title": "Movie 7", - "genre": "Fantasy", - "rating": 3.0 - }, - { - "title": "Movie 8", - "genre": "SF", - "rating": 4.8 - }, - { - "title": "Movie 9", - "genre": "SF", - "rating": 4.4 - }, - { - "title": "Movie 10", - "genre": "SF", - "rating": 4.0 - }, - { - "title": "Movie 11", - "genre": "SF", - "rating": 4.1 - } - ], - "watchlist" : [{ - "title": "Movie 1", - "genre": "SF", - "rating": 4.0 - }, - { - "title": "Movie 2", - "genre": "SF", - "rating": 5.0 - }, - { - "title": "Movie 3", - "genre": "SF", - "rating": 4.0 - }] -} - def get_watched_avg_rating(user_data): if not user_data["watched"]: @@ -105,7 +46,6 @@ def get_watched_avg_rating(user_data): print(f"average {test = }") return test -get_watched_avg_rating(user_data) def get_most_watched_genre(user_data): @@ -119,39 +59,22 @@ def get_most_watched_genre(user_data): genre_count[genre] += 1 else: genre_count[genre] = 1 - # return max(genre_count, key=lambda genre: genre_count[genre]) + return max(genre_count, key=lambda genre: genre_count[genre]) # values = None # test = max(genre_count, key=genre_count.get("genre", values)) - test = max(genre_count, key=genre_count.get) - print(f"most {test = }") - return test + # test = max(genre_count, key=genre_count.get) + # print(f"most {test = }") + # return test -get_most_watched_genre(user_data) # ----------------------------------------- # ------------- WAVE 3 -------------------- # ----------------------------------------- # Wave 3 -# Create a function named get_unique_watched. This function should... -# take one parameter: user_data -# the value of user_data will be a dictionary with a "watched" list of movie dictionaries, and a "friends" -# This represents that the user has a list of watched movies and a list of friends -# The value of "friends" is a list -# Each item in "friends" is a dictionary. This dictionary has a key "watched", which has a list of movie dictionaries. -# Each movie dictionary has a "title". + # Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies the user has watched, but none of their friends have watched. # Return a list of dictionaries, that represents a list of movies -# Create a function named get_friends_unique_watched. This function should... -# take one parameter: user_data -# the value of user_data will be a dictionary with a "watched" list of movie dictionaries, and a "friends" -# This represents that the user has a list of watched movies and a list of friends -# The value of "friends" is a list -# Each item in "friends" is a dictionary. This dictionary has a key "watched", which has a list of movie dictionaries. -# Each movie dictionary has a "title". -# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies at least one of the user's friends have watched, but the user has not watched. -# Return a list of dictionaries, that represents a list of movies - # For get_unique_watched: # Get the list of movies that the user has watched. @@ -166,11 +89,46 @@ def get_most_watched_genre(user_data): # Return the list of movies. def get_unique_watched(user_data): - user_movies = set([movie['title'] for movie in user_data['watched']]) - friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) - unique_movies = user_movies.difference(friends_movies) - return [{'title': movie} for movie in unique_movies] + # user_movies = user_data["watched"] + # friend_movies = user_data["friends"] + # unique_movies = [] + + # for user_movie in user_movies: + # movies_watched_by_friends = [] + # for friend in friend_movies: + # for friend_movie in friend["watched"]: + # if user_movie != friend_movie: + # movies_watched_by_friends.append(friend_movie) + + # if user_movie not in movies_watched_by_friends: + # unique_movies.append(user_movie) + + user_movies = user_data["watched"] + friend_movies = [] + for friend in user_data["friends"]: + for movie in friend["watched"]: + friend_movies.append(movie) + + unique_movies = [] + for user_movie in user_movies: + if user_movie not in friend_movies and user_movie not in unique_movies: + unique_movies.append(user_movie) + + print(f"{unique_movies = }") + return unique_movies + + # user_movies = set([movie['title'] for movie in user_data['watched']]) + # friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) + # unique_movies = user_movies.difference(friends_movies) + # unique_movies = [{'title': movie} for movie in unique_movies] + # print(f"{unique_movies = }") + # return unique_movies + +# get_unique_watched(user_data) + +# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies at least one of the user's friends have watched, but the user has not watched. +# Return a list of dictionaries, that represents a list of movies # For get_friends_unique_watched: @@ -187,87 +145,77 @@ def get_unique_watched(user_data): # Return the list of movies. def get_friends_unique_watched(user_data): - user_movies = set([movie['title'] for movie in user_data['watched']]) - friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) - unique_movies = friends_movies.difference(user_movies) - return [{'title': movie} for movie in unique_movies] + user_movies = user_data["watched"] + friend_movies = [] + for friend in user_data["friends"]: + for movie in friend["watched"]: + friend_movies.append(movie) + + unique_movies = [] + + for friend_movie in friend_movies: + if friend_movie not in user_movies and friend_movie not in unique_movies: + unique_movies.append(friend_movie) + + # print(f"{unique_movies = }") + return unique_movies + + + +# user_movies = set([movie['title'] for movie in user_data['watched']]) +# friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) +# unique_movies = friends_movies.difference(user_movies) +# return [{'title': movie} for movie in unique_movies] # ----------------------------------------- # ------------- WAVE 4 -------------------- # ----------------------------------------- -user_data = { - "watched": [ - {"title": "fury", "genre": "action", "rating": 4.5, "host": "amazon"}, - {"title": "love", "genre": "romance", "rating": 4, "host": "netflix"} - ], - "subscriptions": ["netflix", "amazon", "hulu"], - "friends": [ - { - "name": "Amy", - "watched": [ - {"title": "love", "genre": "romance", "rating": 3, "host": "netflix"}, - {"title": "stars", "genre": "fantasy", "rating": 3, "host": "amazon"}, - {"title": "horror movie", "genre": "horror", "rating": 5, "host": "hulu"} - ] - }, - { - "name": "Matt", - "watched": [ - {"title": "fury", "genre": "action", "rating": 4, "host": "amazon"}, - {"title": "silly", "genre": "comedy", "rating": 3, "host": "disney+"} - ] - }, - { - "name": "Will", - "watched": [ - {"title": "fury", "genre": "action", "rating": 4.5, "host": "amazon"}, - {"title": "love", "genre": "romance", "rating": 3.5, "host": "netflix"}, - {"title": "stars", "genre": "fantasy", "rating": 3, "host": "amazon"} - ] - } - ] -} - def get_available_recs(user_data): + movies_not_watched = get_friends_unique_watched(user_data) + print(f"{movies_not_watched = }") recommendations = [] - friend_list = user_data["friends"] - user_watched_list = user_data["watched"] sub_list = user_data["subscriptions"] - for friend in friend_list: - for movie in friend["watched"]: - if movie["host"] in sub_list and movie not in user_watched_list: + for movie in movies_not_watched: + if movie["host"] in sub_list: #1. works but adds duplicates, add something here to prevent that #2.OR use wave 3 has a helper function? either works! recommendations.append(movie) return recommendations +# get_available_recs(user_data) + + + # recommendations = [] + # friend_list = user_data["friends"] + # user_watched_list = user_data["watched"] + # sub_list = user_data["subscriptions"] + # for friend in friend_list: + # for movie in friend["watched"]: + # if movie["host"] in sub_list and movie not in user_watched_list: + # #1. works but adds duplicates, add something here to prevent that + # #2.OR use wave 3 has a helper function? either works! + # recommendations.append(movie) + # return recommendations + # get_available_recs(user_data) # Wave 4 -# Create a function named get_available_recs. This function should... -# take one parameter: user_data -# user_data will have a field "subscriptions". The value of "subscriptions" is a list of strings -# This represents the names of streaming services that the user has access to -# Each friend in "friends" has a watched list. Each movie in the watched list has a "host", which is a string that says what streaming service it's hosted on -# Determine a list of recommended movies. A movie should be added to this list if and only if: + + + + # The user has not watched it # At least one of the user's friends has watched # The "host" of the movie is a service that is in the user's "subscriptions" # Return the list of recommended movies -# iterate over FRIENDS: -# check to see if any of their movies != movies in watched -# if their movies are NOT in watched (True) -# check to see if the value to host is in SUBS? -# add those movies to recommended movies -# return recommended movies -# For each friend f in the friends list: -# For each movie m in the watched list of friend f: +# For each friend in the friends list: +# For each movie in the watched list of friend: # If the user has not watched the movie m -# and the movie m is hosted on a streaming service that is in the user's subscriptions list: -# Check if the movie m is already in the recs list. If not, add it to the recs list +# and the movie is hosted on a streaming service that is in the user's subscriptions list: +# Check if the movie is already in the recs list. If not, add it to the recs list # Return the recs list @@ -276,36 +224,50 @@ def get_available_recs(user_data): # ----------------------------------------- # Wave 5 -# Create a function named get_new_rec_by_genre. This function should... -# take one parameter: user_data -# Consider the user's most frequently watched genre. Then, determine a list of recommended movies. A movie should be added to this list if and only if: -# The user has not watched it -# At least one of the user's friends has watched + + +# A movie should be added to this list if and only if: + + # The "genre" of the movie is the same as the user's most frequent genre # Return the list of recommended movies -# Create a function named get_rec_from_favorites. This function should... -# take one parameter: user_data -# user_data will have a field "favorites". The value of "favorites" is a list of movie dictionaries -# This represents the user's favorite movies -# Determine a list of recommended movies. A movie should be added to this list if and only if: -# The movie is in the user's "favorites" -# None of the user's friends have watched it -# Return the list of recommended movies - -def get_new_rec_by_genre(user_data): +def get_new_rec_by_genre(user_data): - available_recs = [] - user_watchlist = get_unique_watched(user_data) + recommendations = [] + not_watched_yet = get_friends_unique_watched(user_data) + fav_genre = get_most_watched_genre(user_data) + # print(f"{not_watched_yet = }") + # print(f"{fav_genre = }") + + for movie in not_watched_yet: + if movie["genre"] == fav_genre: + recommendations.append(movie) + # print(f"{recommendations = }") + return recommendations +# get_new_rec_by_genre(user_data) - # for i in range(len(user_data["favorites"])): - # if user_data["favorites"][i] in user_watchlist: - # available_recs.append(user_data["favorites"][i]) - # return available_recs - return user_watchlist +def get_rec_from_favorites(user_data): + print(f"{user_data = }") + recommendations = [] + favorites = user_data["favorites"] + print(f"{favorites = }") + user_unique = get_unique_watched(user_data) + for movie in user_unique: + if movie in favorites: + recommendations.append(movie) + print(f"{recommendations = }") + return recommendations +# get_rec_from_favorites(user_data) +# user_data will have a field "favorites". The value of "favorites" is a list of movie dictionaries +# This represents the user's favorite movies +# Determine a list of recommended movies. A movie should be added to this list if and only if: +# The movie is in the user's "favorites" +# None of the user's friends have watched it get_unique_watched(user_data): +# Return the list of recommended movies \ No newline at end of file From cf54269c122a71283571b1c2987a9b25ff7c7eba Mon Sep 17 00:00:00 2001 From: Jessica Date: Fri, 31 Mar 2023 10:21:54 -0600 Subject: [PATCH 3/3] More cleaned up --- viewing_party/party.py | 132 +---------------------------------------- 1 file changed, 2 insertions(+), 130 deletions(-) diff --git a/viewing_party/party.py b/viewing_party/party.py index 2c5462b61..ed4977ea7 100644 --- a/viewing_party/party.py +++ b/viewing_party/party.py @@ -20,7 +20,6 @@ def add_to_watchlist(user_data, movie): user_data["watchlist"].append(movie) return user_data - def watch_movie(user_data, title): for movie in user_data["watchlist"]: @@ -41,12 +40,8 @@ def get_watched_avg_rating(user_data): return 0.0 else: total_rating = sum(movie["rating"] for movie in user_data["watched"]) - # return total_rating / len(user_data["watched"]) - test = total_rating / len(user_data["watched"]) - print(f"average {test = }") - return test + return total_rating / len(user_data["watched"]) - def get_most_watched_genre(user_data): if not user_data["watched"]: @@ -60,48 +55,12 @@ def get_most_watched_genre(user_data): else: genre_count[genre] = 1 return max(genre_count, key=lambda genre: genre_count[genre]) - # values = None - # test = max(genre_count, key=genre_count.get("genre", values)) - # test = max(genre_count, key=genre_count.get) - # print(f"most {test = }") - # return test - # ----------------------------------------- # ------------- WAVE 3 -------------------- # ----------------------------------------- -# Wave 3 - -# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies the user has watched, but none of their friends have watched. -# Return a list of dictionaries, that represents a list of movies -# For get_unique_watched: - -# Get the list of movies that the user has watched. -# Create an empty set to hold the titles of all the movies that the user's friends have watched. -# For each friend in the user's "friends" list: -# For each movie that the friend has watched: -# Add the movie title to the set of movies that the user's friends have watched. -# Create an empty list to hold the movies that the user has watched but none of their friends have watched. -# For each movie that the user has watched: -# If the title of the movie is not in the set of movies that the user's friends have watched: -# Add the movie to the list of movies that the user has watched but none of their friends have watched. -# Return the list of movies. - def get_unique_watched(user_data): - # user_movies = user_data["watched"] - # friend_movies = user_data["friends"] - # unique_movies = [] - - # for user_movie in user_movies: - # movies_watched_by_friends = [] - # for friend in friend_movies: - # for friend_movie in friend["watched"]: - # if user_movie != friend_movie: - # movies_watched_by_friends.append(friend_movie) - - # if user_movie not in movies_watched_by_friends: - # unique_movies.append(user_movie) user_movies = user_data["watched"] friend_movies = [] @@ -125,25 +84,6 @@ def get_unique_watched(user_data): # print(f"{unique_movies = }") # return unique_movies -# get_unique_watched(user_data) - -# Consider the movies that the user has watched, and consider the movies that their friends have watched. Determine which movies at least one of the user's friends have watched, but the user has not watched. -# Return a list of dictionaries, that represents a list of movies - -# For get_friends_unique_watched: - -# Get the list of movies that the user has watched. -# Create an empty set to hold the titles of all the movies that the user's friends have watched. -# For each friend in the user's "friends" list: -# For each movie that the friend has watched: -# Add the movie title to the set of movies that the user's friends have watched. -# Create an empty list to hold the movies that at least one of the user's friends has watched but the user has not watched. -# For each movie that the user's friends have watched: -# If the title of the movie is not in the list of movies that the user has watched: -# If the title of the movie is not already in the list of movies that at least one of the user's friends have watched: -# Add the movie to the list of movies that at least one of the user's friends have watched but the user has not watched. -# Return the list of movies. - def get_friends_unique_watched(user_data): user_movies = user_data["watched"] friend_movies = [] @@ -160,8 +100,6 @@ def get_friends_unique_watched(user_data): # print(f"{unique_movies = }") return unique_movies - - # user_movies = set([movie['title'] for movie in user_data['watched']]) # friends_movies = set([movie['title'] for friend in user_data['friends'] for movie in friend['watched']]) # unique_movies = friends_movies.difference(user_movies) @@ -173,101 +111,35 @@ def get_friends_unique_watched(user_data): def get_available_recs(user_data): movies_not_watched = get_friends_unique_watched(user_data) - print(f"{movies_not_watched = }") recommendations = [] sub_list = user_data["subscriptions"] for movie in movies_not_watched: if movie["host"] in sub_list: - #1. works but adds duplicates, add something here to prevent that - #2.OR use wave 3 has a helper function? either works! recommendations.append(movie) return recommendations -# get_available_recs(user_data) - - - # recommendations = [] - # friend_list = user_data["friends"] - # user_watched_list = user_data["watched"] - # sub_list = user_data["subscriptions"] - # for friend in friend_list: - # for movie in friend["watched"]: - # if movie["host"] in sub_list and movie not in user_watched_list: - # #1. works but adds duplicates, add something here to prevent that - # #2.OR use wave 3 has a helper function? either works! - # recommendations.append(movie) - # return recommendations - -# get_available_recs(user_data) -# Wave 4 - - - - -# The user has not watched it -# At least one of the user's friends has watched -# The "host" of the movie is a service that is in the user's "subscriptions" -# Return the list of recommended movies - - - -# For each friend in the friends list: -# For each movie in the watched list of friend: -# If the user has not watched the movie m -# and the movie is hosted on a streaming service that is in the user's subscriptions list: -# Check if the movie is already in the recs list. If not, add it to the recs list -# Return the recs list - - # ----------------------------------------- # ------------- WAVE 5 -------------------- # ----------------------------------------- -# Wave 5 - - -# A movie should be added to this list if and only if: - - -# The "genre" of the movie is the same as the user's most frequent genre -# Return the list of recommended movies - - - def get_new_rec_by_genre(user_data): recommendations = [] not_watched_yet = get_friends_unique_watched(user_data) fav_genre = get_most_watched_genre(user_data) - # print(f"{not_watched_yet = }") - # print(f"{fav_genre = }") for movie in not_watched_yet: if movie["genre"] == fav_genre: recommendations.append(movie) - # print(f"{recommendations = }") return recommendations -# get_new_rec_by_genre(user_data) def get_rec_from_favorites(user_data): - print(f"{user_data = }") recommendations = [] favorites = user_data["favorites"] - print(f"{favorites = }") user_unique = get_unique_watched(user_data) for movie in user_unique: if movie in favorites: recommendations.append(movie) - print(f"{recommendations = }") - - return recommendations -# get_rec_from_favorites(user_data) - -# user_data will have a field "favorites". The value of "favorites" is a list of movie dictionaries -# This represents the user's favorite movies -# Determine a list of recommended movies. A movie should be added to this list if and only if: -# The movie is in the user's "favorites" -# None of the user's friends have watched it get_unique_watched(user_data): -# Return the list of recommended movies \ No newline at end of file + return recommendations \ No newline at end of file