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
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")