def import_cast(start, end): movie = Movie() cast_list = [] for index in range(start, end): try: m = movie.credits(index)['cast'] for i in m: try: actor_id = i['id'] movie_id = index identity = "Act: " + i['character'] c = DbCast(movie_id=movie_id, actor_id=actor_id, identity=identity) cast_list.append(c) print(movie_id, actor_id, identity) except TypeError: pass k = movie.credits(index)['crew'] for j in k: try: actor_id = j['id'] movie_id = index identity = "Produce: " + j['job'] c = DbCast(movie_id=movie_id, actor_id=actor_id, identity=identity) cast_list.append(c) print(movie_id, actor_id, identity) except TypeError: pass except TMDbException: pass return cast_list
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
def handle(self, *args, **options): not_added = 0 added = 0 mov_id = 1 user_count = 1 from tmdbv3api import TMDb tmdb = TMDb() tmdb.api_key = '' # api_key tmdb.language = 'en' tmdb.debug = True from tmdbv3api import Movie mov = Movie() #file1 = open('film/management/commands/Attributes_Imdb_test1', 'r') #Lines = file1.readlines() imdb_id_list = [] """ f = open("recommendedfilm") recommend = {} for i in f: l = i.split("\n")[0].split("\t") recommend[l[0]] = eval(l[1]) """ f = open("film/management/commands/watchedfilms") watchedfilms = {} for i in f: l = i.split("\n")[0].split("\t") watchedfilms[l[0]] = eval(l[1]) """ for line in Lines: k = line.split('\t')[0] imdb_id_list.append(k) """ for user_id in watchedfilms.keys(): films = watchedfilms[user_id] user_email = "*****@*****.**" % user_count try: auth_user = User.objects.create_user(username=user_id, email=user_email, password='******') except: my_user = User.objects.get(username=user_id) user_profile = UserProfile.objects.create(user=my_user, spec_id=user_id) printed = 'User ID %d is added' % user_count print(printed) user_count = user_count + 1 for film in films: # film[0] = imdb_id ve film[1] = user_score imdb_id = film[0] user_score = Decimal(film[1]) control_exist = Mov.objects.filter(imdb=imdb_id) if control_exist: my_movie = Mov.objects.get(imdb=imdb_id) score = Score(user=my_user, movie=my_movie, score=user_score) score.save() user_profile.scores.add(score) user_profile.save() else: k = mov.details(imdb_id) try: m = k.poster_path img_path = "https://image.tmdb.org/t/p/w185%s" % m big_img_path = "https://image.tmdb.org/t/p/w500%s" % m except: error_id = "imdb id = %s can not be added" % imdb_id print(error_id) not_added = not_added+1 continue try: p = k.vote_average vote_average = Decimal(p) vote_average = vote_average/2 vote_average = round(vote_average, 1) except: vote_average = Decimal(0.0) genre_list = [] if k.original_title: title = k.original_title if k.overview: overview = k.overview for genre in k.genres: genre_list.append(genre) vid = mov.videos(imdb_id) key = "" if vid: key = vid[0].key yt_url = "https://www.youtube.com/embed/%s" % key rls_date = k.release_date rls_year = k.release_date.split('-')[0] credits = mov.credits(imdb_id) cast_list = [] for c in credits.cast: cast_list.append(c) if cast_list: print(cast_list[0]['name']) for c in cast_list: t = c['profile_path'] c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t writer_list = [] director_list = [] for c in credits.crew: if c['department'] == "Writing": writer_list.append(c) if c['department'] == "Directing" and c['job'] == "Director": director_list.append(c) for c in writer_list: t = c['profile_path'] c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t for c in director_list: t = c['profile_path'] c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t movie = Mov(year=rls_year, date=rls_date, imdb=imdb_id, title=title, topic=overview,poster_url=img_path,poster_big_url=big_img_path, video_url=yt_url, avg_score=vote_average) try: movie.save() except: print("There is invalid field somewhere in movie fields. So this can not be added") not_added = not_added + 1 continue adding_control = "movie_id %d is added" % mov_id print(adding_control) mov_id = mov_id + 1 for i in cast_list: person_query = Person.objects.filter(id_unique = i['id']) if not person_query: person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Star') person.save() movie.starring.add(person) movie.save() else: person = Person.objects.get(id_unique = i['id']) movie.starring.add(person) movie.save() for i in writer_list: person_query = Person.objects.filter(id_unique=i['id']) if not person_query: person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Writer') person.save() movie.writer.add(person) movie.save() else: person = Person.objects.get(id_unique=i['id']) movie.writer.add(person) movie.save() for i in director_list: person_query = Person.objects.filter(id_unique=i['id']) if not person_query: person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Director') person.save() movie.director.add(person) movie.save() else: person = Person.objects.get(id_unique=i['id']) movie.director.add(person) movie.save() for i in genre_list: existing_genre = Genre.objects.filter(name__exact=i['name']) if not existing_genre: genre = Genre(name=i['name']) genre.save() movie.genres.add(genre) movie.save() else: genre = Genre.objects.get(name=i['name']) movie.genres.add(genre) movie.save() score = Score(user=my_user, movie=movie, score=user_score) score.save() user_profile.scores.add(score) user_profile.save() """ if user_count == 6: break """ not_added_result = 'Eklenmeyen sayisi = %d' % not_added print(not_added_result) self.stdout.write(self.style.SUCCESS('Successfully added'))
def main(): movie = Movie() n=idTerakhir() while n > 353000: #353000 just a limit for iteration, may be changed to 1 for all movie id m = movie.details(n) try: if m==[] or m is None or m==() or m=="": print("Data film ini tidak ditemukan") else: id_movie=n attr = getattr(m, "original_title", None) if attr is not None: judul=m.original_title budget=m.budget overview=m.overview popularity=m.popularity poster=m.poster_path tglrelease=m.release_date pendapatan=m.revenue runtime=m.runtime status = m.status voteavrg = m.vote_average votecount = m.vote_count tagline = m.tagline homepage = m.homepage negaraproduksi = m.production_countries bahasa=m.original_language revenue=m.revenue print("Mengambil Data Film "+judul) for x in range(0,len(m.genres)): insert_genre(m.genres[x]["id"],m.genres[x]["name"]) insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,m.genres[x]["id"],bahasa,1000000,1000000,1000000,1000000,"",budget) xtanggal = m.release_date if xtanggal!="": a,b,c = xtanggal.split("-") insert_waktu(a,b,c,xtanggal) insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,xtanggal,1000000,1000000,1000000,"",budget) else: print("Belum ada release data") for z in range(0,len(m.production_companies)): insert_companies(m.production_companies[z]["id"],m.production_companies[z]["name"],m.production_companies[z]["origin_country"],m.production_companies[z]["logo_path"]) insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,1000000,m.production_companies[z]["id"],"",budget) for y in range(0,len(m.production_countries)): sqlprod = "insert ignore into sma_tbl_dimnegara(id_negara,nama_negara) values(%s,%s)" args = (m.production_countries[y]["iso_3166_1"],m.production_countries[y]["name"]) cursor.execute(sqlprod, args) mydb.commit() insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,m.production_countries[y]["iso_3166_1"],1000000,1000000,"",budget) r = movie.reviews(n) if r==[]: print("Tidak ada data review") else: for h in range(0,len(r.results)): dtreview = "Author: "+r.results[h]["author"]+"<br>"+r.results[h]["content"] insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,1000000,1000000,dtreview,budget) c = movie.credits(n) if c==[]: print("Tidak ada data person") else: for dd in c.cast: id_person =dd["id"] nama =dd["name"] job ="Cast" with urllib.request.urlopen("https://api.themoviedb.org/3/person/"+str(id_person)+"?api_key=ee183266d8fc13c415cad996a43d03b1&language=en-US") as url: c = json.loads(url.read().decode()) popularity =c["popularity"] pob =c["place_of_birth"] foto =c["profile_path"] birthday =c["birthday"] homepage =c["homepage"] biography =c["biography"] insert_person(id_person,nama,biography,popularity,pob,foto,job,birthday,homepage) insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,id_person,1000000,"",budget) c = movie.credits(n) if c==[]: print("Tidak ada data person") else: for cc in c.crew: id_person =cc["id"] nama =cc["name"] job ="Crew" with urllib.request.urlopen("https://api.themoviedb.org/3/person/"+str(id_person)+"?api_key=ee183266d8fc13c415cad996a43d03b1&language=en-US") as url: c = json.loads(url.read().decode()) popularity =c["popularity"] pob =c["place_of_birth"] foto =c["profile_path"] birthday =c["birthday"] homepage =c["homepage"] biography =c["biography"] insert_person(id_person,nama,biography,popularity,pob,foto,job,birthday,homepage) insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,id_person,1000000,"",budget)
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 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('title' in movie) self.assertTrue('overview' in movie) self.assertTrue('id' in movie) 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('id' in review)) self.assertTrue('content' in review)) 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' })
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")
from tmdbv3api import TMDb, Movie import pandas as pd tmdb = TMDb() tmdb.api_key = '' movie = Movie() movie_list = pd.read_csv('./movie.csv', sep=';', names=["id", "tmdbid", "title"]) movies = pd.DataFrame( columns=['id', 'genres', 'cast', 'vote_average', 'director', 'keywords']) map_name = lambda a: a.name map_original_name = lambda a: a.original_name for index, row in movie_list.iterrows(): m = movie.details(movie_id=row['tmdbid']) c = movie.credits(movie_id=row['tmdbid']) id = row['id'] genres = list(map(map_name, m.genres)) cast = list(map(map_original_name, c.cast)) vote_average = m.vote_average director = None for crewmate in c.crew: if (crewmate.job == "Director"): director = crewmate.original_name keywords = list(map(map_name, m.keywords.keywords)) movies.loc[id - 1] = [id, genres, cast, vote_average, director, keywords] print("Downloading: " + str(index) + " / " + str(len(movie_list.index)), end='\r') movies.to_csv('movies.csv', index=False)
class TMDbClient: def __init__(self): ''' A custom client for The Movie Database API for French movies ''' self.client = TMDb() self.client.language = 'fr-FR' self.movie_db = Movie() self.search = Search() def find_movie_id(self, movie: str) -> Union[int, None]: ''' Looks for a particular movie in TMDb Parameters ---------- movie: str a movie title Returns ------- id: Union[int, None] the most relevant movie id if we found one, or None ''' results = self.search.movies({'query': movie}) if len(results) > 0: return results[0].id def get_movie_details(self, movie_id: int) -> MovieDetails: ''' Get a movie main features Parameters ---------- movie_id: int a movie id (the tmdb one) Returns ------- details: MovieDetails A movie details ''' details = self.movie_db.details(movie_id) details = unmarshal_details(details) return details def get_movie_cast(self, movie_id: int) -> MovieCast: ''' Get a movie cast Parameters ---------- movie_id: int a movie id (the tmdb one) Returns ------- cast: MovieCast A movie cast ''' credits = self.movie_db.credits(movie_id) cast = unmarshal_credits(credits) return cast def find_movie_features(self, movie: str) -> Union[None, MovieCard]: ''' Find all relevant features (details and cast) given a movie title Parameters ---------- movie: str a movie title Returns ------- card: Union[None, MovieCard] A movie card. None if no movie was found ''' movie_id = self.find_movie_id(movie) if movie_id: card = self.get_movie_details(movie_id) card['cast'] = self.get_movie_cast(movie_id) return card else: return None