def search_movie(query):
tmdb = TMDb()
tmdb.api_key = 'PLEASE GENERATE UR OWN API KEY, ALL INFO IN README FILE'
movie = Movie()
result = movie.search(query)
number_of_movies = len(result)
if number_of_movies == 0:
print("SORRY, I CAN'T FIND ANYTHING, PLEASE TRY ANOTHER PHRASE")
else:
random_movie_title = choice(result).title
print(
f'I have found {number_of_movies} movies, here is a random choice for you:'
)
print(f'Title: {random_movie_title}')
for res in result:
if res.title == random_movie_title:
if res.overview == "":
print('Sorry, no plot available :c')
else:
print(f'Movie id: {res.id}')
print(f'Plot: {res.overview}')
print(f'Released in {res.release_date}')
similar = movie.similar(res.id)
for sim in similar:
print(
f'Similar movie: {sim} (movie id: {sim.id}), released in {sim.release_date}'
)
break
break
def movie_details(request, movie_name):
comment_form = CommentForm()
movie = Movie()
found_movie = movie.search(movie_name)[0]
poster_path = found_movie.poster_path[1:]
similar = movie.similar(found_movie.id)
print(found_movie.id)
comments = Comment.objects.filter(film=movie_name)
print(found_movie)
context = {'movie': found_movie,
'comment_form': comment_form,
'comments': comments,
'poster_path': poster_path,
'similar': similar}
return render(request, 'movie/details.html', context)
def get_similar(string):
movie = Movie()
movies = movie.search(string)
if len(movies) == 0:
return 0
similar_movies = movie.similar(random.choice(movies).id)
if len(similar_movies) == 0:
return 1
similar_movie = random.choice(similar_movies)
return {
"title": similar_movie.title,
"overview": similar_movie.overview,
"vote": str(similar_movie.vote_average) + "/10",
"poster":
"https://image.tmdb.org/t/p/w1280" + similar_movie.poster_path
}
def serialize_movie_details(id):
m = Movie()
k = m.details(int(id))
casts = []
if len(k.casts["cast"])>20:
k.casts["cast"] = k.casts["cast"][:20]
for i in k.casts["cast"]:
try:
casts.append({'name':i['name'], 'character': i['character'], 'image': 'https://image.tmdb.org/t/p/w500' + i['profile_path']})
except:
casts.append({'name':i['name'], 'character': i['character']})
director = ""
for i in k.casts["crew"]:
if i["job"] == "Director":
director += i['name']
genres_str = ""
for j in k.genres:
genres_str += j['name'] + ", "
genres_str = genres_str[:-2]
response = {'title':k.original_title, 'director': director, 'year': str(k.release_date)[:4], 'runtime': k.runtime,
'genres': genres_str, 'rating' : k.vote_average, 'backdrop' : 'https://image.tmdb.org/t/p/w500' + k.backdrop_path,
'poster':'https://image.tmdb.org/t/p/w500'+k.poster_path,'summary':k.overview, 'casts':casts}
similar = m.similar(int(id))
if len(similar)>10:
similar = similar[:10]
similar_movies = []
for i in similar:
if len(i['title'])>30:
i['title'] = i['title'][:30] + "..."
genres_str = ""
if len(i["genre_ids"])>3:
i["genre_ids"] = i["genre_ids"][:3]
for j in i["genre_ids"]:
genres_str += genres[str(j)] + ", "
genres_str = genres_str[:-2]
similar_movies.append({'title':i['title'], 'poster':'https://image.tmdb.org/t/p/w500'+i['poster_path'],
'genres':genres_str, 'id':i["id"], 'year': str(k.release_date)[:4]})
return [response,similar_movies]
class TMDbTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ['TMDB_API_KEY']
self.tmdb.language = 'en'
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.movie = Movie()
self.discover = Discover()
self.tv = TV()
self.person = Person()
self.collection = Collection()
self.company = Company()
self.season = Season()
def test_get_movie(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie.title, 'Scarface')
self.assertEqual(movie.id, 111)
self.assertTrue(hasattr(movie, 'title'))
self.assertTrue(hasattr(movie, 'overview'))
self.assertTrue(hasattr(movie, 'id'))
def test_get_movie_reviews(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
first = search[0]
reviews = self.movie.reviews(first.id)
self.assertTrue(len(reviews) > 0)
for review in reviews:
self.assertTrue(hasattr(review, 'id'))
self.assertTrue(hasattr(review, 'content'))
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertTrue(len(lists) > 0)
self.assertTrue(hasattr(lists[0], 'description'))
self.assertTrue(hasattr(lists[0], 'name'))
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertTrue(len(videos) > 0)
self.assertTrue(hasattr(videos[0], 'id'))
def test_get_movie_recommendations(self):
recs = self.movie.recommendations(111)
self.assertTrue(len(recs) > 0)
self.assertTrue(hasattr(recs[0], 'id'))
def test_discover_movies(self):
discover = self.discover.discover_movies({
'primary_release_year': '2015',
'with_genres': '28',
'page': '1',
'vote_average.gte': '8'
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], 'id'))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 28:
has_genre = True
self.assertTrue(has_genre)
def test_discover_tv_shows(self):
discover = self.discover.discover_tv_shows({
'with_genres': '16',
'vote_average.gte': '8',
'page': '1'
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], 'id'))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 16:
has_genre = True
self.assertTrue(has_genre)
def test_get_latest_movie(self):
videos = self.movie.latest()
self.assertIsNotNone(videos)
self.assertTrue(hasattr(videos, 'id'))
def test_now_playing(self):
now_playing = self.movie.now_playing()
self.assertTrue(len(now_playing) > 0)
self.assertTrue(hasattr(now_playing[0], 'id'))
def test_top_rated(self):
top_rated = self.movie.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], 'id'))
def test_upcoming(self):
upcoming = self.movie.upcoming()
self.assertTrue(len(upcoming) > 0)
self.assertTrue(hasattr(upcoming[0], 'id'))
def test_popular(self):
popular = self.movie.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], 'id'))
def test_search(self):
search = self.movie.search('Mad Max')
self.assertTrue(len(search) > 0)
self.assertTrue(hasattr(search[0], 'id'))
def test_similar(self):
similar = self.movie.similar(111)
self.assertTrue(len(similar) > 0)
self.assertTrue(hasattr(similar[0], 'id'))
def test_get_tv_show(self):
show = self.tv.details(12)
self.assertIsNotNone(show)
self.assertTrue(hasattr(show, 'id'))
def test_get_latest_tv_show(self):
latest_tv = self.tv.latest()
self.assertIsNotNone(latest_tv)
self.assertTrue(hasattr(latest_tv, 'id'))
def test_search_tv(self):
search_tv = self.tv.search('Sunny')
self.assertTrue(len(search_tv) > 0)
self.assertTrue(hasattr(search_tv[0], 'id'))
def test_popular_shows(self):
popular = self.tv.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], 'id'))
def test_top_rated_shows(self):
top_rated = self.tv.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], 'id'))
def test_get_person(self):
person = self.person.details(234)
self.assertIsNotNone(person)
self.assertTrue(hasattr(person, 'id'))
def test_search_person(self):
search_person = self.person.search('Bryan')
self.assertTrue(len(search_person) > 0)
self.assertTrue(hasattr(search_person[0], 'id'))
def test_collection_details(self):
c = Collection()
details = c.details(10)
self.assertEqual(details.name, 'Star Wars Collection')
self.assertEqual(details.id, 10)
self.assertTrue(hasattr(details, 'overview'))
self.assertTrue(hasattr(details, 'poster_path'))
def test_collection_images(self):
c = Collection()
images = c.images(10)
self.assertTrue(hasattr(images, 'backdrops'))
self.assertTrue(hasattr(images, 'posters'))
def test_popular_people(self):
popular = self.person.popular()
self.assertTrue(len(popular) > 0)
first = popular[0]
self.assertTrue(hasattr(first, 'name'))
self.assertTrue(hasattr(first, 'known_for'))
def test_latest_person(self):
latest_person = self.person.latest()
self.assertIsNotNone(latest_person)
self.assertTrue(hasattr(latest_person, 'name'))
self.assertTrue(hasattr(latest_person, 'id'))
def test_person_images(self):
images = self.person.images(11)
self.assertIsNotNone(images)
self.assertTrue(hasattr(images, 'profiles'))
self.assertTrue(hasattr(images, 'id'))
def test_company_details(self):
c = self.company.details(1)
self.assertTrue(hasattr(c, 'name'))
self.assertEqual(c.name, 'Lucasfilm')
def test_company_movies(self):
company = self.company.movies(1)
self.assertTrue(len(company) > 0)
first = company[0]
self.assertTrue(hasattr(first, 'title'))
self.assertTrue(hasattr(first, 'overview'))
def test_config(self):
config = Configuration()
info = config.info()
self.assertIsNotNone(info)
self.assertTrue(hasattr(info, 'images'))
def test_genres(self):
genres = Genre()
movie_genres = genres.movie_list()
self.assertIsNotNone(movie_genres)
tv_genres = genres.tv_list()
self.assertIsNotNone(tv_genres)
def test_season(self):
s = self.season.details(1418, 1)
self.assertIsNotNone(s)
self.assertEqual(s.name, 'Season 1')
self.assertEqual(s.id, 3738)
self.assertTrue(hasattr(s, 'episodes'))
self.assertTrue(hasattr(s, 'overview'))
self.assertTrue(hasattr(s, 'id'))
def test_get_season_changes(self):
s = self.season.changes(1418, 1)
self.assertIsNotNone(s)
def test_get_season_external_ids(self):
s = self.season.external_ids(1418, 1)
self.assertIsNotNone(s)
self.assertIsNotNone(s['tvdb_id'])
def test_get_season_videos(self):
s = self.season.videos(1418, 1)
def test_get_season_images(self):
s = self.season.images(1418, 1)
for l in s:
self.assertIsNotNone(l.width)
self.assertIsNotNone(l.height)
def test_get_season_credits(self):
s = self.season.credits(1418, 1)
for c in s:
self.assertIsNotNone(c.name)
self.assertIsNotNone(c.character)
def test_get_movie_by_external_id(self):
ex = self.movie.external(external_id="tt8155288", external_source="imdb_id")
res = ex['movie_results'][0]
self.assertTrue(res['title'] == "Happy Death Day 2U")
class Tmdbapi:
tmdb = TMDb()
tmdb.api_key = API_KEY
def __init__(self):
self.movie = Movie()
self.tv = TV()
# Movies
# Search for a movie and find the movie's data, its director and its cast
# Put all of that in a data holding object
# The data is NOT LINKED TO EACH OTHER
# This linking has to be done elsewhere by checking the database
# For example:
# the movie's director property will be None, the director's id will be None, the cast's id's will be None
# Their names need to be checked in the database first to make sure not to add them twice
# Convert tmdbv3 API data into our own MovieSearchResult
def tmdb_to_movie(self, moviedata) -> MovieSearchResult:
movie = database.Movie()
movie.tmdbId = moviedata.id
movie.title = moviedata.title
movie.description = moviedata.overview
movie_credits = self.movie.credits(moviedata.id).entries
movie.director = None
movie_details = self.movie.details(moviedata.id).entries
runtime = None
genre = None
if movie_details is not None:
if "runtime" in movie_details.keys():
runtime = movie_details["runtime"]
else:
runtime = 0
if "genres" in movie_details.keys():
genres = movie_details["genres"]
else:
genres = None
if genres is not None and len(genres) > 0:
genre = genres[0]["name"]
else:
genre = "Unknown"
movie.runtime = runtime
movie.genre = genre
if hasattr(moviedata,
'release_date') and len(moviedata.release_date) != 0:
movie.releaseYear = int(moviedata.release_date[0:4])
else:
movie.releaseYear = 0
movie.avgRating = moviedata.vote_average
# Director
director = None
director_name = None
crew = []
if "crew" in movie_credits.keys():
crew = movie_credits["crew"]
for person in crew:
if person["job"] == "Director":
director_name = person["name"]
break
if director_name is not None:
director = database.Contributor()
director.name = director_name
# Cast
cast = []
actors = []
if "cast" in movie_credits.keys():
actors = movie_credits["cast"]
for actor in actors[0:CAST_AMOUNT]:
cast_member = database.Contributor()
cast_member.name = actor["name"]
cast.append(cast_member)
output = MovieSearchResult()
output.movie = movie
output.director = director
output.cast = cast
return output
# Search for a movie by title and duration
def search_movie(self, query: str, duration: int) -> MovieSearchResult:
search = self.movie.search(query)
output = None
for movie_data in search:
movie = self.tmdb_to_movie(movie_data)
if output is None:
output = movie
#elif abs(movie.movie.runtime - duration) < abs(output.movie.runtime - duration):
#output = movie
return output
# Search multiple movies by title
def search_movies(self, query: str,
max_movies: int) -> [MovieSearchResult]:
search = self.movie.search(query)
output = []
for movie_data in search:
if len(output) >= max_movies:
break
movie = self.tmdb_to_movie(movie_data)
output.append(movie)
return output
# "Download" a movie thumbnail
def get_poster_movie(self, tmdb_id: int) -> str:
movie_result = self.movie.details(tmdb_id)
poster_path = movie_result.poster_path
if poster_path is None:
return None
return "https://image.tmdb.org/t/p/w500" + poster_path
# Get similar tmdb movies
def get_similar_tmdb_movies(self, tmdb_id: int) -> [MovieSearchResult]:
output = []
for moviedata in self.movie.similar(tmdb_id):
output.append(self.tmdb_to_movie(moviedata))
if len(output) == SIMILAR_AMOUNT:
break
return output
# TV shows
# Convert tmdbv3 API data into our own TvShowSearchResult
def tmdb_to_tvshow(self, tvshowdata) -> TvShowSearchResult:
tvshow = database.TvShow()
tvshow.title = tvshowdata.name
tvshow.tmdbId = tvshowdata.id
tvshow.description = tvshowdata.overview
tvshow.director = None
tvshow_details = self.tv.details(tvshowdata.id).entries
runtime = 0
genre = None
if tvshow_details is not None:
if "episode_run_time" in tvshow_details.keys():
runtimes = tvshow_details["episode_run_time"]
else:
runtimes = None
if runtimes is not None and len(runtimes) != 0:
runtime = runtimes[0]
if "genres" in tvshow_details.keys():
genres = tvshow_details["genres"]
else:
genres = None
if genres is not None and len(genres) > 0:
genre = genres[0]["name"]
else:
genre = "Unknown"
tvshow.runtime = runtime
tvshow.genre = genre
if hasattr(tvshowdata,
'first_air_date') and len(tvshowdata.first_air_date) != 0:
tvshow.releaseYear = int(tvshowdata.first_air_date[0:4])
else:
tvshow.releaseYear = 0
tvshow.avgRating = tvshowdata.vote_average
# Director
director = None
if "created_by" in tvshow_details.keys():
created_by = tvshow_details["created_by"]
else:
created_by = None
if created_by is not None and len(created_by) != 0:
director = database.Contributor()
director.name = created_by[0]["name"]
# Cast
cast = []
if "credits" in tvshow_details.keys():
if "cast" in tvshow_details["credits"].keys():
actors = tvshow_details["credits"]["cast"]
else:
actors = []
for actor in actors[0:CAST_AMOUNT]:
cast_member = database.Contributor()
cast_member.name = actor["name"]
cast.append(cast_member)
# Episodes
episodes = []
if "seasons" in tvshow_details.keys():
seasons_data = tvshow_details["seasons"]
for season_data in seasons_data:
season_nr = season_data["season_number"]
for episode_nr in range(1, season_data["episode_count"] + 1):
episode = database.Episode()
episode.tmdbId = None
episode.season = season_nr
episode.episode = episode_nr
episodes.append(episode)
output = TvShowSearchResult()
output.tvshow = tvshow
output.episodes = episodes
output.director = director
output.cast = cast
return output
# Search for a tv show via the API and turn the found data into a database supported object
def search_tvshow(self, query: str, duration: int) -> TvShowSearchResult:
search = self.tv.search(query)
output = None
for tvshow_data in search:
tvshow = self.tmdb_to_tvshow(tvshow_data)
if output is None:
output = tvshow
#elif abs(tvshow.tvshow.runtime - duration) < abs(output.tvshow.runtime - duration):
#output = tvshow
return output
# Search for a tv show via the API and turn the found data into a database supported object
def search_tvshows(self, query: str,
max_tvshows: int) -> [TvShowSearchResult]:
search = self.tv.search(query)
output = []
for tvshowdata in search:
if len(output) >= max_tvshows:
break
tvshow = self.tmdb_to_tvshow(tvshowdata)
output.append(tvshow)
return output
# "Download" a tv show thumbnail
def get_poster_tv(self, tmdb_id: int) -> str:
tv_result = self.tv.details(tmdb_id)
poster_path = tv_result.poster_path
if poster_path is None:
return None
return "https://image.tmdb.org/t/p/w500" + poster_path
# Get the similar items of a tv show
def get_similar_tmdb_tvshows(self, tmdb_id: int) -> [TvShowSearchResult]:
output = []
for tvshowdata in self.tv.similar(tmdb_id):
output.append(self.tmdb_to_tvshow(tvshowdata))
if len(output) == SIMILAR_AMOUNT:
break
return output
class TMDbTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ["TMDB_API_KEY"]
self.tmdb.language = "en"
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.movie = Movie()
self.discover = Discover()
self.tv = TV()
self.person = Person()
self.collection = Collection()
self.company = Company()
self.season = Season()
self.list = List()
def test_get_tv_keywords(self):
keywords = self.tv.keywords(1396)
self.assertGreater(len(keywords), 0)
def test_get_tv_reviews(self):
reviews = self.tv.reviews(1396)
self.assertGreater(len(reviews), 0)
def test_get_movie_repr(self):
search = self.movie.search("Mad Max")
for results in search:
print(results)
def test_get_tv_show_repr(self):
search_tv = self.tv.search("Breaking Bad")
for results in search_tv:
print(results)
def test_get_movie(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie.title, "Scarface")
self.assertEqual(movie.id, 111)
self.assertTrue(hasattr(movie, "title"))
self.assertTrue(hasattr(movie, "overview"))
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_reviews(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
first = search[0]
reviews = self.movie.reviews(first.id)
self.assertTrue(len(reviews) > 0)
for review in reviews:
self.assertTrue(hasattr(review, "id"))
self.assertTrue(hasattr(review, "content"))
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertTrue(len(lists) > 0)
self.assertTrue(hasattr(lists[0], "description"))
self.assertTrue(hasattr(lists[0], "name"))
def test_get_movie_credits(self):
credits = self.movie.credits(111)
print(credits)
self.assertIsNotNone(credits)
def test_get_movie_images(self):
images = self.movie.images(111)
print(images)
self.assertIsNotNone(images)
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertTrue(len(videos) > 0)
self.assertTrue(hasattr(videos[0], "id"))
def test_get_movie_recommendations(self):
recs = self.movie.recommendations(111)
self.assertTrue(len(recs) > 0)
self.assertTrue(hasattr(recs[0], "id"))
def test_discover_movies(self):
discover = self.discover.discover_movies({
"primary_release_year": "2015",
"with_genres": "28",
"page": "1",
"vote_average.gte": "8",
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], "id"))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 28:
has_genre = True
self.assertTrue(has_genre)
def test_discover_tv_shows(self):
discover = self.discover.discover_tv_shows({
"with_genres": "16",
"vote_average.gte": "8",
"page": "1"
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], "id"))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 16:
has_genre = True
self.assertTrue(has_genre)
def test_get_latest_movie(self):
videos = self.movie.latest()
self.assertIsNotNone(videos)
self.assertTrue(hasattr(videos, "id"))
def test_now_playing(self):
now_playing = self.movie.now_playing()
self.assertTrue(len(now_playing) > 0)
self.assertTrue(hasattr(now_playing[0], "id"))
def test_top_rated(self):
top_rated = self.movie.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], "id"))
def test_upcoming(self):
upcoming = self.movie.upcoming()
self.assertTrue(len(upcoming) > 0)
self.assertTrue(hasattr(upcoming[0], "id"))
def test_popular(self):
popular = self.movie.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], "id"))
def test_search(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
self.assertTrue(hasattr(search[0], "id"))
def test_similar(self):
similar = self.movie.similar(111)
self.assertTrue(len(similar) > 0)
self.assertTrue(hasattr(similar[0], "id"))
def test_get_tv_show(self):
show = self.tv.details(12)
self.assertIsNotNone(show)
self.assertTrue(hasattr(show, "id"))
def test_on_the_air(self):
show = self.tv.on_the_air()
self.assertTrue(len(show) > 0)
def test_airing_today(self):
show = self.tv.on_the_air()
self.assertTrue(len(show) > 0)
def test_tv_videos(self):
show = self.tv.videos(1396)
self.assertTrue(len(show) > 0)
def test_tv_recommendations(self):
show = self.tv.recommendations(1396)
self.assertTrue(len(show) > 0)
def test_external_ids(self):
show = self.tv.external_ids(1776)
self.assertEqual(show["imdb_id"], "tt0488262")
def test_get_latest_tv_show(self):
latest_tv = self.tv.latest()
self.assertIsNotNone(latest_tv)
self.assertTrue(hasattr(latest_tv, "id"))
def test_search_tv(self):
search_tv = self.tv.search("Sunny")
self.assertTrue(len(search_tv) > 0)
self.assertTrue(hasattr(search_tv[0], "id"))
def test_popular_shows(self):
popular = self.tv.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], "id"))
def test_top_rated_shows(self):
top_rated = self.tv.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], "id"))
def test_get_person(self):
person = self.person.details(234)
self.assertIsNotNone(person)
self.assertTrue(hasattr(person, "id"))
def test_search_person(self):
search_person = self.person.search("Bryan")
self.assertTrue(len(search_person) > 0)
self.assertTrue(hasattr(search_person[0], "id"))
def test_collection_details(self):
c = Collection()
details = c.details(10)
self.assertEqual(details.name, "Star Wars Collection")
self.assertEqual(details.id, 10)
self.assertTrue(hasattr(details, "overview"))
self.assertTrue(hasattr(details, "poster_path"))
def test_collection_images(self):
c = Collection()
images = c.images(10)
self.assertTrue(hasattr(images, "backdrops"))
self.assertTrue(hasattr(images, "posters"))
def test_popular_people(self):
popular = self.person.popular()
self.assertTrue(len(popular) > 0)
first = popular[0]
self.assertTrue(hasattr(first, "name"))
self.assertTrue(hasattr(first, "known_for"))
def test_latest_person(self):
latest_person = self.person.latest()
self.assertIsNotNone(latest_person)
self.assertTrue(hasattr(latest_person, "name"))
self.assertTrue(hasattr(latest_person, "id"))
def test_person_images(self):
images = self.person.images(11)
self.assertIsNotNone(images)
self.assertTrue(hasattr(images, "profiles"))
self.assertTrue(hasattr(images, "id"))
def test_company_details(self):
c = self.company.details(1)
self.assertTrue(hasattr(c, "name"))
self.assertEqual(c.name, "Lucasfilm Ltd.")
def test_company_movies(self):
company = self.company.movies(1)
self.assertTrue(len(company) > 0)
first = company[0]
self.assertTrue(hasattr(first, "title"))
self.assertTrue(hasattr(first, "overview"))
def test_config(self):
config = Configuration()
info = config.info()
self.assertIsNotNone(info)
self.assertTrue(hasattr(info, "images"))
def test_genres(self):
genres = Genre()
movie_genres = genres.movie_list()
self.assertIsNotNone(movie_genres)
tv_genres = genres.tv_list()
self.assertIsNotNone(tv_genres)
def test_season(self):
s = self.season.details(1418, 1)
self.assertIsNotNone(s)
self.assertEqual(s.name, "Season 1")
self.assertEqual(s.id, 3738)
self.assertTrue(hasattr(s, "episodes"))
self.assertTrue(hasattr(s, "overview"))
self.assertTrue(hasattr(s, "id"))
def test_get_season_changes(self):
s = self.season.changes(1418)
self.assertIsNotNone(s)
def test_get_season_external_ids(self):
s = self.season.external_ids(1418, 1)
self.assertIsNotNone(s)
self.assertIsNotNone(s["tvdb_id"])
def test_get_season_videos(self):
s = self.season.videos(1418, 1)
def test_get_season_images(self):
s = self.season.images(1418, 1)
for l in s:
self.assertIsNotNone(l.width)
self.assertIsNotNone(l.height)
def test_get_season_credits(self):
s = self.season.credits(1418, 1)
for c in s:
self.assertIsNotNone(c.name)
self.assertIsNotNone(c.character)
def test_get_movie_by_external_id(self):
ex = self.movie.external(external_id="tt8155288",
external_source="imdb_id")
res = ex["movie_results"][0]
self.assertTrue(res["title"] == "Happy Death Day 2U")
def test_get_list(self):
list = self.list.details(list_id="112870")
self.assertTrue(len(list) > 10)
self.assertTrue(hasattr(list[0], "id"))
self.assertTrue(hasattr(list[0], "title"))
def test_get_certifications(self):
certifications = Certification()
movie_certifications = certifications.movie_list()
self.assertIsNotNone(movie_certifications)
tv_certifications = certifications.tv_list()
self.assertIsNotNone(tv_certifications)
class MovieRepository:
def __init__(self):
self.__tmdb = TMDb()
self.__tmdb.api_key = os.getenv('MOVIE_API_KEY')
self.__tmdb.language = 'en'
self.__tmdb.debug = True
self.__movie = ApiMovies()
self.__db_engine = db.create_engine(os.getenv('DB_ENGINE'))
self.__db_connection = self.__db_engine.connect()
self.__db_metadata = db.MetaData()
self.__followed_movies = db.Table("followed_movies",
self.__db_metadata,
autoload=True,
autoload_with=self.__db_engine)
self.__watched_movies = db.Table("watched_movies",
self.__db_metadata,
autoload=True,
autoload_with=self.__db_engine)
def add(self, movie: Movie):
pass
def delete(self, movie: Movie):
pass
def update(self, movie: Movie):
pass
def getById(self, movie_id: int, user_id: UserId = None):
movie_from_api = self.__movie.details(movie_id)
# There are cases where the api returns an object without properties
# We need to return None in those cases too
if not movie_from_api or not hasattr(movie_from_api, 'id'):
return None
return self.__getMovieFromApiResult(movie_from_api, user_id)
def getPopularMovies(self, user_id: UserId = None):
movies_from_api = self.__movie.popular()
if not movies_from_api:
return None
movies = []
for movie_from_api in movies_from_api:
movies.append(self.__getMovieFromApiResult(movie_from_api,
user_id))
return movies
def getTopRated(self, user_id: UserId = None):
movies_from_api = self.__movie.top_rated()
if not movies_from_api:
return None
movies = []
for movie_from_api in movies_from_api:
movies.append(self.__getMovieFromApiResult(movie_from_api,
user_id))
return movies
def getByTitle(self, title: str, user_id: UserId = None):
movies_from_api = self.__movie.search(title)
if not movies_from_api:
return None
movies = []
for movie_from_api in movies_from_api:
movies.append(self.__getMovieFromApiResult(movie_from_api,
user_id))
return movies
def getSimilarById(self, movie_id: int, user_id: UserId = None):
# When the movie_id is a 404 in the api tmdbv3api returns an error
# So we have to force the 404 in that case
try:
movies_from_api = self.__movie.similar(movie_id)
except Exception as e:
return None
if not movies_from_api:
return None
movies = []
for movie_from_api in movies_from_api:
movies.append(self.__getMovieFromApiResult(movie_from_api,
user_id))
return movies
def get_following_movies(self, user_id: UserId):
query = db.select([
self.__followed_movies.columns.movie_id
]).where(self.__followed_movies.columns.user_id == user_id.value)
result_proxy = self.__db_connection.execute(query)
result_set = result_proxy.fetchall()
following_movies_ids = self.__getMovieIdsFromResult(result_set)
movies = []
for following_movie_id in following_movies_ids:
movies.append(self.getById(following_movie_id, user_id))
return movies
def get_watched_movies(self, user_id: UserId):
query = db.select([
self.__watched_movies.columns.movie_id
]).where(self.__watched_movies.columns.user_id == user_id.value)
result_proxy = self.__db_connection.execute(query)
result_set = result_proxy.fetchall()
watched_movies_ids = self.__getMovieIdsFromResult(result_set)
movies = []
for watched_movie_id in watched_movies_ids:
movies.append(self.getById(watched_movie_id, user_id))
return movies
def follow_movie(self, user_id: UserId, movie_id: int):
if self.__is_following(movie_id, user_id):
return False
query = db.insert(self.__followed_movies).values(user_id=user_id.value,
movie_id=movie_id)
resultProxy = self.__db_connection.execute(query)
def unfollow_movie(self, user_id: UserId, movie_id: int):
if not self.__is_following(movie_id, user_id):
return False
query = db.delete(self.__followed_movies).where(
and_(self.__followed_movies.columns.user_id == user_id.value,
self.__followed_movies.columns.movie_id == movie_id))
resultProxy = self.__db_connection.execute(query)
def watch_movie(self, user_id: UserId, movie_id: int):
if self.__has_watched(movie_id, user_id):
return False
query = db.insert(self.__watched_movies).values(user_id=user_id.value,
movie_id=movie_id)
resultProxy = self.__db_connection.execute(query)
def unwatch_movie(self, user_id: UserId, movie_id: int):
if not self.__has_watched(movie_id, user_id):
return False
query = db.delete(self.__watched_movies).where(
and_(self.__followed_movies.columns.user_id == user_id.value,
self.__followed_movies.columns.movie_id == movie_id))
resultProxy = self.__db_connection.execute(query)
def __getMovieIdsFromResult(self, result: tuple):
movie_ids = []
for movie_id_result in result:
movie_id = movie_id_result[0]
movie_ids.append(movie_id)
return movie_ids
def __getMovieFromApiResult(self, result: Movie, user_id: UserId = None):
following = False
watched = False
if user_id:
following = self.__is_following(result.id, user_id)
watched = self.__has_watched(result.id, user_id)
poster = ""
if result.poster_path:
poster = (POSTER_URL + result.poster_path)
genres = []
if hasattr(result, "genres"):
genres = result.genres
return Movie(movie_id=result.id,
title=result.title,
poster_url=poster,
rating=result.vote_average,
genres=genres,
overview=result.overview,
following=following,
watched=watched)
def __is_following(self, movie_id: int, user_id: UserId):
query = db.select([self.__followed_movies]).where(
and_(self.__followed_movies.columns.user_id == user_id.value,
self.__followed_movies.columns.movie_id == movie_id))
resultProxy = self.__db_connection.execute(query)
resultSet = resultProxy.fetchall()
if not resultSet:
return False
return True
def __has_watched(self, movie_id: int, user_id: UserId):
query = db.select([self.__watched_movies]).where(
and_(self.__watched_movies.columns.user_id == user_id.value,
self.__watched_movies.columns.movie_id == movie_id))
resultProxy = self.__db_connection.execute(query)
resultSet = resultProxy.fetchall()
if not resultSet:
return False
return True
class MovieTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ['TMDB_API_KEY']
self.tmdb.language = "en"
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.tmdb.cache = False
self.movie = Movie()
def test_get_movie_repr(self):
search = self.movie.search("Mad Max")
self.assertGreater(len(search), 0)
for result in search:
self.assertNotEqual(str(result), "TMDB Obj")
def test_get_movie_details(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie.id, 111)
self.assertTrue(hasattr(movie, 'title'))
self.assertTrue(hasattr(movie, 'overview'))
self.assertTrue(hasattr(movie, 'release_dates'))
def test_get_movie_alternative_titles(self):
alternative_titles = self.movie.alternative_titles(111)
self.assertEqual(alternative_titles.id, 111)
self.assertGreater(len(alternative_titles.titles), 0)
for title in alternative_titles.titles:
self.assertIn('iso_3166_1', title)
self.assertIn('title', title)
self.assertIn('type', title)
def test_get_movie_changes(self):
changes = self.movie.changes(111,
start_date="2016-08-29",
end_date="2016-09-10")
self.assertIsNotNone(changes)
changes = self.movie.changes(111, start_date="2016-08-29")
self.assertIsNotNone(changes)
changes = self.movie.changes(111, end_date="2016-09-10")
self.assertIsNotNone(changes)
changes = self.movie.changes(111, page=2)
self.assertIsNotNone(changes)
def test_get_movie_credits(self):
credits = self.movie.credits(111)
self.assertEqual(credits.id, 111)
self.assertTrue(hasattr(credits, "cast"))
self.assertTrue(hasattr(credits, "crew"))
def test_get_movie_external_ids(self):
external_ids = self.movie.external_ids(111)
self.assertIn("imdb_id", external_ids)
self.assertIn("facebook_id", external_ids)
self.assertIn("instagram_id", external_ids)
self.assertIn("twitter_id", external_ids)
self.assertIn("id", external_ids)
def test_get_movie_images(self):
images = self.movie.images(111, include_image_language="en,null")
self.assertEqual(images.id, 111)
self.assertGreater(len(images.backdrops), 0)
self.assertGreater(len(images.posters), 0)
for image in images.backdrops:
self.assertIn("file_path", image)
for image in images.posters:
self.assertIn("file_path", image)
def test_get_movie_keywords(self):
keywords = self.movie.keywords(111)
for keyword in keywords.keywords:
self.assertIn("id", keyword)
self.assertIn("name", keyword)
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertGreater(len(lists), 0)
for list in lists:
self.assertTrue(hasattr(list, "description"))
self.assertTrue(hasattr(list, "name"))
def test_get_movie_recommendations(self):
recommendations = self.movie.recommendations(111)
self.assertGreater(len(recommendations), 0)
for movie in recommendations:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_release_dates(self):
release_dates = self.movie.release_dates(111)
self.assertIsNotNone(release_dates)
self.assertEqual(release_dates.id, 111)
def test_get_movie_reviews(self):
reviews = self.movie.reviews(111)
self.assertGreater(len(reviews), 0)
for review in reviews:
self.assertTrue(hasattr(review, "id"))
self.assertTrue(hasattr(review, "content"))
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertGreater(len(videos), 0)
for video in videos:
self.assertTrue(hasattr(video, "id"))
def test_get_movie_latest(self):
latest = self.movie.latest()
self.assertIsNotNone(latest)
self.assertTrue(hasattr(latest, "id"))
def test_get_movie_now_playing(self):
now_playing = self.movie.now_playing()
self.assertGreater(len(now_playing), 0)
for movie in now_playing:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_top_rated(self):
top_rated = self.movie.top_rated()
self.assertGreater(len(top_rated), 0)
for movie in top_rated:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_upcoming(self):
upcoming = self.movie.upcoming()
self.assertGreater(len(upcoming), 0)
for movie in upcoming:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_popular(self):
popular = self.movie.popular()
self.assertGreater(len(popular), 0)
for movie in popular:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_search(self):
search = self.movie.search("Mad Max")
self.assertGreater(len(search), 0)
for movie in search:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_similar(self):
similar = self.movie.similar(111)
self.assertGreater(len(similar), 0)
for movie in similar:
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_external(self):
external = self.movie.external(external_id="tt8155288",
external_source="imdb_id")
self.assertGreater(len(external), 0)
for movie in external["movie_results"]:
self.assertIn("id", movie)
external_ids = self.movie.external_ids(movie["id"])
self.assertEqual(external_ids["imdb_id"], "tt8155288")
