def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
title = row['Title']
release_year = int(row['Year'])
movie = Movie(title, release_year)
self.__dataset_of_movies.append(movie)
actors = row["Actors"]
actors = actors.split(",")
for actor in actors:
actor = Actor(actor)
movie.add_actor(actor)
if actor not in self.__dataset_of_actors:
self.__dataset_of_actors.append(actor)
director = Director(row["Director"])
movie.director = director
if director not in self.__dataset_of_directors:
self.__dataset_of_directors.append(director)
genres = row["Genre"]
genres = genres.split(",")
for genre in genres:
genre = Genre(genre)
movie.add_genre(genre)
if genre not in self.__dataset_of_genres:
self.__dataset_of_genres.append(genre)
movie.description = row["Description"]
movie.runtime_minutes = row["Runtime (Minutes)"]
def test_movie_runtime(self):
movie = Movie("Moana", 2016)
movie.description = " This is a movie "
assert movie.description == "This is a movie"
movie.director = Director("Ron Clements")
assert movie.director.director_full_name is "Ron Clements"
assert repr(movie.director) == "<Director Ron Clements>"
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
assert repr(
movie.actors
) == "[<Actor Auli\'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
movie.remove_actor(Actor("Dwayne Johnson"))
assert repr(
movie.actors
) == "[<Actor Auli\'i Cravalho>, <Actor Rachel House>, <Actor Temuera Morrison>]"
genres = [Genre("Animated"), Genre("Comedy")]
for genre in genres:
movie.add_genre(genre)
assert repr(movie.genres) == "[<Genre Animated>, <Genre Comedy>]"
movie.remove_genre(Genre("Comedy"))
assert repr(movie.genres) == "[<Genre Animated>]"
movie.runtime_minutes = 100
assert movie.runtime_minutes is 100
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
title = row['Title']
release_year = int(row['Year'])
movie = Movie(title, release_year)
for actor in row['Actors'].split(","):
actor = Actor(actor.strip())
if actor not in self.__actors:
self.__actors.add(actor)
movie.add_actor(actor)
director = Director(row['Director'].strip())
if director not in self.__directors:
self.__directors.add(director)
movie.director = director
for genre in row['Genre'].split(','):
genre = Genre(genre.strip())
if genre not in self.__genres:
self.__genres.add(genre)
movie.add_genre(genre)
movie.runtime_minutes = row["Runtime (Minutes)"]
movie.description = row["Description"]
self.__movies.append(movie)
index += 1
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
movie = Movie(row['Title'], int(row['Year']))
movie.description = row['Description']
movie.runtime_minutes = int(row['Runtime (Minutes)'])
director = Director(row['Director'])
self.__dataset_of_directors.add(director)
movie.director = director
parsed_genres = row['Genre'].split(',')
for genre_string in parsed_genres:
genre = Genre(genre_string)
self.__dataset_of_genres.add(genre)
movie.add_genre(genre)
parsed_actors = row['Actors'].split(',')
for actor_string in parsed_actors:
actor = Actor(actor_string)
self.__dataset_of_actors.add(actor)
movie.add_actor(actor)
self.__dataset_of_movies.append(movie)
def test_remove_actor(self):
movie1 = Movie("Moana", 2016)
movie1.add_actor(Actor("Some Actor"))
assert len(movie1.actors) == 1
movie1.remove_actor(Actor("Some Actor"))
assert len(movie1.actors) == 0
movie1.remove_actor(Actor("Some Actor"))
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
title = row["Title"]
release_year = int(row["Year"])
movie = Movie(title, release_year)
movie.description = row["Description"]
director = row["Director"]
movie.director = director
if Director(director) not in self.__dataset_of_directors:
self.__dataset_of_directors.append(Director(director))
actors = row["Actors"].split(",")
for actor in actors:
movie.add_actor(Actor(actor))
if Actor(actor) not in self.__dataset_of_actors:
self.__dataset_of_actors.append(Actor(actor))
genres = row["Genre"].split(",")
for genre in genres:
movie.add_genre(Genre(genre))
if Genre(genre) not in self.__dataset_of_genres:
self.__dataset_of_genres.append(Genre(genre))
movie.runtime_minutes = int(row["Runtime (Minutes)"])
try:
movie.external_rating = float(row["Rating"])
except ValueError:
pass
try:
movie.rating_votes = int(row["Votes"])
except ValueError:
pass
try:
movie.revenue_in_millions = float(row["Revenue (Millions)"])
except ValueError:
pass
try:
movie.metascore = int(row["Metascore"])
except ValueError:
pass
self.__dataset_of_movies.append(movie)
# title = row['Title']
# release_year = int(row['Year'])
# print(f"Movie {index} with title: {title}, release year {release_year}")
index += 1
def test_actors():
movie1 = Movie("Moana", 2016)
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie1.add_actor(actor)
assert movie1.actors == actors
def test_add_actor():
movie1 = Movie("Spirited Away", 2000)
movie1.actors = [Actor("James Huang")]
movie1.add_actor(Actor("Jack Huang"))
assert movie1.actors == [Actor("James Huang"), Actor("Jack Huang")]
movie1.add_actor("Ron Huang")
movie1.add_actor("")
movie1.add_actor(None)
movie1.add_actor(21345648)
assert movie1.actors == [Actor("James Huang"), Actor("Jack Huang")]
def test_top_actors(stats):
movie2 = Movie('Brin', 2002)
movie2.add_actor(Actor("Tom Cruise"))
stats.user.watch_movie(movie2)
stats.update_watched_lists()
assert stats.top_actors(2) == [Actor("Tom Cruise"), Actor("Will Smith")]
assert stats.top_actors(6) == []
assert stats.top_actors(-1) == [
Actor("Tom Cruise"),
Actor("Will Smith"),
Actor("Selena Gomez"),
Actor("Daniel Radcliff")
]
def test_movies():
movie_file_reader = MovieFileCSVReader('test.csv')
movie_file_reader.read_csv_file()
movie1 = Movie("Guardians of the Galaxy", 2014)
movie1.description = "A group of intergalactic criminals are forced to work together to stop a fanatical warrior from taking control of the universe."
movie1.runtime_minutes = 121
movie1.votes = 757074
movie1.rating = 8.1
movie1.add_genre(Genre("Action"))
movie1.add_genre(Genre("Adventure"))
movie1.add_genre(Genre("Sci-Fi"))
movie1.add_actor(Actor("Chris Pratt"))
movie1.add_actor(Actor("Vin Diesel"))
movie1.add_actor(Actor("Bradley Cooper"))
movie1.add_actor(Actor("Zoe Saldana"))
movie1.director = Director("James Gunn")
assert movie_file_reader.dataset_of_movies[0] == movie1
assert movie_file_reader.dataset_of_movies[0].runtime_minutes == movie1.runtime_minutes
assert movie_file_reader.dataset_of_movies[0].description == movie1.description
assert movie_file_reader.dataset_of_movies[0].votes == movie1.votes
assert movie_file_reader.dataset_of_movies[0].rating == movie1.rating
assert movie_file_reader.dataset_of_movies[0].actors == movie1.actors
assert movie_file_reader.dataset_of_movies[0].genres == movie1.genres
assert movie_file_reader.dataset_of_movies[0].director == movie1.director
assert movie_file_reader.dataset_of_actors[0] == Actor("Chris Pratt")
assert movie_file_reader.dataset_of_actors[1] == Actor("Vin Diesel")
assert movie_file_reader.dataset_of_actors[2] == Actor("Bradley Cooper")
assert movie_file_reader.dataset_of_actors[3] == Actor("Zoe Saldana")
assert repr(movie_file_reader.dataset_of_actors[0].actor_colleague_list) == "[<Actor Vin Diesel>, <Actor Bradley Cooper>, <Actor Zoe Saldana>, <Actor Jennifer Lawrence>, <Actor Michael Sheen>, <Actor Laurence Fishburne>, <Actor Denzel Washington>, <Actor Ethan Hawke>, <Actor Vincent D'Onofrio>, <Actor Bryce Dallas Howard>, <Actor Ty Simpkins>, <Actor Judy Greer>, <Actor Will Ferrell>, <Actor Elizabeth Banks>, <Actor Will Arnett>, <Actor Jessica Chastain>, <Actor Joel Edgerton>, <Actor Mark Strong>, <Actor Channing Tatum>, <Actor Rosario Dawson>, <Actor Jenna Dewan Tatum>]"
assert movie_file_reader.dataset_of_directors[0] == Director("James Gunn")
assert movie_file_reader.dataset_of_genres[0] == Genre("Action")
assert movie_file_reader.dataset_of_genres[1] == Genre("Adventure")
assert movie_file_reader.dataset_of_genres[2] == Genre("Sci-Fi")
def test_remove_actor():
movie1 = Movie("Spirited Away", 2000)
movie1.actors = [Actor("James Huang"), Actor("Ron Huang")]
movie1.add_actor(Actor("Jack Huang"))
movie1.remove_actor(Actor("Jack Huang"))
assert movie1.actors == [Actor("James Huang"), Actor("Ron Huang")]
movie1.remove_actor(Actor("James Huang"))
movie1.remove_actor(Actor("Jawer"))
movie1.remove_actor(Actor("Jackwerang"))
movie1.remove_actor(Actor("Jweruang"))
assert movie1.actors == [Actor("Ron Huang")]
movie1.remove_actor(Actor("Ron Huang"))
assert movie1.actors == []
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
try:
movie = Movie(row['Title'], int(row['Year']))
except ValueError:
print("Invalid release year")
else:
director = Director(row['Director'].strip())
actors = row['Actors'].split(",")
genres = row['Genre'].split(",")
movie.director = director
if director not in self.__dataset_of_directors:
self.__dataset_of_directors.append(director)
movie.description = row['Description'].strip()
for actor_name in actors:
actor_name = actor_name.strip()
actor = Actor(actor_name.strip())
if actor in self.dataset_of_actors:
i = self.dataset_of_actors.index(actor)
actor = self.dataset_of_actors[i]
else:
self.__dataset_of_actors.append(actor)
for actor1_name in actors:
actor1_name = actor1_name.strip()
if not actor.check_if_this_actor_worked_with(Actor(actor1_name)) and (actor_name != actor1_name):
actor.add_actor_colleague(Actor(actor1_name))
movie.add_actor(actor)
for genre_name in genres:
genre = Genre(genre_name.strip())
movie.add_genre(genre)
if genre not in self.__dataset_of_genres:
self.__dataset_of_genres.append(genre)
try:
movie.runtime_minutes = int(row['Runtime (Minutes)'])
except ValueError:
movie.runtime_minutes = None
try:
movie.votes = int(row['Votes'])
except ValueError:
movie.votes = None
try:
movie.rating = float(row['Rating'])
except ValueError:
movie.rating = None
if movie not in self.__dataset_of_movies: # Check if this takes into account the same movie but different objects
self.__dataset_of_movies.append(movie)
index += 1
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
title = row['Title']
release_year = int(row['Year'])
#print(f"Movie {index} with title: {title}, release year {release_year}")
m = Movie(title, release_year)
m.description = row['Description']
director = Director(row['Director'])
try:
# if director exists, assign the same director object to the movie
index = self.dataset_of_directors.index(director)
director = self.dataset_of_directors[index]
except ValueError:
self.dataset_of_directors.append(director)
m.director = director
m.votes = int(row['Votes'])
m.rating = float(row['Rating'])
m.runtime_minutes = int(row['Runtime (Minutes)'])
if row['Metascore'] != 'N/A':
m.metascore = float(row['Metascore'])
if row['Revenue (Millions)'] != 'N/A':
m.revenue = float(row['Revenue (Millions)'])
for g in row['Genre'].split(","):
genre = Genre(g)
try:
index = self.dataset_of_genres.index(genre)
genre = self.dataset_of_genres[index]
except ValueError:
self.dataset_of_genres.append(genre)
m.add_genre(genre)
for a in row['Actors'].split(","):
actor = Actor(a)
try:
index = self.dataset_of_actors.index(actor)
actor = self.dataset_of_actors[index]
except ValueError:
self.dataset_of_actors.append(actor)
m.add_actor(actor)
if m not in self.dataset_of_movies:
self.dataset_of_movies.append(m)
def test_actors():
aa = Movie("Emu Wars", 2000)
actor1 = Actor("Rick Astley")
actor2 = Actor("Voldemort")
actor3 = Actor("Winnie the Pooh")
aa.add_actor(actor1)
aa.add_actor(actor2)
aa.add_actor(actor2)
assert aa.actors == [actor1, actor2]
aa.remove_actor(actor1)
aa.remove_actor(actor3)
assert aa.actors == [actor2]
def test_init(self):
movie1 = Movie("Moana", 2016)
#movie1.release_year = 2017
assert repr(movie1) == "<Movie Moana, 2016>"
director1 = Director("Ron Clements")
movie1.director = director1
the_director = movie1.director
assert the_director == director1
print(movie1.director)
actors = [Actor("Auli'i Cravalho"), Actor("Dwayne Johnson"), Actor("Rachel House"), Actor("Temuera Morrison")]
for actor in actors:
movie1.add_actor(actor)
print(movie1.actors)
movie1.runtime_minutes = 107
print("Movie runtime: {} minutes".format(movie1.runtime_minutes))
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
title = row['Title']
genres = row['Genre']
description = row['Description']
release_year = int(row['Year'])
director = row["Director"]
actors = row["Actors"]
runtime = int(row["Runtime (Minutes)"])
rating = row["Rating"]
votes = row["Votes"]
revenue = row["Revenue (Millions)"]
metascore = row["Metascore"]
#print(f"Movie {index} with title: {title}, release year {release_year}")
#print(index, title, genre, release_year, director, actors, runtime, rating, votes, revenue, metascore)
movie_director = Director(director)
movie = Movie(title, release_year)
movie.director = movie_director
movie.description = description.strip()
for actor in actors.split(","):
actor = Actor(actor)
movie.add_actor(actor)
if actor not in self.__dataset_of_actors:
self.__dataset_of_actors.append(actor)
movie.runtime_minutes = runtime
for genre in genres.split(","):
genre = Genre(genre)
movie.add_genre(genre)
if genre not in self.__dataset_of_genres:
self.__dataset_of_genres.append(genre)
if movie not in self.__dataset_of_movies:
self.__dataset_of_movies.append(movie)
if movie_director not in self.__dataset_of_directors:
self.__dataset_of_directors.append(movie_director)
index += 1
def test_movie_set_actors(self):
movie = Movie("Moana", 2016)
movie.description = " This is a movie "
assert movie.description == "This is a movie"
movie.director = Director("Ron Clements")
assert movie.director.director_full_name is "Ron Clements"
assert repr(movie.director) == "<Director Ron Clements>"
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
assert repr(
movie.actors
) == "[<Actor Auli\'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
def test_basic():
movie = Movie("Moana", 2015)
assert str(movie) == "<Movie Moana, 2015>"
director = Director("Ron Clements")
movie.director = director
assert movie.director == Director("Ron Clements")
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
assert movie.actors == actors
movie.runtime_minutes = 107
assert movie.runtime_minutes == 107
def test_more_methods(self):
a_movie = Movie("Back To The Future", 1965)
actor1 = Actor("Michael J. Fox")
actor2 = Actor("Christopher Lloyd")
genre1 = Genre("Horror")
genre2 = Genre("Comedy")
a_movie.add_actor(actor1)
assert a_movie.actors == [actor1]
a_movie.add_actor(actor1)
assert a_movie.actors == [actor1] # test it doesn't add duplicate actors
a_movie.add_actor(actor2)
assert a_movie.actors == [actor1, actor2] # tests actors are added (and in order, not that it matters)
a_movie.remove_actor(actor1)
assert a_movie.actors == [actor2]
a_movie.remove_actor(5) # test it doesn't throw an error if not an actor
assert a_movie.actors == [actor2] # test it doesn't randomly remove an actor (I don't see how but yeah)
a_movie.add_genre(genre1)
assert a_movie.genres == [genre1]
a_movie.add_genre(genre1)
assert a_movie.genres == [genre1] # test it doesn't add duplicate actors
a_movie.add_genre(genre2)
assert a_movie.genres == [genre1, genre2] # tests actors are added (and in order, not that it matters)
a_movie.remove_genre(genre1)
assert a_movie.genres == [genre2]
a_movie.remove_genre(5) # test it doesn't throw an error if not a genre
assert a_movie.genres == [genre2] # test it doesn't randomly remove an genre (I don't see how but yeah)
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
rank = row['Rank']
# make movie from data
movie = Movie(row['Title'], int(row['Year']))
movie.description = row['Description']
movie.runtime_minutes = int(row['Runtime (Minutes)'])
movie.external_rating = float(
row['Rating']) if row['Rating'] != "N/A" else None
movie.rating_votes = int(
row['Votes']) if row['Votes'] != "N/A" else None
movie.revenue = float(
row['Revenue (Millions)']
) if row['Revenue (Millions)'] != "N/A" else None
movie.metascore = int(
row['Metascore']) if row['Metascore'] != "N/A" else None
director = Director(row['Director'])
actors = row['Actors'].split(",")
genres = row['Genre'].split(",")
movie.director = director
self._directors.add(director)
for actor in actors:
actor = Actor(actor)
movie.add_actor(actor)
self._actors.add(actor)
for genre in genres:
genre = Genre(genre)
movie.add_genre(genre)
self._genres.add(genre)
self.dataset_of_movies.add(movie)
def test_update(stats):
movie2 = Movie('Brain', 2002)
movie2.add_actor(Actor("Julia Roberts"))
movie2.add_actor(Actor("Tom Cruise"))
movie2.add_genre(Genre("Sci-Fi"))
movie2.add_genre(Genre("Action"))
director = Director("Christopher Nolan")
movie2.director = director
stats.user.watch_movie(movie2)
stats.update_watched_lists()
assert stats.user == User("aram", "one1")
assert stats.watched_movies == [
Movie("Up", 2009),
Movie("Down", 2013),
Movie("Boom", 1999),
Movie("Brain", 2002)
]
assert stats.watched_actors == {
Actor("Will Smith"): 2,
Actor("Daniel Radcliff"): 1,
Actor("Selena Gomez"): 1,
Actor("Tom Cruise"): 3,
Actor("Julia Roberts"): 1
}
assert stats.watched_directors == {
Director("Peter Jackson"): 2,
Director("Taika Waititi"): 1,
Director("Christopher Nolan"): 1
}
assert stats.watched_genres == {
Genre("Comedy"): 3,
Genre("Romance"): 1,
Genre("Drama"): 1,
Genre("Action"): 2,
Genre("Sci-Fi"): 1
}
def test_movies(self):
movie = Movie("Moana", 2016)
print(movie)
movie2 = Movie("Moana", 1901)
print(movie.release_year)
director = Director("Ron Clements")
movie.director = director
print(movie.director)
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
print(movie.actors)
movie.runtime_minutes = 107
print("Movie runtime: {} minutes".format(movie.runtime_minutes))
def test_movie_init_full(self):
movie = Movie("Moana", 2016)
assert repr(movie) == "<Movie Moana, 2016>"
director = Director("Ron Clements")
movie.director = director
assert repr(movie.director) == "<Director Ron Clements>"
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie.add_actor(actor)
assert repr(
movie.actors
) == "[<Actor Auli\'i Cravalho>, <Actor Dwayne Johnson>, <Actor Rachel House>, <Actor Temuera Morrison>]"
movie.runtime_minutes = 107
assert ("Movie runtime: {} minutes".format(
movie.runtime_minutes)) == "Movie runtime: 107 minutes"
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
# Read in Title
title = row['Title']
# Read in Year
release_year = int(row['Year'])
movie = Movie(title, release_year)
self.__dataset_of_movies.append(movie)
# Read in description
description = row["Description"]
movie.description = description
# Read in runtime
runtime = row["Runtime (Minutes)"]
movie.runtime_minutes = int(runtime)
# Read in Actors
actors = row['Actors']
actor = actors.split(",")
for i in actor:
actor = i.strip()
movie.add_actor(Actor(actor))
self.__dataset_of_actors.add(Actor(actor))
# Read in Directors
director = row['Director']
movie.director = Director(director)
self.__dataset_of_directors.add(Director(director))
# Read in Genre
genres = row['Genre']
genre = genres.split(",")
for i in genre:
a = i.strip()
movie.add_genre(Genre(a))
self.__dataset_of_genres.add(Genre(a))
# Read in Rank
rank = row["Rank"]
movie.rank = rank
# Read in Rating
rating = row["Rating"]
movie.rating = rating
# Read in Votes
vote = row["Votes"]
movie.votes = vote
# Read in revenue
revenue = row["Revenue (Millions)"]
movie.revenue = revenue
# Read in meta_scores
metascore = row["Metascore"]
movie.metascore = metascore
index += 1
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader = csv.DictReader(csvfile)
index = 0
for row in movie_file_reader:
# read data of row into variables
title = row['Title']
genres_str = row['Genre'].split(",")
genres = []
for genre in genres_str:
genres.append(Genre(genre))
year = int(row['Year'])
description = row['Description']
director = Director(row['Director'])
actors_str = row['Actors'].split(",")
actors = []
for actor in actors_str:
actors.append(Actor(actor))
runtime = row['Runtime (Minutes)']
rating = row['Rating']
votes = row['Votes']
revenue = row['Revenue (Millions)']
metascore = row['Metascore']
# create and populate Movie obj
movieObj = Movie(title, year)
for genre in genres:
movieObj.add_genre(genre)
movieObj.description = description
movieObj.director = director
for actor in actors:
movieObj.add_actor(actor)
if not runtime == "N/A":
movieObj.runtime_minutes = int(runtime)
if not rating == "N/A":
movieObj.rating = float(rating)
if not votes == "N/A":
movieObj.votes = int(votes)
if not revenue == "N/A":
movieObj.revenue = float(revenue)
if not metascore == "N/A":
movieObj.metascore = int(metascore)
# populate datasets
self.dataset_of_movies.append(movieObj)
for actor in actors:
if actor not in self.dataset_of_actors:
self.dataset_of_actors.append(actor)
if director not in self.dataset_of_directors:
self.dataset_of_directors.append(director)
for genre in genres:
if genre not in self.dataset_of_genres:
self.dataset_of_genres.append(genre)
index += 1
def test_movie():
movie1 = Movie("Moana", 2016)
director = Director("Ron Clements")
movie1.director = director
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie1.add_actor(actor)
movie1.runtime_minutes = 107
movie2 = Movie(" The Lion King ", 1994)
director = Director("Rob Minkoff")
movie2.director = director
actors = [
Actor("James Jones"),
Actor("Jeremy Irons"),
Actor("Matthew Boderick"),
Actor("Nathan Lane")
]
for actor in actors:
movie2.add_actor(actor)
movie2.runtime_minutes = 99
movie2.add_genre(Genre("Animation"))
movie2.add_genre(Genre("Family"))
assert movie1.__repr__() == "<Movie Moana, 2016>"
assert movie1.director == Director("Ron Clements")
assert movie2.actors == actors
assert movie1.runtime_minutes == 107
assert movie1 < movie2
assert movie2.title == "The Lion King"
assert hash(movie1) != hash(movie2)
movie2.remove_actor(actors[2]) # removes actor
movie2.remove_actor(actors[2]) # does nothing
movie2.remove_genre(Genre("Family")) # removes genre
movie2.remove_genre(Genre("Family")) # does nothing
assert len(movie2.actors) == 3
assert len(movie2.genres) == 1
movie3 = Movie("", 1750)
director = Director("Me")
movie3.director = director
actors = [Actor("Someone"), Genre("This shouldn't be added")]
for actor in actors:
movie3.add_actor(actor)
with pytest.raises(ValueError):
movie3.runtime_minutes = -30
assert movie3.year is None
assert len(movie3.actors) == 1
def load_movies_and_actors_genres_director(data_path: str,
repo: MemoryRepository):
actor_dict = dict()
genre_dict = dict()
directors = dict()
for data_row in read_csv_file(os.path.join(data_path,
'Data1000Movies.csv')):
movie_key = int(data_row[0])
genres = data_row[2]
actors = data_row[5]
director = data_row[4]
genre_list = genres.rsplit(",")
actor_list = actors.rsplit(",")
for genre in genre_list:
if genre not in genre_dict.keys():
genre_dict[genre] = list()
genre_dict[genre].append(movie_key)
for actor in actor_list:
if actor not in actor_dict.keys():
actor_dict[actor] = list()
actor_dict[actor].append(movie_key)
if director not in directors.keys():
directors[director] = list()
directors[director].append(movie_key)
movie = Movie(data_row[1], int(data_row[6]))
movie.rank = movie_key
movie.description = data_row[3]
movie.runtime_minutes = int(data_row[7])
if data_row[8] != "N/A":
movie.rating = float(data_row[8])
if data_row[9] != "N/A":
movie.votes = int(data_row[9])
if data_row[10] != "N/A":
movie.revenue = float(data_row[10])
if data_row[11] != "N/A":
movie.metascore = float(data_row[11])
repo.add_movie(movie)
for genre_name in genre_dict.keys():
genre = Genre(genre_name)
for movie_id in genre_dict[genre_name]:
movie = repo.get_movie(movie_id)
genre.add_movie(movie)
movie.add_genre(genre)
repo.add_genre(genre)
for actor_name in actor_dict.keys():
actor = Actor(actor_name)
for movie_id in actor_dict[actor_name]:
movie = repo.get_movie(movie_id)
actor.add_movie(movie)
movie.add_actor(actor)
repo.add_actor(actor)
for director_name in directors.keys():
director = Director(director_name)
for movie_id in directors[director_name]:
movie = repo.get_movie(movie_id)
director.add_movie(movie)
movie.director = director
repo.add_director(director)
def movie_list():
m1 = Movie("Twilight", 2008)
m1.add_actor(Actor("Robert Pattinson"))
m2 = Movie("Moana", 2016)
m2.add_actor(Actor("Dwayne Johnson"))
m3 = Movie("Furious 7", 2015)
m3.add_actor(Actor("Dwayne Johnson"))
m3.add_actor(Actor("Paul Walker"))
m3.director = Director("James Wan")
m4 = Movie("Furious 6", 2013)
m4.add_actor(Actor("Dwayne Johnson"))
m4.add_actor(Actor("Paul Walker"))
m4.director = Director("Justin Lin")
return [m1, m2, m3, m4]
def test_init(self):
movie1 = Movie("Moana", 2016)
assert repr(movie1) == "<Movie Moana, 2016>"
movie2 = Movie("")
assert movie2.title is None
assert movie2.year is None
movie3 = Movie(3)
assert movie3.title is None
movie1.director = "er"
assert movie1.director is None
movie4 = Movie("Moana", 2016)
movie5 = Movie("Mn", 2017)
assert (movie1 == movie5) == False
assert (movie1 == movie4) == True
assert movie1.title == "Moana"
assert movie1.description == None
movie1.description = 2
assert movie1.description == None
movie1.description = "adcsdv"
assert movie1.description == "adcsdv"
movie1.director = "as"
assert movie1.director is None
movie1.director = Director("asd")
assert (movie1.director == Director("asd")) == True
actors = [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]
for actor in actors:
movie1.add_actor(actor)
movie6 = Movie("as", 190)
genres = [Genre("asdc"), Genre("dfg")]
for genre in genres:
movie1.add_genre(genre)
assert (movie6 == Movie("as", None)) == True
assert (movie6.title == "as") == True
assert movie6.year is None
with pytest.raises(ValueError):
movie1.runtime_minutes = -10
movie1.runtime_minutes = 10
assert movie1.runtime_minutes == 10
string1 = "a"
assert (movie1 == 123) == False
movie7 = Movie("a", 1900)
movie8 = Movie("None", None)
print(movie8.concate())
assert (movie7 < movie8) == False
movie1.add_actor("sasa")
assert (movie1.actors == [
Actor("Auli'i Cravalho"),
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]) == True
movie1.remove_actor(Actor("Auli'i Cravalho"))
assert (movie1.actors == [
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]) == True
movie1.remove_actor("asd")
assert (movie1.actors == [
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison")
]) == True
movie1.add_actor(Actor("Auli'i Cravalho"))
assert (movie1.actors == [
Actor("Dwayne Johnson"),
Actor("Rachel House"),
Actor("Temuera Morrison"),
Actor("Auli'i Cravalho")
]) == True
movie1.remove_genre(Genre("asdc"))
assert (movie1.genres == [Genre("dfg")]) == True
movie1.add_genre(Genre("asdc"))
assert (movie1.genres == [Genre("dfg")]) == False
with pytest.raises(ValueError):
movie1.runtime_minutes = "sd"
movie1.actors = ['a', 'b']
from domainmodel.genre import Genre
from domainmodel.user import User
from domainmodel.review import Review
d1 = Director("DJ Khaled")
d2 = Director("Angry Shrek")
a1 = Actor("Bill Nye")
a2 = Actor("Notch")
g1 = Genre("Sci-fi")
g2 = Genre("Fantasy")
m0 = Movie("The", 2020)
m1 = Movie("Tragedy", 2020)
m1.director = d1
m1.add_actor(a1)
m1.add_genre(g1)
m2 = Movie("of", 2020)
m3 = Movie("Darth", 2020)
m3.director = d1
m4 = Movie("Plagueis", 2020)
m4.add_actor(a1)
m4.add_actor(a2)
m4.add_genre(g1)
m5 = Movie("the", 2020)
m5.add_actor(a1)
m5.add_actor(a2)
