def get_fuzzy_search_movies(fuzzy, repo):
"""
"""
movies = list(repo.dataset_of_movies)
movie_title_dict = dict(enumerate([movie.title for movie in movies]))
best_matches = process.extractBests(fuzzy, movie_title_dict, score_cutoff=50)
return [utils.movie_to_dict(movie) for movie in [movies[z] for (x, y, z) in best_matches]]
def get_movies(actors, genres, director, repo: AbstractRepository):
"""
"""
movies = repo.dataset_of_movies
matches = set()
for movie in movies:
for actor in actors:
if actor in [actor.actor_full_name for actor in movie.actors]:
if len(genres) > 0:
for genre in genres:
if genre in [genre.genre_name for genre in movie.genres]:
if director is not None:
if director == movie.director.director_full_name:
matches.add(movie)
else:
if movie in matches:
matches.remove(movie)
else:
matches.add(movie)
else:
if movie in matches:
matches.remove(movie)
else:
if movie in matches:
matches.remove(movie)
return [utils.movie_to_dict(movie) for movie in matches]
def get_actors(repo: AbstractRepository):
"""
"""
actors = []
for actor in sorted(repo.dataset_of_actors):
movies = repo.get_movies_by_actor(actor)
actors.append(dict(name=actor.actor_full_name, movies=[utils.movie_to_dict(movie) for movie in movies]))
return actors
def get_user_watchlist(username: str, repo: AbstractRepository):
"""
"""
watchlist = repo.get_watchlists_for_user(repo.get_user(username=username))
if watchlist and watchlist.size() != 0:
return [utils.movie_to_dict(movie) for movie in watchlist]
else:
return []
def get_movies_by_first_letter(character: str, repo: AbstractRepository):
"""
"""
matching_movies = []
for movie in sorted(repo.dataset_of_movies):
if movie.title[0] == character.upper():
matching_movies.append(utils.movie_to_dict(movie))
return matching_movies
def get_genres(repo: AbstractRepository):
"""
"""
genres = []
for genre in sorted(repo.dataset_of_genres):
movies = repo.get_movies_by_genre(genre)
genres.append(dict(name=genre.genre_name, movies=[utils.movie_to_dict(movie) for movie in movies]))
return genres
def get_movies_by_director(director: str, repo: AbstractRepository):
"""
"""
director = repo.get_director_by_name(director)
if director is None:
raise BrowseException
movies = repo.get_movies_by_director(director)
return [utils.movie_to_dict(movie) for movie in movies]
def get_movies_by_genre(genre: str, repo: AbstractRepository):
"""
"""
genre = repo.get_genre(genre)
if genre is None:
raise UnknownGenreException
movies = repo.get_movies_by_genre(genre)
return [utils.movie_to_dict(movie) for movie in movies]
def get_movie(title: str, year: str, repo: AbstractRepository):
"""
"""
try:
movie = repo.get_movie(title, int(year))
if not movie:
raise UnknownMovieException
return utils.movie_to_dict(movie)
except:
pass
def get_directors_by_first_letter(character: str, repo: AbstractRepository):
"""
"""
matching_directors = []
for director in sorted(repo.dataset_of_directors):
if director.director_full_name[0] == character.upper():
movies = repo.get_movies_by_director(director)
matching_directors.append(
dict(name=director.director_full_name, movies=[utils.movie_to_dict(movie) for movie in movies]))
return matching_directors
def get_movies_by_director(director: str, repo: AbstractRepository):
"""
"""
director = repo.get_director_by_name(director)
if director is None:
raise PersonException
movies = repo.get_movies_by_director(director)
return [
utils.movie_to_dict(movie)
for movie in sorted(movies, key=lambda x: x.rank)
]
def get_movies_by_actor(actor, repo: AbstractRepository):
"""
"""
actor = repo.get_actor(actor)
if actor is None:
raise PersonException('Actor does not exist')
movies = repo.get_movies_by_actor(actor)
return [
utils.movie_to_dict(movie)
for movie in sorted(movies, key=lambda x: x.rank)
], get_collegues(actor)
def user_to_dict(user: User):
"""
"""
user_dict = dict(
username=user.user_name,
watchlist=utils.get_user_watchlist(),
watched_movies=[
utils.movie_to_dict(movie) for movie in user.watched_movies
],
reviews=utils.reviews_to_dict(user.reviews),
time_spent=user.time_spent_watching_movies_minutes,
isAdmin=user.is_admin,
)
def get_movies_for_genres(genres, repo):
"""
"""
movies = set()
to_remove = []
for genre in genres:
genre_obj = Genre(genre)
for movie in repo.get_movies_by_genre(genre_obj):
movies.add(movie)
for genre in genres:
genre_obj = Genre(genre)
for movie in movies:
if genre_obj not in movie.genres:
to_remove.append(movie)
for item in to_remove:
movies.remove(item)
return [utils.movie_to_dict(movie) for movie in movies]
def get_search_results(actors, genres, director, fuzzy, repo: AbstractRepository):
"""
"""
results = [utils.movie_to_dict(movie) for movie in repo.dataset_of_movies]
if actors:
actor_movies = get_movies_for_actors(actors, repo)
results = [movie for movie in results if movie in actor_movies]
if genres:
genre_movies = get_movies_for_genres(genres, repo)
results = [movie for movie in results if movie in genre_movies]
if director and director != 'None':
director_movies = get_movies_for_director(director, repo)
results = [movie for movie in results if movie in director_movies]
if fuzzy:
fuzzy_search_results = get_fuzzy_search_movies(fuzzy, repo)
results = [movie for movie in results if movie in fuzzy_search_results]
return sorted(results, key=lambda x: x['rank'])
def get_movies_for_actors(actors, repo):
"""
"""
movies = set()
to_remove = []
for actor in actors:
actor_obj = Actor(actor)
for movie in repo.get_movies_by_actor(actor_obj):
movies.add(movie)
for actor in actors:
actor_obj = Actor(actor)
for movie in movies:
if actor_obj not in movie.actors:
to_remove.append(movie)
for item in to_remove:
if item in movies:
movies.remove(item)
return [utils.movie_to_dict(movie) for movie in movies]
def get_movies_for_director(director, repo):
"""
"""
if director is None:
return []
return [utils.movie_to_dict(movie) for movie in repo.get_movies_by_director(Director(director))]
def get_top_100movies(repo: AbstractRepository):
"""
"""
movies = repo.get_movies_by_rank()[0:100]
return [utils.movie_to_dict(movie) for movie in movies]
def get_movies(repo: AbstractRepository):
"""
"""
return [utils.movie_to_dict(movie) for movie in sorted(repo.dataset_of_movies, key=lambda x: x.rank)]