curProper.indexerid = parse_result.show.indexerid
# set the indexer in the db to the show's indexer
curProper.indexer = parse_result.show.indexer
# populate our Proper instance
curProper.show = parse_result.show
curProper.season = parse_result.season_number if parse_result.season_number is not None else 1
curProper.episode = parse_result.episode_numbers[0]
curProper.release_group = parse_result.release_group
curProper.version = parse_result.version
curProper.quality = Quality.nameQuality(curProper.name, parse_result.is_anime)
curProper.content = None
# filter release
bestResult = pickBestResult(curProper, parse_result.show)
if not bestResult:
logger.log(u"Proper " + curProper.name + " were rejected by our release filters.", logger.DEBUG)
continue
# only get anime proper if it has release group and version
if bestResult.show.is_anime:
if not bestResult.release_group and bestResult.version == -1:
logger.log(u"Proper " + bestResult.name + " doesn't have a release group and version, ignoring it",
logger.DEBUG)
continue
# check if we actually want this proper (if it's the right quality)
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?",
[bestResult.indexerid, bestResult.season, bestResult.episode])
def _getProperList(self): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""
Walk providers for propers
"""
propers = {}
search_date = datetime.datetime.today() - datetime.timedelta(days=2)
# for each provider get a list of the
origThreadName = threading.currentThread().name
providers = [x for x in sickbeard.providers.sortedProviderList(sickbeard.RANDOMIZE_PROVIDERS) if x.is_active()]
for curProvider in providers:
threading.currentThread().name = origThreadName + " :: [" + curProvider.name + "]"
logger.log(u"Searching for any new PROPER releases from " + curProvider.name)
try:
curPropers = curProvider.find_propers(search_date)
except AuthException as e:
logger.log(u"Authentication error: " + ex(e), logger.DEBUG)
continue
except Exception as e:
logger.log(u"Exception while searching propers in " + curProvider.name + ", skipping: " + ex(e), logger.ERROR)
logger.log(traceback.format_exc(), logger.DEBUG)
continue
# if they haven't been added by a different provider than add the proper to the list
for x in curPropers:
if not re.search(r'\b(proper|repack|real)\b', x.name, re.I):
logger.log(u'find_propers returned a non-proper, we have caught and skipped it.', logger.DEBUG)
continue
name = self._genericName(x.name)
if name not in propers:
logger.log(u"Found new proper: " + x.name, logger.DEBUG)
x.provider = curProvider
propers[name] = x
threading.currentThread().name = origThreadName
# take the list of unique propers and get it sorted by
sortedPropers = sorted(propers.values(), key=operator.attrgetter('date'), reverse=True)
finalPropers = []
for curProper in sortedPropers:
try:
parse_result = NameParser(False).parse(curProper.name)
except (InvalidNameException, InvalidShowException) as error:
logger.log(u"{0}".format(error), logger.DEBUG)
continue
if not parse_result.series_name:
continue
if not parse_result.episode_numbers:
logger.log(
u"Ignoring " + curProper.name + " because it's for a full season rather than specific episode",
logger.DEBUG)
continue
logger.log(
u"Successful match! Result " + parse_result.original_name + " matched to show " + parse_result.show.name,
logger.DEBUG)
# set the indexerid in the db to the show's indexerid
curProper.indexerid = parse_result.show.indexerid
# set the indexer in the db to the show's indexer
curProper.indexer = parse_result.show.indexer
# populate our Proper instance
curProper.show = parse_result.show
curProper.season = parse_result.season_number if parse_result.season_number is not None else 1
curProper.episode = parse_result.episode_numbers[0]
curProper.release_group = parse_result.release_group
curProper.version = parse_result.version
curProper.quality = Quality.nameQuality(curProper.name, parse_result.is_anime)
curProper.content = None
# filter release
bestResult = pickBestResult(curProper, parse_result.show)
if not bestResult:
logger.log(u"Proper " + curProper.name + " were rejected by our release filters.", logger.DEBUG)
continue
# only get anime proper if it has release group and version
if bestResult.show.is_anime:
if not bestResult.release_group and bestResult.version == -1:
logger.log(u"Proper " + bestResult.name + " doesn't have a release group and version, ignoring it",
logger.DEBUG)
continue
# check if we actually want this proper (if it's the right quality)
main_db_con = db.DBConnection()
sql_results = main_db_con.select("SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?",
[bestResult.indexerid, bestResult.season, bestResult.episode])
if not sql_results:
continue
# only keep the proper if we have already retrieved the same quality ep (don't get better/worse ones)
oldStatus, oldQuality = Quality.splitCompositeStatus(int(sql_results[0]["status"]))
if oldStatus not in (DOWNLOADED, SNATCHED) or oldQuality != bestResult.quality:
continue
# check if we actually want this proper (if it's the right release group and a higher version)
if bestResult.show.is_anime:
main_db_con = db.DBConnection()
sql_results = main_db_con.select(
"SELECT release_group, version FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?",
[bestResult.indexerid, bestResult.season, bestResult.episode])
oldVersion = int(sql_results[0]["version"])
oldRelease_group = (sql_results[0]["release_group"])
if -1 < oldVersion < bestResult.version:
logger.log(u"Found new anime v" + str(bestResult.version) + " to replace existing v" + str(oldVersion))
else:
continue
if oldRelease_group != bestResult.release_group:
logger.log(u"Skipping proper from release group: " + bestResult.release_group + ", does not match existing release group: " + oldRelease_group)
continue
# if the show is in our list and there hasn't been a proper already added for that particular episode then add it to our list of propers
if bestResult.indexerid != -1 and (bestResult.indexerid, bestResult.season, bestResult.episode) not in {(p.indexerid, p.season, p.episode) for p in finalPropers}:
logger.log(u"Found a proper that we need: " + str(bestResult.name))
finalPropers.append(bestResult)
return finalPropers
def _get_proper_results(self): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""
Retrieve a list of recently aired episodes, and search for these episodes in the different providers.
"""
propers = {}
# for each provider get a list of the
original_thread_name = threading.currentThread().name
providers = enabled_providers('backlog')
# Get the recently aired (last 2 days) shows from db
search_date = datetime.datetime.today() - datetime.timedelta(days=2)
main_db_con = db.DBConnection()
search_qualities = list(set(Quality.DOWNLOADED + Quality.SNATCHED + Quality.SNATCHED_BEST))
search_q_params = ','.join('?' for _ in search_qualities)
recently_aired = main_db_con.select(
b'SELECT s.show_name, e.showid, e.season, e.episode, e.status, e.airdate'
b' FROM tv_episodes AS e'
b' INNER JOIN tv_shows AS s ON (e.showid = s.indexer_id)'
b' WHERE e.airdate >= ?'
b' AND e.status IN ({0})'.format(search_q_params),
[search_date.toordinal()] + search_qualities
)
if not recently_aired:
logger.log('No recently aired new episodes, nothing to search for')
return []
# Loop through the providers, and search for releases
for cur_provider in providers:
threading.currentThread().name = '{thread} :: [{provider}]'.format(thread=original_thread_name, provider=cur_provider.name)
logger.log('Searching for any new PROPER releases from {provider}'.format
(provider=cur_provider.name))
try:
cur_propers = cur_provider.find_propers(recently_aired)
except AuthException as e:
logger.log('Authentication error: {error}'.format
(error=ex(e)), logger.DEBUG)
continue
except (SocketTimeout) as e:
logger.log('Socket time out while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except (requests_exceptions.HTTPError, requests_exceptions.TooManyRedirects) as e:
logger.log('HTTP error while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.ConnectionError as e:
logger.log('Connection error while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.Timeout as e:
logger.log('Connection timed out while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.ContentDecodingError as e:
logger.log('Content-Encoding was gzip, but content was not compressed while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except Exception as e:
if 'ECONNRESET' in e or (hasattr(e, 'errno') and e.errno == errno.ECONNRESET):
logger.log('Connection reset by peer while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
else:
logger.log('Unknown exception while searching for propers in {provider}, skipping: {error}'.format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
logger.log(traceback.format_exc(), logger.DEBUG)
continue
# if they haven't been added by a different provider than add the proper to the list
for proper in cur_propers:
name = self._genericName(proper.name, remove=False)
if name not in propers:
logger.log('Found new possible proper result: {name}'.format
(name=proper.name), logger.DEBUG)
proper.provider = cur_provider
propers[name] = proper
threading.currentThread().name = original_thread_name
# take the list of unique propers and get it sorted by
sorted_propers = sorted(propers.values(), key=operator.attrgetter('date'), reverse=True)
final_propers = []
# Keep only last 100 items of processed propers:
self.processed_propers = self.processed_propers[-100:]
for cur_proper in sorted_propers:
if cur_proper.name in self.processed_propers:
logger.log(u'Proper already processed. Skipping: {0}'.format(cur_proper.name), logger.DEBUG)
continue
try:
parse_result = NameParser(False).parse(cur_proper.name)
except (InvalidNameException, InvalidShowException) as error:
logger.log('{0}'.format(error), logger.DEBUG)
continue
if not parse_result.proper_tags:
logger.log('Skipping non-proper: {name}'.format(name=cur_proper.name))
continue
logger.log('Proper tags for {proper}: {tags}'.format
(proper=cur_proper.name, tags=parse_result.proper_tags), logger.DEBUG)
if not parse_result.series_name:
logger.log('Ignoring invalid show: {name}'.format
(name=cur_proper.name), logger.DEBUG)
self.processed_propers.append(cur_proper.name)
continue
if not parse_result.episode_numbers:
logger.log('Ignoring full season instead of episode: {name}'.format
(name=cur_proper.name), logger.DEBUG)
self.processed_propers.append(cur_proper.name)
continue
logger.log('Successful match! Matched {original_name} to show {new_name}'.format
(original_name=parse_result.original_name, new_name=parse_result.show.name), logger.DEBUG)
# set the indexerid in the db to the show's indexerid
cur_proper.indexerid = parse_result.show.indexerid
# set the indexer in the db to the show's indexer
cur_proper.indexer = parse_result.show.indexer
# populate our Proper instance
cur_proper.show = parse_result.show
cur_proper.season = parse_result.season_number if parse_result.season_number is not None else 1
cur_proper.episode = parse_result.episode_numbers[0]
cur_proper.release_group = parse_result.release_group
cur_proper.version = parse_result.version
cur_proper.quality = Quality.nameQuality(cur_proper.name, parse_result.is_anime)
cur_proper.content = None
cur_proper.proper_tags = parse_result.proper_tags
# filter release
best_result = pickBestResult(cur_proper, parse_result.show)
if not best_result:
logger.log('Rejected proper due to release filters: {name}'.format
(name=cur_proper.name))
self.processed_propers.append(cur_proper.name)
continue
# only get anime proper if it has release group and version
if best_result.show.is_anime:
if not best_result.release_group and best_result.version == -1:
logger.log('Ignoring proper without release group and version: {name}'.format
(name=best_result.name))
self.processed_propers.append(cur_proper.name)
continue
# check if we actually want this proper (if it's the right quality)
main_db_con = db.DBConnection()
sql_results = main_db_con.select(b'SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?',
[best_result.indexerid, best_result.season, best_result.episode])
if not sql_results:
logger.log('Ignoring proper with incorrect quality: {name}'.format
(name=best_result.name))
self.processed_propers.append(cur_proper.name)
continue
# only keep the proper if we have already retrieved the same quality ep (don't get better/worse ones)
old_status, old_quality = Quality.splitCompositeStatus(int(sql_results[0][b'status']))
if old_status not in (DOWNLOADED, SNATCHED) or old_quality != best_result.quality:
logger.log('Ignoring proper because quality is different or episode is already archived: {name}'.format
(name=best_result.name))
self.processed_propers.append(cur_proper.name)
continue
# check if we actually want this proper (if it's the right release group and a higher version)
if best_result.show.is_anime:
main_db_con = db.DBConnection()
sql_results = main_db_con.select(
b'SELECT release_group, version FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?',
[best_result.indexerid, best_result.season, best_result.episode])
old_version = int(sql_results[0][b'version'])
old_release_group = (sql_results[0][b'release_group'])
if -1 < old_version < best_result.version:
logger.log('Found new anime version {new} to replace existing version {old}: {name}'.format
(old=old_version, new=best_result.version, name=best_result.name))
else:
logger.log('Ignoring proper with the same or lower version: {name}'.format
(name=best_result.name))
self.processed_propers.append(cur_proper.name)
continue
if old_release_group != best_result.release_group:
logger.log('Ignoring proper from release group {new} instead of current group {old}'.format
(new=best_result.release_group, old=old_release_group))
self.processed_propers.append(cur_proper.name)
continue
# if the show is in our list and there hasn't been a proper already added for that particular episode then add it to our list of propers
if best_result.indexerid != -1 and (best_result.indexerid, best_result.season, best_result.episode) not in map(
operator.attrgetter('indexerid', 'season', 'episode'), final_propers):
logger.log('Found a desired proper: {name}'.format(name=best_result.name))
final_propers.append(best_result)
self.processed_propers.append(cur_proper.name)
return final_propers
curProper.indexerid = parse_result.show.indexerid
# set the indexer in the db to the show's indexer
curProper.indexer = parse_result.show.indexer
# populate our Proper instance
curProper.show = parse_result.show
curProper.season = parse_result.season_number if parse_result.season_number is not None else 1
curProper.episode = parse_result.episode_numbers[0]
curProper.release_group = parse_result.release_group
curProper.version = parse_result.version
curProper.quality = Quality.nameQuality(curProper.name, parse_result.is_anime)
curProper.content = None
# filter release
bestResult = pickBestResult(curProper, parse_result.show)
if not bestResult:
logger.log(u"Proper " + curProper.name + " were rejected by our release filters.", logger.DEBUG)
continue
# only get anime proper if it has release group and version
if bestResult.show.is_anime:
if not bestResult.release_group and bestResult.version == -1:
logger.log(u"Proper " + bestResult.name + " doesn't have a release group and version, ignoring it",
logger.DEBUG)
continue
# check if we actually want this proper (if it's the right quality)
myDB = db.DBConnection()
sqlResults = myDB.select("SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?",
[bestResult.indexerid, bestResult.season, bestResult.episode])
def __init__(self, force=None, show=None):
#TODOif not sickbeard.DOWNLOAD_FRENCH:
# return
if sickbeard.showList==None:
return
logger.log(u"Beginning the search for french episodes older than "+ str(sickbeard.FRENCH_DELAY) +" days")
frenchlist=[]
#get list of english episodes that we want to search in french
myDB = db.DBConnection()
today = datetime.date.today().toordinal()
if show:
frenchsql=myDB.select("SELECT showid, season, episode from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ? order by showid, airdate asc",[show,today,sickbeard.FRENCH_DELAY])
count=myDB.select("SELECT count(*) from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ?",[show,today,sickbeard.FRENCH_DELAY])
else:
frenchsql=myDB.select("SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ? order by showid, airdate asc",[today,sickbeard.FRENCH_DELAY])
count=myDB.select("SELECT count(*) from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ?",[today,sickbeard.FRENCH_DELAY])
#make the episodes objects
logger.log(u"Searching for "+str(count[0][0]) +" episodes in french")
for episode in frenchsql:
showObj = helpers.findCertainShow(sickbeard.showList, episode[0])
epObj = showObj.getEpisode(episode[1], episode[2])
frenchlist.append(epObj)
#for each episode in frenchlist fire a search in french
delay=[]
for frepisode in frenchlist:
if frepisode.show.tvdbid in delay:
logger.log(u"Previous episode for show "+str(frepisode.show.tvdbid)+" not found in french so skipping this search", logger.DEBUG)
continue
result=[]
for curProvider in providers.sortedProviderList():
if not curProvider.isActive():
continue
logger.log(u"Searching for french episodes on "+curProvider.name +" for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
try:
curfrench = curProvider.findFrench(frepisode, manualSearch=True)
except:
logger.log(u"Exception", logger.DEBUG)
pass
test=0
if curfrench:
for x in curfrench:
if not show_name_helpers.filterBadReleases(x.name):
logger.log(u"French "+x.name+" isn't a valid scene release that we want, ignoring it", logger.DEBUG)
test+=1
continue
if sickbeard.IGNORE_WORDS == "":
ignore_words="ztreyfgut"
else:
ignore_words=str(sickbeard.IGNORE_WORDS)
for fil in resultFilters + ignore_words.split(','):
if fil == showLanguages.get(u"fr"):
continue
if re.search('(^|[\W_])'+fil+'($|[\W_])', x.url, re.I):
logger.log(u"Invalid scene release: "+x.url+" contains "+fil+", ignoring it", logger.DEBUG)
test+=1
if test==0:
result.append(x)
best=None
try:
epi={}
epi[1]=frepisode
best = search.pickBestResult(result, episode = epi)
except:
pass
if best:
best.name=best.name + ' snatchedfr'
logger.log(u"Found french episode for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
try:
search.snatchEpisode(best, SNATCHED_FRENCH)
except:
logger.log(u"Exception", logger.DEBUG)
pass
else:
delay.append(frepisode.show.tvdbid)
logger.log(u"No french episodes found for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
def __init__(self, force=None, show=None):
#TODOif not sickbeard.DOWNLOAD_FRENCH:
# return
if sickbeard.showList == None:
return
logger.log(u"Beginning the search for french episodes older than " +
str(sickbeard.FRENCH_DELAY) + " days")
frenchlist = []
#get list of english episodes that we want to search in french
myDB = db.DBConnection()
today = datetime.date.today().toordinal()
if show:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[show, today, sickbeard.FRENCH_DELAY])
count = myDB.select(
"SELECT count(*) from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ?",
[show, today, sickbeard.FRENCH_DELAY])
else:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[today, sickbeard.FRENCH_DELAY])
count = myDB.select(
"SELECT count(*) from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ?",
[today, sickbeard.FRENCH_DELAY])
#make the episodes objects
logger.log(u"Searching for " + str(count[0][0]) +
" episodes in french")
for episode in frenchsql:
showObj = helpers.findCertainShow(sickbeard.showList, episode[0])
epObj = showObj.getEpisode(episode[1], episode[2])
frenchlist.append(epObj)
#for each episode in frenchlist fire a search in french
delay = []
for frepisode in frenchlist:
if frepisode.show.tvdbid in delay:
logger.log(
u"Previous episode for show " +
str(frepisode.show.tvdbid) +
" not found in french so skipping this search",
logger.DEBUG)
continue
result = []
for curProvider in providers.sortedProviderList():
if not curProvider.isActive():
continue
logger.log(u"Searching for french episodes on " +
curProvider.name + " for " + frepisode.show.name +
" season " + str(frepisode.season) + " episode " +
str(frepisode.episode))
try:
curfrench = curProvider.findFrench(frepisode,
manualSearch=True)
except:
logger.log(u"Exception", logger.DEBUG)
pass
for x in curfrench:
result.append(x)
best = None
try:
epi = {}
epi[1] = frepisode
best = search.pickBestResult(result, episode=epi)
except:
pass
if best:
best.name = best.name + ' snatchedfr'
logger.log(u"Found french episode for " + frepisode.show.name +
" season " + str(frepisode.season) + " episode " +
str(frepisode.episode))
try:
search.snatchEpisode(best, SNATCHED_FRENCH)
except:
logger.log(u"Exception", logger.DEBUG)
pass
else:
delay.append(frepisode.show.tvdbid)
logger.log(u"No french episodes found for " +
frepisode.show.name + " season " +
str(frepisode.season) + " episode " +
str(frepisode.episode))
def _getProperList(self): # pylint: disable=too-many-locals, too-many-branches, too-many-statements
"""
Walk providers for propers
"""
propers = {}
search_date = datetime.datetime.today() - datetime.timedelta(days=2)
# for each provider get a list of the
original_thread_name = threading.currentThread().name
providers = enabled_providers('backlog')
for cur_provider in providers:
threading.currentThread().name = '{thread} :: [{provider}]'.format(thread=original_thread_name, provider=cur_provider.name)
logger.log(u"Searching for any new PROPER releases from {provider}".format
(provider=cur_provider.name))
try:
cur_propers = cur_provider.find_propers(search_date)
except AuthException as e:
logger.log(u"Authentication error: {error}".format
(error=ex(e)), logger.DEBUG)
continue
except (SocketTimeout) as e:
logger.log(u"Socket time out while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except (requests_exceptions.HTTPError, requests_exceptions.TooManyRedirects) as e:
logger.log(u"HTTP error while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.ConnectionError as e:
logger.log(u"Connection error while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.Timeout as e:
logger.log(u"Connection timed out while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except requests_exceptions.ContentDecodingError as e:
logger.log(u"Content-Encoding was gzip, but content was not compressed while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
continue
except Exception as e:
if u'ECONNRESET' in e or (hasattr(e, 'errno') and e.errno == errno.ECONNRESET):
logger.log(u"Connection reset by peer while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
else:
logger.log(u"Unknown exception while searching for propers in {provider}, skipping: {error}".format
(provider=cur_provider.name, error=ex(e)), logger.DEBUG)
logger.log(traceback.format_exc(), logger.DEBUG)
continue
# if they haven't been added by a different provider than add the proper to the list
for proper in cur_propers:
guess = guessit(proper.name)
if not guess.get('proper_count'):
logger.log(u'Skipping non-proper: {name}'.format(name=proper.name))
continue
name = self._genericName(proper.name, remove=False)
if name not in propers:
logger.log(u'Found new proper result: {name}'.format
(name=proper.name), logger.DEBUG)
proper.provider = cur_provider
propers[name] = proper
threading.currentThread().name = original_thread_name
# take the list of unique propers and get it sorted by
sorted_propers = sorted(propers.values(), key=operator.attrgetter('date'), reverse=True)
final_propers = []
for cur_proper in sorted_propers:
try:
parse_result = NameParser(False).parse(cur_proper.name)
except (InvalidNameException, InvalidShowException) as error:
logger.log(u'{}'.format(error), logger.DEBUG)
continue
if not parse_result.series_name:
logger.log(u"Ignoring invalid show: {name}".format
(name=cur_proper.name), logger.DEBUG)
continue
if not parse_result.episode_numbers:
logger.log(u"Ignoring full season instead of episode: {name}".format
(name=cur_proper.name), logger.DEBUG)
continue
logger.log(u'Successful match! Matched {} to show {}'.format
(parse_result.original_name, parse_result.show.name), logger.DEBUG)
# set the indexerid in the db to the show's indexerid
cur_proper.indexerid = parse_result.show.indexerid
# set the indexer in the db to the show's indexer
cur_proper.indexer = parse_result.show.indexer
# populate our Proper instance
cur_proper.show = parse_result.show
cur_proper.season = parse_result.season_number if parse_result.season_number is not None else 1
cur_proper.episode = parse_result.episode_numbers[0]
cur_proper.release_group = parse_result.release_group
cur_proper.version = parse_result.version
cur_proper.quality = Quality.nameQuality(cur_proper.name, parse_result.is_anime)
cur_proper.content = None
# filter release
best_result = pickBestResult(cur_proper, parse_result.show)
if not best_result:
logger.log(u'Rejected proper due to release filters: {name}'.format
(name=cur_proper.name))
continue
# only get anime proper if it has release group and version
if best_result.show.is_anime:
if not best_result.release_group and best_result.version == -1:
logger.log(u"Ignoring proper without release group and version: {name}".format
(name=best_result.name))
continue
# check if we actually want this proper (if it's the right quality)
main_db_con = db.DBConnection()
sql_results = main_db_con.select('SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?',
[best_result.indexerid, best_result.season, best_result.episode])
if not sql_results:
logger.log(u"Ignoring proper with incorrect quality: {name}".format
(name=best_result.name))
continue
# only keep the proper if we have already retrieved the same quality ep (don't get better/worse ones)
old_status, old_quality = Quality.splitCompositeStatus(int(sql_results[0]['status']))
if old_status not in (DOWNLOADED, SNATCHED) or old_quality != best_result.quality:
logger.log(u"Ignoring proper because quality is different or episode is already archived: {name}".format
(name=best_result.name))
continue
# check if we actually want this proper (if it's the right release group and a higher version)
if best_result.show.is_anime:
main_db_con = db.DBConnection()
sql_results = main_db_con.select(
'SELECT release_group, version FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?',
[best_result.indexerid, best_result.season, best_result.episode])
old_version = int(sql_results[0]['version'])
old_release_group = (sql_results[0]['release_group'])
if -1 < old_version < best_result.version:
logger.log(u'Found new anime version {new} to replace existing version {old}: {name}'.format
(old=old_version, new=best_result.version, name=best_result.name))
else:
logger.log(u'Ignoring proper with the same or lower version: {name}'.format
(name=best_result.name))
continue
if old_release_group != best_result.release_group:
logger.log(u"Ignoring proper from release group {new} instead of current group {old}".format
(new=best_result.release_group, old=old_release_group))
continue
# if the show is in our list and there hasn't been a proper already added for that particular episode then add it to our list of propers
if best_result.indexerid != -1 and (best_result.indexerid, best_result.season, best_result.episode) not in map(
operator.attrgetter('indexerid', 'season', 'episode'), final_propers):
logger.log(u'Found a desired proper: {name}'.format(name=best_result.name))
final_propers.append(best_result)
return final_propers
def run(self, force=None, show=None):
if sickbeard.showList == None:
return
logger.log(u"Beginning the search for french episodes older than " +
str(sickbeard.FRENCH_DELAY) + " days")
foundResults = {}
finalResults = []
#show = self
frenchlist = []
#get list of english episodes that we want to search in french
myDB = db.DBConnection()
today = datetime.date.today().toordinal()
if show:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[show, today, sickbeard.FRENCH_DELAY])
logger.log(
"SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid ="
+ str(show) + "and (" + str(today) +
" - tv_episodes.airdate) > " + str(sickbeard.FRENCH_DELAY) +
"order by showid, airdate asc")
count = myDB.select(
"SELECT count(*) from tv_episodes where audio_langs='eng' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ?",
[show, today, sickbeard.FRENCH_DELAY])
else:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[today, sickbeard.FRENCH_DELAY])
count = myDB.select(
"SELECT count(*) from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ?",
[today, sickbeard.FRENCH_DELAY])
#make the episodes objects
#logger.log("SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid =" + str(show) +"and (" +str(today)+" - tv_episodes.airdate) > "+ str(sickbeard.FRENCH_DELAY) +"order by showid, airdate asc")
logger.log(
"SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and ("
+ str(today) + " - tv_episodes.airdate) > " +
str(sickbeard.FRENCH_DELAY) + " order by showid, airdate asc")
logger.log(u"Searching for " + str(count[0][0]) +
" episodes in french")
#logger.log(frenchsql)
#logger.log(sickbeard.showList.)
for episode in frenchsql:
showObj = Show.find(sickbeard.showList, int(episode[0]))
if showObj == None:
logger.log("Show not in show list")
#showObj = helpers.findCertainShow(sickbeard.showList, episode[0])
epObj = showObj.getEpisode(episode[1], episode[2])
#epObj = showObj.getEpisode(int(epInfo[0]), int(epInfo[1]))
frenchlist.append(epObj)
#for each episode in frenchlist fire a search in french
delay = []
temp = None
rest = count[0][0]
for frepisode in frenchlist:
rest = rest - 1
if frepisode.show.indexerid in delay:
logger.log(
u"Previous episode for show " + str(frepisode.show.name) +
" not found in french so skipping this search",
logger.DEBUG)
continue
result = []
for curProvider in providers.sortedProviderList():
foundResults[curProvider.name] = {}
if not curProvider.is_active():
continue
logger.log(u"Searching for french episode on " +
curProvider.name + " for " + frepisode.show.name +
" season " + str(frepisode.season) + " episode " +
str(frepisode.episode))
#try:
# logger.log(frepisode)
# temp = GenericProvider()
# curfrench = temp.findFrench(self, episode=frepisode, manualSearch=True)
#curfrench = GenericProvider.findFrench(episode=frepi sode,manualSearch=True)
#curProvider.findFrench(frepisode, manualSearch=True)
#except:
# logger.log(u"Exception", logger.DEBUG)
# pass
#for curProvider in providers:
# if curProvider.anime_only and not show.is_anime:
# logger.log(u"" + str(show.name) + " is not an anime, skipping", logger.DEBUG)
# continue
curfrench = curProvider.find_search_results(
frepisode.show, frenchlist, 'sponly', True, True, 'french')
#curfrench = curProvider.findFrench(frepisode, True)
#temp = GenericProvider('temp')
#curfrench = temp.findFrench( episode=frepisode, manualSearch=True)
if len(curfrench):
#make a list of all the results for this provider
for curEp in curfrench:
if curEp in foundResults:
foundResults[
curProvider.name][curEp] += curfrench[curEp]
else:
foundResults[
curProvider.name][curEp] = curfrench[curEp]
if not foundResults[curProvider.name]:
continue
bestSeasonResult = None
#if SEASON_RESULT in foundResults[curProvider.name]:
# bestSeasonResult = search.pickBestResult(foundResults[curProvider.name][SEASON_RESULT], show)
#_______________________________________________________
test = 0
if foundResults[curProvider.name]:
for cur_episode in foundResults[curProvider.name]:
for x in foundResults[curProvider.name][cur_episode]:
tmp = x
if not show_name_helpers.filterBadReleases(
x.name): #x.name):
logger.log(
u"French " + x.name +
" isn't a valid scene release that we want, ignoring it",
logger.DEBUG)
test += 1
continue
if sickbeard.IGNORE_WORDS == "":
ignore_words = "ztreyfgut"
else:
ignore_words = str(sickbeard.IGNORE_WORDS)
for fil in resultFilters + ignore_words.split(','):
if fil == showLanguages.get(u"fre"):
continue
if re.search('(^|[\W_])' + fil + '($|[\W_])',
x.url, re.I) or re.search(
'(^|[\W_])' + fil +
'($|[\W_])', x.name, re.I):
logger.log(
u"Invalid scene release: " + x.url +
" contains " + fil + ", ignoring it",
logger.DEBUG)
test += 1
if test == 0:
result.append(x)
best = None
try:
epi = {}
epi[1] = frepisode
best = search.pickBestResult(result, showObj)
except:
pass
if best:
best.name = best.name + ' snatchedfr'
logger.log(u"Found french episode for " + frepisode.show.name +
" season " + str(frepisode.season) + " episode " +
str(frepisode.episode))
try:
search.snatchEpisode(best, SNATCHED_FRENCH)
except:
logger.log(u"Exception", logger.DEBUG)
pass
else:
delay.append(frepisode.show.indexerid)
logger.log(u"No french episode found for " +
frepisode.show.name + " season " +
str(frepisode.season) + " episode " +
str(frepisode.episode))
logger.log(str(rest) + u" episodes left")
def __init__(self, force=None, show=None):
#TODOif not sickbeard.DOWNLOAD_FRENCH:
# return
if sickbeard.showList==None:
return
logger.log(u"Beginning the search for french episodes older than "+ str(sickbeard.FRENCH_DELAY) +" days")
frenchlist=[]
#get list of english episodes that we want to search in french
myDB = db.DBConnection()
today = datetime.date.today().toordinal()
if show:
frenchsql=myDB.select("SELECT showid, season, episode from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ? order by showid, airdate asc",[show,today,sickbeard.FRENCH_DELAY])
count=myDB.select("SELECT count(*) from tv_episodes where audio_langs='en' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ?",[show,today,sickbeard.FRENCH_DELAY])
else:
frenchsql=myDB.select("SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ? order by showid, airdate asc",[today,sickbeard.FRENCH_DELAY])
count=myDB.select("SELECT count(*) from tv_episodes, tv_shows where audio_langs='en' and tv_episodes.showid = tv_shows.tvdb_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ?",[today,sickbeard.FRENCH_DELAY])
#make the episodes objects
logger.log(u"Searching for "+str(count[0][0]) +" episodes in french")
for episode in frenchsql:
showObj = helpers.findCertainShow(sickbeard.showList, episode[0])
epObj = showObj.getEpisode(episode[1], episode[2])
frenchlist.append(epObj)
#for each episode in frenchlist fire a search in french
delay=[]
for frepisode in frenchlist:
if frepisode.show.tvdbid in delay:
logger.log(u"Previous episode for show "+str(frepisode.show.tvdbid)+" not found in french so skipping this search", logger.DEBUG)
continue
result=[]
for curProvider in providers.sortedProviderList():
if not curProvider.isActive():
continue
logger.log(u"Searching for french episodes on "+curProvider.name +" for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
try:
curfrench = curProvider.findFrench(frepisode, manualSearch=True)
except:
logger.log(u"Exception", logger.DEBUG)
pass
for x in curfrench:
result.append(x)
best=None
try:
epi={}
epi[1]=frepisode
best = search.pickBestResult(result, episode = epi)
except:
pass
if best:
best.name=best.name + ' snatchedfr'
logger.log(u"Found french episode for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
try:
search.snatchEpisode(best, SNATCHED_FRENCH)
except:
logger.log(u"Exception", logger.DEBUG)
pass
else:
delay.append(frepisode.show.tvdbid)
logger.log(u"No french episodes found for " +frepisode.show.name +" season "+str(frepisode.season)+" episode "+str(frepisode.episode))
def run(self, force=None, show=None):
if sickbeard.showList == None:
return
logger.log(u"Beginning the search for french episodes older than " + str(sickbeard.FRENCH_DELAY) + " days")
foundResults = {}
finalResults = []
# show = self
frenchlist = []
# get list of english episodes that we want to search in french
myDB = db.DBConnection()
today = datetime.date.today().toordinal()
if show:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[show, today, sickbeard.FRENCH_DELAY],
)
logger.log(
"SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid ="
+ str(show)
+ "and ("
+ str(today)
+ " - tv_episodes.airdate) > "
+ str(sickbeard.FRENCH_DELAY)
+ "order by showid, airdate asc"
)
count = myDB.select(
"SELECT count(*) from tv_episodes where audio_langs='eng' and tv_episodes.showid =? and (? - tv_episodes.airdate) > ?",
[show, today, sickbeard.FRENCH_DELAY],
)
else:
frenchsql = myDB.select(
"SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ? order by showid, airdate asc",
[today, sickbeard.FRENCH_DELAY],
)
count = myDB.select(
"SELECT count(*) from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and (? - tv_episodes.airdate) > ?",
[today, sickbeard.FRENCH_DELAY],
)
# make the episodes objects
# logger.log("SELECT showid, season, episode from tv_episodes where audio_langs='eng' and tv_episodes.showid =" + str(show) +"and (" +str(today)+" - tv_episodes.airdate) > "+ str(sickbeard.FRENCH_DELAY) +"order by showid, airdate asc")
logger.log(
"SELECT showid, season, episode from tv_episodes, tv_shows where audio_langs='eng' and tv_episodes.showid = tv_shows.indexer_id and tv_shows.frenchsearch = 1 and ("
+ str(today)
+ " - tv_episodes.airdate) > "
+ str(sickbeard.FRENCH_DELAY)
+ " order by showid, airdate asc"
)
logger.log(u"Searching for " + str(count[0][0]) + " episodes in french")
# logger.log(frenchsql)
# logger.log(sickbeard.showList.)
for episode in frenchsql:
showObj = Show.find(sickbeard.showList, int(episode[0]))
if showObj == None:
logger.log("Show not in show list")
# showObj = helpers.findCertainShow(sickbeard.showList, episode[0])
epObj = showObj.getEpisode(episode[1], episode[2])
# epObj = showObj.getEpisode(int(epInfo[0]), int(epInfo[1]))
frenchlist.append(epObj)
# for each episode in frenchlist fire a search in french
delay = []
temp = None
rest = count[0][0]
for frepisode in frenchlist:
rest = rest - 1
if frepisode.show.indexerid in delay:
logger.log(
u"Previous episode for show "
+ str(frepisode.show.name)
+ " not found in french so skipping this search",
logger.DEBUG,
)
continue
result = []
for curProvider in providers.sortedProviderList():
foundResults[curProvider.name] = {}
if not curProvider.is_active():
continue
logger.log(
u"Searching for french episode on "
+ curProvider.name
+ " for "
+ frepisode.show.name
+ " season "
+ str(frepisode.season)
+ " episode "
+ str(frepisode.episode)
)
# try:
# logger.log(frepisode)
# temp = GenericProvider()
# curfrench = temp.findFrench(self, episode=frepisode, manualSearch=True)
# curfrench = GenericProvider.findFrench(episode=frepi sode,manualSearch=True)
# curProvider.findFrench(frepisode, manualSearch=True)
# except:
# logger.log(u"Exception", logger.DEBUG)
# pass
# for curProvider in providers:
# if curProvider.anime_only and not show.is_anime:
# logger.log(u"" + str(show.name) + " is not an anime, skipping", logger.DEBUG)
# continue
curfrench = curProvider.find_search_results(frepisode.show, frenchlist, "sponly", True, True, "french")
# curfrench = curProvider.findFrench(frepisode, True)
# temp = GenericProvider('temp')
# curfrench = temp.findFrench( episode=frepisode, manualSearch=True)
if len(curfrench):
# make a list of all the results for this provider
for curEp in curfrench:
if curEp in foundResults:
foundResults[curProvider.name][curEp] += curfrench[curEp]
else:
foundResults[curProvider.name][curEp] = curfrench[curEp]
if not foundResults[curProvider.name]:
continue
bestSeasonResult = None
# if SEASON_RESULT in foundResults[curProvider.name]:
# bestSeasonResult = search.pickBestResult(foundResults[curProvider.name][SEASON_RESULT], show)
# _______________________________________________________
test = 0
if foundResults[curProvider.name]:
for cur_episode in foundResults[curProvider.name]:
for x in foundResults[curProvider.name][cur_episode]:
tmp = x
if not show_name_helpers.filterBadReleases(x.name): # x.name):
logger.log(
u"French " + x.name + " isn't a valid scene release that we want, ignoring it",
logger.DEBUG,
)
test += 1
continue
if sickbeard.IGNORE_WORDS == "":
ignore_words = "ztreyfgut"
else:
ignore_words = str(sickbeard.IGNORE_WORDS)
for fil in resultFilters + ignore_words.split(","):
if fil == showLanguages.get(u"fre"):
continue
if re.search("(^|[\W_])" + fil + "($|[\W_])", x.url, re.I) or re.search(
"(^|[\W_])" + fil + "($|[\W_])", x.name, re.I
):
logger.log(
u"Invalid scene release: " + x.url + " contains " + fil + ", ignoring it",
logger.DEBUG,
)
test += 1
if test == 0:
result.append(x)
best = None
try:
epi = {}
epi[1] = frepisode
best = search.pickBestResult(result, showObj)
except:
pass
if best:
best.name = best.name + " snatchedfr"
logger.log(
u"Found french episode for "
+ frepisode.show.name
+ " season "
+ str(frepisode.season)
+ " episode "
+ str(frepisode.episode)
)
try:
search.snatchEpisode(best, SNATCHED_FRENCH)
except:
logger.log(u"Exception", logger.DEBUG)
pass
else:
delay.append(frepisode.show.indexerid)
logger.log(
u"No french episode found for "
+ frepisode.show.name
+ " season "
+ str(frepisode.season)
+ " episode "
+ str(frepisode.episode)
)
logger.log(str(rest) + u" episodes left")
