def queryTVShowsFromTmdb(tv_shows_id):
""" Collect current tv show data from tmdb api
Args:
tv_shows_id (int list): list of tv shows id
Returns:
tv_shows_data (str list): list of each TV show raw data in JSON format
"""
# Create a TV object
tv = TV()
# Iterate over each TV show and get their details
tv_shows_data = []
for id in tv_shows_id:
try:
tv_show = tv.details(id)
tv_show_dict = tv_show.__dict__
query_datetime = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
tv_show_dict['query_datetime'] = query_datetime
except Exception as e:
logging.error(str(e))
logging.error(
'TV show id={} could not be queried properly'.format(id))
else:
tv_shows_data.append(json.dumps(tv_show_dict))
# Check how many TV shows are successfully queried
if len(tv_shows_data) == len(tv_shows_id):
logging.info('All {} tv shows are queried successfully'.format(
len(tv_shows_data)))
else:
logging.warning('{}/{} tv shows are queried successfully'.format(
len(tv_shows_data), len(tv_shows_id)))
return tv_shows_data
def get_dim_tmdb(tv_shows_id):
""" Queries TV show details from TMDB and
extracts genres, networks and tv show data
Args:
tv_shows_id (int list): list of tv shows id
Returns:
df_genre (dataframe) : genre id and name
df_network (dataframe) : network id, name and origin country
df_tvshow (dataframe) : TV show id, name, original name, genre ids and network ids
"""
# Create the TV object
tv = TV()
# Retrieve raw TV show data
tv_shows_raw = []
for tv_show_id in tv_shows_id:
tv_show_detail = tv.details(tv_show_id)
tv_shows_raw.append(tv_show_detail.__dict__)
# Define the columns
genre_columns = ['id', 'name']
network_columns = ['id', 'name', 'origin_country']
tv_show_columns = ['id', 'name', 'original_name', 'original_language', 'genres_id', 'networks_id']
# Initialize the dataframes
df_genre = pd.DataFrame(columns=genre_columns)
df_network = pd.DataFrame(columns=network_columns)
df_tvshow = pd.DataFrame(columns=tv_show_columns)
# Extract from the raw data
for tv_show_data in tv_shows_raw:
# Genres
for genre in tv_show_data.get('genres', []):
genre_id, genre_name = int(genre['id']), genre['name']
if not ((df_genre['id'] == genre_id) & (df_genre['name'] == genre_name)).any():
df_genre.loc[len(df_genre),:] = genre_id, genre_name
# Networks
for network in tv_show_data.get('networks', []):
network_id, network_name, network_country = int(network['id']), network['name'], network['origin_country']
if not ((df_network['id'] == network_id) & (df_network['name'] == network_name)).any():
df_network.loc[len(df_network),:] = network_id, network_name, network_country
# TV shows
genres_id = []
for genre in tv_show_data.get('genres', []):
genres_id.append(int(genre['id']))
networks_id = []
for network in tv_show_data.get('networks', []):
networks_id.append(int(network['id']))
df_tvshow.loc[len(df_tvshow),:] = [int(tv_show_data['id']), tv_show_data['name'],
tv_show_data['original_name'], tv_show_data['original_language'], genres_id,networks_id]
return df_genre, df_network, df_tvshow
def get_detalles(id, tipo=''):
try:
if id == '':
abort(404, "Post id {0} doesn't exist.".format(id))
if tipo == '':
abort(403)
detalles = ""
if tipo == "peliculas":
movie = Movie()
detalles = movie.details(id)
elif tipo == "series":
season = Season()
detalles = season.details(id)
elif tipo == "tv":
tv = TV()
detalles = tv.details(id)
return detalles
except Exception as e:
raise e
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
def getSeriesNamePoster(series_id):
id = int(series_id)
series = TV()
s = series.details(id)
return s.name, s.poster_path
def singleSeries(request, series_id):
data = {}
id = int(series_id)
# Fetching all the reviews of that series
reviews = ReviewSeries.objects.filter(seriesid=id)
userReviews = []
if reviews.exists():
temp = {}
for review in reviews:
userReviews.append({'review': review.review, 'date': review.date, 'userid': review.userid})
data['userReview'] = userReviews
else:
data['userReview'] = None
# Checking if the logged in user has reviewed it or not.
check = ReviewSeries.objects.filter(seriesid=id).filter(userid=request.user.username)
if check.exists():
data['check'] = True
else:
data['check'] = False
# If user send review this part is executed.
if request.method == "POST":
username = request.user.username
series_id = int(series_id)
text = request.POST['review']
# Calling getSentiment function to get probability and sentiment of review.
prob, sen = getSentiment(text)
x = ReviewSeries(
userid = username,
seriesid = series_id,
review = text,
sentiment = sen,
probability = prob
)
# Saving the review and sending a conformation message.
x.save()
messages.success(request, 'Your review has been saved successfully.')
return redirect(singleSeries, id)
# setting series details
series = TV()
s = series.details(id)
# Arranging series data
cast = []
temp = s.credits.cast
length = min(len(temp),20)
for i in range(length):
if temp[i].known_for_department == "Acting":
cast.append({'original_name': temp[i].original_name, 'character': temp[i].character, 'photo': temp[i].profile_path})
crew = []
temp = s.credits.crew
length = min(len(temp),20)
for i in range(length):
crew.append({'department': temp[i].department, 'name': temp[i].original_name, 'photo': temp[i].profile_path})
del temp
data['title'] = s.name
data['homepage'] = s.homepage
data['networks'] = [{'name': x.name, 'logo': x.logo_path} for x in s.networks]
data['description'] = s.overview
data['tagline'] = s.tagline
data['languages'] = s.languages
data['seasons'] = s.seasons
data['created_by'] = [{'name': x.name, 'photo': x.profile_path} for x in s.created_by]
data['status'] = s.status
data['country'] = s.origin_country
data['trailer'] = s.videos.results[0].key
data['type'] = s.type
data['cast'] = cast
data['crew'] = crew
data['runtime'] = s.episode_run_time
data['release_date'] = s.first_air_date
data['votes'] = getRatingSeries(seriesid=id)
data['negative'] = 100 - data['votes']
data['poster'] = s.poster_path
context = {}
context['data'] = data
return render(request, 'rhub/seriesInfo.html', context)
class ShowAPIDB():
def __init__(self):
self.tmdb = TMDb()
self.tmdb.api_key = "e00b72174e4ae097af808f34a8f220fc"
self.tv = TV()
self.season = Season()
self.movie = Movie()
self.discover = Discover()
def buscarSerie(self, nombre):
resultado = self.tv.search(nombre)
series = []
for i in resultado:
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
series.append(serie)
return series
def buscarPelicula(self, nombre):
resultado = self.movie.search(nombre)
pelis = []
for i in resultado:
peli = Tablas.Show()
peli.tipo = 0
peli.nombre = i.title
peli.idShow = i.id
peli.overview = i.overview
peli.poster = i.poster_path
peli.puntuacionIMDB = i.vote_average
pelis.append(peli)
return pelis
def buscarPeliculaPorID(self, id):
resultado = self.movie.details(id)
peli = Tablas.Show()
peli.tipo = 0
peli.nombre = resultado.title
peli.idShow = resultado.id
peli.overview = resultado.overview
peli.poster = resultado.poster_path
peli.puntuacionIMDB = resultado.vote_average
return peli
def buscarSeriePorID(self, id):
i = self.tv.details(id)
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
return serie
def descubrir(self):
show = self.discover.discover_tv_shows({'sort_by': 'popularity.desc'})
series = []
for i in show:
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
series.append(serie)
return series
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)
def tmdb_get_shows(config_path, plex, data, is_list=False):
config_tools.TraktClient(config_path)
tmdb_id = int(data)
t_tvs = []
t_tv = TV()
t_tv.api_key = config_tools.TMDB(
config_path).apikey # Set TMDb api key for Movie
if t_tv.api_key == "None":
raise KeyError("Invalid TMDb API Key")
if is_list:
tmdb = List()
tmdb.api_key = t_tv.api_key
try:
t_col = tmdb.details(tmdb_id)
for ttv in t_col:
if ttv.media_type == "tv":
t_tvs.append(ttv.id)
except:
raise ValueError(
"| Config Error: TMDb List: {} not found".format(tmdb_id))
else:
try:
t_tv.details(tmdb_id).number_of_seasons
t_tvs.append(tmdb_id)
except:
raise ValueError(
"| Config Error: TMDb ID: {} not found".format(tmdb_id))
p_tv_map = {}
for item in plex.Library.all():
guid = urlparse(item.guid)
item_type = guid.scheme.split('.')[-1]
if item_type == 'thetvdb':
tvdb_id = guid.netloc
elif item_type == 'themoviedb':
tvdb_id = get_tvdb_id_from_tmdb_id(guid.netloc)
else:
tvdb_id = None
p_tv_map[item] = tvdb_id
matched = []
missing = []
for mid in t_tvs:
match = False
tvdb_id = get_tvdb_id_from_tmdb_id(mid)
if tvdb_id is None:
print(
"| Trakt Error: tmbd_id: {} could not converted to tvdb_id try just using tvdb_id instead"
.format(mid))
else:
for t in p_tv_map:
if p_tv_map[t] and "tt" not in p_tv_map[t] != "None":
if p_tv_map[t] is not None and int(
p_tv_map[t]) == int(tvdb_id):
match = True
break
if match:
matched.append(t)
else:
missing.append(tvdb_id)
return matched, missing
def tmdb_get_shows(config_path, plex, plex_map, data, method):
config_tools.TraktClient(config_path)
t_tvs = []
t_tv = TV()
t_tv.api_key = config_tools.TMDB(config_path).apikey
if t_tv.api_key == "None":
raise KeyError("Invalid TMDb API Key")
count = 0
if method in ["tmdb_discover", "tmdb_company", "tmdb_network"]:
if method in ["tmdb_company", "tmdb_network"]:
tmdb = Company() if method == "tmdb_company" else Network()
tmdb.api_key = t_tv.api_key
tmdb_id = int(data)
tmdb_name = str(tmdb.details(tmdb_id))
discover_method = "with_companies" if method == "tmdb_company" else "with_networks"
attrs = {discover_method: tmdb_id}
limit = 0
else:
attrs = data.copy()
limit = int(attrs.pop('limit'))
discover = Discover()
discover.api_key = t_tv.api_key
discover.discover_tv_shows(attrs)
total_pages = int(os.environ["total_pages"])
total_results = int(os.environ["total_results"])
amount = total_results if limit == 0 or total_results < limit else limit
if method in ["tmdb_company", "tmdb_network"]:
print("| Processing {}: {} ({} {} shows)".format(
method, tmdb_id, amount, tmdb_name))
else:
print("| Processing {}: {} shows".format(method, amount))
for attr, value in attrs.items():
print("| {}: {}".format(attr, value))
for x in range(total_pages):
attrs["page"] = x + 1
tmdb_shows = discover.discover_tv_shows(attrs)
for tshow in tmdb_shows:
count += 1
t_tvs.append(tshow.id)
if count == data:
break
if count == data:
break
elif method in [
"tmdb_popular", "tmdb_top_rated", "tmdb_trending_daily",
"tmdb_trending_weekly"
]:
trending = Trending()
trending.api_key = t_tv.api_key
for x in range(int(int(data) / 20) + 1):
if method == "tmdb_popular":
tmdb_shows = t_tv.popular(x + 1)
elif method == "tmdb_top_rated":
tmdb_shows = t_tv.top_rated(x + 1)
elif method == "tmdb_trending_daily":
tmdb_shows = trending.tv_day(x + 1)
elif method == "tmdb_trending_weekly":
tmdb_shows = trending.tv_week(x + 1)
for tshow in tmdb_shows:
count += 1
t_tvs.append(tshow.id)
if count == amount:
break
if count == amount:
break
print("| Processing {}: {} Items".format(method, data))
else:
tmdb_id = int(data)
if method == "tmdb_list":
tmdb = List()
tmdb.api_key = t_tv.api_key
try:
t_col = tmdb.details(tmdb_id)
tmdb_name = str(t_col)
for ttv in t_col:
if ttv.media_type == "tv":
t_tvs.append(ttv.id)
except:
raise ValueError(
"| Config Error: TMDb List: {} not found".format(tmdb_id))
else:
try:
t_tv.details(tmdb_id).number_of_seasons
tmdb_name = str(t_tv.details(tmdb_id))
t_tvs.append(tmdb_id)
except:
raise ValueError(
"| Config Error: TMDb ID: {} not found".format(tmdb_id))
print("| Processing {}: ({}) {}".format(method, tmdb_id, tmdb_name))
matched = []
missing = []
for mid in t_tvs:
tvdb_id = tmdb_get_tvdb(config_path, mid)
if tvdb_id is None:
print(
"| TMDb Error: tmdb_id: {} ({}) has no associated tvdb_id. Try just using tvdb_id instead"
.format(mid,
t_tv.details(mid).name))
elif tvdb_id in plex_map:
matched.append(plex.Server.fetchItem(plex_map[tvdb_id]))
else:
missing.append(tvdb_id)
return matched, missing
class TvTests(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.tv = TV()
def test_get_tv_repr(self):
search = self.tv.search("Breaking Bad")
self.assertGreater(len(search), 0)
for result in search:
self.assertNotEqual(str(result), "TMDB Obj")
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_tv_details(self):
show = self.tv.details(12)
self.assertIsNotNone(show)
self.assertTrue(hasattr(show, "id"))
def test_get_tv_on_the_air(self):
show = self.tv.on_the_air()
self.assertGreater(len(show), 0)
def test_get_tv_airing_today(self):
show = self.tv.on_the_air()
self.assertGreater(len(show), 0)
def test_get_tv_videos(self):
show = self.tv.videos(1396)
self.assertGreater(len(show), 0)
def test_get_tv_recommendations(self):
show = self.tv.recommendations(1396)
self.assertGreater(len(show), 0)
def test_get_tv_external_ids(self):
show = self.tv.external_ids(1776)
self.assertEqual(show["imdb_id"], "tt0488262")
def test_get_tv_latest(self):
latest_tv = self.tv.latest()
self.assertIsNotNone(latest_tv)
self.assertTrue(hasattr(latest_tv, "id"))
def test_get_tv_search(self):
search_tv = self.tv.search("Sunny")
self.assertGreater(len(search_tv), 0)
self.assertTrue(hasattr(search_tv[0], "id"))
def test_get_tv_popular(self):
popular = self.tv.popular()
self.assertGreater(len(popular), 0)
self.assertTrue(hasattr(popular[0], "id"))
def test_get_tv_top_rated(self):
top_rated = self.tv.top_rated()
self.assertGreater(len(top_rated), 0)
self.assertTrue(hasattr(top_rated[0], "id"))
def tmdb_get_shows(config_path, plex, data, method):
config_tools.TraktClient(config_path)
t_tvs = []
t_tv = TV()
t_tv.api_key = config_tools.TMDB(config_path).apikey # Set TMDb api key for Movie
if t_tv.api_key == "None":
raise KeyError("Invalid TMDb API Key")
discover = Discover()
discover.api_key = t_tv.api_key
count = 0
if method == "tmdb_discover":
discover.discover_tv_shows(data)
total_pages = int(os.environ["total_pages"])
total_results = int(os.environ["total_results"])
limit = int(data.pop('limit'))
amount = total_results if total_results < limit else limit
print("| Processing {}: {} items".format(method, amount))
for attr, value in data.items():
print("| {}: {}".format(attr, value))
for x in range(total_pages):
data["page"] = x + 1
tmdb_shows = discover.discover_tv_shows(data)
for tshow in tmdb_shows:
count += 1
t_tvs.append(tshow.id)
if count == amount:
break
if count == amount:
break
run_discover(data)
elif method in ["tmdb_popular", "tmdb_top_rated", "tmdb_trending_daily", "tmdb_trending_weekly"]:
#trending = Trending() #TURNON:Trending
#trending.api_key = t_movie.api_key #TURNON:Trending
for x in range(int(data / 20) + 1):
if method == "tmdb_popular":
tmdb_shows = t_tv.popular(x + 1)
elif method == "tmdb_top_rated":
tmdb_shows = t_tv.top_rated(x + 1)
#elif method == "tmdb_trending_daily": #TURNON:Trending
# tmdb_shows = trending.tv_day(x + 1) #TURNON:Trending
#elif method == "tmdb_trending_weekly": #TURNON:Trending
# tmdb_shows = trending.tv_week(x + 1) #TURNON:Trending
for tshow in tmdb_shows:
count += 1
t_tvs.append(tshow.id)
if count == amount:
break
if count == amount:
break
print("| Processing {}: {} Items".format(method, data))
else:
tmdb_id = int(data)
if method == "tmdb_list":
tmdb = List()
tmdb.api_key = t_tv.api_key
try:
t_col = tmdb.details(tmdb_id)
tmdb_name = str(t_col)
for ttv in t_col:
if ttv.media_type == "tv":
t_tvs.append(ttv.id)
except:
raise ValueError("| Config Error: TMDb List: {} not found".format(tmdb_id))
elif method in ["tmdb_company", "tmdb_network"]:
if method == "tmdb_company":
tmdb = Company()
tmdb.api_key = t_tv.api_key
tmdb_name = str(tmdb.details(tmdb_id))
else:
#tmdb = Network() #TURNON:Trending
#tmdb.api_key = t_tv.api_key #TURNON:Trending
tmdb_name = ""#str(tmdb.details(tmdb_id)) #TURNON:Trending
discover_method = "with_companies" if method == "tmdb_company" else "with_networks"
tmdb_shows = discover.discover_tv_shows({discover_method: tmdb_id})
for tshow in tmdb_shows:
t_tvs.append(tshow.id)
else:
try:
t_tv.details(tmdb_id).number_of_seasons
tmdb_name = str(t_tv.details(tmdb_id))
t_tvs.append(tmdb_id)
except:
raise ValueError("| Config Error: TMDb ID: {} not found".format(tmdb_id))
print("| Processing {}: ({}) {}".format(method, tmdb_id, tmdb_name))
p_tv_map = {}
for item in plex.Library.all():
guid = urlparse(item.guid)
item_type = guid.scheme.split('.')[-1]
if item_type == 'thetvdb':
tvdb_id = guid.netloc
elif item_type == 'themoviedb':
tvdb_id = get_tvdb_id_from_tmdb_id(guid.netloc)
else:
tvdb_id = None
p_tv_map[item] = tvdb_id
matched = []
missing = []
for mid in t_tvs:
match = False
tvdb_id = get_tvdb_id_from_tmdb_id(mid)
if tvdb_id is None:
print("| Trakt Error: tmbd_id: {} could not converted to tvdb_id try just using tvdb_id instead".format(mid))
else:
for t in p_tv_map:
if p_tv_map[t] and "tt" not in p_tv_map[t] != "None":
if p_tv_map[t] is not None and int(p_tv_map[t]) == int(tvdb_id):
match = True
break
if match:
matched.append(t)
else:
missing.append(tvdb_id)
return matched, missing