def popular_movies(request):
movie = Movie()
popular = movie.popular()
trailers = []
keys = []
products = []
for p in popular:
videos = movie.videos(p.id)
trailers.append(videos)
for t in trailers:
for i in t:
video_key = i.key
product = {
'title': p.title,
'poster_path': p.poster_path,
'backdrop_path': p.backdrop_path,
'duration': p.runtime,
'year': p.release_date,
'video': video_key,
}
return keys
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")
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'))
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")
