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