def load_movies(data_path: str, repo: MemoryRepository):
movies = dict()
for data_row in read_csv_file(os.path.join(data_path, 'Data1000Movies.csv')):
movie = Movie(
rank=int(data_row[0]),
title=data_row[1].strip(),
release_year=int(data_row[6]),
description=data_row[3].strip()
)
actors = data_row[5]
actors = actors.split(',')
for actor in actors:
actor = actor.strip()
if Actor(actor) not in movie.actors:
movie.add_actor(Actor(actor))
genres = data_row[2]
genres = genres.split(',')
for genre in genres:
genre = genre.strip()
if Genre(genre) not in movie.genres:
movie.add_genre(Genre(genre))
director = data_row[4]
director = director.strip()
movie.director = Director(director)
repo.add_movie(movie)
movies[data_row[0]] = movie
return movies
def test_genre():
genre1 = Genre("a")
assert genre1.genre_name == "a"
assert repr(genre1) == "<Genre a>"
genre2 = Genre("b")
genre3 = Genre("a")
assert genre2 > genre1
assert genre1 < genre2
assert genre1 == genre3
assert genre1 != genre2
assert hash(genre1) != hash(genre2)
def test_repository_can_retrieve_movie(in_memory_repo):
movie = in_memory_repo.get_movie(1)
assert movie.title == "Guardians of the Galaxy"
assert movie.genres == [
Genre("Action"), Genre("Adventure"),
Genre("Sci-Fi")
]
assert movie.runtime_minutes == 121
assert movie.is_tagged_by(Genre("Action"))
assert movie.director.director_full_name == 'James Gunn'
assert movie.has_actor('Chris Pratt')
def test_get_movie_by_genre(in_memory_repo):
assert in_memory_repo.get_movie_by_genre('Action') == [
Movie(
1, 'Guardians of the Galaxy', 2014, "A group of \
intergalactic criminals are forced to work together\
to stop a fanatical warrior from taking control of\
the universe."),
Movie(
5, 'Suicide Squad', 2016, "A secret government agency\
recruits some of the most dangerous incarcerated \
super-villains to form a defensive task force. \
Their first mission: save the world from the apocalypse."
),
Movie(
6, 'The Great Wall', 2016, "European mercenaries \
searching for black powder become embroiled in the defense\
of the Great Wall of China against a horde of monstrous\
creatures."),
Movie(
9, 'The Lost City of Z', 2016, "A true-life drama, \
centering on British explorer Col. Percival Fawcett, who\
disappeared while searching for a mysterious city in the\
Amazon in the 1920s."
)
]
movie1 = Movie(11, '1', 2000, "a")
movie2 = Movie(12, '2', 3000, "a")
genre1 = Genre('a')
movie1.add_genre(genre1)
movie2.add_genre(genre1)
in_memory_repo.add_movie(movie1)
in_memory_repo.add_movie(movie2)
assert in_memory_repo.get_movie_by_genre('a') == [movie1, movie2]
def test_repository_can_add_a_genre(session_factory):
repo = SqlAlchemyRepository(session_factory)
genre = Genre('Motoring')
repo.add_genre(genre)
assert genre in repo.get_genres()
def test_genre_construction(genre: Genre):
assert genre.genre_name == 'Action'
for movie in genre.genre_movies:
assert False
assert not genre.is_applied_to(Movie(0, "", "", 0, 0, 0, 0, None, None))
def test_add_genre():
movie1 = Movie("Spirited Away", 2000)
movie1.genres = [Genre("Comedy")]
movie1.add_genre(Genre("Horror"))
assert movie1.genres == [Genre("Comedy"), Genre("Horror")]
movie1.add_genre("Scifi")
movie1.add_genre(Genre("Hhiya"))
movie1.add_genre("")
movie1.add_genre(None)
movie1.add_genre(21345648)
assert movie1.genres == [Genre("Comedy"), Genre("Horror"), Genre("Hhiya")]
def test_repository_can_retrieve_movie(session_factory):
repo = SqlAlchemyRepository(session_factory)
movie = repo.get_movie(1)
# Check that the Movie has the expected title.
assert movie.title == 'Guardians of the Galaxy'
# Check that the Movie is reviewed as expected.
review_one = [
review for review in movie.reviews
if review.review == 'Oh no, COVID-19 has hit New Zealand'
][0]
review_two = [
review for review in movie.reviews
if review.review == 'Yeah Freddie, bad news'
][0]
assert review_one.user.username == 'fmercury'
assert review_two.user.username == "thorke"
# Check that the Movie is genreged as expected.
assert movie.is_genreged_by(Genre('Adventure'))
assert movie.is_genreged_by(Genre('Adventure'))
def test_repository_can_retrieve_movie(in_memory_repo):
movie = in_memory_repo.get_movie(1)
# Check that the Movie has the expected title.
assert movie.title == 'Guardians of the Galaxy'
# Check that the Article is commented as expected.
comment_one = [
comment for comment in movie.comments
if comment.comment == 'Oh no, COVID-19 has hit New Zealand'
][0]
comment_two = [
comment for comment in movie.comments
if comment.comment == 'Yeah Freddie, bad movies'
][0]
assert comment_one.user.username == 'fmercury'
assert comment_two.user.username == "thorke"
assert movie.is_belong_to_genre(Genre('Action'))
assert movie.director == Director('James Gunn')
def load_movies_and_genres(data_path: str, repo: MemoryRepository):
genres = dict()
for data_row in read_csv_file(os.path.join(data_path, 'Data1000Movies.csv')):
movie_key = int(data_row[0])
movie_genres = data_row[2].split(",")
# Add any new genres; associate the current movie with genres.
for genre in movie_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_key)
# Create Movie object.
movie = Movie(
date=date.fromisoformat(data_row[6]+"-01-01"),
title=data_row[1],
first_para=data_row[3],
hyperlink="",
rank=data_row[0],
director=data_row[4],
time=data_row[7],
rating=data_row[8],
actors=data_row[5],
id=movie_key,
image_hyperlink = "https://image.tmdb.org/t/p/w780" + data_row[14]
)
# Add the Movie to the repository.
repo.add_movie(movie)
# Create Genre objects, associate them with Movies and add them to the repository.
for genre_name in genres.keys():
genre = Genre(genre_name)
for movie_id in genres[genre_name]:
movie = repo.get_movie(movie_id)
make_genre_association(movie, genre)
repo.add_genre(genre)
def genre():
return Genre('Action')
def test_genres():
movie1 = Movie("Spirited Away", 2000)
movie2 = Movie("Your Name", 2000)
movie3 = Movie("Batman", 2000)
movie4 = Movie(None, None)
movie1.genres = [Genre("Comedy"), Genre("Horror"), Genre("Sci-fi")]
assert movie1.genres == [Genre("Comedy"), Genre("Horror"), Genre("Sci-fi")]
movie2.genres = [Genre("Comedy"), Genre("Horror"), Genre("Sci-fi"), 12345]
assert movie2.genres == []
movie3.genres = Genre("Comedy")
assert movie3.genres == [Genre("Comedy")]
movie4.genres = "Comedy"
assert movie4.genres == []
def make_genre():
genre = Genre("News")
return genre
def test_repository_can_add_a_genre(in_memory_repo):
genre = Genre('Motoring')
in_memory_repo.add_genre(genre)
assert genre in in_memory_repo.get_genres()
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 remove_genre():
movie1 = Movie("Spirited Away", 2000)
movie1.genres = [Genre("Comedy")]
movie1.add_genre(Genre("Horror"))
movie1.add_genre(Genre("Happy ending"))
assert movie1.genres == [
Genre("Comedy"),
Genre("Horror"),
Genre("Happy ending")
]
movie1.remove_genre("Scifi")
movie1.remove_genre(Genre("Hhiya"))
movie1.remove_genre("")
movie1.remove_genre(None)
movie1.remove_genre(21345648)
movie1.remove_genre(Genre("Happy ending"))
assert movie1.genres == [Genre("Comedy"), Genre("Horror")]
movie1.remove_genre(Genre("Comedy"))
assert movie1.genres == [Genre("Horror")]
movie1.remove_genre(Genre("Horror"))
assert movie1.genres == []
def load_movies_and_genres_and_actors_and_directors(data_path: str,
repo: MemoryRepository):
genres = dict()
actors = dict()
directors = dict()
for data_row in read_csv_file(os.path.join(data_path, 'movies.csv')):
movie_id = int(data_row[0])
movie_genres = data_row[2].split(",")
movie_director = data_row[4]
movie_actors = data_row[5].replace(", ", ",").split(",")
for genre in movie_genres:
if genre not in genres.keys():
genres[genre] = list()
genres[genre].append(movie_id)
for actor in movie_actors:
if actor not in actors.keys():
actors[actor] = list()
actors[actor].append(movie_id)
if movie_director not in directors.keys():
directors[movie_director] = list()
directors[movie_director].append(movie_id)
if data_row[10] == "N/A":
revenue = None
else:
revenue = float(data_row[10])
if data_row[11] == "N/A":
metascore = None
else:
metascore = int(data_row[11])
movie = Movie(id=movie_id,
title=data_row[1],
description=data_row[3],
year=int(data_row[6]),
runtime=int(data_row[7]),
rating=float(data_row[8]),
votes=int(data_row[9]),
revenue=revenue,
metascore=metascore)
repo.add_movie(movie)
for genre_name in genres.keys():
genre = Genre(genre_name)
for movie_id in genres[genre_name]:
movie = repo.get_movie(movie_id)
make_genre_association(movie, genre)
repo.add_genre(genre)
for actor_name in actors.keys():
actor = Actor(actor_name)
for movie_id in actors[actor_name]:
movie = repo.get_movie(movie_id)
make_actor_association(movie, 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)
make_director_association(movie, director)
repo.add_director(director)
def genre():
return Genre('New Zealand')
