def test_configuration_info(self):
change_keys = CHANGE_KEYS
config = tmdb.Configuration()
response = config.info()
self.assertEqual(config.change_keys, change_keys)
# Also test that bad API_KEY results in exception
# Restore key for sequential tests
api_key_save = tmdb.API_KEY
tmdb.API_KEY = 0
config = tmdb.Configuration()
self.assertRaises(tmdb.APIKeyError, config.info)
tmdb.API_KEY = api_key_save
def _retrieve_show_image_urls_from_tmdb(self, show, img_type):
types = {'poster': 'poster_path',
'banner': None,
'fanart': 'backdrop_path',
'poster_thumb': 'poster_path',
'banner_thumb': None}
# get TMDB configuration info
tmdbsimple.API_KEY = sickbeard.TMDB_API_KEY
config = tmdbsimple.Configuration()
response = config.info()
base_url = response['images']['base_url']
sizes = response['images']['poster_sizes']
def size_str_to_int(x):
return float("inf") if x == 'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
search = tmdbsimple.Search()
for show_name in allPossibleShowNames(show):
for result in search.collection(query=show_name)['results'] + search.tv(query=show_name)['results']:
if types[img_type] and getattr(result, types[img_type]):
return "{0}{1}{2}".format(base_url, max_size, result[types[img_type]])
except Exception:
pass
logger.log("Could not find any " + img_type + " images on TMDB for " + show.name, logger.INFO)
def get_context_data(self, **kwargs):
context = {'page_type': 'myrating_page'}
myratings = []
try:
data_entries = MovieRatings.objects.filter(user=self.request.user)
for entry in data_entries:
movie = tmdb.Movies(int(entry.movie_id))
config = tmdb.Configuration().info()
POSTER_SIZE = 1
myratings.insert(0, (movie.info(), entry.rating,
config['images']['base_url'] + config['images']['poster_sizes'][POSTER_SIZE]))
if self.request.user.is_authenticated:
if not myratings:
context['status'] = 'failure'
else:
context['status'] = 'success'
context['results'] = myratings
return context
except (requests.exceptions.HTTPError, tmdb.APIKeyError)as e:
context = {}
print ("API ERROR")
context["status"] = 'failure'
return context
def viewRatings(request):
context = {'page_type': 'myrating_page'}
myratings = []
if request.method == 'POST':
response = dict(
errors=list(),
)
tmdb.API_KEY = settings.TMDB_API_KEY
data_entries = MovieRatings.objects.filter(user=request.user)
for entry in data_entries:
movie = tmdb.Movies(int(entry.movie_id))
config = tmdb.Configuration().info()
POSTER_SIZE = 1
myratings.insert(0, (movie.info(), entry.rating, config['images']['base_url'] + config['images']['poster_sizes'][POSTER_SIZE]))
if request.user.is_authenticated:
if not myratings:
context['status'] = 'failure'
else:
context['status'] = 'success'
context['results'] = myratings
return render(request, 'myratings.html', context)
else:
raise Http404("No Movie Selected")
def _retrieve_show_images_from_tmdb(show, img_type):
types = {
'poster': 'poster_path',
'banner': None,
'fanart': 'backdrop_path',
'poster_thumb': 'poster_path',
'banner_thumb': None
}
def _request(self, method, path, params=None, payload=None):
url = self._get_complete_url(path)
params = self._get_params(params)
requests.packages.urllib3.disable_warnings()
response = requests.request(
method,
url,
params=params,
data=json.dumps(payload) if payload else payload,
verify=False)
#response.raise_for_status()
response.encoding = 'utf-8'
return response.json()
from tmdbsimple.base import TMDB
TMDB._request = _request
# get TMDB configuration info
tmdb.API_KEY = sickrage.srCore.srConfig.TMDB_API_KEY
response = tmdb.Configuration().info()
base_url = response['images']['base_url']
sizes = response['images']['poster_sizes']
def size_str_to_int(x):
return float("inf") if x == 'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
sickrage.srCore.srLogger.debug("Searching for any " + img_type +
" images on TMDB for " + show.name)
try:
search = tmdb.Search()
from sickrage.core.helpers.show_names import allPossibleShowNames
for show_name in set(allPossibleShowNames(show)):
for result in search.collection(
query=show_name)['results'] + search.tv(
query=show_name)['results']:
if types[img_type] and getattr(result, types[img_type]):
return "{0}{1}{2}".format(base_url, max_size,
result[types[img_type]])
except:
pass
sickrage.srCore.srLogger.debug("Could not find any " + img_type +
" images on TMDB for " + show.name)
class Movie():
"""
This class provides a way to store movie related information.
Utilizes the tmdbsimple library, a wrapper for The Movie Database (TMDb) API v3
"""
# obtain configuration info from TMDb to generate poster URLs
conf = tmdb.Configuration()
reponse = conf.info()
# object for querying the database
search = tmdb.Search()
# class variables
YOUTUBE_BASE_URL = 'https://www.youtube.com/watch?v='
POSTER_SECURE_BASE_URL = conf.images['secure_base_url']
POSTER_SIZE = 'w342'
def __init__(self, title):
self.movie = tmdb.Movies(self.get_movie_id(title))
self.title = self.get_movie_title(title)
self.poster_image_url = self.POSTER_SECURE_BASE_URL + \
self.POSTER_SIZE + self.get_poster_path()
self.trailer_youtube_url = self.YOUTUBE_BASE_URL + self.get_youtube_key()
def get_movie_id(self, title):
'''
Returns the movie ID for a given title query
If title is an ID itself, function simply returns the ID
'''
if type(title) is int:
return title
else:
reponse = self.search.movie(query=title)
return self.search.results[0]['id']
def get_movie_title(self,title):
'''
Returns the movie title from the database for a given title query
If title is an ID itself, function returns title from info()
'''
if type(title) is int:
response = self.movie.info()
return self.movie.title
else:
return self.search.results[0]['title']
def get_youtube_key(self):
'''Returns the YouTube key for the movie trailer'''
response = self.movie.videos()
return self.movie.results[0]['key']
def get_poster_path(self):
'''Returns the poster path for the movie poster'''
response = self.movie.images()
return self.movie.posters[0]['file_path']
def populate_movies_info(self, movie_index):
movie = tmdb.Movies(movie_index)
movie.info()
title = movie.title
# use the first poster in the list of posters returned
poster_image_file_path = movie.images()["posters"][0]["file_path"]
base_url = tmdb.Configuration().info()["images"]["base_url"]
poster_image_url = base_url + poster_image_size + poster_image_file_path # NOQA
# use the first link in the list of trailer links returned
youtube_video_key = movie.videos()["results"][0]["key"]
trailer_youtube_url = youtube_base_url + youtube_video_key
return Movies(title, trailer_youtube_url, poster_image_url)
def download_config():
""" downloads and caches the tmdb config """
tmdb_config = tmdbsimple.Configuration().info()
tmdb_config['lastaccess'] = datetime.datetime.now().strftime('%Y-%m-%d')
pathonly = os.path.dirname(CACHEFILE)
if not os.path.exists(pathonly):
os.makedirs(pathonly)
with open(CACHEFILE, 'w') as cache:
json.dump(tmdb_config, cache)
return tmdb_config
def sort(request):
sort_option = 'popularity.desc'
genre_option = ''
page = '1'
context = {'page_type' : 'sort_and_filter'}
tmdb.API_KEY = settings.TMDB_API_KEY
try:
discover = tmdb.Discover()
config = tmdb.Configuration().info()
POSTER_SIZE = 2
if request.method == 'POST':
context['status'] = 'success'
sort_option = request.POST['sort_by']
genre_option = request.POST['genre']
if request.POST.__contains__('prev_page'):
page = request.POST.get('prev_page', '2')
pageNumber = int(page)
page = str(pageNumber - 1)
elif request.POST.__contains__('next_page'):
page = request.POST.get('next_page', '0')
pageNumber = int(page)
page = str(pageNumber + 1)
else:
page = '1'
movie_query = discover.movie(page=page, sort_by=sort_option, with_genres=genre_option, with_release_type='2|3|4|5|6')
# For testing purposes, you can use commented query below to get result which will only return 2 pages
# movie_query = discover.movie(page=page, sort_by=sort_option, with_genres=genre_option, vote_count_gte='6234')
context['results'] = movie_query['results']
context['last_page'] = 'false'
if int(page) == movie_query['total_pages']:
context['last_page'] = 'true'
if len(context['results']) == 0:
context['status'] = 'noresult'
context['image_path'] = config['images']['base_url'] + config['images']['poster_sizes'][POSTER_SIZE]
context['sort_selected'] = sort_option
context['genre_selected'] = genre_option
context['page_num'] = page
return render(request, 'home.html', context)
except (requests.exceptions.HTTPError, tmdb.APIKeyError)as e:
print("THE API IS WRONG")
context["status"] = 'failure'
return render(request, 'home.html', context)
def post(request, *args, **kwargs):
context_instance = RequestContext(request)
action = request.POST.get('action', '')
if action == "rate_movie":
# get important info
movieID = int(request.POST['movie_id'])
rating_given = int(request.POST['rating'])
current_user = request.user
updated = False
context = {}
if current_user.is_authenticated:
try:
movie = MovieRatings.objects.get(user=current_user, movie_id=movieID)
if rating_given == 0:
movie.delete()
else:
# update rating
movie.rating = int(rating_given)
movie.save()
updated = True
except MovieRatings.DoesNotExist:
MovieRatings.objects.create(user=current_user, movie_id=movieID, rating=rating_given)
updated = True
myratings=[]
try:
data_entries = MovieRatings.objects.filter(user=request.user)
for entry in data_entries:
movie = tmdb.Movies(int(entry.movie_id))
config = tmdb.Configuration().info()
POSTER_SIZE = 1
myratings.insert(0, (movie.info(), entry.rating,
config['images']['base_url'] + config['images']['poster_sizes'][
POSTER_SIZE]))
if not myratings:
context['status'] = 'failure'
else:
context['status'] = 'success'
context['results'] = myratings
except (requests.exceptions.HTTPError, tmdb.APIKeyError)as e:
context["status"] = 'failure'
return render(request, 'myratings.html', context)
return render(request, 'myratings.html', {})
def get_context_data(self, **kwargs):
try:
movies = tmdb.Movies()
config = tmdb.Configuration().info()
POSTER_SIZE = 2
context = {}
context['status'] = 'success'
context['results'] = movies.top_rated(page = 1)['results'][:10]
context['image_path'] = config['images']['base_url'] + config['images']['poster_sizes'][POSTER_SIZE]
return context
except (requests.exceptions.HTTPError, tmdb.APIKeyError )as e:
context = {}
print ("THE API IS WRONG")
context["status"] = 'failure'
return context
def _load_base_urls(url_settings):
urls = {}
urls['original'] = url_settings.getSettingString('originalUrl')
urls['preview'] = url_settings.getSettingString('previewUrl')
last_updated = url_settings.getSettingString('lastUpdated')
if not urls['original'] or not urls['preview'] or not last_updated or \
float(last_updated) < _get_date_numeric(datetime.now() - timedelta(days=30)):
conf = tmdbsimple.Configuration().info()
if conf:
urls['original'] = conf['images']['base_url'] + 'original'
urls['preview'] = conf['images']['base_url'] + 'w780'
url_settings.setSetting('originalUrl', urls['original'])
url_settings.setSetting('previewUrl', urls['preview'])
url_settings.setSetting('lastUpdated',
str(_get_date_numeric(datetime.now())))
return urls
def __init__(self, showid, id_type, season=None, episode=None, language='en'):
# Showinfo is a dict containing the name of the show, episode, season
super(FetcherTmdb, self).__init__(showid, id_type, season=season, episode=episode, language=language)
tmdb.API_KEY = FetcherTmdb.api_key
self.tmdbconfig = tmdb.Configuration().info()
self.definition = 'original'
if self.id_type == 'tmdb_id':
self._fetcherid = self.showid
if self.id_type in ['imdb_id', 'freebase_mid', 'freebase_id', 'tvdb_id', 'tvrage_id']:
find = tmdb.Find(self.showid)
if self.__class__.ftype == 'tv':
self._fetcherid = find.info(external_source=self.id_type)['tv_results'][0]['id']
elif self.__class__.ftype == 'movie':
self._fetcherid = find.info(external_source=self.id_type)['movie_results'][0]['id']
def __init__(self, movie_title, movie_release_date):
""" Initialises the Movie_Details Class.
uses the tmdbsimple library to connect to the moviedb api
uses a key to securely connect
sets up the connection and sets some object level
variables to be used in the methods
"""
self.movie_title = movie_title
self.movie_release_date = movie_release_date
# setup the apikey required to connect to the moviedb
moviedb.API_KEY = '5c5354c3aa31e31a67ec9a4897882aee'
self.config = moviedb.Configuration()
# search for the movie in the moviedb
self.moviedb_search = moviedb.Search()
response = self.moviedb_search.movie(
query=movie_title, year=movie_release_date)
def _retrieve_show_images_from_tmdb(show, img_type):
types = {
u'poster': u'poster_path',
u'banner': None,
u'fanart': u'backdrop_path',
u'poster_thumb': u'poster_path',
u'banner_thumb': None
}
# get TMDB configuration info
tmdb.API_KEY = app.TMDB_API_KEY
config = tmdb.Configuration()
try:
response = config.info()
except RequestException as error:
log.warning(u'Indexer TMDB is unavailable at this time: {reason}',
{u'reason': error})
return False
base_url = response[u'images'][u'base_url']
sizes = response[u'images'][u'poster_sizes']
def size_str_to_int(x):
return float(u'inf') if x == u'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
search = tmdb.Search()
for show_name in show.get_all_possible_names():
for result in search.collection(
query=show_name)[u'results'] + search.tv(
query=show_name)[u'results']:
if types[img_type] and result.get(types[img_type]):
return u'{0}{1}{2}'.format(base_url, max_size,
result[types[img_type]])
except Exception:
pass
log.info(u'Could not find any {type} images on TMDB for {series}', {
u'type': img_type,
u'series': show.name
})
def find_movie_ids(input):
global tmdb_img_config
if tmdb_img_config is None:
tmdb_img_config = tmdbsimple.Configuration().info()["images"]
base_url = tmdb_img_config["secure_base_url"]
poster_size = "w92" if "w92" in tmdb_img_config["poster_sizes"] else tmdb_img_config["poster_sizes"][0]
search = tmdbsimple.Search()
results = search.movie(query=input)["results"]
infos = []
for s in results:
title = s["title"]
if "release_date" in s.keys() and s["release_date"] != "":
title = "%s (%s)" % (title, arrow.get(s["release_date"]).year)
result = {"label": title, "value": s["id"], "title": s["title"]}
if "poster_path" in s and s["poster_path"]:
result["poster"] = base_url + poster_size + s["poster_path"]
infos.append(result)
return infos
def _retrieve_show_image_urls_from_tmdb(show, img_type, multiple=False):
types = {
'poster': 'posters',
'banner': None,
'fanart': 'backdrops',
'poster_thumb': 'posters',
'banner_thumb': None
}
if not types[img_type]:
return [] if multiple else ""
# get TMDB configuration info
tmdbsimple.API_KEY = settings.TMDB_API_KEY
config = tmdbsimple.Configuration()
response = config.info()
base_url = response['images']['base_url']
sizes = response['images']['poster_sizes']
def size_str_to_int(x):
return float("inf") if x == 'original' else int(x[1:])
max_size = max(sizes, key=size_str_to_int)
try:
results = []
find = tmdbsimple.Find(show.indexerid)
found = find.info(external_source='tvdb_id')
if found['tv_results']:
tmdb_show = tmdbsimple.TV(found['tv_results'][0]['id'])
images = tmdb_show.images()
if types[img_type] in images:
for result in images[types[img_type]]:
results.append("{0}{1}{2}".format(
base_url, max_size, result['file_path']))
if not multiple:
return results[0]
return results
except Exception as error:
logger.debug(error)
logger.info("Could not find any " + img_type + " images on TMDB for " +
show.name)
def test_configuration_jobs(self):
config = tmdb.Configuration()
config.jobs()
self.assertTrue(hasattr(config, 'jobs'))
import tmdbsimple as tmdb
import urllib
import os
import string
valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
if __name__ == "__main__":
tmdb.API_KEY = 'x'
search = tmdb.Movies()
base = tmdb.Configuration().info().get("images").get("secure_base_url")
genres = tmdb.Genres().list().get("genres")
genre_map = {}
total_pages = 100 #Maxiumum 284 for top_rated, 983 for popular
#Directory of downloads to be saved. It should be same in reader
path = "Data"
if path != "":
if not os.path.exists(path):
os.makedirs(path)
os.chdir(path)
for genre in genres:
genre_map[genre.get('id')] = genre.get('name')
for page in range(1, total_pages):
print("Page: " + page)
list = search.top_rated(page=page).get(
'results') #search.popular() can also be used.
def config(self):
if not self.__config:
self.__config = tmdb.Configuration().info()
return self.__config
def base_url():
return tmdbsimple.Configuration().info()['images']['secure_base_url']
def test_configuration_languages(self):
config = tmdb.Configuration()
response = config.languages()
# First language is No Language
self.assertEqual(response[0][ISO_639_1], NO_LANGUAGE)
def _get_config():
config = tmdb.Configuration()
response = config.info()
return config
def configuration():
conf = tmdb.Configuration()
return _query_retry(conf.info)
# This is a sample Python script. import tmdbsimple as tmdb tmdb.API_KEY = '73972aa479b5ec8c31a15ff73eba8ef3' # from flask import Flask # app = Flask(__name__) discover = tmdb.Discover() genre = tmdb.Genres() movies = discover.movie(sort_by='vote_average', vote_count_gte=1000)['results'] config = tmdb.Configuration() print(discover.movie()['results'])
def get_tmdb_metadata(tmdb, title):
# extract basic metadata
config = tmdb.Configuration().info()['images']
search = tmdb.Search()
res = search.movie(query=title)
if len(res['results'])>0:
mov_id = res['results'][0]['id'] #HACK: use the first one
movie = tmdb.Movies(mov_id)
# General movie info
info = movie.info()
keywords = movie.keywords()['keywords']
# Characters & Director info
credit = movie.credits()
cast = []
for person in credit['cast']:
detail = tmdb.People(person['id']).info()
actor = {
'name': person['name'],
'credit_order': person['order'],
'character': person['character'],
'birthdate': detail['birthday'],
'gender': detail['gender'],
'mdb_id': person['id'],
'imdb_id': detail['imdb_id']
}
if person['profile_path'] is not None:
actor['img_url'] = config['base_url'] + \
config['profile_sizes'][0] + person['profile_path']
cast.append(actor)
director = None
for person in credit['crew']:
if person['job']=='Director':
director = {
'name': person['name']
}
if person['profile_path'] is not None:
director['img_url'] = config['base_url'] + \
config['profile_sizes'][0] + person['profile_path']
record = {
'query_title': title,
'original_title': info['original_title'],
'release_date': info['release_date'],
'mdb_id': info['id'],
'imdb_id': info['imdb_id'],
'backdrop_path': config['base_url'] + config['backdrop_sizes'][0] + info['backdrop_path'],
'vote_average': info['vote_average'],
'vote_count': info['vote_count'],
'tagline': info['tagline'],
'runtime': info['runtime'],
'genres': map(lambda x: x['name'], info['genres']),
'keywords': map(lambda x: x['name'], keywords),
'cast':cast,
'director':director
}
return record
return None
def test_configuration_timezones(self):
config = tmdb.Configuration()
response = config.timezones()
# First country is Andorra
self.assertEqual(response[0][ISO_3166_1], ANDORRA)
def test_configuration_primary_translations(self):
config = tmdb.Configuration()
response = config.primary_translations()
# First primary translation is Arabic
self.assertEqual(response[0], ARABIC)
def test_configuration_languages(self):
config = tmdb.Configuration()
response = config.languages()
# Languages are two lowercase letters
self.assertTrue(re.match('^[a-z]{2}$', response[0][ISO_639_1]))
def test_configuration_countries(self):
config = tmdb.Configuration()
response = config.countries()
# Countries are two capital letters
self.assertTrue(re.match('^[A-Z]{2}$', response[0][ISO_3166_1]))