def get_indexer_absolute_numbering_for_xem(indexer_id,
indexer,
sceneAbsoluteNumber,
scene_season=None):
"""
Reverse of find_xem_numbering: lookup a tvdb season and episode using scene numbering
:param indexer_id: int
:param sceneAbsoluteNumber: int
:return: int
"""
if indexer_id is None or sceneAbsoluteNumber is None:
return sceneAbsoluteNumber
indexer_id = int(indexer_id)
indexer = int(indexer)
xem_refresh(indexer_id, indexer)
if scene_season is None:
rows = main_db.MainDB().select(
"SELECT absolute_number FROM tv_episodes WHERE indexer = ? AND showid = ? AND scene_absolute_number = ?",
[indexer, indexer_id, sceneAbsoluteNumber])
else:
rows = main_db.MainDB().select(
"SELECT absolute_number FROM tv_episodes WHERE indexer = ? AND showid = ? AND scene_absolute_number = ? AND scene_season = ?",
[indexer, indexer_id, sceneAbsoluteNumber, scene_season])
if rows:
return int(rows[0][b"absolute_number"])
return sceneAbsoluteNumber
def setUp_test_db(force=False):
"""upgrades the db to the latest version
"""
global TESTDB_INITALIZED
if not TESTDB_INITALIZED or force:
# remove old db files
tearDown_test_db()
# upgrade main
main_db.MainDB().InitialSchema().upgrade()
# sanity check main
main_db.MainDB().SanityCheck()
# upgrade cache
cache_db.CacheDB().InitialSchema().upgrade()
# upgrade failed
failed_db.FailedDB().InitialSchema().upgrade()
# populate scene exceiptions table
# retrieve_exceptions(False, False)
TESTDB_INITALIZED = True
def get_indexer_absolute_numbering(indexer_id,
indexer,
sceneAbsoluteNumber,
fallback_to_xem=True,
scene_season=None):
"""
Returns a tuple, (season, episode, absolute_number) with the TVDB absolute numbering for (sceneAbsoluteNumber)
(this works like the reverse of get_absolute_numbering)
"""
if indexer_id is None or sceneAbsoluteNumber is None:
return sceneAbsoluteNumber
indexer_id = int(indexer_id)
indexer = int(indexer)
if scene_season is None:
rows = main_db.MainDB().select(
"SELECT absolute_number FROM scene_numbering WHERE indexer = ? AND indexer_id = ? AND scene_absolute_number = ?",
[indexer, indexer_id, sceneAbsoluteNumber])
else:
rows = main_db.MainDB().select(
"SELECT absolute_number FROM scene_numbering WHERE indexer = ? AND indexer_id = ? AND scene_absolute_number = ? AND scene_season = ?",
[indexer, indexer_id, sceneAbsoluteNumber, scene_season])
if rows:
return int(rows[0][b"absolute_number"])
else:
if fallback_to_xem:
return get_indexer_absolute_numbering_for_xem(
indexer_id, indexer, sceneAbsoluteNumber, scene_season)
return sceneAbsoluteNumber
def already_postprocessed(dirName, videofile, force, result):
"""
Check if we already post processed a file
:param dirName: Directory a file resides in
:param videofile: File name
:param force: Force checking when already checking (currently unused)
:param result: True if file is already postprocessed, False if not
:return:
"""
if force:
return False
# Avoid processing the same dir again if we use a process method <> move
if main_db.MainDB().select(
"SELECT * FROM tv_episodes WHERE release_name = ?", [dirName]):
# result.output += logHelper(u"You're trying to post process a dir that's already been processed, skipping", LOGGER.DEBUG)
return True
else:
if main_db.MainDB().select(
"SELECT * FROM tv_episodes WHERE release_name = ?",
[videofile.rpartition('.')[0]]):
# result.output += logHelper(u"You're trying to post process a video that's already been processed, skipping", LOGGER.DEBUG)
return True
# Needed if we have downloaded the same episode @ different quality
# But we need to make sure we check the history of the episode we're going to PP, and not others
np = NameParser(dirName, tryIndexers=True)
try:
parse_result = np.parse(dirName)
except:
parse_result = False
search_sql = "SELECT tv_episodes.indexerid, history.resource FROM tv_episodes INNER JOIN history ON history.showid=tv_episodes.showid" # This part is always the same
search_sql += " WHERE history.season=tv_episodes.season and history.episode=tv_episodes.episode"
# If we find a showid, a season number, and one or more episode numbers then we need to use those in the query
if parse_result and (parse_result.show.indexerid
and parse_result.episode_numbers
and parse_result.season_number):
search_sql += " and tv_episodes.showid = '" + str(
parse_result.show.indexerid
) + "' and tv_episodes.season = '" + str(
parse_result.season_number
) + "' and tv_episodes.episode = '" + str(
parse_result.episode_numbers[0]) + "'"
search_sql += " and tv_episodes.status IN (" + ",".join(
[str(x) for x in Quality.DOWNLOADED]) + ")"
search_sql += " and history.resource LIKE ?"
if main_db.MainDB().select(search_sql, ['%' + videofile]):
# result.output += logHelper(u"You're trying to post process a video that's already been processed, skipping", LOGGER.DEBUG)
return True
return False
def get(self, limit=100, action=None):
"""
:param limit: The maximum number of elements to return
:param action: The type of action to filter in the history. Either 'downloaded' or 'snatched'. Anything else or
no value will return everything (up to ``limit``)
:return: The last ``limit`` elements of type ``action`` in the history
"""
action = action.lower() if isinstance(action, str) else ''
limit = int(limit)
if action == 'downloaded':
actions = Quality.DOWNLOADED
elif action == 'snatched':
actions = Quality.SNATCHED
else:
actions = []
common_sql = 'SELECT action, date, episode, provider, h.quality, resource, season, show_name, showid ' \
'FROM history h, tv_shows s ' \
'WHERE h.showid = s.indexer_id '
filter_sql = 'AND action in (' + ','.join(['?'] * len(actions)) + ') '
order_sql = 'ORDER BY date DESC '
if limit == 0:
if len(actions) > 0:
results = main_db.MainDB().select(
common_sql + filter_sql + order_sql, actions)
else:
results = main_db.MainDB().select(common_sql + order_sql)
else:
if len(actions) > 0:
results = main_db.MainDB().select(
common_sql + filter_sql + order_sql + 'LIMIT ?',
actions + [limit])
else:
results = main_db.MainDB().select(
common_sql + order_sql + 'LIMIT ?', [limit])
data = []
for result in results:
data.append({
'action': result[b'action'],
'date': result[b'date'],
'episode': result[b'episode'],
'provider': result[b'provider'],
'quality': result[b'quality'],
'resource': result[b'resource'],
'season': result[b'season'],
'show_id': result[b'showid'],
'show_name': result[b'show_name']
})
return data
def _set_lastBacklog(self, when):
sickrage.srLogger.debug("Setting the last backlog in the DB to " +
str(when))
sqlResults = main_db.MainDB().select("SELECT * FROM info")
if len(sqlResults) == 0:
main_db.MainDB().action(
"INSERT INTO info (last_backlog, last_indexer) VALUES (?,?)",
[str(when), 0])
else:
main_db.MainDB().action("UPDATE info SET last_backlog=" +
str(when))
def get_xem_absolute_numbering_for_show(indexer_id, indexer):
"""
Returns a dict of (season, episode) : (sceneSeason, sceneEpisode) mappings
for an entire show. Both the keys and values of the dict are tuples.
Will be empty if there are no scene numbers set in xem
"""
if indexer_id is None:
return {}
indexer_id = int(indexer_id)
indexer = int(indexer)
xem_refresh(indexer_id, indexer)
result = {}
rows = main_db.MainDB().select(
'SELECT absolute_number, scene_absolute_number FROM tv_episodes WHERE indexer = ? AND showid = ? AND scene_absolute_number != 0 ORDER BY absolute_number',
[indexer, indexer_id])
for row in rows:
absolute_number = int(row[b'absolute_number'])
scene_absolute_number = int(row[b'scene_absolute_number'])
result[absolute_number] = scene_absolute_number
return result
def _del_all_keywords(self, table):
"""
DB: Remove all keywords for current show
:param table: SQL table remove keywords from
"""
main_db.MainDB().action('DELETE FROM [' + table + '] WHERE show_id = ?', [self.show_id])
def addEpisodeToTraktWatchList(self):
if sickrage.srConfig.TRAKT_SYNC_WATCHLIST and sickrage.srConfig.USE_TRAKT:
sickrage.srLogger.debug("WATCHLIST::ADD::START - Look for Episodes to Add to Trakt Watchlist")
sql_selection = 'SELECT tv_shows.indexer, tv_shows.startyear, showid, show_name, season, episode FROM tv_episodes,tv_shows WHERE tv_shows.indexer_id = tv_episodes.showid AND tv_episodes.status IN (' + ','.join(
[str(x) for x in Quality.SNATCHED + Quality.SNATCHED_PROPER + [WANTED]]) + ')'
episodes = main_db.MainDB().select(sql_selection)
if episodes is not None:
trakt_data = []
for cur_episode in episodes:
trakt_id = sickrage.srCore.INDEXER_API(cur_episode[b"indexer"]).config[b'trakt_id']
if not self._checkInList(trakt_id, str(cur_episode[b"showid"]), str(cur_episode[b"season"]),
str(cur_episode[b"episode"])):
sickrage.srLogger.debug("Adding Episode %s S%02dE%02d to watchlist" %
(cur_episode[b"show_name"], cur_episode[b"season"], cur_episode[b"episode"]))
trakt_data.append((cur_episode[b"showid"], cur_episode[b"indexer"], cur_episode[b"show_name"],
cur_episode[b"startyear"], cur_episode[b"season"],
cur_episode[b"episode"]))
if len(trakt_data):
try:
data = self.trakt_bulk_data_generate(trakt_data)
self.trakt_api.traktRequest("sync/watchlist", data, method='POST')
self._getEpisodeWatchlist()
except traktException as e:
sickrage.srLogger.warning("Could not connect to Trakt service. Error %s" % e)
sickrage.srLogger.debug("WATCHLIST::ADD::FINISH - Look for Episodes to Add to Trakt Watchlist")
def removeEpisodeFromTraktCollection(self):
if sickrage.srConfig.TRAKT_SYNC_REMOVE and sickrage.srConfig.TRAKT_SYNC and sickrage.srConfig.USE_TRAKT:
sickrage.srLogger.debug("COLLECTION::REMOVE::START - Look for Episodes to Remove From Trakt Collection")
sql_selection = 'SELECT tv_shows.indexer, tv_shows.startyear, showid, show_name, season, episode, tv_episodes.status, tv_episodes.location FROM tv_episodes,tv_shows WHERE tv_shows.indexer_id = tv_episodes.showid'
episodes = main_db.MainDB().select(sql_selection)
if episodes is not None:
trakt_data = []
for cur_episode in episodes:
trakt_id = sickrage.srCore.INDEXER_API(cur_episode[b"indexer"]).config[b'trakt_id']
if self._checkInList(trakt_id, str(cur_episode[b"showid"]), str(cur_episode[b"season"]),
str(cur_episode[b"episode"]), List='Collection'):
if cur_episode[b"location"] == '':
sickrage.srLogger.debug("Removing Episode %s S%02dE%02d from collection" %
(cur_episode[b"show_name"], cur_episode[b"season"], cur_episode[b"episode"]))
trakt_data.append(
(cur_episode[b"showid"], cur_episode[b"indexer"], cur_episode[b"show_name"],
cur_episode[b"startyear"], cur_episode[b"season"], cur_episode[b"episode"]))
if len(trakt_data):
try:
data = self.trakt_bulk_data_generate(trakt_data)
self.trakt_api.traktRequest("sync/collection/remove", data, method='POST')
self._getShowCollection()
except traktException as e:
sickrage.srLogger.warning("Could not connect to Trakt service. Error: %s" % e)
sickrage.srLogger.debug("COLLECTION::REMOVE::FINISH - Look for Episodes to Remove From Trakt Collection")
def _logHistoryItem(action,
showid,
season,
episode,
quality,
resource,
provider,
version=-1):
"""
Insert a history item in DB
:param action: action taken (snatch, download, etc)
:param showid: showid this entry is about
:param season: show season
:param episode: show episode
:param quality: media quality
:param resource: resource used
:param provider: provider used
:param version: tracked version of file (defaults to -1)
"""
logDate = datetime.today().strftime(History.date_format)
resource = resource
main_db.MainDB().action(
"INSERT INTO history (action, date, showid, season, episode, quality, resource, provider, version) VALUES (?,?,?,?,?,?,?,?,?)",
[
action, logDate, showid, season, episode, quality, resource,
provider, version
])
def get_xem_numbering_for_show(indexer_id, indexer):
"""
Returns a dict of (season, episode) : (sceneSeason, sceneEpisode) mappings
for an entire show. Both the keys and values of the dict are tuples.
Will be empty if there are no scene numbers set in xem
"""
if indexer_id is None:
return {}
indexer_id = int(indexer_id)
indexer = int(indexer)
xem_refresh(indexer_id, indexer)
rows = main_db.MainDB().select(
'SELECT season, episode, scene_season, scene_episode FROM tv_episodes WHERE indexer = ? AND showid = ? AND (scene_season OR scene_episode) != 0 ORDER BY season, episode',
[indexer, indexer_id])
result = {}
for row in rows:
season = int(row[b'season'])
episode = int(row[b'episode'])
scene_season = int(row[b'scene_season'])
scene_episode = int(row[b'scene_episode'])
result[(season, episode)] = (scene_season, scene_episode)
return result
def get_indexer_numbering_for_xem(indexer_id, indexer, sceneSeason,
sceneEpisode):
"""
Reverse of find_xem_numbering: lookup a tvdb season and episode using scene numbering
:param indexer_id: int
:param sceneSeason: int
:param sceneEpisode: int
:return: (int, int) a tuple of (season, episode)
"""
if indexer_id is None or sceneSeason is None or sceneEpisode is None:
return sceneSeason, sceneEpisode
indexer_id = int(indexer_id)
indexer = int(indexer)
xem_refresh(indexer_id, indexer)
rows = main_db.MainDB().select(
"SELECT season, episode FROM tv_episodes WHERE indexer = ? AND showid = ? AND scene_season = ? AND scene_episode = ?",
[indexer, indexer_id, sceneSeason, sceneEpisode])
if rows:
return int(rows[0][b"season"]), int(rows[0][b"episode"])
return sceneSeason, sceneEpisode
def get_absolute_number_from_season_and_episode(show, season, episode):
"""
Find the absolute number for a show episode
:param show: Show object
:param season: Season number
:param episode: Episode number
:return: The absolute number
"""
absolute_number = None
if season and episode:
sql = "SELECT * FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?"
sqlResults = main_db.MainDB().select(sql,
[show.indexerid, season, episode])
if len(sqlResults) == 1:
absolute_number = int(sqlResults[0][b"absolute_number"])
sickrage.srLogger.debug(
"Found absolute number %s for show %s S%02dE%02d" %
(absolute_number, show.name, season, episode))
else:
sickrage.srLogger.debug(
"No entries for absolute number for show %s S%02dE%02d" %
(show.name, season, episode))
return absolute_number
def get_indexer_numbering(indexer_id,
indexer,
sceneSeason,
sceneEpisode,
fallback_to_xem=True):
"""
Returns a tuple, (season, episode) with the TVDB numbering for (sceneSeason, sceneEpisode)
(this works like the reverse of get_scene_numbering)
"""
if indexer_id is None or sceneSeason is None or sceneEpisode is None:
return sceneSeason, sceneEpisode
indexer_id = int(indexer_id)
indexer = int(indexer)
rows = main_db.MainDB().select(
"SELECT season, episode FROM scene_numbering WHERE indexer = ? AND indexer_id = ? AND scene_season = ? AND scene_episode = ?",
[indexer, indexer_id, sceneSeason, sceneEpisode])
if rows:
return int(rows[0][b"season"]), int(rows[0][b"episode"])
else:
if fallback_to_xem:
return get_indexer_numbering_for_xem(indexer_id, indexer,
sceneSeason, sceneEpisode)
return sceneSeason, sceneEpisode
def searchDBForShow(regShowName, log=False):
"""
Searches if show names are present in the DB
:param regShowName: list of show names to look for
:param log: Boolean, log debug results of search (defaults to False)
:return: Indexer ID of found show
"""
showNames = [re.sub('[. -]', ' ', regShowName)]
yearRegex = r"([^()]+?)\s*(\()?(\d{4})(?(2)\))$"
for showName in showNames:
sqlResults = main_db.MainDB().select(
"SELECT * FROM tv_shows WHERE show_name LIKE ?", [showName])
if len(sqlResults) == 1:
return int(sqlResults[0][b"indexer_id"])
else:
# if we didn't get exactly one result then try again with the year stripped off if possible
match = re.match(yearRegex, showName)
if match and match.group(1):
if log:
sickrage.srLogger.debug(
"Unable to match original name but trying to manually strip and specify show year"
)
sqlResults = main_db.MainDB().select(
"SELECT * FROM tv_shows WHERE (show_name LIKE ?) AND startyear = ?",
[match.group(1) + '%',
match.group(3)])
if len(sqlResults) == 0:
if log:
sickrage.srLogger.debug(
"Unable to match a record in the DB for " + showName)
continue
elif len(sqlResults) > 1:
if log:
sickrage.srLogger.debug(
"Multiple results for " + showName +
" in the DB, unable to match show name")
continue
else:
return int(sqlResults[0][b"indexer_id"])
def _set_lastProperSearch(self, when):
"""
Record last propersearch in DB
:param when: When was the last proper search
"""
sickrage.srLogger.debug(
"Setting the last Proper search in the DB to " + str(when))
sqlResults = main_db.MainDB().select("SELECT * FROM info")
if len(sqlResults) == 0:
main_db.MainDB().action(
"INSERT INTO info (last_backlog, last_indexer, last_proper_search) VALUES (?,?,?)",
[0, 0, str(when)])
else:
main_db.MainDB().action("UPDATE info SET last_proper_search=" +
str(when))
def _add_keywords(self, table, values):
"""
DB: Adds keywords into database for current show
:param table: SQL table to add keywords to
:param values: Values to be inserted in table
"""
for value in values:
main_db.MainDB().action('INSERT INTO [' + table + '] (show_id, keyword) VALUES (?,?)',
[self.show_id, value])
def trim(self):
"""
Remove all elements older than 30 days from the history
"""
main_db.MainDB().action(
'DELETE '
'FROM history '
'WHERE date < ?',
[(datetime.today() - timedelta(days=30)).strftime(
History.date_format)])
def set_scene_numbering(indexer_id,
indexer,
season=None,
episode=None,
absolute_number=None,
sceneSeason=None,
sceneEpisode=None,
sceneAbsolute=None):
"""
Set scene numbering for a season/episode.
To clear the scene numbering, leave both sceneSeason and sceneEpisode as None.
"""
if indexer_id is None:
return
indexer_id = int(indexer_id)
indexer = int(indexer)
if season and episode:
main_db.MainDB().action(
"INSERT OR IGNORE INTO scene_numbering (indexer, indexer_id, season, episode) VALUES (?,?,?,?)",
[indexer, indexer_id, season, episode])
main_db.MainDB().action(
"UPDATE scene_numbering SET scene_season = ?, scene_episode = ? WHERE indexer = ? AND indexer_id = ? AND season = ? AND episode = ?",
[sceneSeason, sceneEpisode, indexer, indexer_id, season, episode])
elif absolute_number:
main_db.MainDB().action(
"INSERT OR IGNORE INTO scene_numbering (indexer, indexer_id, absolute_number) VALUES (?,?,?)",
[indexer, indexer_id, absolute_number])
main_db.MainDB().action(
"UPDATE scene_numbering SET scene_absolute_number = ? WHERE indexer = ? AND indexer_id = ? AND absolute_number = ?",
[sceneAbsolute, indexer, indexer_id, absolute_number])
# Reload data from DB so that cache and db are in sync
show = findCertainShow(sickrage.srCore.SHOWLIST, indexer_id)
show.flushEpisodes()
def _get_lastProperSearch():
"""
Find last propersearch from DB
"""
sqlResults = main_db.MainDB().select("SELECT * FROM info")
try:
last_proper_search = date.fromordinal(
int(sqlResults[0][b"last_proper_search"]))
except:
return date.fromordinal(1)
return last_proper_search
def makeSceneSearchString(show, ep_obj):
numseasons = 0
numseasonsSQlResult = main_db.MainDB().select(
"SELECT COUNT(DISTINCT season) as numseasons FROM tv_episodes WHERE showid = ? and season != 0",
[show.indexerid])
if numseasonsSQlResult:
numseasons = int(numseasonsSQlResult[0][0])
# see if we should use dates instead of episodes
if (show.air_by_date
or show.sports) and ep_obj.airdate != date.fromordinal(1):
epStrings = [str(ep_obj.airdate)]
elif show.is_anime:
epStrings = [
"%02i" %
int(ep_obj.scene_absolute_number
if ep_obj.scene_absolute_number > 0 else ep_obj.scene_episode)
]
else:
epStrings = [
"S%02iE%02i" %
(int(ep_obj.scene_season), int(ep_obj.scene_episode)),
"%ix%02i" % (int(ep_obj.scene_season), int(ep_obj.scene_episode))
]
# for single-season shows just search for the show name -- if total ep count (exclude s0) is less than 11
# due to the amount of qualities and releases, it is easy to go over the 50 result limit on rss feeds otherwise
if numseasons == 1 and not ep_obj.show.is_anime:
epStrings = ['']
showNames = set(makeSceneShowSearchStrings(show, ep_obj.scene_season))
toReturn = []
for curShow in showNames:
for curEpString in epStrings:
if ep_obj.show.is_anime:
if ep_obj.show.release_groups is not None:
if len(ep_obj.show.release_groups.whitelist) > 0:
for keyword in ep_obj.show.release_groups.whitelist:
toReturn.append(keyword + '.' + curShow + '.' +
curEpString)
elif len(ep_obj.show.release_groups.blacklist) == 0:
# If we have neither whitelist or blacklist we just append what we have
toReturn.append(curShow + '.' + curEpString)
else:
toReturn.append(curShow + '.' + curEpString)
return toReturn
def loadFromDB(self):
"""
Populates the showList with shows from the database
"""
sqlResults = main_db.MainDB().select("SELECT * FROM tv_shows")
for sqlShow in sqlResults:
try:
curShow = TVShow(int(sqlShow[b"indexer"]),
int(sqlShow[b"indexer_id"]))
curShow.saveToDB()
curShow.loadFromDB(skipNFO=True)
sickrage.srCore.SHOWLIST.append(curShow)
except Exception as e:
print "There was an error creating the show"
def find_scene_absolute_numbering(indexer_id, indexer, absolute_number):
"""
Same as get_scene_numbering(), but returns None if scene numbering is not set
"""
if indexer_id is None or absolute_number is None:
return absolute_number
indexer_id = int(indexer_id)
indexer = int(indexer)
rows = main_db.MainDB().select(
"SELECT scene_absolute_number FROM scene_numbering WHERE indexer = ? AND indexer_id = ? AND absolute_number = ? AND scene_absolute_number != 0",
[indexer, indexer_id, absolute_number])
if rows:
return int(rows[0][b"scene_absolute_number"])
def find_scene_numbering(indexer_id, indexer, season, episode):
"""
Same as get_scene_numbering(), but returns None if scene numbering is not set
"""
if indexer_id is None or season is None or episode is None:
return season, episode
indexer_id = int(indexer_id)
indexer = int(indexer)
rows = main_db.MainDB().select(
"SELECT scene_season, scene_episode FROM scene_numbering WHERE indexer = ? AND indexer_id = ? AND season = ? AND episode = ? AND (scene_season OR scene_episode) != 0",
[indexer, indexer_id, season, episode])
if rows:
return int(rows[0][b"scene_season"]), int(rows[0][b"scene_episode"])
def _get_segments(self, show, fromDate):
if show.paused:
sickrage.srLogger.debug(
"Skipping backlog for {show_name} because the show is paused".
format(show_name=show.name))
return {}
anyQualities, bestQualities = Quality.splitQuality(
show.quality) # @UnusedVariable
sickrage.srLogger.debug(
"Seeing if we need anything from {show_name}".format(
show_name=show.name))
sqlResults = main_db.MainDB().select(
"SELECT status, season, episode FROM tv_episodes WHERE season > 0 AND airdate > ? AND showid = ?",
[fromDate.toordinal(), show.indexerid])
# check through the list of statuses to see if we want any
wanted = {}
for result in sqlResults:
curCompositeStatus = int(result[b"status"] or -1)
curStatus, curQuality = Quality.splitCompositeStatus(
curCompositeStatus)
if bestQualities:
highestBestQuality = max(bestQualities)
lowestBestQuality = min(bestQualities)
else:
highestBestQuality = 0
lowestBestQuality = 0
# if we need a better one then say yes
if (curStatus in (DOWNLOADED, SNATCHED, SNATCHED_PROPER) and
curQuality < highestBestQuality) or curStatus == WANTED:
epObj = show.getEpisode(int(result[b"season"]),
int(result[b"episode"]))
# only fetch if not archive on first match, or if show is lowest than the lower expected quality
if (epObj.show.archive_firstmatch == 0
or curQuality < lowestBestQuality):
if epObj.season not in wanted:
wanted[epObj.season] = [epObj]
else:
wanted[epObj.season].append(epObj)
return wanted
def load_shows(self):
"""
Populates the showlist with shows from the database
"""
for sqlShow in main_db.MainDB().select("SELECT * FROM tv_shows"):
try:
curshow = TVShow(int(sqlShow[b"indexer"]), int(sqlShow[b"indexer_id"]))
sickrage.srLogger.debug("Loading data for show: [{}]".format(curshow.name))
self.NAMECACHE.buildNameCache(curshow)
curshow.nextEpisode()
self.SHOWLIST += [curshow]
except Exception as e:
sickrage.srLogger.error(
"There was an error creating the show in {}: {}".format(sqlShow[b"location"], e.message))
sickrage.srLogger.debug(traceback.format_exc())
continue
def _get_lastBacklog(self):
sickrage.srLogger.debug("Retrieving the last check time from the DB")
sqlResults = main_db.MainDB().select("SELECT * FROM info")
if len(sqlResults) == 0:
lastBacklog = 1
elif sqlResults[0][b"last_backlog"] is None or sqlResults[0][
b"last_backlog"] == "":
lastBacklog = 1
else:
lastBacklog = int(sqlResults[0][b"last_backlog"])
if lastBacklog > date.today().toordinal():
lastBacklog = 1
self._lastBacklog = lastBacklog
return self._lastBacklog
def _load_list(self, table):
"""
DB: Fetch keywords for current show
:param table: Table to fetch list of keywords from
:return: keywords in list
"""
sqlResults = main_db.MainDB().select('SELECT keyword FROM [' + table + '] WHERE show_id = ?', [self.show_id])
if not sqlResults or not len(sqlResults):
return []
groups = []
for result in sqlResults:
groups.append(result[b"keyword"])
sickrage.srLogger.debug('BWL: ' + str(self.show_id) + ' loaded keywords from ' + table + ': ' + str(groups))
return groups
def _is_season_pack(name):
try:
myParser = NameParser(tryIndexers=True)
parse_result = myParser.parse(name)
except InvalidNameException:
sickrage.srLogger.debug(
"Unable to parse the filename %s into a valid episode" % name)
return False
except InvalidShowException:
sickrage.srLogger.debug(
"Unable to parse the filename %s into a valid show" % name)
return False
sql_selection = "SELECT count(*) AS count FROM tv_episodes WHERE showid = ? AND season = ?"
episodes = main_db.MainDB().select(
sql_selection,
[parse_result.show.indexerid, parse_result.season_number])
if int(episodes[0][b'count']) == len(parse_result.episode_numbers):
return True
