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")