mirror of
https://github.com/SickGear/SickGear.git
synced 2024-12-18 16:53:38 +00:00
0fbf88651d
Add new get_languages TVInfo Interface method that returns a list of dicts by the indexer supported languages and the sg_lang map code [{'id': 'lang code', 'name': 'english name', 'nativeName': 'native name', 'sg_lang': 'sg lang code'}].
Add all returned languages to webserve method.
Use new interface parameter language for get_show.
1231 lines
51 KiB
Python
1231 lines
51 KiB
Python
#
|
|
# This file is part of SickGear.
|
|
#
|
|
# SickGear is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# SickGear is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with SickGear. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from collections import OrderedDict
|
|
|
|
import datetime
|
|
import io
|
|
import os.path
|
|
import re
|
|
|
|
from . import helpers as metadata_helpers
|
|
from .. import logger
|
|
import sg_helpers
|
|
from ..indexers import indexer_config
|
|
from ..indexers.indexer_config import TVINFO_TVDB, TVINFO_TMDB
|
|
from lib.tvinfo_base import TVInfoImage, TVInfoImageType, TVInfoImageSize
|
|
from lib.tvinfo_base.exceptions import *
|
|
import sickgear
|
|
from exceptions_helper import ex
|
|
from lib.fanart.core import Request as fanartRequest
|
|
import lib.fanart as fanart
|
|
from lxml_etree import etree
|
|
|
|
from six import iteritems, itervalues, string_types
|
|
|
|
# noinspection PyUnreachableCode
|
|
if False:
|
|
from typing import AnyStr, Dict, Generator, List, Optional, Tuple, Union
|
|
from lib.tvinfo_base import TVInfoShow
|
|
from ..tv import TVShow
|
|
|
|
|
|
map_image_types = {
|
|
'poster': TVInfoImageType.poster,
|
|
'banner': TVInfoImageType.banner,
|
|
'fanart': TVInfoImageType.fanart,
|
|
'poster_thumb': TVInfoImageType.poster,
|
|
'banner_thumb': TVInfoImageType.banner,
|
|
}
|
|
|
|
|
|
class ShowInfosDict(OrderedDict):
|
|
|
|
def __getitem__(self, k):
|
|
v = OrderedDict.__getitem__(self, k)
|
|
if callable(v):
|
|
v = v(k)
|
|
OrderedDict.__setitem__(self, k, v)
|
|
return v
|
|
|
|
|
|
class GenericMetadata(object):
|
|
"""
|
|
Base class for all metadata providers. Default behavior is meant to mostly
|
|
follow XBMC 12+ metadata standards. Has support for:
|
|
- show metadata file
|
|
- episode metadata file
|
|
- episode thumbnail
|
|
- show fanart
|
|
- show poster
|
|
- show banner
|
|
- season thumbnails (poster)
|
|
- season thumbnails (banner)
|
|
- season all poster
|
|
- season all banner
|
|
"""
|
|
|
|
def __init__(self,
|
|
show_metadata=False, # type: bool
|
|
episode_metadata=False, # type: bool
|
|
use_fanart=False, # type: bool
|
|
use_poster=False, # type: bool
|
|
use_banner=False, # type: bool
|
|
episode_thumbnails=False, # type: bool
|
|
season_posters=False, # type: bool
|
|
season_banners=False, # type: bool
|
|
season_all_poster=False, # type: bool
|
|
season_all_banner=False # type: bool
|
|
):
|
|
|
|
self.name = "Generic" # type: AnyStr
|
|
|
|
self._ep_nfo_extension = "nfo" # type: AnyStr
|
|
self._show_metadata_filename = "tvshow.nfo" # type: AnyStr
|
|
|
|
self.fanart_name = "fanart.jpg" # type: AnyStr
|
|
self.poster_name = "poster.jpg" # type: AnyStr
|
|
self.banner_name = "banner.jpg" # type: AnyStr
|
|
|
|
self.season_all_poster_name = "season-all-poster.jpg" # type: AnyStr
|
|
self.season_all_banner_name = "season-all-banner.jpg" # type: AnyStr
|
|
|
|
self.show_metadata = show_metadata
|
|
self.episode_metadata = episode_metadata
|
|
self.fanart = use_fanart
|
|
self.poster = use_poster
|
|
self.banner = use_banner
|
|
self.episode_thumbnails = episode_thumbnails
|
|
self.season_posters = season_posters
|
|
self.season_banners = season_banners
|
|
self.season_all_poster = season_all_poster
|
|
self.season_all_banner = season_all_banner
|
|
|
|
def get_config(self):
|
|
# type: (...) -> AnyStr
|
|
config_list = [self.show_metadata, self.episode_metadata, self.fanart, self.poster, self.banner,
|
|
self.episode_thumbnails, self.season_posters, self.season_banners, self.season_all_poster,
|
|
self.season_all_banner]
|
|
return '|'.join([str(int(x)) for x in config_list])
|
|
|
|
def get_id(self):
|
|
# type: (...) -> AnyStr
|
|
return GenericMetadata.make_id(self.name)
|
|
|
|
@staticmethod
|
|
def make_id(name):
|
|
# type: (AnyStr) -> AnyStr
|
|
name_id = re.sub("[+]", "plus", name)
|
|
name_id = re.sub(r"[^\w_]", "_", name_id).lower()
|
|
return name_id
|
|
|
|
def set_config(self, string):
|
|
# type: (AnyStr) -> None
|
|
config_list = [bool(int(x)) for x in string.split('|')]
|
|
self.show_metadata = config_list[0]
|
|
self.episode_metadata = config_list[1]
|
|
self.fanart = config_list[2]
|
|
self.poster = config_list[3]
|
|
self.banner = config_list[4]
|
|
self.episode_thumbnails = config_list[5]
|
|
self.season_posters = config_list[6]
|
|
self.season_banners = config_list[7]
|
|
self.season_all_poster = config_list[8]
|
|
self.season_all_banner = config_list[9]
|
|
|
|
def _has_show_metadata(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_show_file_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_show_file_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
def has_episode_metadata(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> bool
|
|
result = os.path.isfile(self.get_episode_file_path(ep_obj))
|
|
logger.debug(f'Checking if {self.get_episode_file_path(ep_obj)} exists: {result}')
|
|
return result
|
|
|
|
def _has_fanart(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_fanart_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_fanart_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
def _has_poster(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_poster_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_poster_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
def _has_banner(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_banner_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_banner_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
def has_episode_thumb(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> bool
|
|
location = self.get_episode_thumb_path(ep_obj)
|
|
result = None is not location and os.path.isfile(location)
|
|
if location:
|
|
logger.debug(f'Checking if {location} exists: {result}')
|
|
return result
|
|
|
|
def _has_season_poster(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow,int) -> bool
|
|
location = self.get_season_poster_path(show_obj, season)
|
|
result = None is not location and os.path.isfile(location)
|
|
if location:
|
|
logger.debug(f'Checking if {location} exists: {result}')
|
|
return result
|
|
|
|
def _has_season_banner(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow,int) -> bool
|
|
location = self.get_season_banner_path(show_obj, season)
|
|
result = None is not location and os.path.isfile(location)
|
|
if location:
|
|
logger.debug(f'Checking if {location} exists: {result}')
|
|
return result
|
|
|
|
def _has_season_all_poster(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_season_all_poster_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_season_all_poster_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
def _has_season_all_banner(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
result = os.path.isfile(self.get_season_all_banner_path(show_obj))
|
|
logger.debug(f'Checking if {self.get_season_all_banner_path(show_obj)} exists: {result}')
|
|
return result
|
|
|
|
@staticmethod
|
|
def get_show_year(show_obj, show_info, year_only=True):
|
|
# type: (sickgear.tv.TVShow, Dict, bool) -> Optional[AnyStr]
|
|
if None is not getattr(show_info, 'firstaired', None):
|
|
try:
|
|
first_aired = datetime.datetime.strptime(show_info['firstaired'], '%Y-%m-%d')
|
|
if first_aired:
|
|
if year_only:
|
|
return str(first_aired.year)
|
|
return str(first_aired.date())
|
|
except (BaseException, Exception):
|
|
pass
|
|
if isinstance(show_obj, sickgear.tv.TVShow):
|
|
if year_only and show_obj.startyear:
|
|
return '%s' % show_obj.startyear
|
|
if not show_obj.sxe_ep_obj.get(1, {}).get(1, None):
|
|
show_obj.get_all_episodes()
|
|
try:
|
|
first_ep_obj = show_obj.first_aired_regular_episode
|
|
except (BaseException, Exception):
|
|
first_ep_obj = None
|
|
if isinstance(first_ep_obj, sickgear.tv.TVEpisode) \
|
|
and isinstance(first_ep_obj.airdate, datetime.date) and 1900 < first_ep_obj.airdate.year:
|
|
return '%s' % (first_ep_obj.airdate.year, first_ep_obj.airdate)[not year_only]
|
|
|
|
def get_show_file_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self._show_metadata_filename)
|
|
|
|
def get_episode_file_path(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> AnyStr
|
|
return sg_helpers.replace_extension(ep_obj.location, self._ep_nfo_extension)
|
|
|
|
def get_fanart_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self.fanart_name)
|
|
|
|
def get_poster_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self.poster_name)
|
|
|
|
def get_banner_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self.banner_name)
|
|
|
|
def get_episode_thumb_path(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> Optional[AnyStr]
|
|
"""
|
|
Returns the path where the episode thumbnail should be stored.
|
|
ep_obj: a TVEpisode instance for which to create the thumbnail
|
|
"""
|
|
if os.path.isfile(ep_obj.location):
|
|
|
|
tbn_filename = ep_obj.location.rpartition('.')
|
|
|
|
if '' == tbn_filename[0]:
|
|
tbn_filename = ep_obj.location
|
|
else:
|
|
tbn_filename = tbn_filename[0]
|
|
|
|
return tbn_filename + '-thumb.jpg'
|
|
|
|
def get_season_poster_path(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow, int) -> AnyStr
|
|
"""
|
|
Returns the full path to the file for a given season poster.
|
|
|
|
show_obj: a TVShow instance for which to generate the path
|
|
season: a season number to be used for the path. Note that season 0
|
|
means specials.
|
|
"""
|
|
|
|
# Our specials thumbnail is, well, special
|
|
if 0 == season:
|
|
season_poster_filename = 'season-specials'
|
|
else:
|
|
season_poster_filename = 'season' + str(season).zfill(2)
|
|
|
|
return os.path.join(show_obj.location, season_poster_filename + '-poster.jpg')
|
|
|
|
def get_season_banner_path(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow, int) -> AnyStr
|
|
"""
|
|
Returns the full path to the file for a given season banner.
|
|
|
|
show_obj: a TVShow instance for which to generate the path
|
|
season: a season number to be used for the path. Note that season 0
|
|
means specials.
|
|
"""
|
|
|
|
# Our specials thumbnail is, well, special
|
|
if 0 == season:
|
|
season_banner_filename = 'season-specials'
|
|
else:
|
|
season_banner_filename = 'season' + str(season).zfill(2)
|
|
|
|
return os.path.join(show_obj.location, season_banner_filename + '-banner.jpg')
|
|
|
|
def get_season_all_poster_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self.season_all_poster_name)
|
|
|
|
def get_season_all_banner_path(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> AnyStr
|
|
return os.path.join(show_obj.location, self.season_all_banner_name)
|
|
|
|
def _show_data(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> Optional[Union[bool, etree.Element]]
|
|
"""
|
|
This should be overridden by the implementing class. It should
|
|
provide the content of the show metadata file.
|
|
"""
|
|
return None
|
|
|
|
@staticmethod
|
|
def _valid_show(fetched_show_info, show_obj):
|
|
# type: (Dict, sickgear.tv.TVShow) -> bool
|
|
"""
|
|
Test the integrity of fetched show data
|
|
|
|
:param fetched_show_info: the object returned from the tvinfo source
|
|
:param show_obj: Show that the fetched data relates to
|
|
:return: True if fetched_show_obj is valid data otherwise False
|
|
"""
|
|
if not (isinstance(fetched_show_info, dict) and
|
|
isinstance(getattr(fetched_show_info, 'data', None), (list, dict)) and
|
|
'seriesname' in getattr(fetched_show_info, 'data', [])) and \
|
|
not hasattr(fetched_show_info, 'seriesname'):
|
|
logger.warning(f'Show {show_obj.name} not found on {sickgear.TVInfoAPI(show_obj.tvid).name} ')
|
|
return False
|
|
return True
|
|
|
|
def _ep_data(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> Optional[Union[bool, etree.Element]]
|
|
"""
|
|
This should be overridden by the implementing class. It should
|
|
provide the content of the episode metadata file.
|
|
"""
|
|
return None
|
|
|
|
def create_show_metadata(self, show_obj, force=False):
|
|
# type: (sickgear.tv.TVShow, bool) -> bool
|
|
result = False
|
|
if self.show_metadata and show_obj and (not self._has_show_metadata(show_obj) or force):
|
|
logger.debug('Metadata provider %s creating show metadata for %s' % (self.name, show_obj.unique_name))
|
|
try:
|
|
result = self.write_show_file(show_obj)
|
|
except BaseTVinfoError as e:
|
|
logger.warning(f'Unable to find useful show metadata for {self.name}'
|
|
f' on {sickgear.TVInfoAPI(show_obj.tvid).name}: {ex(e)}')
|
|
|
|
return result
|
|
|
|
def create_episode_metadata(self, ep_obj, force=False):
|
|
# type: (sickgear.tv.TVEpisode, bool) -> bool
|
|
result = False
|
|
if self.episode_metadata and ep_obj and (not self.has_episode_metadata(ep_obj) or force):
|
|
logger.debug('Metadata provider %s creating episode metadata for %s' % (self.name, ep_obj.pretty_name()))
|
|
try:
|
|
result = self.write_ep_file(ep_obj)
|
|
except BaseTVinfoError as e:
|
|
logger.warning(f'Unable to find useful episode metadata for {self.name}'
|
|
f' on {sickgear.TVInfoAPI(ep_obj.show_obj.tvid).name}: {ex(e)}')
|
|
|
|
return result
|
|
|
|
def update_show_indexer_metadata(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.show_metadata and show_obj and self._has_show_metadata(show_obj):
|
|
logger.debug(f'Metadata provider {self.name}'
|
|
f' updating show indexer metadata file for {show_obj.unique_name}')
|
|
|
|
nfo_file_path = self.get_show_file_path(show_obj)
|
|
with io.open(nfo_file_path, 'r', encoding='utf8') as xmlFileObj:
|
|
show_xml = etree.ElementTree(file=xmlFileObj)
|
|
|
|
tvid = show_xml.find('indexer')
|
|
prodid = show_xml.find('id')
|
|
|
|
root = show_xml.getroot()
|
|
show_tvid = str(show_obj.tvid)
|
|
if None is not tvid:
|
|
tvid.text = '%s' % show_tvid
|
|
else:
|
|
etree.SubElement(root, 'indexer').text = '%s' % show_tvid
|
|
|
|
show_prodid = str(show_obj.prodid)
|
|
if None is not prodid:
|
|
prodid.text = '%s' % show_prodid
|
|
else:
|
|
etree.SubElement(root, 'id').text = '%s' % show_prodid
|
|
|
|
# Make it purdy
|
|
sg_helpers.indent_xml(root)
|
|
|
|
sg_helpers.write_file(nfo_file_path, show_xml, xmltree=True, utf8=True)
|
|
|
|
return True
|
|
|
|
def create_fanart(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.fanart and show_obj and not self._has_fanart(show_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating fanart for {show_obj.unique_name}')
|
|
return self.save_fanart(show_obj)
|
|
return False
|
|
|
|
def create_poster(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.poster and show_obj and not self._has_poster(show_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating poster for {show_obj.unique_name}')
|
|
return self.save_poster(show_obj)
|
|
return False
|
|
|
|
def create_banner(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.banner and show_obj and not self._has_banner(show_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating banner for {show_obj.unique_name}')
|
|
return self.save_banner(show_obj)
|
|
return False
|
|
|
|
def create_episode_thumb(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> bool
|
|
if self.episode_thumbnails and ep_obj and not self.has_episode_thumb(ep_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating episode thumbnail for {ep_obj.pretty_name()}')
|
|
return self.save_thumbnail(ep_obj)
|
|
return False
|
|
|
|
def create_season_posters(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.season_posters and show_obj:
|
|
result = []
|
|
for season, _ in iteritems(show_obj.sxe_ep_obj):
|
|
if not self._has_season_poster(show_obj, season):
|
|
logger.debug(f'Metadata provider {self.name} creating season posters for {show_obj.unique_name}')
|
|
result = result + [self.save_season_posters(show_obj, season)]
|
|
return all(result)
|
|
return False
|
|
|
|
def create_season_banners(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.season_banners and show_obj:
|
|
result = []
|
|
for season, _ in iteritems(show_obj.sxe_ep_obj):
|
|
if not self._has_season_banner(show_obj, season):
|
|
logger.debug(f'Metadata provider {self.name} creating season banners for {show_obj.unique_name}')
|
|
result = result + [self.save_season_banners(show_obj, season)]
|
|
return all(result)
|
|
return False
|
|
|
|
def create_season_all_poster(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.season_all_poster and show_obj and not self._has_season_all_poster(show_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating season all posters for {show_obj.unique_name}')
|
|
return self.save_season_all_poster(show_obj)
|
|
return False
|
|
|
|
def create_season_all_banner(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
if self.season_all_banner and show_obj and not self._has_season_all_banner(show_obj):
|
|
logger.debug(f'Metadata provider {self.name} creating season all banner for {show_obj.unique_name}')
|
|
return self.save_season_all_banner(show_obj)
|
|
return False
|
|
|
|
@staticmethod
|
|
def _get_episode_thumb_url(ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> Optional[AnyStr]
|
|
"""
|
|
Returns the URL to use for downloading an episode's thumbnail. Uses
|
|
theTVDB.com and TVRage.com data.
|
|
|
|
:param ep_obj: a TVEpisode object for which to grab the thumb URL
|
|
:return: URL to thumb
|
|
"""
|
|
|
|
ep_obj_list = [ep_obj] + ep_obj.related_ep_obj
|
|
|
|
# validate show
|
|
from .. import helpers
|
|
if not helpers.validate_show(ep_obj.show_obj):
|
|
return None
|
|
|
|
# try all included episodes in case some have thumbs and others don't
|
|
for cur_ep_obj in ep_obj_list:
|
|
if TVINFO_TVDB == cur_ep_obj.show_obj.tvid:
|
|
show_lang = cur_ep_obj.show_obj.lang
|
|
|
|
try:
|
|
tvinfo_config = sickgear.TVInfoAPI(TVINFO_TVDB).api_params.copy()
|
|
tvinfo_config['dvdorder'] = 0 != cur_ep_obj.show_obj.dvdorder
|
|
tvinfo_config['no_dummy'] = True
|
|
|
|
if show_lang and not 'en' == show_lang:
|
|
tvinfo_config['language'] = show_lang
|
|
|
|
t = sickgear.TVInfoAPI(TVINFO_TVDB).setup(**tvinfo_config)
|
|
|
|
ep_info = t.get_show(cur_ep_obj.show_obj.prodid, language=show_lang)[
|
|
cur_ep_obj.season][cur_ep_obj.episode]
|
|
except (BaseTVinfoEpisodenotfound, BaseTVinfoSeasonnotfound, TypeError):
|
|
ep_info = None
|
|
else:
|
|
ep_info = helpers.validate_show(cur_ep_obj.show_obj, cur_ep_obj.season, cur_ep_obj.episode)
|
|
|
|
if not ep_info:
|
|
continue
|
|
|
|
thumb_url = getattr(ep_info, 'filename', None) \
|
|
or (isinstance(ep_info, dict) and ep_info.get('filename', None))
|
|
if thumb_url not in (None, False, ''):
|
|
return thumb_url
|
|
|
|
return None
|
|
|
|
def write_show_file(self, show_obj):
|
|
# type: (sickgear.tv.TVShow) -> bool
|
|
"""
|
|
Generates and writes show_obj's metadata under the given path to the
|
|
filename given by get_show_file_path()
|
|
|
|
show_obj: TVShow object for which to create the metadata
|
|
|
|
path: An absolute or relative path where we should put the file. Note that
|
|
the file name will be the default show_file_name.
|
|
|
|
Note that this method expects that _show_data will return an ElementTree
|
|
object. If your _show_data returns data in another format you'll need to
|
|
override this method.
|
|
"""
|
|
|
|
data = self._show_data(show_obj)
|
|
|
|
if not data:
|
|
return False
|
|
|
|
nfo_file_path = self.get_show_file_path(show_obj)
|
|
|
|
logger.debug(f'Writing show metadata file: {nfo_file_path}')
|
|
|
|
return sg_helpers.write_file(nfo_file_path, data, xmltree=True, utf8=True)
|
|
|
|
def write_ep_file(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> bool
|
|
"""
|
|
Generates and writes ep_obj's metadata under the given path with the
|
|
given filename root. Uses the episode's name with the extension in
|
|
_ep_nfo_extension.
|
|
|
|
ep_obj: TVEpisode object for which to create the metadata
|
|
|
|
file_name_path: The file name to use for this metadata. Note that the extension
|
|
will be automatically added based on _ep_nfo_extension. This should
|
|
include an absolute path.
|
|
|
|
Note that this method expects that _ep_data will return an ElementTree
|
|
object. If your _ep_data returns data in another format you'll need to
|
|
override this method.
|
|
"""
|
|
|
|
data = self._ep_data(ep_obj)
|
|
|
|
if not data:
|
|
return False
|
|
|
|
nfo_file_path = self.get_episode_file_path(ep_obj)
|
|
|
|
logger.debug(f'Writing episode metadata file: {nfo_file_path}')
|
|
|
|
return sg_helpers.write_file(nfo_file_path, data, xmltree=True, utf8=True)
|
|
|
|
def save_thumbnail(self, ep_obj):
|
|
# type: (sickgear.tv.TVEpisode) -> bool
|
|
"""
|
|
Retrieves a thumbnail and saves it to the correct spot. This method should not need to
|
|
be overridden by implementing classes, changing get_episode_thumb_path and
|
|
_get_episode_thumb_url should suffice.
|
|
|
|
ep_obj: a TVEpisode object for which to generate a thumbnail
|
|
"""
|
|
|
|
file_path = self.get_episode_thumb_path(ep_obj)
|
|
|
|
if not file_path:
|
|
logger.debug('Unable to find a file path to use for this thumbnail, not generating it')
|
|
return False
|
|
|
|
thumb_url = self._get_episode_thumb_url(ep_obj)
|
|
|
|
# if we can't find one then give up
|
|
if not thumb_url:
|
|
logger.debug('No thumb is available for this episode, not creating a thumb')
|
|
return False
|
|
|
|
thumb_data = metadata_helpers.get_show_image(thumb_url, show_name=ep_obj.show_obj.name)
|
|
|
|
result = self._write_image(thumb_data, file_path)
|
|
|
|
if not result:
|
|
return False
|
|
|
|
for cur_ep_obj in [ep_obj] + ep_obj.related_ep_obj:
|
|
cur_ep_obj.hastbn = True
|
|
|
|
return True
|
|
|
|
def save_fanart(self, show_obj, which=None):
|
|
# type: (sickgear.tv.TVShow, Optional[AnyStr]) -> bool
|
|
"""
|
|
Downloads a fanart image and saves it to the filename specified by fanart_name
|
|
inside the show's root folder.
|
|
|
|
show_obj: a TVShow object for which to download fanart
|
|
"""
|
|
|
|
# use the default fanart name
|
|
fanart_path = self.get_fanart_path(show_obj)
|
|
|
|
fanart_data = self._retrieve_show_image('fanart', show_obj, which,
|
|
img_cache_type=sickgear.image_cache.ImageCache.FANART)
|
|
|
|
if not fanart_data:
|
|
logger.debug('No fanart image was retrieved, unable to write fanart')
|
|
return False
|
|
|
|
return self._write_image(fanart_data, fanart_path)
|
|
|
|
def save_poster(self, show_obj, which=None):
|
|
# type: (sickgear.tv.TVShow, Optional[AnyStr]) -> bool
|
|
"""
|
|
Downloads a poster image and saves it to the filename specified by poster_name
|
|
inside the show's root folder.
|
|
|
|
show_obj: a TVShow object for which to download a poster
|
|
"""
|
|
|
|
# use the default poster name
|
|
poster_path = self.get_poster_path(show_obj)
|
|
|
|
poster_data = self._retrieve_show_image('poster', show_obj, which,
|
|
img_cache_type=sickgear.image_cache.ImageCache.POSTER)
|
|
|
|
if not poster_data:
|
|
logger.debug('No show poster image was retrieved, unable to write poster')
|
|
return False
|
|
|
|
return self._write_image(poster_data, poster_path)
|
|
|
|
def save_banner(self, show_obj, which=None):
|
|
# type: (sickgear.tv.TVShow, Optional[AnyStr]) -> bool
|
|
"""
|
|
Downloads a banner image and saves it to the filename specified by banner_name
|
|
inside the show's root folder.
|
|
|
|
show_obj: a TVShow object for which to download a banner
|
|
"""
|
|
|
|
# use the default banner name
|
|
banner_path = self.get_banner_path(show_obj)
|
|
|
|
banner_data = self._retrieve_show_image('banner', show_obj, which,
|
|
img_cache_type=sickgear.image_cache.ImageCache.BANNER)
|
|
|
|
if not banner_data:
|
|
logger.debug('No show banner image was retrieved, unable to write banner')
|
|
return False
|
|
|
|
return self._write_image(banner_data, banner_path)
|
|
|
|
def save_season_posters(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow, int) -> bool
|
|
"""
|
|
Saves all season posters to disk for the given show.
|
|
|
|
show_obj: a TVShow object for which to save the season thumbs
|
|
|
|
Cycles through all seasons and saves the season posters if possible.
|
|
"""
|
|
|
|
season_dict = self._season_image_dict(show_obj, season, 'seasons')
|
|
result = []
|
|
|
|
# Returns a nested dictionary of season art with the season
|
|
# number as primary key. It's really overkill but gives the option
|
|
# to present to user via ui to pick down the road.
|
|
for cur_season in season_dict:
|
|
|
|
cur_season_art = season_dict[cur_season]
|
|
|
|
if 0 == len(cur_season_art):
|
|
continue
|
|
|
|
# Just grab whatever is there for now
|
|
art_id, season_url = cur_season_art.popitem()
|
|
|
|
season_poster_file_path = self.get_season_poster_path(show_obj, cur_season)
|
|
|
|
if not season_poster_file_path:
|
|
logger.debug(f'Path for season {cur_season} came back blank, skipping this season')
|
|
continue
|
|
|
|
season_data = metadata_helpers.get_show_image(season_url, show_name=show_obj.name)
|
|
|
|
if not season_data:
|
|
logger.debug('No season poster data available, skipping this season')
|
|
continue
|
|
|
|
result = result + [self._write_image(season_data, season_poster_file_path)]
|
|
|
|
if result:
|
|
return all(result)
|
|
return False
|
|
|
|
def save_season_banners(self, show_obj, season):
|
|
# type: (sickgear.tv.TVShow, int) -> bool
|
|
"""
|
|
Saves all season banners to disk for the given show.
|
|
|
|
show_obj: a TVShow object for which to save the season thumbs
|
|
|
|
Cycles through all seasons and saves the season banners if possible.
|
|
"""
|
|
|
|
season_dict = self._season_image_dict(show_obj, season, 'seasonwides')
|
|
result = []
|
|
|
|
# Returns a nested dictionary of season art with the season
|
|
# number as primary key. It's really overkill but gives the option
|
|
# to present to user via ui to pick down the road.
|
|
for cur_season in season_dict:
|
|
|
|
cur_season_art = season_dict[cur_season]
|
|
|
|
if 0 == len(cur_season_art):
|
|
continue
|
|
|
|
# Just grab whatever is there for now
|
|
art_id, season_url = cur_season_art.popitem()
|
|
|
|
season_banner_file_path = self.get_season_banner_path(show_obj, cur_season)
|
|
|
|
if not season_banner_file_path:
|
|
logger.debug(f'Path for season {cur_season} came back blank, skipping this season')
|
|
continue
|
|
|
|
season_data = metadata_helpers.get_show_image(season_url, show_name=show_obj.name)
|
|
|
|
if not season_data:
|
|
logger.debug('No season banner data available, skipping this season')
|
|
continue
|
|
|
|
result = result + [self._write_image(season_data, season_banner_file_path)]
|
|
|
|
if result:
|
|
return all(result)
|
|
return False
|
|
|
|
def save_season_all_poster(self, show_obj, which=None):
|
|
# type: (sickgear.tv.TVShow, Optional[AnyStr]) -> bool
|
|
# use the default season all poster name
|
|
poster_path = self.get_season_all_poster_path(show_obj)
|
|
|
|
poster_data = self._retrieve_show_image('poster', show_obj, which,
|
|
img_cache_type=sickgear.image_cache.ImageCache.POSTER)
|
|
|
|
if not poster_data:
|
|
logger.debug('No show poster image was retrieved, unable to write season all poster')
|
|
return False
|
|
|
|
return self._write_image(poster_data, poster_path)
|
|
|
|
def save_season_all_banner(self, show_obj, which=None):
|
|
# type: (sickgear.tv.TVShow, Optional[AnyStr]) -> bool
|
|
# use the default season all banner name
|
|
banner_path = self.get_season_all_banner_path(show_obj)
|
|
|
|
banner_data = self._retrieve_show_image('banner', show_obj, which,
|
|
img_cache_type=sickgear.image_cache.ImageCache.BANNER)
|
|
|
|
if not banner_data:
|
|
logger.debug('No show banner image was retrieved, unable to write season all banner')
|
|
return False
|
|
|
|
return self._write_image(banner_data, banner_path)
|
|
|
|
@staticmethod
|
|
def _write_image(image_data, image_path, force=False):
|
|
# type: (bytes, AnyStr, bool) -> bool
|
|
"""
|
|
Saves the data in image_data to the location image_path. Returns True/False
|
|
to represent success or failure.
|
|
|
|
image_data: binary image data to write to file
|
|
image_path: file location to save the image to
|
|
"""
|
|
|
|
# don't bother overwriting it
|
|
if not force and os.path.isfile(image_path):
|
|
logger.debug('Image already exists, not downloading')
|
|
return False
|
|
|
|
if not image_data:
|
|
logger.warning('Unable to retrieve image, skipping')
|
|
return False
|
|
|
|
image_dir = os.path.dirname(image_path)
|
|
|
|
try:
|
|
if not os.path.isdir(image_dir):
|
|
logger.debug(f'Metadata dir didn"t exist, creating it at {image_dir}')
|
|
os.makedirs(image_dir)
|
|
sg_helpers.chmod_as_parent(image_dir)
|
|
|
|
out_file = open(image_path, 'wb')
|
|
out_file.write(image_data)
|
|
out_file.close()
|
|
sg_helpers.chmod_as_parent(image_path)
|
|
except IOError as e:
|
|
logger.error(f'Unable to write image to {image_path} - are you sure the show folder is writable? {ex(e)}')
|
|
return False
|
|
|
|
return True
|
|
|
|
@staticmethod
|
|
def gen_show_infos_dict(show_obj):
|
|
# type: (TVShow) -> ShowInfosDict
|
|
show_infos = ShowInfosDict()
|
|
|
|
def _get_show_info(tv_id):
|
|
try:
|
|
show_lang = show_obj.lang
|
|
# There's gotta be a better way of doing this, but we don't want to
|
|
# change the language value elsewhere
|
|
tvinfo_config = sickgear.TVInfoAPI(tv_id).api_params.copy()
|
|
tvinfo_config['fanart'] = True
|
|
tvinfo_config['posters'] = True
|
|
tvinfo_config['banners'] = True
|
|
tvinfo_config['dvdorder'] = 0 != show_obj.dvdorder
|
|
|
|
if show_lang and not 'en' == show_lang:
|
|
tvinfo_config['language'] = show_lang
|
|
|
|
t = sickgear.TVInfoAPI(tv_id).setup(**tvinfo_config)
|
|
return t.get_show((show_obj.ids[tv_id]['id'], show_obj.prodid)[tv_src == show_obj.tvid],
|
|
load_episodes=False, banners=True, posters=True, fanart=True, language=show_lang)
|
|
except (BaseTVinfoError, IOError) as e:
|
|
logger.warning(f'Unable to look up show on {sickgear.TVInfoAPI(tv_id).name},'
|
|
f' not downloading images: {ex(e)}')
|
|
|
|
# todo: when tmdb is added as tv source remove the hardcoded TVINFO_TMDB
|
|
for tv_src in list(OrderedDict.fromkeys([show_obj.tvid] + list(sickgear.TVInfoAPI().search_sources) +
|
|
[TVINFO_TMDB])):
|
|
if tv_src != show_obj.tvid and not show_obj.ids.get(tv_src, {}).get('id'):
|
|
continue
|
|
if tv_src == show_obj.tvid:
|
|
show_infos[tv_src] = _get_show_info(tv_src)
|
|
else:
|
|
show_infos[tv_src] = _get_show_info
|
|
|
|
return show_infos
|
|
|
|
def _retrieve_image_urls(self, show_obj, image_type, show_infos):
|
|
# type: (TVShow, AnyStr, TVInfoShow) -> Generator
|
|
image_urls, alt_tvdb_urls, fanart_fetched, de_dupe, show_lang = [], [], False, set(), show_obj.lang
|
|
|
|
def build_url(s_o, image_mode):
|
|
_urls = [[], []]
|
|
_url = s_o[image_mode]
|
|
if _url and _url.startswith('http'):
|
|
if 'poster' == image_mode:
|
|
_url = re.sub('posters', '_cache/posters', _url)
|
|
elif 'banner' == image_mode:
|
|
_url = re.sub('graphical', '_cache/graphical', _url)
|
|
_urls[0].append(_url)
|
|
|
|
try:
|
|
alt_url = '%swww.%s%s' % re.findall(
|
|
r'(https?://)(?:artworks\.)?(thetvdb\.[^/]+/banners/\D+[^.]+)_t(.*)', _url)[0][0:3]
|
|
if alt_url not in _urls[0]:
|
|
_urls[1].append(alt_url)
|
|
except (IndexError, Exception):
|
|
try:
|
|
alt_url = '%sartworks.%s_t%s' % re.findall(
|
|
r'(https?://)(?:www\.)?(thetvdb\.[^/]+/banners/\D+[^.]+)(.*)', _url)[0][0:3]
|
|
if alt_url not in _urls[0]:
|
|
_urls[1].append(alt_url)
|
|
except (IndexError, Exception):
|
|
pass
|
|
return _urls
|
|
|
|
def _get_fanart_tv():
|
|
return [_de_dupe((f_item[2], (f_item[2], f_item[2]))[image_type in ('poster', 'banner')])
|
|
for f_item in self._fanart_urls_from_show(show_obj, image_type, show_lang) or []]
|
|
|
|
def _de_dupe(images_list):
|
|
# type:(Union[List[AnyStr], AnyStr]) -> Optional[Union[List[AnyStr], AnyStr]]
|
|
if not isinstance(images_list, list):
|
|
return_list = False
|
|
temp_list = [images_list]
|
|
else:
|
|
return_list = True
|
|
temp_list = images_list
|
|
images_list = [i for i in temp_list if i not in de_dupe]
|
|
[de_dupe.add(_i) for _i in images_list]
|
|
if not return_list:
|
|
if images_list:
|
|
return images_list[0]
|
|
return None
|
|
return images_list
|
|
|
|
if image_type.startswith('fanart'):
|
|
for r in _get_fanart_tv():
|
|
yield r
|
|
|
|
for tv_src in show_infos:
|
|
if not self._valid_show(show_infos[tv_src], show_obj):
|
|
continue
|
|
|
|
if 'poster_thumb' == image_type:
|
|
if None is not getattr(show_infos[tv_src], image_type, None):
|
|
image_urls, alt_tvdb_urls = build_url(show_infos[tv_src], image_type)
|
|
elif None is not getattr(show_infos[tv_src], 'poster', None):
|
|
image_urls, alt_tvdb_urls = build_url(show_infos[tv_src], 'poster')
|
|
|
|
image_urls, alt_tvdb_urls = _de_dupe(image_urls), _de_dupe(alt_tvdb_urls)
|
|
for item in image_urls + alt_tvdb_urls:
|
|
yield item
|
|
|
|
elif 'banner_thumb' == image_type:
|
|
if None is not getattr(show_infos[tv_src], image_type, None):
|
|
image_urls, alt_tvdb_urls = build_url(show_infos[tv_src], image_type)
|
|
elif None is not getattr(show_infos[tv_src], 'banner', None):
|
|
image_urls, alt_tvdb_urls = build_url(show_infos[tv_src], 'banner')
|
|
|
|
image_urls, alt_tvdb_urls = _de_dupe(image_urls), _de_dupe(alt_tvdb_urls)
|
|
for item in image_urls + alt_tvdb_urls:
|
|
yield item
|
|
|
|
else:
|
|
if None is not getattr(show_infos[tv_src], image_type, None):
|
|
image_url = show_infos[tv_src][image_type]
|
|
if image_type in ('poster', 'banner'):
|
|
if None is not getattr(show_infos[tv_src], '%s_thumb' % image_type, None):
|
|
thumb_url = show_infos[tv_src]['%s_thumb' % image_type]
|
|
else:
|
|
thumb_url = image_url
|
|
else:
|
|
thumb_url = None
|
|
if image_url:
|
|
r = _de_dupe(((image_url, thumb_url), image_url)[None is thumb_url])
|
|
if r:
|
|
yield r
|
|
|
|
# check extra provided images in '_banners' key
|
|
if None is not getattr(show_infos[tv_src], '_banners', None) and \
|
|
isinstance(show_infos[tv_src]['_banners'].get(image_type, None), (list, dict)):
|
|
for res, value in iteritems(show_infos[tv_src]['_banners'][image_type]):
|
|
for item in itervalues(value):
|
|
thumb = item['thumbnailpath']
|
|
if not thumb:
|
|
thumb = item['bannerpath']
|
|
|
|
r = _de_dupe((item['bannerpath'], (item['bannerpath'], thumb))[
|
|
image_type in ('poster', 'banner')])
|
|
if r:
|
|
yield r
|
|
|
|
# extra images via images property
|
|
tvinfo_type = map_image_types.get(image_type)
|
|
tvinfo_size = (TVInfoImageSize.original, TVInfoImageSize.medium)['_thumb' in image_type]
|
|
if tvinfo_type and getattr(show_infos[tv_src], 'images', None) and \
|
|
show_infos[tv_src].images.get(tvinfo_type):
|
|
for img in show_infos[tv_src].images[tvinfo_type]: # type: TVInfoImage
|
|
for img_size, img_url in iteritems(img.sizes):
|
|
if tvinfo_size == img_size:
|
|
img_url = _de_dupe(img_url)
|
|
if not img_url:
|
|
continue
|
|
if image_type in ('poster', 'banner'):
|
|
thumb_url = img.sizes.get(TVInfoImageSize.medium, img_url)
|
|
if thumb_url:
|
|
thumb_url = _de_dupe(thumb_url)
|
|
if not thumb_url:
|
|
thumb_url = img_url
|
|
yield img_url, thumb_url
|
|
elif img_url:
|
|
yield img_url
|
|
|
|
if not image_type.startswith('fanart'):
|
|
for r in _get_fanart_tv():
|
|
yield r
|
|
|
|
def _retrieve_show_image(self,
|
|
image_type, # type: AnyStr
|
|
show_obj, # type: sickgear.tv.TVShow
|
|
which=None, # type: int
|
|
return_links=False, # type: bool
|
|
show_infos=None, # type: ShowInfosDict
|
|
img_cache_type=None # type: int
|
|
):
|
|
# type: (...) -> Optional[bytes, List[AnyStr]]
|
|
"""
|
|
Gets an image URL from theTVDB.com, fanart.tv and TMDB.com, downloads it and returns the data.
|
|
If type is fanart, multiple image src urls are returned instead of a single data image.
|
|
|
|
image_type: type of image to retrieve (currently supported: fanart, poster, banner, poster_thumb, banner_thumb)
|
|
show_obj: a TVShow object to use when searching for the image
|
|
which: optional, a specific numbered poster to look for
|
|
|
|
Returns: the binary image data if available, or else None
|
|
"""
|
|
if not show_infos:
|
|
show_infos = self.gen_show_infos_dict(show_obj)
|
|
|
|
if 'fanart_all' == image_type:
|
|
return_links = True
|
|
image_type = 'fanart'
|
|
|
|
if image_type not in ('poster', 'banner', 'fanart', 'poster_thumb', 'banner_thumb'):
|
|
logger.error(f'Invalid image type {image_type}, couldn\'t find it in the'
|
|
f' {sickgear.TVInfoAPI(show_obj.tvid).name} object')
|
|
return
|
|
|
|
image_urls = self._retrieve_image_urls(show_obj, image_type, show_infos)
|
|
|
|
if image_urls:
|
|
if return_links:
|
|
return image_urls
|
|
else:
|
|
img_data = None
|
|
image_cache = sickgear.image_cache.ImageCache()
|
|
for image_url in image_urls or []:
|
|
if image_type in ('poster', 'banner'):
|
|
if isinstance(image_url, tuple):
|
|
image_url = image_url[0]
|
|
img_data = metadata_helpers.get_show_image(image_url, which, show_obj.name)
|
|
if img_cache_type and img_cache_type != image_cache.which_type(img_data, is_binary=True):
|
|
img_data = None
|
|
continue
|
|
if None is not img_data:
|
|
break
|
|
|
|
if None is not img_data:
|
|
return img_data
|
|
|
|
def _season_image_dict(self, show_obj, season, image_type):
|
|
# type: (sickgear.tv.TVShow, int, AnyStr) -> Dict[int, Dict[int, AnyStr]]
|
|
"""
|
|
image_type : Type of image to fetch, 'seasons' or 'seasonwides'
|
|
image_type type : String
|
|
|
|
Should return a dict like:
|
|
|
|
result = {<season number>:
|
|
{1: '<url 1>', 2: <url 2>, ...},}
|
|
"""
|
|
result = {}
|
|
|
|
try:
|
|
# There's gotta be a better way of doing this, but we don't want to
|
|
# change the language value elsewhere
|
|
tvinfo_config = sickgear.TVInfoAPI(show_obj.tvid).api_params.copy()
|
|
tvinfo_config[image_type] = True
|
|
tvinfo_config['dvdorder'] = 0 != show_obj.dvdorder
|
|
|
|
if 'en' != getattr(show_obj, 'lang', None):
|
|
tvinfo_config['language'] = show_obj.lang
|
|
|
|
t = sickgear.TVInfoAPI(show_obj.tvid).setup(**tvinfo_config)
|
|
tvinfo_obj_show = t.get_show(show_obj.prodid, language=show_obj.lang)
|
|
except (BaseTVinfoError, IOError) as e:
|
|
logger.warning(f'Unable to look up show on {sickgear.TVInfoAPI(show_obj.tvid).name},'
|
|
f' not downloading images: {ex(e)}')
|
|
return result
|
|
|
|
if not self._valid_show(tvinfo_obj_show, show_obj):
|
|
return result
|
|
|
|
season_images = getattr(tvinfo_obj_show, 'banners', {}).get(
|
|
('season', 'seasonwide')['seasonwides' == image_type], {}).get(season, {})
|
|
for image_id in season_images:
|
|
if season not in result:
|
|
result[season] = {}
|
|
result[season][image_id] = season_images[image_id]['bannerpath']
|
|
|
|
return result
|
|
|
|
def retrieve_show_metadata(self, folder):
|
|
# type: (AnyStr) -> Union[Tuple[int, int, AnyStr], Tuple[None, None, None]]
|
|
"""
|
|
Used only when mass adding Existing Shows,
|
|
using previously generated Show metadata to reduce the need to query TVDB.
|
|
"""
|
|
|
|
from sickgear.indexers.indexer_config import TVINFO_TVDB
|
|
|
|
empty_return = (None, None, None)
|
|
|
|
metadata_path = os.path.join(folder, self._show_metadata_filename)
|
|
|
|
if not os.path.isdir(folder) or not os.path.isfile(metadata_path):
|
|
logger.debug(f'Can\'t load the metadata file from {repr(metadata_path)}, it doesn\'t exist')
|
|
return empty_return
|
|
|
|
logger.debug(f'Loading show info from metadata file in {folder}')
|
|
|
|
try:
|
|
with io.open(metadata_path, 'r', encoding='utf8') as xmlFileObj:
|
|
show_xml = etree.ElementTree(file=xmlFileObj)
|
|
|
|
if None is show_xml.findtext('title') \
|
|
or all(None is _f for _f in (show_xml.find('//uniqueid[@type]'),
|
|
show_xml.findtext('tvdbid'),
|
|
show_xml.findtext('id'),
|
|
show_xml.findtext('indexer'))):
|
|
logger.log(f'Invalid info in tvshow.nfo (missing name or id):'
|
|
f'{show_xml.findtext("title")} {show_xml.findtext("indexer")} '
|
|
f'{show_xml.findtext("tvdbid")} {show_xml.findtext("id")}')
|
|
return empty_return
|
|
|
|
name = show_xml.findtext('title')
|
|
|
|
try:
|
|
tvid = int(show_xml.findtext('indexer'))
|
|
except (BaseException, Exception):
|
|
tvid = None
|
|
|
|
# handle v2 format of .nfo file
|
|
default_source = show_xml.find('//uniqueid[@default="true"]')
|
|
if None is not default_source:
|
|
use_tvid = default_source.attrib.get('type') or tvid
|
|
if isinstance(use_tvid, string_types):
|
|
use_tvid = {sickgear.TVInfoAPI(x).config['slug']: x
|
|
for x, _ in iteritems(sickgear.TVInfoAPI().all_sources)}.get(use_tvid)
|
|
prodid = sg_helpers.try_int(default_source.text, None)
|
|
if use_tvid and None is not prodid:
|
|
return use_tvid, prodid, name
|
|
|
|
prodid = show_xml.find('//uniqueid[@type="tvdb"]')
|
|
if None is not prodid:
|
|
prodid = int(prodid.text)
|
|
tvid = TVINFO_TVDB
|
|
elif None is not show_xml.findtext('tvdbid'):
|
|
prodid = int(show_xml.findtext('tvdbid'))
|
|
tvid = TVINFO_TVDB
|
|
elif None is not show_xml.findtext('id'):
|
|
prodid = int(show_xml.findtext('id'))
|
|
try:
|
|
tvid = TVINFO_TVDB if [s for s in show_xml.findall('.//*')
|
|
if s.text and -1 != s.text.find('thetvdb.com')] else tvid
|
|
except (BaseException, Exception):
|
|
pass
|
|
else:
|
|
logger.warning('Empty <id> or <tvdbid> field in NFO, unable to find a ID')
|
|
return empty_return
|
|
|
|
if None is prodid:
|
|
logger.warning(f'Invalid Show ID (%s), not using metadata file {prodid}')
|
|
return empty_return
|
|
|
|
except (BaseException, Exception) as e:
|
|
logger.warning(f'There was an error parsing your existing metadata file: "{metadata_path}" error: {ex(e)}')
|
|
return empty_return
|
|
|
|
return tvid, prodid, name
|
|
|
|
def _fanart_urls_from_show(self, show_obj, image_type='banner', lang='en', thumb=False):
|
|
# type: (sickgear.tv.TVShow, AnyStr, AnyStr, bool) -> Optional[List[int, int, AnyStr]]
|
|
try:
|
|
tvdb_id = show_obj.ids.get(indexer_config.TVINFO_TVDB, {}).get('id', None)
|
|
if tvdb_id:
|
|
return self._fanart_urls(tvdb_id, image_type, lang, thumb)
|
|
except (BaseException, Exception):
|
|
pass
|
|
|
|
logger.debug(f'Could not find any {image_type} images on Fanart.tv for {show_obj.name}')
|
|
|
|
@staticmethod
|
|
def _fanart_urls(tvdb_id, image_type='banner', lang='en', thumb=False):
|
|
# type: (int, AnyStr, AnyStr, bool) -> Optional[List[int, int, AnyStr]]
|
|
types = {'poster': fanart.TYPE.TV.POSTER,
|
|
'banner': fanart.TYPE.TV.BANNER,
|
|
'fanart': fanart.TYPE.TV.BACKGROUND,
|
|
'poster_thumb': fanart.TYPE.TV.POSTER,
|
|
'banner_thumb': fanart.TYPE.TV.BANNER}
|
|
|
|
try:
|
|
if tvdb_id:
|
|
request = fanartRequest(apikey=sickgear.FANART_API_KEY, tvdb_id=tvdb_id, types=types[image_type])
|
|
resp = request.response()
|
|
itemlist = []
|
|
dedupe = []
|
|
for art in filter(lambda i: 10 < len(i.get('url', '')) and (lang == i.get('lang', '')[0:2]),
|
|
# remove "[0:2]" ... to strictly use only data where "en" is at source
|
|
resp[types[image_type]]): # type: dict
|
|
try:
|
|
url = (art['url'], art['url'].replace('/fanart/', '/preview/'))[thumb]
|
|
if url not in dedupe:
|
|
dedupe += [url]
|
|
itemlist += [
|
|
[int(art['id']), int(art['likes']), url]
|
|
]
|
|
except (BaseException, Exception):
|
|
continue
|
|
|
|
itemlist.sort(key=lambda a: (a[1], a[0]), reverse=True)
|
|
return itemlist
|
|
|
|
except (BaseException, Exception):
|
|
raise
|
|
|
|
def retrieve_show_image(self, image_type, show_obj, which=None, return_links=False, show_infos=None):
|
|
# type: (AnyStr, sickgear.tv.TVShow, bool, bool, ShowInfosDict) -> Optional[bytes]
|
|
return self._retrieve_show_image(image_type=image_type, show_obj=show_obj, which=which,
|
|
return_links=return_links, show_infos=show_infos)
|
|
|
|
def write_image(self, image_data, image_path, force=False):
|
|
# type: (bytes, AnyStr, bool) -> bool
|
|
return self._write_image(image_data=image_data, image_path=image_path, force=force)
|