def lookup(self, entry, search_allowed=True, key=None):
"""
Perform Rotten Tomatoes lookup for entry.
:param entry: Entry instance
:param search_allowed: Allow fallback to search
:param key: optionally specify an API key to use
:raises PluginError: Failure reason
"""
if not key:
key = self.key or plugin_api_rottentomatoes.API_KEY
movie = plugin_api_rottentomatoes.lookup_movie(
smart_match=entry['title'],
rottentomatoes_id=entry.get('rt_id', eval_lazy=False),
only_cached=(not search_allowed),
api_key=key,
)
logger.debug('Got movie: {}', movie)
entry.update_using_map(self.field_map, movie)
if not entry.get('imdb_id', eval_lazy=False):
for alt_id in movie.alternate_ids:
if alt_id.name == 'imdb':
entry['imdb_id'] = 'tt' + alt_id.id
break
def lazy_lookup(entry, lazy_lookup_name, media_type):
with Session() as session:
try:
db_data = get_db_data_for(media_type, entry, session)
except LookupError as e:
logger.debug(e)
else:
entry.update_using_map(lazy_lookup_types[lazy_lookup_name], db_data)
return entry
def trakt_lazy_lookup(entry, field_map, lookup_function):
with Session() as session:
try:
result = lookup_function(entry, session)
except LookupError as e:
logger.debug(e)
else:
entry.update_using_map(field_map, result)
return entry
def lazy_lookup(self, entry, media_type, mapping):
"""Does the lookup for this entry and populates the entry fields."""
with Session() as session:
try:
trakt_media = self.getter_map[media_type](entry, session)
except LookupError as e:
logger.debug(e)
else:
entry.update_using_map(mapping, trakt_media)
return entry
def lazy_loader(self, entry):
"""Does the lookup for this entry and populates the entry fields."""
lookup = plugin.get('api_bluray', self).lookup
try:
with Session() as session:
title, year = split_title_year(entry['title'])
movie = lookup(title=title, year=year, session=session)
entry.update_using_map(self.field_map, movie)
except LookupError:
log_once('Bluray lookup failed for %s' % entry['title'], logger,
'WARNING')
def series_lookup(self, entry, language, field_map, session=None):
try:
series = plugin_api_tvdb.lookup_series(
entry.get('series_name', eval_lazy=False),
tvdb_id=entry.get('tvdb_id', eval_lazy=False),
language=entry.get('language', language),
session=session,
)
entry.update_using_map(field_map, series)
except LookupError as e:
logger.debug('Error looking up tvdb series information for {}: {}',
entry['title'], e.args[0])
return entry
def lazy_season_lookup(self, entry):
season_lookup = plugin.get('api_tvmaze', self).season_lookup
with Session(expire_on_commit=False) as session:
lookupargs = {
'title': entry.get('series_name', eval_lazy=False),
'year': entry.get('year', eval_lazy=False),
'tvmaze_id': entry.get('tvmaze_id', eval_lazy=False),
'tvdb_id': entry.get('tvdb_id', eval_lazy=False),
'tvrage_id': entry.get('tvrage_id', eval_lazy=False),
'series_season': entry.get('series_season', eval_lazy=False),
'session': session,
}
try:
season = season_lookup(**lookupargs)
except LookupError as e:
logger.debug(e)
else:
entry.update_using_map(self.season_map, season)
return entry
def lazy_series_lookup(self, entry):
"""Does the lookup for this entry and populates the entry fields."""
series_lookup = plugin.get('api_tvmaze', self).series_lookup
with Session() as session:
lookupargs = {
'title': entry.get('series_name', eval_lazy=False),
'year': entry.get('year', eval_lazy=False),
'tvmaze_id': entry.get('tvmaze_id', eval_lazy=False),
'tvdb_id': entry.get('tvdb_id', eval_lazy=False),
'tvrage_id': entry.get('tvrage_idk', eval_lazy=False),
'session': session,
}
try:
series = series_lookup(**lookupargs)
except LookupError as e:
logger.debug(e)
else:
entry.update_using_map(self.series_map, series)
return entry
def lazy_loader(self, entry, language):
"""Does the lookup for this entry and populates the entry fields."""
lookup = plugin.get('api_tmdb', self).lookup
imdb_id = entry.get('imdb_id', eval_lazy=False) or extract_id(
entry.get('imdb_url', eval_lazy=False))
try:
with Session() as session:
movie = lookup(
smart_match=entry['title'],
tmdb_id=entry.get('tmdb_id', eval_lazy=False),
imdb_id=imdb_id,
language=language,
session=session,
)
entry.update_using_map(self.field_map, movie)
except LookupError:
log_once('TMDB lookup failed for %s' % entry['title'], logger,
'WARNING')
def lazy_loader(self, entry, auth):
if not auth:
return
if not auth.logged:
auth.login()
emby_api = EmbyApi(auth)
emby_data = emby_api.search(**entry)
if not emby_data:
return
emby_type = EmbyApi.get_type(**emby_data)
lazy_fields = get_field_map(media_type=emby_type)
if not lazy_fields:
return
entry.update_using_map(lazy_fields, emby_data, ignore_none=True)
def lazy_episode_lookup(self, entry, language):
try:
season_offset = entry.get('thetvdb_lookup_season_offset', 0)
episode_offset = entry.get('thetvdb_lookup_episode_offset', 0)
if not isinstance(season_offset, int):
logger.error('thetvdb_lookup_season_offset must be an integer')
season_offset = 0
if not isinstance(episode_offset, int):
logger.error(
'thetvdb_lookup_episode_offset must be an integer')
episode_offset = 0
if season_offset != 0 or episode_offset != 0:
logger.debug(
f'Using offset for tvdb lookup: season: {season_offset}, '
f'episode: {episode_offset}')
lookupargs = {
'name': entry.get('series_name', eval_lazy=False),
'tvdb_id': entry.get('tvdb_id', eval_lazy=False),
'language': entry.get('language', language),
}
if entry['series_id_type'] == 'ep':
lookupargs[
'season_number'] = entry['series_season'] + season_offset
lookupargs['episode_number'] = entry[
'series_episode'] + episode_offset
elif entry['series_id_type'] == 'sequence':
lookupargs[
'absolute_number'] = entry['series_id'] + episode_offset
elif entry['series_id_type'] == 'date':
# TODO: Should thetvdb_lookup_episode_offset be used for date lookups as well?
lookupargs['first_aired'] = entry['series_date']
episode = plugin_api_tvdb.lookup_episode(**lookupargs)
entry.update_using_map(self.episode_map, episode)
except LookupError as e:
logger.debug(
'Error looking up tvdb episode information for {}: {}',
entry['title'], e.args[0])
def lookup(self, entry, search_allowed=True, session=None):
"""
Perform imdb lookup for entry.
:param entry: Entry instance
:param search_allowed: Allow fallback to search
:raises PluginError: Failure reason
"""
from flexget.manager import manager
if entry.get('imdb_id', eval_lazy=False):
logger.debug('No title passed. Lookup for {}', entry['imdb_id'])
elif entry.get('imdb_url', eval_lazy=False):
logger.debug('No title passed. Lookup for {}', entry['imdb_url'])
elif entry.get('title', eval_lazy=False):
logger.debug('lookup for {}', entry['title'])
else:
raise plugin.PluginError(
'looking up IMDB for entry failed, no title, imdb_url or imdb_id passed.'
)
# if imdb_id is included, build the url.
if entry.get('imdb_id', eval_lazy=False) and not entry.get(
'imdb_url', eval_lazy=False):
entry['imdb_url'] = make_url(entry['imdb_id'])
# make sure imdb url is valid
if entry.get('imdb_url', eval_lazy=False):
imdb_id = extract_id(entry['imdb_url'])
if imdb_id:
entry['imdb_url'] = make_url(imdb_id)
else:
logger.debug('imdb url {} is invalid, removing it',
entry['imdb_url'])
entry['imdb_url'] = ''
# no imdb_url, check if there is cached result for it or if the
# search is known to fail
if not entry.get('imdb_url', eval_lazy=False):
result = (session.query(db.SearchResult).filter(
db.SearchResult.title == entry['title']).first())
if result:
# TODO: 1.2 this should really be checking task.options.retry
if result.fails and not manager.options.execute.retry:
# this movie cannot be found, not worth trying again ...
logger.debug('{} will fail lookup', entry['title'])
raise plugin.PluginError('IMDB lookup failed for %s' %
entry['title'])
else:
if result.url:
logger.trace('Setting imdb url for {} from db',
entry['title'])
entry['imdb_id'] = result.imdb_id
entry['imdb_url'] = result.url
# no imdb url, but information required, try searching
if not entry.get('imdb_url', eval_lazy=False) and search_allowed:
logger.verbose('Searching from imdb `{}`', entry['title'])
search = ImdbSearch()
search_name = entry.get('movie_name',
entry['title'],
eval_lazy=False)
search_result = search.smart_match(search_name)
if search_result:
entry['imdb_url'] = search_result['url']
# store url for this movie, so we don't have to search on every run
result = db.SearchResult(entry['title'], entry['imdb_url'])
session.add(result)
session.commit()
logger.verbose('Found {}', entry['imdb_url'])
else:
log_once(
'IMDB lookup failed for %s' % entry['title'],
logger,
'WARNING',
session=session,
)
# store FAIL for this title
result = db.SearchResult(entry['title'])
result.fails = True
session.add(result)
session.commit()
raise plugin.PluginError('Title `%s` lookup failed' %
entry['title'])
# check if this imdb page has been parsed & cached
movie = session.query(
db.Movie).filter(db.Movie.url == entry['imdb_url']).first()
# If we have a movie from cache, we are done
if movie and not movie.expired:
entry.update_using_map(self.field_map, movie)
return
# Movie was not found in cache, or was expired
if movie is not None:
if movie.expired:
logger.verbose('Movie `{}` details expired, refreshing ...',
movie.title)
# Remove the old movie, we'll store another one later.
session.query(db.MovieLanguage).filter(
db.MovieLanguage.movie_id == movie.id).delete()
session.query(
db.Movie).filter(db.Movie.url == entry['imdb_url']).delete()
session.commit()
# search and store to cache
if 'title' in entry:
logger.verbose('Parsing imdb for `{}`', entry['title'])
else:
logger.verbose('Parsing imdb for `{}`', entry['imdb_id'])
try:
movie = self._parse_new_movie(entry['imdb_url'], session)
except UnicodeDecodeError:
logger.error(
'Unable to determine encoding for {}. Installing chardet library may help.',
entry['imdb_url'],
)
# store cache so this will not be tried again
movie = db.Movie()
movie.url = entry['imdb_url']
session.add(movie)
session.commit()
raise plugin.PluginError('UnicodeDecodeError')
except ValueError as e:
# TODO: might be a little too broad catch, what was this for anyway? ;P
if manager.options.debug:
logger.exception(e)
raise plugin.PluginError(
'Invalid parameter: %s' % entry['imdb_url'], logger)
for att in [
'title',
'score',
'votes',
'meta_score',
'year',
'genres',
'languages',
'actors',
'directors',
'writers',
'mpaa_rating',
]:
logger.trace('movie.{}: {}', att, getattr(movie, att))
# Update the entry fields
entry.update_using_map(self.field_map, movie)
