def get_movies_by_actor(self, actor):
# Fetch the Movies.
try:
movies = self._movie_actor[Actor(actor)]
except KeyError:
print("KeyError has been raised!")
pass # Ignore exception and return None.
return movies
def test_repository_can_add_actor_dict(in_memory_repo):
movie = Movie(
"I am Legend",
1981
)
actor = Actor("Will Smith")
movie.actors=actor
dict_actor = {}
dict_actor[actor]=[movie]
in_memory_repo.add_actor(dict_actor)
assert in_memory_repo.get_actors() is dict_actor
def load_movie_data(data_path: str, repo: MemoryRepository):
actors = dict()
genres = dict()
directors = dict()
for line in read_csv_file(os.path.join(data_path, 'Data1000Movies.csv')):
movie_id = line[0]
movie_genres = line[2].split(',')
movie_director = line[4].strip()
movie_actors = line[5].split(',')
for actor in movie_actors:
actor = actor.strip()
if actor not in actors.keys():
actors[actor] = list()
actors[actor].append(movie_id)
for genre in movie_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_id)
if movie_director not in directors.keys():
directors[movie_director] = list()
directors[movie_director].append(movie_id)
movie = Movie(
title=line[1], description=line[3], year=line[6], runtime_minutes=line[7], rating=line[8],
votes=line[9], revenue_millions=line[10], meta_score=line[11], id=movie_id
)
repo.add_movie(movie)
for actor in actors.keys():
actorobj = Actor(actor)
for movie_id in actors[actor]:
movie = repo.get_movie(movie_id)
make_actor_association(movie, actorobj)
repo.add_actor(actorobj)
for genre in genres.keys():
genreobj = Genre(genre)
for movie_id in genres[genre]:
movie = repo.get_movie(movie_id)
make_genre_association(movie, genreobj)
repo.add_genre(genreobj)
for director in directors.keys():
directorobj = Director(director)
for movie_id in directors[director]:
movie = repo.get_movie(movie_id)
make_director_association(movie, directorobj)
repo.add_director(directorobj)
def test_init(actor):
actor1 = Actor("Angelina Jolie")
assert repr(actor1) == "<Actor Angelina Jolie>"
actor2 = Actor("")
assert actor2.actor_full_name is None
actor3 = Actor(42)
assert actor3.actor_full_name is None
# check for equality of two Director object instances by comparing the names
actor4 = Actor("Angelina Jolie")
assert (actor1 == actor4) == True
# implement a sorting order defined by the name
a_list = []
actor5 = Actor("Aatrox")
a_list.append(actor1)
a_list.append(actor5)
a_list.sort()
assert a_list[0] == actor5
# defines which attribute is used for computing a hash value as used in set or dictionary keys
actors = {actor1, actor4}
assert len(actors) == 1
# add coleague and check whether it is inside the list
actor1.add_actor_colleague(actor5)
assert actor1.check_if_this_actor_worked_with(actor5) == True
def test_init(review):
user = User('Steve', 'pass123')
movie = Movie("Moana", 2016)
review_text = "This movie was very enjoyable."
rating = 8
timestamp = datetime.today()
review = Review(user, movie, review_text, timestamp, rating)
## test cr3
assert repr(review.movie) == "<Movie Moana, 2016>"
assert "Review: {}".format(
review.review_text) == "Review: This movie was very enjoyable."
assert "Rating: {}".format(review.rating) == "Rating: 8"
##test movie
actor = Actor("Will Smith")
review.movie = actor ##illegal
assert repr(review.movie) == "<Movie Moana, 2016>"
movie = Movie("Will Smith smith Will Smith?", 1900)
review.movie = movie ##legal
assert repr(review.movie) == "<Movie Will Smith smith Will Smith?, 1900>"
##test review text
review.review_text = 1900 ##illegal
assert review.review_text == "This movie was very enjoyable."
review.review_text = "Will Smith will smith Will Smith" ##legal
assert review.review_text == "Will Smith will smith Will Smith"
##test rating
review.rating = 10.1
assert review.rating == 8
review.rating = 9
assert review.rating == 9
##test __eq__
movie = Movie("Will Smith smith Will Smith?", 1900)
review_text = "Will Smith will smith Will Smith"
rating = 9
review1 = Review(user, movie, review_text, timestamp, rating)
assert review == review1
def test_properties(movie):
movie1 = Movie("Moana", 2016)
movie1.title = "Hokage" # legal title
assert repr(movie1) == "<Movie Hokage, 2016>"
movie1.title = 1234 # illegal title
assert repr(movie1) == "<Movie Hokage, 2016>"
movie2 = Movie("Raikage", 2004)
movie2.description = " Faster than speed of light for real " # legal description
assert movie2.description == "Faster than speed of light for real"
movie2.description = "" # illegal description
assert movie2.description == "Faster than speed of light for real"
movie3 = Movie("Moana", 2016)
actor = Actor("Jacinda Adern")
director = Director("Ron Clements")
movie3.director = actor #illegal director
assert movie3.director is None
movie3.director = director #legal director
assert repr(movie3.director) == "<Director Ron Clements>"
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie3.add_actor(actor) ##legal adding actor
assert str(
movie3.actors
) == "[<Actor Auli'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
movie3.add_actor(director) ##illegal adding actor
assert str(
movie3.actors
) == "[<Actor Auli'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
movie3.remove_actor(Actor("Rachel House")) ##legal remove actor
assert str(
movie3.actors
) == "[<Actor Auli'i Cravalho>, <Actor Dwayne Johnson>, <Actor Temuera Morrison>]"
movie3.remove_actor(director) ##illegal remove actor
assert str(
movie3.actors
) == "[<Actor Auli'i Cravalho>, <Actor Dwayne Johnson>, <Actor Temuera Morrison>]"
movie3.actors = Actor("Dwayne Johnson") ##test setter
assert str(movie3.actors) == "[<Actor Dwayne Johnson>]"
genres = [
Genre("Comedy"),
Genre("Action"),
Genre("Disney"),
Genre("Romantic")
]
for genre in genres:
movie3.add_genre(genre) ##legal adding genre
assert str(
sorted(movie3.genres)
) == "[<Genre Action>, <Genre Comedy>, <Genre Disney>, <Genre Romantic>]"
movie3.add_genre(director) ##illegal adding genre
assert str(
movie3.genres
) == "[<Genre Comedy>, <Genre Action>, <Genre Disney>, <Genre Romantic>]"
movie3.remove_genre(Genre("Romantic")) ##legal remove genre
assert str(
movie3.genres) == "[<Genre Comedy>, <Genre Action>, <Genre Disney>]"
movie3.remove_genre(director) ##illegal remove genre
assert str(
movie3.genres) == "[<Genre Comedy>, <Genre Action>, <Genre Disney>]"
movie3.genres = Genre("Comedy") ##test setter
assert str(movie3.genres) == "[<Genre Comedy>]"
movie3.runtime_minutes = 107 ## legal runtime
assert "Movie runtime: {} minutes".format(
movie3.runtime_minutes) == "Movie runtime: 107 minutes"
with pytest.raises(ValueError):
movie3.runtime_minutes = -1 ## illegal runtime
###################################### test extension ######################################
movie3.rank = 185 ## legal rank
assert movie3.rank == 185
with pytest.raises(ValueError):
movie3.rank = -1 ## illegal rank
movie3.rating = 8.1 ## legal rating
assert movie3.rating == 8.1
with pytest.raises(ValueError):
movie3.rating = 11 ## illegal rating
movie3.votes = 107583 ## legal votes
assert movie3.votes == 107583
with pytest.raises(ValueError):
movie3.votes = -1 ## illegal votes
movie3.revenue_millions = 510.365 ## legal revenue_millions
assert movie3.revenue_millions == 510.365
with pytest.raises(ValueError):
movie3.revenue_millions = -510.365 ## illegal revenue_millions
movie3.metascore = 91.6 ## legal metascore
assert movie3.metascore == 91.6
with pytest.raises(ValueError):
movie3.metascore = -91.6 ## illegal metascore
def load_movies(data_path: str, repo: MemoryRepository):
dataset_of_movies = []
dataset_of_actors = []
dataset_of_directors = []
dataset_of_genres = []
dictionary_genres = {} # extension
dictionary_actors = {} # extension
dictionary_directors = {} # extension
dictionary_years = {}
ignore_row = 0
for row in read_csv_file(os.path.join(data_path, 'Data1000Movies.csv')):
if ignore_row == 0:
ignore_row += 1
continue
rank = int(row[0])
title = row[1]
genres = row[2].split(',')
description = row[3]
director = Director(str(row[4]))
actors = row[5].split(',')
release_year = int(row[6])
runtime_minutes = int(row[7])
rating = float(row[8])
votes = int(row[9])
revenue_millions = row[10]
metascore = row[11]
image_hyperlink = row[12]
# create movie object
movie = Movie(title, release_year)
dataset_of_movies.append(movie)
if movie.year not in dictionary_years:
dictionary_years[movie.year] = [movie] # extension
else:
dictionary_years[movie.year].append(movie)
# add actors
for actor in actors:
actor_obj = Actor(actor)
movie.add_actor(actor_obj)
if actor_obj not in dataset_of_actors:
dataset_of_actors.append(actor_obj)
dictionary_actors[actor_obj] = [movie] # extension
else:
dictionary_actors[actor_obj].append(movie) # extension
# add director
movie.director = director
if director not in dataset_of_directors:
dataset_of_directors.append(director)
dictionary_directors[director] = [movie]
else:
dictionary_directors[director].append(movie)
# add genre
for genre in genres:
genre_obj = Genre(genre)
movie.add_genre(genre_obj)
if genre_obj not in dataset_of_genres:
dataset_of_genres.append(genre_obj)
dictionary_genres[genre_obj] = [movie] # extension
else:
dictionary_genres[genre_obj].append(movie) # extension
# add description
movie.description = description
# add runtime
movie.runtime_minutes = runtime_minutes
# add rank
movie.rank = rank
# add rating
movie.rating = rating
# add votes
movie.votes = votes
# add revenue_million
movie.revenue_millions = revenue_millions
# add metascore
movie.metascore = metascore
# add metascore
movie.image_hyperlink = image_hyperlink
# Add the Movie to the repository.
repo.add_movie(movie)
repo.add_year(dictionary_years)
repo.add_genres(dictionary_genres)
repo.add_director(dictionary_directors)
repo.add_actor(dictionary_actors)
def actor():
return Actor('')
def dict_to_actors(dict_list):
actor_list = []
for dict in dict_list:
actor_list.append(Actor(dict.actor_name))
return actor_list
def actor():
return Actor('Chris Pratt')