def run(self):
ShowQueueItem.run(self)
sickrage.LOGGER.info("Performing refresh on " + self.show.name)
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache()
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
self.finish()
def run(self):
ShowQueueItem.run(self)
sickrage.LOGGER.info("Performing refresh on " + self.show.name)
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache()
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
self.finish()
def run(self):
super(QueueItemRefresh, self).run()
sickrage.srCore.srLogger.info("Performing refresh for show: {}".format(self.show.name))
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache()
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
sickrage.srCore.srLogger.info("Finished refresh for show: {}".format(self.show.name))
def run(self):
super(QueueItemRefresh, self).run()
sickrage.srCore.srLogger.info("Performing refresh for show: {}".format(self.show.name))
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache()
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
sickrage.srCore.srLogger.info("Finished refresh for show: {}".format(self.show.name))
def run(self):
sickrage.app.log.info("Performing refresh for show: {}".format(self.show.name))
self.show.refreshDir()
self.show.writeMetadata(force=self.force)
self.show.populateCache(force=self.force)
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
self.show.last_refresh = datetime.date.today().toordinal()
self.finish()
sickrage.app.log.info(
"Finished refresh in {}s for show: {}".format(round(time.time() - self.startTime, 2), self.show.name))
def run(self):
sickrage.srCore.srLogger.info("Performing refresh for show: {}".format(self.show.name))
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache()
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
self.show.last_refresh = datetime.date.today().toordinal()
self.finish()
sickrage.srCore.srLogger.info("Finished refresh for show: {}".format(self.show.name))
def run(self):
sickrage.app.log.info("Performing refresh for show: {}".format(self.show.name))
self.show.refreshDir()
self.show.writeMetadata()
if self.force:
self.show.updateMetadata()
self.show.populateCache(self.force)
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer)
self.show.last_refresh = datetime.date.today().toordinal()
self.finish()
sickrage.app.log.info(
"Finished refresh in {}s for show: {}".format(round(time.time() - self.startTime, 2), self.show.name))
def loadFromDB(self, season, episode):
sickrage.LOGGER.debug("%s: Loading episode details from DB for episode %s S%02dE%02d" % (
self.show.indexerid, self.show.name, season or 0, episode or 0))
sqlResults = main_db.MainDB().select(
"SELECT * FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?",
[self.show.indexerid, season, episode])
if len(sqlResults) > 1:
raise MultipleEpisodesInDatabaseException("Your DB has two records for the same show somehow.")
elif len(sqlResults) == 0:
sickrage.LOGGER.debug("%s: Episode S%02dE%02d not found in the database" % (
self.show.indexerid, self.season or 0, self.episode or 0))
return False
else:
# NAMEIT sickrage.LOGGER.info(u"AAAAA from" + str(self.season)+"x"+str(self.episode) + " -" + self.name + " to " + str(sqlResults[0][b"name"]))
if sqlResults[0][b"name"]:
self.name = sqlResults[0][b"name"]
self.season = season
self.episode = episode
self.absolute_number = sqlResults[0][b"absolute_number"]
self.description = sqlResults[0][b"description"]
if not self.description:
self.description = ""
if sqlResults[0][b"subtitles"] and sqlResults[0][b"subtitles"]:
self.subtitles = sqlResults[0][b"subtitles"].split(",")
self.subtitles_searchcount = sqlResults[0][b"subtitles_searchcount"]
self.subtitles_lastsearch = sqlResults[0][b"subtitles_lastsearch"]
self.airdate = datetime.date.fromordinal(int(sqlResults[0][b"airdate"]))
# sickrage.LOGGER.debug(u"1 Status changes from " + str(self.status) + " to " + str(sqlResults[0][b"status"]))
self.status = int(sqlResults[0][b"status"] or -1)
# don't overwrite my location
if sqlResults[0][b"location"] and sqlResults[0][b"location"]:
self.location = os.path.normpath(sqlResults[0][b"location"])
if sqlResults[0][b"file_size"]:
self.file_size = int(sqlResults[0][b"file_size"])
else:
self.file_size = 0
self.indexerid = int(sqlResults[0][b"indexerid"])
self.indexer = int(sqlResults[0][b"indexer"])
xem_refresh(self.show.indexerid, self.show.indexer)
self.scene_season = tryInt(sqlResults[0][b"scene_season"], 0)
self.scene_episode = tryInt(sqlResults[0][b"scene_episode"], 0)
self.scene_absolute_number = tryInt(sqlResults[0][b"scene_absolute_number"], 0)
if self.scene_absolute_number == 0:
self.scene_absolute_number = get_scene_absolute_numbering(
self.show.indexerid,
self.show.indexer,
self.absolute_number
)
if self.scene_season == 0 or self.scene_episode == 0:
self.scene_season, self.scene_episode = get_scene_numbering(
self.show.indexerid,
self.show.indexer,
self.season, self.episode
)
if sqlResults[0][b"release_name"] is not None:
self.release_name = sqlResults[0][b"release_name"]
if sqlResults[0][b"is_proper"]:
self.is_proper = int(sqlResults[0][b"is_proper"])
if sqlResults[0][b"version"]:
self.version = int(sqlResults[0][b"version"])
if sqlResults[0][b"release_group"] is not None:
self.release_group = sqlResults[0][b"release_group"]
self.dirty = False
return True
def run(self):
super(QueueItemAdd, self).run()
sickrage.srCore.srLogger.info("Started adding show {}".format(self.showDir))
index_name = srIndexerApi(self.indexer).name
# make sure the Indexer IDs are valid
try:
lINDEXER_API_PARMS = srIndexerApi(self.indexer).api_params.copy()
if self.lang:
lINDEXER_API_PARMS['language'] = self.lang
sickrage.srCore.srLogger.info("{}: {}".format(index_name, repr(lINDEXER_API_PARMS)))
t = srIndexerApi(self.indexer).indexer(**lINDEXER_API_PARMS)
s = t[self.indexer_id]
# this usually only happens if they have an NFO in their show dir which gave us a Indexer ID that has no proper english version of the show
if not getattr(s, 'seriesname'):
sickrage.srCore.srLogger.error(
"Show in {} has no name on {}, probably the wrong language used to search with".format(self.showDir,
index_name))
sickrage.srCore.srNotifications.error("Unable to add show",
"Show in {} has no name on {}, probably the wrong language. Delete .nfo and add manually in the correct language".format(
self.showDir, index_name))
return self._finishEarly()
# if the show has no episodes/seasons
if not len(s):
sickrage.srCore.srLogger.error("Show " + str(s['seriesname']) + " is on " + str(
srIndexerApi(self.indexer).name) + " but contains no season/episode data.")
sickrage.srCore.srNotifications.error("Unable to add show",
"Show " + str(s['seriesname']) + " is on " + str(srIndexerApi(
self.indexer).name) + " but contains no season/episode data.")
return self._finishEarly()
except Exception as e:
sickrage.srCore.srLogger.error(
"{}: Error while loading information from indexer {}. Error: {}".format(self.indexer_id, index_name,
e.message))
sickrage.srCore.srNotifications.error(
"Unable to add show",
"Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding manually again.".format(
self.showDir, index_name, self.indexer_id)
)
if sickrage.srCore.srConfig.USE_TRAKT:
trakt_id = srIndexerApi(self.indexer).config['trakt_id']
trakt_api = TraktAPI(sickrage.srCore.srConfig.SSL_VERIFY, sickrage.srCore.srConfig.TRAKT_TIMEOUT)
title = self.showDir.split("/")[-1]
data = {
'shows': [
{
'title': title,
'ids': {}
}
]
}
if trakt_id == 'tvdb_id':
data['shows'][0]['ids']['tvdb'] = self.indexer_id
else:
data['shows'][0]['ids']['tvrage'] = self.indexer_id
trakt_api.traktRequest("sync/watchlist/remove", data, method='POST')
return self._finishEarly()
try:
self.show = TVShow(self.indexer, self.indexer_id, self.lang)
self.show.loadFromIndexer()
# set up initial values
self.show.location = self.showDir
self.show.subtitles = self.subtitles or sickrage.srCore.srConfig.SUBTITLES_DEFAULT
self.show.quality = self.quality or sickrage.srCore.srConfig.QUALITY_DEFAULT
self.show.flatten_folders = self.flatten_folders or sickrage.srCore.srConfig.FLATTEN_FOLDERS_DEFAULT
self.show.anime = self.anime or sickrage.srCore.srConfig.ANIME_DEFAULT
self.show.scene = self.scene or sickrage.srCore.srConfig.SCENE_DEFAULT
self.show.archive_firstmatch = self.archive or sickrage.srCore.srConfig.ARCHIVE_DEFAULT
self.show.paused = self.paused or False
# set up default new/missing episode status
sickrage.srCore.srLogger.info(
"Setting all current episodes to the specified default status: " + str(self.default_status))
self.show.default_ep_status = self.default_status
if self.show.anime:
self.show.release_groups = BlackAndWhiteList(self.show.indexerid)
if self.blacklist:
self.show.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
self.show.release_groups.set_white_keywords(self.whitelist)
# # be smartish about this
# if self.show.genre and "talk show" in self.show.genre.lower():
# self.show.air_by_date = 1
# if self.show.genre and "documentary" in self.show.genre.lower():
# self.show.air_by_date = 0
# if self.show.classification and "sports" in self.show.classification.lower():
# self.show.sports = 1
except indexer_exception as e:
sickrage.srCore.srLogger.error(
"Unable to add show due to an error with " + srIndexerApi(
self.indexer).name + ": {}".format(e.message))
if self.show:
sickrage.srCore.srNotifications.error(
"Unable to add " + str(self.show.name) + " due to an error with " + srIndexerApi(
self.indexer).name + "")
else:
sickrage.srCore.srNotifications.error(
"Unable to add show due to an error with " + srIndexerApi(self.indexer).name + "")
return self._finishEarly()
except MultipleShowObjectsException:
sickrage.srCore.srLogger.warning("The show in " + self.showDir + " is already in your show list, skipping")
sickrage.srCore.srNotifications.error('Show skipped',
"The show in " + self.showDir + " is already in your show list")
return self._finishEarly()
except Exception as e:
sickrage.srCore.srLogger.error("Error trying to add show: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
raise self._finishEarly()
sickrage.srCore.srLogger.debug("Retrieving show info from TMDb")
try:
self.show.loadTMDbInfo()
except Exception as e:
sickrage.srCore.srLogger.error("Error loading TMDb info: {}".format(e.message))
try:
sickrage.srCore.srLogger.debug("Attempting to retrieve show info from IMDb")
self.show.loadIMDbInfo()
except Exception as e:
sickrage.srCore.srLogger.error("Error loading IMDb info: {}".format(e.message))
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer, force=True)
# check if show has XEM mapping so we can determin if searches should go by scene numbering or indexer numbering.
if not self.scene and get_xem_numbering_for_show(self.show.indexerid, self.show.indexer):
self.show.scene = 1
try:
self.show.saveToDB()
except Exception as e:
sickrage.srCore.srLogger.error("Error saving the show to the database: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
raise self._finishEarly()
# add it to the show list
sickrage.srCore.SHOWLIST.append(self.show)
try:
self.show.loadEpisodesFromIndexer()
except Exception as e:
sickrage.srCore.srLogger.error(
"Error with " + srIndexerApi(
self.show.indexer).name + ", not creating episode list: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
try:
self.show.loadEpisodesFromDir()
except Exception as e:
sickrage.srCore.srLogger.debug("Error searching dir for episodes: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
# if they set default ep status to WANTED then run the backlog to search for episodes
if self.show.default_ep_status == WANTED:
sickrage.srCore.srLogger.info("Launching backlog for this show since its episodes are WANTED")
sickrage.srCore.BACKLOGSEARCHER.searchBacklog([self.show])
self.show.writeMetadata()
self.show.updateMetadata()
self.show.populateCache()
if sickrage.srCore.srConfig.USE_TRAKT:
# if there are specific episodes that need to be added by trakt
sickrage.srCore.TRAKTSEARCHER.manageNewShow(self.show)
# add show to trakt.tv library
if sickrage.srCore.srConfig.TRAKT_SYNC:
sickrage.srCore.TRAKTSEARCHER.addShowToTraktLibrary(self.show)
if sickrage.srCore.srConfig.TRAKT_SYNC_WATCHLIST:
sickrage.srCore.srLogger.info("update watchlist")
sickrage.srCore.notifiersDict.trakt_notifier.update_watchlist(show_obj=self.show)
# After initial add, set to default_status_after.
sickrage.srCore.srLogger.info(
"Setting all future episodes to the specified default status: " + str(self.default_status_after))
self.show.default_ep_status = self.default_status_after
self.show.saveToDB()
sickrage.srCore.NAMECACHE.buildNameCache(self.show)
sickrage.srCore.srLogger.info("Finished adding show {}".format(self.showDir))
def run(self):
start_time = time.time()
sickrage.app.log.info(
"Started adding show {} from show dir: {}".format(
self.show_name, self.showDir))
index_name = IndexerApi(self.indexer).name
# make sure the Indexer IDs are valid
lINDEXER_API_PARMS = IndexerApi(self.indexer).api_params.copy()
lINDEXER_API_PARMS['cache'] = False
lINDEXER_API_PARMS[
'language'] = self.lang or sickrage.app.config.indexer_default_language
sickrage.app.log.info("{}: {}".format(index_name,
repr(lINDEXER_API_PARMS)))
t = IndexerApi(self.indexer).indexer(**lINDEXER_API_PARMS)
s = t[self.indexer_id]
if not s:
sickrage.app.alerts.error(
_("Unable to add show"),
_("Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding "
"manually again.").format(self.showDir, index_name,
self.indexer_id))
if sickrage.app.config.use_trakt:
title = self.showDir.split("/")[-1]
data = {
'shows': [{
'title': title,
'ids': {
IndexerApi(self.indexer).trakt_id: self.indexer_id
}
}]
}
TraktAPI()["sync/watchlist"].remove(data)
return self._finish_early()
# this usually only happens if they have an NFO in their show dir which gave us a Indexer ID that has no
# proper english version of the show
try:
s.seriesname
except AttributeError:
sickrage.app.log.warning(
"Show in {} has no name on {}, probably the wrong language used to search with"
.format(self.showDir, index_name))
sickrage.app.alerts.error(
_("Unable to add show"),
_("Show in {} has no name on {}, probably the wrong language. Delete .nfo "
"and add manually in the correct language").format(
self.showDir, index_name))
return self._finish_early()
# if the show has no episodes/seasons
if not len(s):
sickrage.app.log.warning("Show " + str(s['seriesname']) +
" is on " +
str(IndexerApi(self.indexer).name) +
"but contains no season/episode "
"data.")
sickrage.app.alerts.error(
_("Unable to add show"),
_("Show ") + str(s['seriesname']) + _(" is on ") +
str(IndexerApi(self.indexer).name) +
_(" but contains no season/episode data."))
return self._finish_early()
try:
# add show to database
show_obj = TVShow(self.indexer_id,
self.indexer,
lang=self.lang,
location=self.showDir)
# set up initial values
show_obj.subtitles = self.subtitles if self.subtitles is not None else sickrage.app.config.subtitles_default
show_obj.sub_use_sr_metadata = self.sub_use_sr_metadata if self.sub_use_sr_metadata is not None else False
show_obj.quality = self.quality if self.quality is not None else sickrage.app.config.quality_default
show_obj.flatten_folders = self.flatten_folders if self.flatten_folders is not None else sickrage.app.config.flatten_folders_default
show_obj.scene = self.scene if self.scene is not None else sickrage.app.config.scene_default
show_obj.anime = self.anime if self.anime is not None else sickrage.app.config.anime_default
show_obj.dvdorder = self.dvdorder if self.dvdorder is not None else False
show_obj.search_format = self.search_format if self.search_format is not None else sickrage.app.config.search_format_default
show_obj.skip_downloaded = self.skip_downloaded if self.skip_downloaded is not None else sickrage.app.config.skip_downloaded_default
show_obj.paused = self.paused if self.paused is not None else False
# set up default new/missing episode status
sickrage.app.log.info(
"Setting all current episodes to the specified default status: "
+ str(self.default_status))
show_obj.default_ep_status = self.default_status
# save to database
show_obj.save()
if show_obj.anime:
if self.blacklist:
show_obj.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
show_obj.release_groups.set_white_keywords(self.whitelist)
except indexer_exception as e:
sickrage.app.log.warning(
_("Unable to add show due to an error with ") +
IndexerApi(self.indexer).name + ": {}".format(e))
sickrage.app.alerts.error(
_("Unable to add show due to an error with ") +
IndexerApi(self.indexer).name + "")
return self._finish_early()
except MultipleShowObjectsException:
sickrage.app.log.warning(
_("The show in ") + self.showDir +
_(" is already in your show list, skipping"))
sickrage.app.alerts.error(
_('Show skipped'),
_("The show in ") + self.showDir +
_(" is already in your show list"))
return self._finish_early()
except Exception as e:
sickrage.app.log.error(_("Error trying to add show: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
raise self._finish_early()
try:
sickrage.app.log.debug(
_("Attempting to retrieve show info from IMDb"))
show_obj.load_imdb_info()
except Exception as e:
sickrage.app.log.debug(_("Error loading IMDb info: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
try:
show_obj.load_episodes_from_indexer()
except Exception as e:
sickrage.app.log.debug(
_("Error with ") + IndexerApi(show_obj.indexer).name +
_(", not creating episode list: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
try:
show_obj.load_episodes_from_dir()
except Exception as e:
sickrage.app.log.debug(
"Error searching dir for episodes: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
show_obj.write_metadata(force=True)
show_obj.populate_cache()
if sickrage.app.config.use_trakt:
# if there are specific episodes that need to be added by trakt
sickrage.app.trakt_searcher.manage_new_show(show_obj)
# add show to trakt.tv library
if sickrage.app.config.trakt_sync:
sickrage.app.trakt_searcher.add_show_to_trakt_library(show_obj)
if sickrage.app.config.trakt_sync_watchlist:
sickrage.app.log.info("update watchlist")
sickrage.app.notifier_providers['trakt'].update_watchlist(
show_obj)
# Retrieve scene exceptions
show_obj.retrieve_scene_exceptions()
# Load XEM data to DB for show
xem_refresh(show_obj.indexer_id, show_obj.indexer, force=True)
# check if show has XEM mapping so we can determine if searches should go by scene numbering or indexer
# numbering.
# if not self.scene and get_xem_numbering_for_show(show_obj.indexer_id, show_obj.indexer):
# show_obj.scene = 1
# if they set default ep status to WANTED then run the backlog to search for episodes
if show_obj.default_ep_status == WANTED:
sickrage.app.log.info(
_("Launching backlog for this show since it has episodes that are WANTED"
))
sickrage.app.backlog_searcher.search_backlog(show_obj.indexer_id)
show_obj.default_ep_status = self.default_status_after
show_obj.save()
sickrage.app.log.info(
"Finished adding show {} in {}s from show dir: {}".format(
self.show_name, round(time.time() - start_time, 2),
self.showDir))
def run(self):
start_time = time.time()
sickrage.app.log.info(
"Started adding show {} from show dir: {}".format(
self.show_name, self.showDir))
index_name = IndexerApi(self.indexer).name
# make sure the Indexer IDs are valid
try:
lINDEXER_API_PARMS = IndexerApi(self.indexer).api_params.copy()
lINDEXER_API_PARMS['cache'] = False
lINDEXER_API_PARMS[
'language'] = self.lang or sickrage.app.config.indexer_default_language
sickrage.app.log.info("{}: {}".format(index_name,
repr(lINDEXER_API_PARMS)))
t = IndexerApi(self.indexer).indexer(**lINDEXER_API_PARMS)
try:
s = t[self.indexer_id]
except indexer_error:
s = None
if not s:
return self._finish_early()
# this usually only happens if they have an NFO in their show dir which gave us a Indexer ID that has no proper english version of the show
if not getattr(s, 'seriesname'):
sickrage.app.log.warning(
"Show in {} has no name on {}, probably the wrong language used to search with"
.format(self.showDir, index_name))
sickrage.app.alerts.error(
_("Unable to add show"),
_("Show in {} has no name on {}, probably the wrong language. Delete .nfo "
"and add manually in the correct language").format(
self.showDir, index_name))
return self._finish_early()
# if the show has no episodes/seasons
if not len(s):
sickrage.app.log.warning(
"Show " + str(s['seriesname']) + " is on " +
str(IndexerApi(self.indexer).name) +
" but contains no season/episode data.")
sickrage.app.alerts.error(
_("Unable to add show"),
_("Show ") + str(s['seriesname']) + _(" is on ") +
str(IndexerApi(self.indexer).name) +
_(" but contains no season/episode data."))
return self._finish_early()
except Exception as e:
sickrage.app.log.error(
"{}: Error while loading information from indexer {}. Error: {}"
.format(self.indexer_id, index_name, e))
sickrage.app.alerts.error(
_("Unable to add show"),
_("Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding "
"manually again.").format(self.showDir, index_name,
self.indexer_id))
if sickrage.app.config.use_trakt:
title = self.showDir.split("/")[-1]
data = {
'shows': [{
'title': title,
'ids': {
IndexerApi(self.indexer).trakt_id: self.indexer_id
}
}]
}
srTraktAPI()["sync/watchlist"].remove(data)
return self._finish_early()
try:
self.show = TVShow(self.indexer, self.indexer_id, self.lang)
self.show.load_from_indexer()
# set up initial values
self.show.location = self.showDir
self.show.subtitles = self.subtitles or sickrage.app.config.subtitles_default
self.show.subtitles_sr_metadata = self.subtitles_sr_metadata
self.show.quality = self.quality or sickrage.app.config.quality_default
self.show.flatten_folders = self.flatten_folders or sickrage.app.config.flatten_folders_default
self.show.anime = self.anime or sickrage.app.config.anime_default
self.show.scene = self.scene or sickrage.app.config.scene_default
self.show.skip_downloaded = self.skip_downloaded or sickrage.app.config.skip_downloaded_default
self.show.paused = self.paused or False
# set up default new/missing episode status
sickrage.app.log.info(
"Setting all current episodes to the specified default status: "
+ str(self.default_status))
self.show.default_ep_status = self.default_status
if self.show.anime:
self.show.release_groups = BlackAndWhiteList(
self.show.indexerid)
if self.blacklist:
self.show.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
self.show.release_groups.set_white_keywords(self.whitelist)
# # be smartish about this
# if self.show.genre and "talk show" in self.show.genre.lower():
# self.show.air_by_date = 1
# if self.show.genre and "documentary" in self.show.genre.lower():
# self.show.air_by_date = 0
# if self.show.classification and "sports" in self.show.classification.lower():
# self.show.sports = 1
except indexer_exception as e:
sickrage.app.log.warning(
"Unable to add show due to an error with " +
IndexerApi(self.indexer).name + ": {}".format(e))
if self.show:
sickrage.app.alerts.error(
_("Unable to add ") + str(self.show.name) +
_(" due to an error with ") +
IndexerApi(self.indexer).name + "")
else:
sickrage.app.alerts.error(
_("Unable to add show due to an error with ") +
IndexerApi(self.indexer).name + "")
return self._finish_early()
except MultipleShowObjectsException:
sickrage.app.log.warning("The show in " + self.showDir +
" is already in your show list, skipping")
sickrage.app.alerts.error(
_('Show skipped'),
_("The show in ") + self.showDir +
_(" is already in your show list"))
return self._finish_early()
except Exception as e:
sickrage.app.log.error("Error trying to add show: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
raise self._finish_early()
try:
sickrage.app.log.debug(
"Attempting to retrieve show info from IMDb")
self.show.load_imdb_info()
except Exception as e:
sickrage.app.log.error("Error loading IMDb info: {}".format(e))
try:
self.show.save_to_db()
except Exception as e:
sickrage.app.log.error(
"Error saving the show to the database: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
raise self._finish_early()
# add it to the show list
if not findCertainShow(self.indexer_id):
sickrage.app.showlist.append(self.show)
try:
self.show.load_episodes_from_indexer()
except Exception as e:
sickrage.app.log.error("Error with " +
IndexerApi(self.show.indexer).name +
", not creating episode list: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
try:
self.show.load_episodes_from_dir()
except Exception as e:
sickrage.app.log.debug(
"Error searching dir for episodes: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
# if they set default ep status to WANTED then run the backlog to search for episodes
if self.show.default_ep_status == WANTED:
sickrage.app.log.info(
"Launching backlog for this show since its episodes are WANTED"
)
sickrage.app.backlog_searcher.search_backlog([self.show])
self.show.write_metadata(force=True)
self.show.populate_cache()
if sickrage.app.config.use_trakt:
# if there are specific episodes that need to be added by trakt
sickrage.app.trakt_searcher.manageNewShow(self.show)
# add show to trakt.tv library
if sickrage.app.config.trakt_sync:
sickrage.app.trakt_searcher.addShowToTraktLibrary(self.show)
if sickrage.app.config.trakt_sync_watchlist:
sickrage.app.log.info("update watchlist")
sickrage.app.notifier_providers['trakt'].update_watchlist(
show_obj=self.show)
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer, force=True)
# check if show has XEM mapping so we can determin if searches should go by scene numbering or indexer numbering.
if not self.scene and get_xem_numbering_for_show(
self.show.indexerid, self.show.indexer):
self.show.scene = 1
self.show.default_ep_status = self.default_status_after
self.show.save_to_db()
sickrage.app.name_cache.build(self.show)
sickrage.app.quicksearch_cache.add_show(self.show.indexerid)
self.finish()
sickrage.app.log.info(
"Finished adding show {} in {}s from show dir: {}".format(
self.show_name, round(time.time() - start_time, 2),
self.showDir))
def run(self):
sickrage.srCore.srLogger.info("Started adding show {}".format(
self.show_name))
index_name = srIndexerApi(self.indexer).name
# make sure the Indexer IDs are valid
try:
lINDEXER_API_PARMS = srIndexerApi(self.indexer).api_params.copy()
if self.lang:
lINDEXER_API_PARMS['language'] = self.lang
sickrage.srCore.srLogger.info("{}: {}".format(
index_name, repr(lINDEXER_API_PARMS)))
t = srIndexerApi(self.indexer).indexer(**lINDEXER_API_PARMS)
s = t[self.indexer_id]
if not s: return self._finishEarly()
# this usually only happens if they have an NFO in their show dir which gave us a Indexer ID that has no proper english version of the show
if not getattr(s, 'seriesname'):
sickrage.srCore.srLogger.error(
"Show in {} has no name on {}, probably the wrong language used to search with"
.format(self.showDir, index_name))
sickrage.srCore.srNotifications.error(
"Unable to add show",
"Show in {} has no name on {}, probably the wrong language. Delete .nfo and add manually in the correct language"
.format(self.showDir, index_name))
return self._finishEarly()
# if the show has no episodes/seasons
if not len(s):
sickrage.srCore.srLogger.error(
"Show " + str(s['seriesname']) + " is on " +
str(srIndexerApi(self.indexer).name) +
" but contains no season/episode data.")
sickrage.srCore.srNotifications.error(
"Unable to add show", "Show " + str(s['seriesname']) +
" is on " + str(srIndexerApi(self.indexer).name) +
" but contains no season/episode data.")
return self._finishEarly()
except Exception as e:
sickrage.srCore.srLogger.error(
"{}: Error while loading information from indexer {}. Error: {}"
.format(self.indexer_id, index_name, e.message))
sickrage.srCore.srNotifications.error(
"Unable to add show",
"Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding manually again."
.format(self.showDir, index_name, self.indexer_id))
if sickrage.srCore.srConfig.USE_TRAKT:
trakt_id = srIndexerApi(self.indexer).config['trakt_id']
trakt_api = TraktAPI(sickrage.srCore.srConfig.SSL_VERIFY,
sickrage.srCore.srConfig.TRAKT_TIMEOUT)
title = self.showDir.split("/")[-1]
data = {'shows': [{'title': title, 'ids': {}}]}
if trakt_id == 'tvdb_id':
data['shows'][0]['ids']['tvdb'] = self.indexer_id
else:
data['shows'][0]['ids']['tvrage'] = self.indexer_id
trakt_api.traktRequest("sync/watchlist/remove",
data,
method='POST')
return self._finishEarly()
try:
self.show = TVShow(self.indexer, self.indexer_id, self.lang)
self.show.loadFromIndexer()
# set up initial values
self.show.location = self.showDir
self.show.subtitles = self.subtitles or sickrage.srCore.srConfig.SUBTITLES_DEFAULT
self.show.quality = self.quality or sickrage.srCore.srConfig.QUALITY_DEFAULT
self.show.flatten_folders = self.flatten_folders or sickrage.srCore.srConfig.FLATTEN_FOLDERS_DEFAULT
self.show.anime = self.anime or sickrage.srCore.srConfig.ANIME_DEFAULT
self.show.scene = self.scene or sickrage.srCore.srConfig.SCENE_DEFAULT
self.show.archive_firstmatch = self.archive or sickrage.srCore.srConfig.ARCHIVE_DEFAULT
self.show.paused = self.paused or False
# set up default new/missing episode status
sickrage.srCore.srLogger.info(
"Setting all current episodes to the specified default status: "
+ str(self.default_status))
self.show.default_ep_status = self.default_status
if self.show.anime:
self.show.release_groups = BlackAndWhiteList(
self.show.indexerid)
if self.blacklist:
self.show.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
self.show.release_groups.set_white_keywords(self.whitelist)
# # be smartish about this
# if self.show.genre and "talk show" in self.show.genre.lower():
# self.show.air_by_date = 1
# if self.show.genre and "documentary" in self.show.genre.lower():
# self.show.air_by_date = 0
# if self.show.classification and "sports" in self.show.classification.lower():
# self.show.sports = 1
except indexer_exception as e:
sickrage.srCore.srLogger.error(
"Unable to add show due to an error with " +
srIndexerApi(self.indexer).name + ": {}".format(e.message))
if self.show:
sickrage.srCore.srNotifications.error(
"Unable to add " + str(self.show.name) +
" due to an error with " +
srIndexerApi(self.indexer).name + "")
else:
sickrage.srCore.srNotifications.error(
"Unable to add show due to an error with " +
srIndexerApi(self.indexer).name + "")
return self._finishEarly()
except MultipleShowObjectsException:
sickrage.srCore.srLogger.warning(
"The show in " + self.showDir +
" is already in your show list, skipping")
sickrage.srCore.srNotifications.error(
'Show skipped', "The show in " + self.showDir +
" is already in your show list")
return self._finishEarly()
except Exception as e:
sickrage.srCore.srLogger.error(
"Error trying to add show: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
raise self._finishEarly()
try:
sickrage.srCore.srLogger.debug(
"Attempting to retrieve show info from IMDb")
self.show.loadIMDbInfo()
except Exception as e:
sickrage.srCore.srLogger.error(
"Error loading IMDb info: {}".format(e.message))
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer, force=True)
# check if show has XEM mapping so we can determin if searches should go by scene numbering or indexer numbering.
if not self.scene and get_xem_numbering_for_show(
self.show.indexerid, self.show.indexer):
self.show.scene = 1
try:
self.show.saveToDB()
except Exception as e:
sickrage.srCore.srLogger.error(
"Error saving the show to the database: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
raise self._finishEarly()
# add it to the show list
sickrage.srCore.SHOWLIST.append(self.show)
try:
self.show.loadEpisodesFromIndexer()
except Exception as e:
sickrage.srCore.srLogger.error(
"Error with " + srIndexerApi(self.show.indexer).name +
", not creating episode list: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
try:
self.show.loadEpisodesFromDir()
except Exception as e:
sickrage.srCore.srLogger.debug(
"Error searching dir for episodes: {}".format(e.message))
sickrage.srCore.srLogger.debug(traceback.format_exc())
# if they set default ep status to WANTED then run the backlog to search for episodes
if self.show.default_ep_status == WANTED:
sickrage.srCore.srLogger.info(
"Launching backlog for this show since its episodes are WANTED"
)
sickrage.srCore.BACKLOGSEARCHER.searchBacklog([self.show])
self.show.writeMetadata()
self.show.updateMetadata()
self.show.populateCache()
if sickrage.srCore.srConfig.USE_TRAKT:
# if there are specific episodes that need to be added by trakt
sickrage.srCore.TRAKTSEARCHER.manageNewShow(self.show)
# add show to trakt.tv library
if sickrage.srCore.srConfig.TRAKT_SYNC:
sickrage.srCore.TRAKTSEARCHER.addShowToTraktLibrary(self.show)
if sickrage.srCore.srConfig.TRAKT_SYNC_WATCHLIST:
sickrage.srCore.srLogger.info("update watchlist")
sickrage.srCore.notifiersDict.trakt_notifier.update_watchlist(
show_obj=self.show)
# After initial add, set to default_status_after.
sickrage.srCore.srLogger.info(
"Setting all future episodes to the specified default status: " +
str(self.default_status_after))
self.show.default_ep_status = self.default_status_after
self.show.saveToDB()
sickrage.srCore.NAMECACHE.build(self.show)
self.finish()
sickrage.srCore.srLogger.info("Finished adding show {}".format(
self.showDir))
def loadFromNFO(self, location):
if not os.path.isdir(self.show._location):
sickrage.LOGGER.info(
str(
self.show.indexerid) + ": The show dir is missing, not bothering to try loading the episode NFO")
return
sickrage.LOGGER.debug(
str(
self.show.indexerid) + ": Loading episode details from the NFO file associated with " + location)
self.location = location
if self.location != "":
if self.status == UNKNOWN:
if isMediaFile(self.location):
sickrage.LOGGER.debug("7 Status changes from " + str(self.status) + " to " + str(
Quality.statusFromName(self.location, anime=self.show.is_anime)))
self.status = Quality.statusFromName(self.location, anime=self.show.is_anime)
nfoFile = replaceExtension(self.location, "nfo")
sickrage.LOGGER.debug(str(self.show.indexerid) + ": Using NFO name " + nfoFile)
if os.path.isfile(nfoFile):
try:
showXML = ElementTree(file=nfoFile)
except (SyntaxError, ValueError) as e:
sickrage.LOGGER.error("Error loading the NFO, backing up the NFO and skipping for now: {}".format(e))
try:
os.rename(nfoFile, nfoFile + ".old")
except Exception as e:
sickrage.LOGGER.error(
"Failed to rename your episode's NFO file - you need to delete it or fix it: {}".format(
e))
raise NoNFOException("Error in NFO format")
for epDetails in showXML.iter('episodedetails'):
if epDetails.findtext('season') is None or int(epDetails.findtext('season')) != self.season or \
epDetails.findtext('episode') is None or int(
epDetails.findtext('episode')) != self.episode:
sickrage.LOGGER.debug(
"%s: NFO has an <episodedetails> block for a different episode - wanted S%02dE%02d but got S%02dE%02d" %
(
self.show.indexerid, self.season or 0, self.episode or 0,
epDetails.findtext('season') or 0,
epDetails.findtext('episode') or 0))
continue
if epDetails.findtext('title') is None or epDetails.findtext('aired') is None:
raise NoNFOException("Error in NFO format (missing episode title or airdate)")
self.name = epDetails.findtext('title')
self.episode = int(epDetails.findtext('episode'))
self.season = int(epDetails.findtext('season'))
xem_refresh(self.show.indexerid, self.show.indexer)
self.scene_absolute_number = get_scene_absolute_numbering(
self.show.indexerid,
self.show.indexer,
self.absolute_number
)
self.scene_season, self.scene_episode = get_scene_numbering(
self.show.indexerid,
self.show.indexer,
self.season, self.episode
)
self.description = epDetails.findtext('plot')
if self.description is None:
self.description = ""
if epDetails.findtext('aired'):
rawAirdate = [int(x) for x in epDetails.findtext('aired').split("-")]
self.airdate = datetime.date(rawAirdate[0], rawAirdate[1], rawAirdate[2])
else:
self.airdate = datetime.date.fromordinal(1)
self.hasnfo = True
else:
self.hasnfo = False
if os.path.isfile(replaceExtension(nfoFile, "tbn")):
self.hastbn = True
else:
self.hastbn = False
def loadFromIndexer(self, season=None, episode=None, cache=True, tvapi=None, cachedSeason=None):
if season is None:
season = self.season
if episode is None:
episode = self.episode
sickrage.LOGGER.debug("%s: Loading episode details from %s for episode S%02dE%02d" %
(self.show.indexerid, sickrage.INDEXER_API(self.show.indexer).name, season or 0, episode or 0))
indexer_lang = self.show.lang
try:
if cachedSeason is None:
if tvapi is None:
lINDEXER_API_PARMS = sickrage.INDEXER_API(self.indexer).api_params.copy()
if not cache:
lINDEXER_API_PARMS[b'cache'] = False
if indexer_lang:
lINDEXER_API_PARMS[b'language'] = indexer_lang
if self.show.dvdorder != 0:
lINDEXER_API_PARMS[b'dvdorder'] = True
t = sickrage.INDEXER_API(self.indexer).indexer(**lINDEXER_API_PARMS)
else:
t = tvapi
myEp = t[self.show.indexerid][season][episode]
else:
myEp = cachedSeason[episode]
except (indexer_error, IOError) as e:
sickrage.LOGGER.debug("" + sickrage.INDEXER_API(self.indexer).name + " threw up an error: {}".format(e))
# if the episode is already valid just log it, if not throw it up
if self.name:
sickrage.LOGGER.debug("" + sickrage.INDEXER_API(
self.indexer).name + " timed out but we have enough info from other sources, allowing the error")
return
else:
sickrage.LOGGER.error("" + sickrage.INDEXER_API(self.indexer).name + " timed out, unable to create the episode")
return False
except (indexer_episodenotfound, indexer_seasonnotfound):
sickrage.LOGGER.debug("Unable to find the episode on " + sickrage.INDEXER_API(
self.indexer).name + "... has it been removed? Should I delete from db?")
# if I'm no longer on the Indexers but I once was then delete myself from the DB
if self.indexerid != -1:
self.deleteEpisode()
return
if getattr(myEp, 'episodename', None) is None:
sickrage.LOGGER.info("This episode %s - S%02dE%02d has no name on %s. Setting to an empty string" % (
self.show.name, season or 0, episode or 0, sickrage.INDEXER_API(self.indexer).name))
setattr(myEp, 'episodename', '')
# # if I'm incomplete on TVDB but I once was complete then just delete myself from the DB for now
# if self.indexerid != -1:
# self.deleteEpisode()
# return False
if getattr(myEp, 'absolute_number', None) is None:
sickrage.LOGGER.debug("This episode %s - S%02dE%02d has no absolute number on %s" % (
self.show.name, season or 0, episode or 0, sickrage.INDEXER_API(self.indexer).name))
else:
sickrage.LOGGER.debug("%s: The absolute_number for S%02dE%02d is: %s " % (
self.show.indexerid, season or 0, episode or 0, myEp[b"absolute_number"]))
self.absolute_number = int(myEp[b"absolute_number"])
self.name = getattr(myEp, 'episodename', "")
self.season = season
self.episode = episode
xem_refresh(self.show.indexerid, self.show.indexer)
self.scene_absolute_number = get_scene_absolute_numbering(
self.show.indexerid,
self.show.indexer,
self.absolute_number
)
self.scene_season, self.scene_episode = get_scene_numbering(
self.show.indexerid,
self.show.indexer,
self.season, self.episode
)
self.description = getattr(myEp, 'overview', "")
firstaired = getattr(myEp, 'firstaired', None)
if not firstaired or firstaired == "0000-00-00":
firstaired = str(datetime.date.fromordinal(1))
rawAirdate = [int(x) for x in firstaired.split("-")]
try:
self.airdate = datetime.date(rawAirdate[0], rawAirdate[1], rawAirdate[2])
except (ValueError, IndexError):
sickrage.LOGGER.warning("Malformed air date of %s retrieved from %s for (%s - S%02dE%02d)" % (
firstaired, sickrage.INDEXER_API(self.indexer).name, self.show.name, season or 0, episode or 0))
# if I'm incomplete on the indexer but I once was complete then just delete myself from the DB for now
if self.indexerid != -1:
self.deleteEpisode()
return False
# early conversion to int so that episode doesn't get marked dirty
self.indexerid = getattr(myEp, 'id', None)
if self.indexerid is None:
sickrage.LOGGER.error("Failed to retrieve ID from " + sickrage.INDEXER_API(self.indexer).name)
if self.indexerid != -1:
self.deleteEpisode()
return False
# don't update show status if show dir is missing, unless it's missing on purpose
if not os.path.isdir(
self.show._location) and not sickrage.CREATE_MISSING_SHOW_DIRS and not sickrage.ADD_SHOWS_WO_DIR:
sickrage.LOGGER.info(
"The show dir %s is missing, not bothering to change the episode statuses since it'd probably be invalid" % self.show._location)
return
if self.location:
sickrage.LOGGER.debug("%s: Setting status for S%02dE%02d based on status %s and location %s" %
(self.show.indexerid, season or 0, episode or 0, statusStrings[self.status],
self.location))
if not os.path.isfile(self.location):
if self.airdate >= datetime.date.today() or self.airdate == datetime.date.fromordinal(1):
sickrage.LOGGER.debug("Episode airs in the future or has no airdate, marking it %s" % statusStrings[
UNAIRED])
self.status = UNAIRED
elif self.status in [UNAIRED, UNKNOWN]:
# Only do UNAIRED/UNKNOWN, it could already be snatched/ignored/skipped, or downloaded/archived to disconnected media
sickrage.LOGGER.debug(
"Episode has already aired, marking it %s" % statusStrings[self.show.default_ep_status])
self.status = self.show.default_ep_status if self.season > 0 else SKIPPED # auto-skip specials
else:
sickrage.LOGGER.debug(
"Not touching status [ %s ] It could be skipped/ignored/snatched/archived" % statusStrings[
self.status])
# if we have a media file then it's downloaded
elif isMediaFile(self.location):
# leave propers alone, you have to either post-process them or manually change them back
if self.status not in Quality.SNATCHED_PROPER + Quality.DOWNLOADED + Quality.SNATCHED + Quality.ARCHIVED:
sickrage.LOGGER.debug(
"5 Status changes from " + str(self.status) + " to " + str(
Quality.statusFromName(self.location)))
self.status = Quality.statusFromName(self.location, anime=self.show.is_anime)
# shouldn't get here probably
else:
sickrage.LOGGER.debug("6 Status changes from " + str(self.status) + " to " + str(UNKNOWN))
self.status = UNKNOWN
def run(self):
super(ShowTaskAdd, self).run()
start_time = time.time()
sickrage.app.log.info(
"Started adding show {} from show dir: {}".format(
self.show_name, self.show_dir))
series_provider_language = self.lang or sickrage.app.config.general.series_provider_default_language
series_info = sickrage.app.series_providers[
self.series_provider_id].get_series_info(
self.series_id,
language=series_provider_language,
enable_cache=False)
if not series_info:
sickrage.app.alerts.error(
_("Unable to add show"),
_("Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding "
"manually again.").format(
self.show_dir, sickrage.app.series_providers[
self.series_provider_id].name, self.series_id))
if sickrage.app.config.trakt.enable:
title = self.show_dir.split("/")[-1]
data = {
'shows': [{
'title': title,
'ids': {
sickrage.app.series_providers[self.series_provider_id].trakt_id:
self.series_id
}
}]
}
TraktAPI()["sync/watchlist"].remove(data)
return self._finish_early()
# this usually only happens if they have an NFO in their show dir which gave us a series id that has no
# proper english version of the show
try:
series_info.name
except AttributeError:
sickrage.app.log.warning(
f"Show in {self.show_dir} has no name on {sickrage.app.series_providers[self.series_provider_id].name}, "
f"probably the wrong language used to search with")
sickrage.app.alerts.error(
_("Unable to add show"),
_(f"Show in {self.show_dir} has no name on {sickrage.app.series_providers[self.series_provider_id].name}, "
f"probably the wrong language. Delete .nfo and add manually in the correct language"
))
return self._finish_early()
# if the show has no episodes/seasons
if not len(series_info):
sickrage.app.log.warning("Show " + str(series_info['name']) +
" is on " +
str(sickrage.app.series_providers[
self.series_provider_id].name) +
"but contains no season/episode data.")
sickrage.app.alerts.error(
_("Unable to add show"),
_("Show ") + str(series_info['name']) + _(" is on ") +
str(sickrage.app.series_providers[
self.series_provider_id].name) +
_(" but contains no season/episode data."))
return self._finish_early()
try:
# add show to database
show_obj = TVShow(self.series_id,
self.series_provider_id,
lang=self.lang,
location=self.show_dir)
# set up initial values
show_obj.subtitles = self.subtitles if self.subtitles is not None else sickrage.app.config.subtitles.default
show_obj.sub_use_sr_metadata = self.sub_use_sr_metadata if self.sub_use_sr_metadata is not None else False
show_obj.quality = self.quality if self.quality is not None else sickrage.app.config.general.quality_default
show_obj.flatten_folders = self.flatten_folders if self.flatten_folders is not None else sickrage.app.config.general.flatten_folders_default
show_obj.scene = self.scene if self.scene is not None else sickrage.app.config.general.scene_default
show_obj.anime = self.anime if self.anime is not None else sickrage.app.config.general.anime_default
show_obj.dvd_order = self.dvd_order if self.dvd_order is not None else False
show_obj.search_format = self.search_format if self.search_format is not None else sickrage.app.config.general.search_format_default
show_obj.skip_downloaded = self.skip_downloaded if self.skip_downloaded is not None else sickrage.app.config.general.skip_downloaded_default
show_obj.paused = self.paused if self.paused is not None else False
# set up default new/missing episode status
sickrage.app.log.info(
"Setting all current episodes to the specified default status: "
+ str(self.default_status))
show_obj.default_ep_status = self.default_status
# save to database
show_obj.save()
if show_obj.anime:
if self.blacklist:
show_obj.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
show_obj.release_groups.set_white_keywords(self.whitelist)
except SeriesProviderException as e:
sickrage.app.log.warning(
_("Unable to add show due to an error with ") +
sickrage.app.series_providers[self.series_provider_id].name +
": {}".format(e))
sickrage.app.alerts.error(
_("Unable to add show due to an error with ") +
sickrage.app.series_providers[self.series_provider_id].name +
"")
return self._finish_early()
except MultipleShowObjectsException:
sickrage.app.log.warning(
_("The show in ") + self.show_dir +
_(" is already in your show list, skipping"))
sickrage.app.alerts.error(
_('Show skipped'),
_("The show in ") + self.show_dir +
_(" is already in your show list"))
return self._finish_early()
except Exception as e:
sickrage.app.log.error(_("Error trying to add show: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
raise self._finish_early()
try:
sickrage.app.log.debug(
_("Attempting to retrieve show info from IMDb"))
show_obj.load_imdb_info()
except Exception as e:
sickrage.app.log.debug(_("Error loading IMDb info: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
try:
show_obj.load_episodes_from_series_provider()
except Exception as e:
sickrage.app.log.debug(
_("Error with ") + show_obj.series_provider.name +
_(", not creating episode list: {}").format(e))
sickrage.app.log.debug(traceback.format_exc())
try:
show_obj.load_episodes_from_dir()
except Exception as e:
sickrage.app.log.debug(
"Error searching dir for episodes: {}".format(e))
sickrage.app.log.debug(traceback.format_exc())
show_obj.write_metadata(force=True)
show_obj.populate_cache()
if sickrage.app.config.trakt.enable:
# if there are specific episodes that need to be added by trakt
sickrage.app.trakt_searcher.manage_new_show(show_obj)
# add show to trakt.tv library
if sickrage.app.config.trakt.sync:
sickrage.app.trakt_searcher.add_show_to_trakt_library(show_obj)
if sickrage.app.config.trakt.sync_watchlist:
sickrage.app.log.info("update watchlist")
sickrage.app.notification_providers['trakt'].update_watchlist(
show_obj)
# Retrieve scene exceptions
show_obj.retrieve_scene_exceptions()
# Load XEM data to DB for show
xem_refresh(show_obj.series_id,
show_obj.series_provider_id,
force=True)
# check if show has XEM mapping so we can determine if searches should go by scene numbering or series_provider_id
# numbering.
# if not self.scene and get_xem_numbering_for_show(show_obj.series_id, show_obj.series_provider_id):
# show_obj.scene = 1
# if they set default ep status to WANTED then run the backlog to search for episodes
if show_obj.default_ep_status == EpisodeStatus.WANTED:
sickrage.app.log.info(
_("Launching backlog for this show since it has episodes that are WANTED"
))
sickrage.app.backlog_searcher.search_backlog(
show_obj.series_id, show_obj.series_provider_id)
show_obj.default_ep_status = self.default_status_after
show_obj.save()
WebSocketMessage('SHOW_ADDED', {
'seriesSlug': show_obj.slug,
'series': show_obj.to_json(progress=True)
}).push()
sickrage.app.log.info(
"Finished adding show {} in {}s from show dir: {}".format(
self.show_name, round(time.time() - start_time, 2),
self.show_dir))
def run(self):
sickrage.app.log.info("Started adding show {} from show dir: {}".format(self.show_name, self.showDir))
index_name = IndexerApi(self.indexer).name
# make sure the Indexer IDs are valid
try:
lINDEXER_API_PARMS = IndexerApi(self.indexer).api_params.copy()
lINDEXER_API_PARMS['cache'] = False
lINDEXER_API_PARMS['language'] = self.lang or sickrage.app.config.indexer_default_language
sickrage.app.log.info("{}: {}".format(index_name, repr(lINDEXER_API_PARMS)))
t = IndexerApi(self.indexer).indexer(**lINDEXER_API_PARMS)
s = t[self.indexer_id]
if not s: return self._finishEarly()
# this usually only happens if they have an NFO in their show dir which gave us a Indexer ID that has no proper english version of the show
if not getattr(s, 'seriesname'):
sickrage.app.log.error(
"Show in {} has no name on {}, probably the wrong language used to search with".format(self.showDir,
index_name))
sickrage.app.alerts.error(_("Unable to add show"),
_(
"Show in {} has no name on {}, probably the wrong language. Delete .nfo and add manually in the correct language").format(
self.showDir, index_name))
return self._finishEarly()
# if the show has no episodes/seasons
if not len(s):
sickrage.app.log.error("Show " + str(s['seriesname']) + " is on " + str(
IndexerApi(self.indexer).name) + " but contains no season/episode data.")
sickrage.app.alerts.error(_("Unable to add show"),
_("Show ") + str(s['seriesname']) + _(" is on ") + str(
IndexerApi(
self.indexer).name) + _(
" but contains no season/episode data."))
return self._finishEarly()
except Exception as e:
sickrage.app.log.error(
"{}: Error while loading information from indexer {}. Error: {}".format(self.indexer_id, index_name,
e.message))
sickrage.app.alerts.error(
_("Unable to add show"),
_("Unable to look up the show in {} on {} using ID {}, not using the NFO. Delete .nfo and try adding "
"manually again.").format(self.showDir, index_name, self.indexer_id)
)
if sickrage.app.config.use_trakt:
title = self.showDir.split("/")[-1]
data = {
'shows': [
{
'title': title,
'ids': {IndexerApi(self.indexer).trakt_id: self.indexer_id}
}
]
}
srTraktAPI()["sync/watchlist"].remove(data)
return self._finishEarly()
try:
self.show = TVShow(self.indexer, self.indexer_id, self.lang)
self.show.loadFromIndexer()
# set up initial values
self.show.location = self.showDir
self.show.subtitles = self.subtitles or sickrage.app.config.subtitles_default
self.show.subtitles_sr_metadata = self.subtitles_sr_metadata
self.show.quality = self.quality or sickrage.app.config.quality_default
self.show.flatten_folders = self.flatten_folders or sickrage.app.config.flatten_folders_default
self.show.anime = self.anime or sickrage.app.config.anime_default
self.show.scene = self.scene or sickrage.app.config.scene_default
self.show.archive_firstmatch = self.archive or sickrage.app.config.archive_default
self.show.paused = self.paused or False
# set up default new/missing episode status
sickrage.app.log.info(
"Setting all current episodes to the specified default status: " + str(self.default_status))
self.show.default_ep_status = self.default_status
if self.show.anime:
self.show.release_groups = BlackAndWhiteList(self.show.indexerid)
if self.blacklist:
self.show.release_groups.set_black_keywords(self.blacklist)
if self.whitelist:
self.show.release_groups.set_white_keywords(self.whitelist)
# # be smartish about this
# if self.show.genre and "talk show" in self.show.genre.lower():
# self.show.air_by_date = 1
# if self.show.genre and "documentary" in self.show.genre.lower():
# self.show.air_by_date = 0
# if self.show.classification and "sports" in self.show.classification.lower():
# self.show.sports = 1
except indexer_exception as e:
sickrage.app.log.error(
"Unable to add show due to an error with " + IndexerApi(
self.indexer).name + ": {}".format(e.message))
if self.show:
sickrage.app.alerts.error(
_("Unable to add ") + str(self.show.name) + _(" due to an error with ") + IndexerApi(
self.indexer).name + "")
else:
sickrage.app.alerts.error(
_("Unable to add show due to an error with ") + IndexerApi(self.indexer).name + "")
return self._finishEarly()
except MultipleShowObjectsException:
sickrage.app.log.warning("The show in " + self.showDir + " is already in your show list, skipping")
sickrage.app.alerts.error(_('Show skipped'),
_("The show in ") + self.showDir + _(" is already in your show list"))
return self._finishEarly()
except Exception as e:
sickrage.app.log.error("Error trying to add show: {}".format(e.message))
sickrage.app.log.debug(traceback.format_exc())
raise self._finishEarly()
try:
sickrage.app.log.debug("Attempting to retrieve show info from IMDb")
self.show.loadIMDbInfo()
except Exception as e:
sickrage.app.log.error("Error loading IMDb info: {}".format(e.message))
try:
self.show.saveToDB()
except Exception as e:
sickrage.app.log.error("Error saving the show to the database: {}".format(e.message))
sickrage.app.log.debug(traceback.format_exc())
raise self._finishEarly()
# add it to the show list
if not findCertainShow(sickrage.app.showlist, self.indexer_id): sickrage.app.showlist.append(self.show)
try:
self.show.loadEpisodesFromIndexer()
except Exception as e:
sickrage.app.log.error(
"Error with " + IndexerApi(
self.show.indexer).name + ", not creating episode list: {}".format(e.message))
sickrage.app.log.debug(traceback.format_exc())
try:
self.show.loadEpisodesFromDir()
except Exception as e:
sickrage.app.log.debug("Error searching dir for episodes: {}".format(e.message))
sickrage.app.log.debug(traceback.format_exc())
# if they set default ep status to WANTED then run the backlog to search for episodes
if self.show.default_ep_status == WANTED:
sickrage.app.log.info("Launching backlog for this show since its episodes are WANTED")
sickrage.app.backlog_searcher.searchBacklog([self.show])
self.show.writeMetadata()
self.show.updateMetadata()
self.show.populateCache()
if sickrage.app.config.use_trakt:
# if there are specific episodes that need to be added by trakt
sickrage.app.trakt_searcher.manageNewShow(self.show)
# add show to trakt.tv library
if sickrage.app.config.trakt_sync:
sickrage.app.trakt_searcher.addShowToTraktLibrary(self.show)
if sickrage.app.config.trakt_sync_watchlist:
sickrage.app.log.info("update watchlist")
sickrage.app.notifier_providers['trakt'].update_watchlist(show_obj=self.show)
# Load XEM data to DB for show
xem_refresh(self.show.indexerid, self.show.indexer, force=True)
# check if show has XEM mapping so we can determin if searches should go by scene numbering or indexer numbering.
if not self.scene and get_xem_numbering_for_show(self.show.indexerid, self.show.indexer):
self.show.scene = 1
self.show.default_ep_status = self.default_status_after
self.show.saveToDB()
sickrage.app.name_cache.build(self.show)
self.finish()
sickrage.app.log.info(
"Finished adding show {} in {}s from show dir: {}".format(self.show_name,
round(time.time() - self.startTime, 2),
self.showDir))
def edit_show(show, any_qualities, best_qualities, exceptions_list, location=None, flatten_folders=None, paused=None, direct_call=None, air_by_date=None,
sports=None, dvdorder=None, indexer_lang=None, subtitles=None, sub_use_sr_metadata=None, skip_downloaded=None, rls_ignore_words=None,
rls_require_words=None, anime=None, blacklist=None, whitelist=None, scene=None, default_ep_status=None, quality_preset=None, search_delay=None,
session=None):
show_obj = find_show(int(show), session=session)
if not show_obj:
err_msg = _("Unable to find the specified show: ") + str(show)
if direct_call:
sickrage.app.alerts.error(_('Error'), err_msg)
return False, err_msg
show_obj.exceptions = get_scene_exceptions(show_obj.indexer_id)
flatten_folders = not checkbox_to_value(flatten_folders) # UI inverts this value
dvdorder = checkbox_to_value(dvdorder)
skip_downloaded = checkbox_to_value(skip_downloaded)
paused = checkbox_to_value(paused)
air_by_date = checkbox_to_value(air_by_date)
scene = checkbox_to_value(scene)
sports = checkbox_to_value(sports)
anime = checkbox_to_value(anime)
subtitles = checkbox_to_value(subtitles)
sub_use_sr_metadata = checkbox_to_value(sub_use_sr_metadata)
if indexer_lang and indexer_lang in IndexerApi(show_obj.indexer).indexer().languages.keys():
indexer_lang = indexer_lang
else:
indexer_lang = show_obj.lang
# if we changed the language then kick off an update
if indexer_lang == show_obj.lang:
do_update = False
else:
do_update = True
if scene == show_obj.scene or anime == show_obj.anime:
do_update_scene_numbering = False
else:
do_update_scene_numbering = True
show_obj.paused = paused
show_obj.scene = scene
show_obj.anime = anime
show_obj.sports = sports
show_obj.subtitles = subtitles
show_obj.sub_use_sr_metadata = sub_use_sr_metadata
show_obj.air_by_date = air_by_date
show_obj.default_ep_status = int(default_ep_status)
show_obj.skip_downloaded = skip_downloaded
# If directCall from mass_edit_update no scene exceptions handling or blackandwhite list handling
if direct_call:
do_update_exceptions = False
else:
if set(exceptions_list) == set(show_obj.exceptions):
do_update_exceptions = False
else:
do_update_exceptions = True
if anime:
if whitelist:
shortwhitelist = short_group_names(whitelist)
show_obj.release_groups.set_white_keywords(shortwhitelist)
else:
show_obj.release_groups.set_white_keywords([])
if blacklist:
shortblacklist = short_group_names(blacklist)
show_obj.release_groups.set_black_keywords(shortblacklist)
else:
show_obj.release_groups.set_black_keywords([])
warnings, errors = [], []
new_quality = try_int(quality_preset, None)
if not new_quality:
new_quality = Quality.combine_qualities(list(map(int, any_qualities)), list(map(int, best_qualities)))
show_obj.quality = new_quality
# reversed for now
if bool(show_obj.flatten_folders) != bool(flatten_folders):
show_obj.flatten_folders = flatten_folders
try:
sickrage.app.show_queue.refresh_show(show_obj.indexer_id, True)
except CantRefreshShowException as e:
errors.append(_("Unable to refresh this show: {}").format(e))
if not direct_call:
show_obj.lang = indexer_lang
show_obj.dvdorder = dvdorder
show_obj.rls_ignore_words = rls_ignore_words.strip()
show_obj.rls_require_words = rls_require_words.strip()
show_obj.search_delay = int(search_delay)
# if we change location clear the db of episodes, change it, write to db, and rescan
if os.path.normpath(show_obj.location) != os.path.normpath(location):
sickrage.app.log.debug(os.path.normpath(show_obj.location) + " != " + os.path.normpath(location))
if not os.path.isdir(location) and not sickrage.app.config.create_missing_show_dirs:
warnings.append("New location {} does not exist".format(location))
# don't bother if we're going to update anyway
elif not do_update:
# change it
try:
show_obj.location = location
try:
sickrage.app.show_queue.refresh_show(show_obj.indexer_id, True)
except CantRefreshShowException as e:
errors.append(_("Unable to refresh this show:{}").format(e))
# grab updated info from TVDB
# showObj.loadEpisodesFromIndexer()
# rescan the episodes in the new folder
except NoNFOException:
warnings.append(
_("The folder at %s doesn't contain a tvshow.nfo - copy your files to that folder before "
"you change the directory in SiCKRAGE.") % location)
# force the update
if do_update:
try:
sickrage.app.show_queue.update_show(show_obj.indexer_id, force=True)
except CantUpdateShowException as e:
errors.append(_("Unable to update show: {}").format(e))
if do_update_exceptions:
try:
update_scene_exceptions(show_obj.indexer_id, exceptions_list)
except CantUpdateShowException:
warnings.append(_("Unable to force an update on scene exceptions of the show."))
if do_update_scene_numbering:
try:
xem_refresh(show_obj.indexer_id, show_obj.indexer, True)
except CantUpdateShowException:
warnings.append(_("Unable to force an update on scene numbering of the show."))
if direct_call:
return True if len(warnings) == 0 and len(errors) == 0 else False, json_encode({'warnings': warnings, 'errors': errors})
if len(warnings) > 0:
sickrage.app.alerts.message(
_('{num_warnings:d} warning{plural} while saving changes:').format(num_warnings=len(warnings),
plural="" if len(
warnings) == 1 else "s"),
'<ul>' + '\n'.join(['<li>{0}</li>'.format(warning) for warning in warnings]) + "</ul>")
if len(errors) > 0:
sickrage.app.alerts.error(
_('{num_errors:d} error{plural} while saving changes:').format(num_errors=len(errors),
plural="" if len(errors) == 1 else "s"),
'<ul>' + '\n'.join(['<li>{0}</li>'.format(error) for error in errors]) + "</ul>")
return True, ""
