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)
if movie not in self.__dataset_of_movies:
self.__dataset_of_movies.add(movie)
actors = row['Actors'].split(",")
for actor in actors:
a_actor = Actor(actor)
if a_actor not in self.__dataset_of_actors:
self.__dataset_of_actors.add(a_actor)
director = row["Director"]
director1 = Director(director)
if director1 not in self.__dataset_of_directors:
self.__dataset_of_directors.add(director1)
genres = row["Genre"].split(",")
for genre in genres:
a_genre = Genre(genre)
if a_genre not in self.__dataset_of_genres:
self.__dataset_of_genres.add(a_genre)
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'])
self.dataset_of_movies.append(Movie(title, release_year))
actors = row['Actors']
actors = actors.split(",")
for x in range(0, len(actors)):
actors[x] = actors[x].strip()
if (actors[x] not in self.dataset_of_actors):
self.dataset_of_actors.add(Actor(actors[x]))
directors = row['Director']
if (directors not in self.dataset_of_directors):
self.dataset_of_directors.add(Director(directors))
genres = row['Genre']
genres = genres.split(",")
for x in range(0, len(genres)):
genres[x] = genres[x].strip()
if (genres[x] not in self.dataset_of_genres):
self.dataset_of_genres.add(Genre(genres[x]))
#print(f"Movie {index} with title: {title}, release year {release_year}")
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_read_csv_file(self):
filename = '../datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
# check dataset sizes
assert len(movie_file_reader.dataset_of_movies) == 1000
assert len(movie_file_reader.dataset_of_actors) == 1985
assert len(movie_file_reader.dataset_of_directors) == 644
assert len(movie_file_reader.dataset_of_genres) == 20
# check assigning of all attributes from CSV to Movie obj
movie = movie_file_reader.dataset_of_movies[0]
assert movie.title == "Guardians of the Galaxy"
assert movie.genres == [
Genre("Action"),
Genre("Adventure"),
Genre("Sci-Fi")
]
assert movie.description == "A group of intergalactic criminals are forced " \
"to work together to stop a fanatical warrior " \
"from taking control of the universe."
assert movie.director == Director("James Gunn")
assert movie.actors == [
Actor("Chris Pratt"),
Actor("Vin Diesel"),
Actor("Bradley Cooper"),
Actor("Zoe Saldana")
]
assert movie.year == 2014
assert movie.runtime_minutes == 121
assert movie.rating == 8.1
assert movie.votes == 757074
assert movie.revenue == 333.13
assert movie.metascore == 76
def movie(self):
movie = Movie("Lady Bug and Bee", 2017)
movie.runtime_minutes = 100
movie.director = Director("Dave")
movie.add_actor(Actor("Sam"))
movie.add_actor(Actor("Cherry"))
movie.add_genre(Genre("Kids"))
return movie
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:
try:
rank = int(row['Rank'])
except ValueError:
rank = None
title = row['Title']
genres = row['Genre'].split(',')
description = row['Description']
actors = row['Actors'].split(',')
try:
release_year = int(row['Year'])
except ValueError:
release_year = None
try:
run_time = int(row['Runtime (Minutes)'])
except ValueError:
run_time = None
try:
rating = int(row['Rating'])
except ValueError:
rating = 0
try:
votes = int(row['Votes'])
except ValueError:
votes = 0
director = Director(row['Director'])
try:
revenue = float(row['Revenue (Millions)'])
except ValueError:
revenue = None
try:
metascore = int(row['Metascore'])
except ValueError:
metascore = None
mov = Movie(title, release_year)
mov.director = director
mov.description = description
mov.metascore = metascore
mov.rank = rank
mov.runtime_minutes = run_time
mov.rating = rating
mov.votes = votes
mov.revenue = revenue
self.load_actors(mov, actors)
if director not in self.__directors:
self.__directors.add(director)
self.load_genres(mov, genres)
if mov not in self.__movies:
self.__movies.append(mov)
def test_set_people(self, movie):
assert movie.actors == [Actor("Sam"), Actor("Cherry")]
assert movie.director == Director("Dave")
assert movie.runtime_minutes == 100
movie.runtime_minutes = "pam"
assert movie.runtime_minutes == 100
assert movie.genres == [Genre("Kids")]
movie1 = Movie("Same", 120)
assert repr(movie1) == "<Movie Same, None>"
def director(self, new_director):
if isinstance(new_director, Director):
self.__director = new_director
elif isinstance(new_director, list):
if len(new_director) > 1:
self.__director = new_director[0]
elif isinstance(new_director, str):
self.__director = Director(new_director)
else:
self.__director = None
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'])
actors_list = row['Actors']
director = row['Director']
genres_list = row['Genre']
movie = Movie(title, release_year)
if movie not in self.__dataset_of_movies:
self.__dataset_of_movies.append(movie)
for actor in actors_list.split(','):
if Actor(actor) not in self.__dataset_of_actors:
self.__dataset_of_actors.add(Actor(actor))
if Director(director) not in self.__dataset_of_directors:
self.__dataset_of_directors.add(Director(director))
for genre in genres_list.split(','):
movie.genres.append(Genre(genre))
if Genre(genre) not in self.__dataset_of_genres:
self.__dataset_of_genres.add(Genre(genre))
rank = row['Rank']
if int(rank) > 0:
movie.rank = rank
rating = row['Rating']
if 0 <= float(rating) <= 10:
movie.rating = rating
votes = row['Votes']
movie.votes = int(votes)
revenue_millions = row['Revenue (Millions)']
movie.revenue_millions = revenue_millions
metascore = row['Metascore']
try:
if 0 <= float(metascore) <= 100:
movie.metascore = metascore
except ValueError:
movie.metascore = metascore
def _read_row(self, row: _ROW) -> Movie:
"""
Helper method to construct a Movie from a row.
Raises:
ValueError: unable to parse row: {row}
"""
error = False
try:
title = row['Title']
genres = [
self._get_genre(Genre(name))
for name in row['Genre'].split(',')
]
description = row['Description']
director = self._get_director(Director(row['Director']))
actors = [
self._get_actor(Actor(name))
for name in row['Actors'].split(',')
]
release_year = int(row['Year'])
runtime_minutes = int(row['Runtime (Minutes)'])
rating = float(row['Rating'])
votes = int(row['Votes'])
revenue_millions = float(
row['Revenue (Millions)']
) if row['Revenue (Millions)'] != 'N/A' else None
metascore = int(
row['Metascore']) if row['Metascore'] != 'N/A' else None
except KeyError:
error = True
except ValueError:
error = True
if error:
raise ValueError(f'unable to parse row: {row}')
movie = Movie(title, release_year)
movie.genres = genres
movie.description = description
movie.director = director
movie.actors = actors
movie.runtime_minutes = runtime_minutes
movie.rating = rating
movie.votes = votes
if revenue_millions:
movie.revenue_millions = revenue_millions
if metascore:
movie.metascore = metascore
return movie
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_director(self):
# correct input
movie1 = Movie("Moana", 2016)
director1 = Director("Ron Clements")
movie1.director = director1
assert movie1.director == director1
# incorrect input
movie2 = Movie("Frozen", 2014)
movie2.director = "Chris Buck"
assert movie2.director is None
def create_movie_instance(self, row):
movie = Movie(row["Title"], int(row["Year"]))
movie.director = Director(row["Director"])
movie.runtime_minutes = int(row["Runtime (Minutes)"])
movie.actors = [
Actor(actor.strip()) for actor in row['Actors'].split(",")
]
movie.genres = [
Genre(genre.strip()) for genre in row['Genre'].split(",")
]
movie.description = row["Description"]
return movie
def test_filter_by_director_normal():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
director = Director("James Gunn")
movie_file_reader.filter_by_director(director)
assert movie_file_reader.movies_filtered_by_director == [
Movie("Guardians of the Galaxy", 2014),
Movie("Slither", 2006),
Movie("Super", 2010)
]
def __init__(self, title: str, release_year: int):
self._release_year: int = release_year if release_year >= 1900 else None
self._title: str = title.strip() if title.strip() != "" else None
self._description: str = ""
self.director: Director = Director("")
self.actors: [Actor] = []
self.genres: [Genre] = []
self._runtime_minutes: int = 0
self._rating: float = 0
self._votes: int = 0
self._revenue: Optional[float] = None
self._metascore: Optional[float] = None
def __init__(self, movie_title: str, release_date: int):
if movie_title == "" or type(movie_title) is not str:
self.__movie_title = None
else:
self.__movie_title: str = movie_title.strip()
self.__release_date: int = release_date
self.__description: str = None
self.__director: Director = Director("")
self.__actors: list = []
self.__genres: list = []
self.__runtime_minutes: int = None
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 __init__(self, title: str, release_year: int):
self.__description = ""
self.__director = Director(None)
self.__actors = []
self.__genres = []
self.__runtime_minutes: int = 0
if (title == "") or (type(title) is not str) or (
release_year < 1900) or (type(release_year) is not int):
self.__title = None
self.__release_year = None
else:
self.__title = title.strip()
self.__release_year = release_year
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(
"datafiles/" + self.__file_name, mode='r', encoding='utf-8-sig'
) as csvfile: #i delete "datafiles/"+ before posting to coderunner, if this isnt here then my IDE, vscode, doesnt find it
movie_file_reader = csv.DictReader(csvfile)
for row in movie_file_reader:
if Movie(row['Title'],
int(row['Year'])) not in self.__dataset_of_movies:
self.__dataset_of_movies.append(
Movie(row['Title'], int(row['Year'])))
#description = row['Description']
self.__dataset_of_directors.add(Director(row['Director']))
self.dataset_of_movies[-1].director = Director(row['Director'])
self.dataset_of_movies[-1].description = row['Description']
self.dataset_of_movies[-1].runtime = row['Runtime (Minutes)']
for g in row['Genre'].split(","):
self.__dataset_of_genres.add(Genre(g.strip()))
for a in row['Actors'].split(","):
self.__dataset_of_actors.add(Actor(a.strip()))
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_init(stats):
assert stats.user == User("aram", "one1")
assert stats.watched_movies == [
Movie("Up", 2009),
Movie("Down", 2013),
Movie("Boom", 1999)
]
assert stats.watched_actors == {
Actor("Will Smith"): 2,
Actor("Daniel Radcliff"): 1,
Actor("Selena Gomez"): 1,
Actor("Tom Cruise"): 2
}
assert stats.watched_directors == {
Director("Peter Jackson"): 2,
Director("Taika Waititi"): 1
}
assert stats.watched_genres == {
Genre("Comedy"): 3,
Genre("Romance"): 1,
Genre("Drama"): 1,
Genre("Action"): 1
}
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)
for row in movie_file_reader:
title = row['Title']
release_year = row['Year']
actors = row['Actors']
director = row['Director']
genres = row['Genre']
self.dataset_of_movies.append(Movie(title, int(release_year)))
a_list = actors.split(",")
for actor in a_list:
if Actor(actor.strip()) not in self.dataset_of_actors:
self.dataset_of_actors.append(Actor(actor.strip()))
if Director(director.strip()) not in self.dataset_of_directors:
self.dataset_of_directors.append(Director(
director.strip()))
a_list = genres.split(",")
for genre in a_list:
if Genre(genre.strip()) not in self.dataset_of_genres:
self.dataset_of_genres.append(Genre(genre.strip()))
def test_filter_by_director_illeagal_inputs():
filename = 'datafiles/Data1000Movies.csv'
movie_file_reader = MovieFileCSVReader(filename)
movie_file_reader.read_csv_file()
director = Director("Nier Automata")
movie_file_reader.filter_by_director(director)
assert movie_file_reader.movies_filtered_by_director == []
director_1 = "James Gunn"
movie_file_reader.filter_by_director(director_1)
assert movie_file_reader.movies_filtered_by_director == []
director_2 = 12345
movie_file_reader.filter_by_director(director_2)
assert movie_file_reader.movies_filtered_by_director == []
def test_remove_actor(self):
movie1 = Movie("Moana", 2016)
movie1.add_actor(Actor("Dwayne Johnson"))
# correct input
movie1.remove_actor(Actor("Dwayne Johnson"))
assert movie1.actors == []
# incorrect input
movie1.add_actor(Actor("Dwayne Johnson"))
movie1.remove_actor(Director("Dwayne Johnson"))
assert movie1.actors == [Actor("Dwayne Johnson")]
# removing an actor not in list
movie1.remove_actor(Actor("Rachel House"))
assert movie1.actors == [Actor("Dwayne Johnson")]
def test_remove_genre(self):
movie1 = Movie("Moana", 2016)
movie1.add_genre(Genre("Animation"))
# correct input
movie1.remove_genre(Genre("Animation"))
assert movie1.genres == []
# incorrect input
movie1.add_genre(Genre("Animation"))
movie1.remove_genre(Director("Animation"))
assert movie1.genres == [Genre("Animation")]
# removing a genre not in list
movie1.remove_genre(Genre("Comedy"))
assert movie1.genres == [Genre("Animation")]
def __init__(self, title: str, year: int):
if title == "" or type(title) is not str:
self._title = None
else:
self._title = title.strip()
if year < 1900 or type(year) is not int:
self._year = None
else:
self._year = year
self._description = ""
self._director = Director("")
self._actors = []
self._genres = []
self._runtime_minutes = 0
def read_csv_file(self):
with open(self.__file_name, mode='r', encoding='utf-8-sig') as csvfile:
movie_file_reader_genre = csv.DictReader(csvfile)
for row in movie_file_reader_genre:
movie = row['Title']
actors = sorted(row['Actors'].strip().split(','))
for i in range(len(actors)):
actors[i] = actors[i].strip()
director = row['Director']
genres = sorted(row['Genre'].strip().split(','))
for i in range(len(genres)):
genres[i] = genres[i].strip()
year = int(row['Year'].strip())
description = row['Description'].strip()
runtime = int(row['Runtime (Minutes)'].strip())
if self.__genre_type in genres:
the_movie = Movie(movie, year)
the_director = Director(director)
the_movie.director = the_director
for i in range(len(actors)):
the_actor = Actor(actors[i])
the_movie.actors.append(the_actor)
the_movie.description = description
the_movie.runtime_minutes = runtime
the_movie.director = the_director
for i in range(len(genres)):
the_genre = Genre(genres[i])
the_movie.genres.append(the_genre)
if the_movie not in self.__dataset_of_movies:
flag = True
for i in range(len(self.__dataset_of_movies)):
if the_movie < self.__dataset_of_movies[i]:
self.__dataset_of_movies.insert(i, the_movie)
flag = False
break
if flag:
self.__dataset_of_movies.insert(i, the_movie)
self.__dataset_of_movies.pop()
def test_create_movie_instance(new_row, new_filter):
movie = new_filter.create_movie_instance(new_row)
assert movie.title == "Test Movie"
assert movie.runtime_minutes == 121
assert movie.release_year == 2020
assert movie.description == "A movie used for unit tests"
assert movie.actors == [
Actor("Chris Pratt"),
Actor("Vin Diesel"),
Actor("Bradley Cooper"),
Actor("Zoe Saldana")
]
assert movie.genres == [
Genre("Action"), Genre("Adventure"),
Genre("Sci-Fi")
]
assert movie.director == Director("John Doe")
