def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.srCore.srLogger.debug("Picking the best result out of " + str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.srCore.srLogger.info(
"Quality of " + cur_result.name + " is " + Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.srCore.srLogger.debug(cur_result.name + " is a quality we know we don't want, rejecting it")
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_ignore_words):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " based on ignored words filter: " + show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_require_words):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " based on required words filter: " + show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " because its not a valid scene release that we want, ignoring it")
continue
if hasattr(cur_result, 'size'):
if sickrage.srCore.srConfig.USE_FAILED_DOWNLOADS and FailedHistory.hasFailed(cur_result.name,
cur_result.size,
cur_result.provider.name):
sickrage.srCore.srLogger.info(cur_result.name + " has previously failed, rejecting it")
continue
# quality definition video file size constraints check
try:
quality_size = sickrage.srCore.srConfig.QUALITY_SIZES[cur_result.quality]
for file, file_size in cur_result.files.items():
if not file.endswith(tuple(video_exts)):
continue
file_size = float(file_size / 1000000)
if file_size > quality_size:
raise Exception(
"Ignoring " + cur_result.name + " with size: {} based on quality size filter: {}, ignoring it".format(
file_size, quality_size)
)
except Exception as e:
sickrage.srCore.srLogger.info(e.message)
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower() or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower() and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower() and "x264" in cur_result.name.lower():
sickrage.srCore.srLogger.info("Preferring " + cur_result.name + " (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.srCore.srLogger.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.srCore.srLogger.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.app.log.debug("Picking the best result out of " +
str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.app.log.info("Quality of " + cur_result.name + " is " +
Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.app.log.debug(
cur_result.name +
" is a quality we know we don't want, rejecting it")
continue
# check if seeders meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider,
'minseed') and cur_result.seeders not in (-1, None):
if int(cur_result.seeders) < int(cur_result.provider.minseed):
sickrage.app.log.info(
"Discarding torrent because it doesn't meet the minimum seeders: {}. Seeders: "
"{}".format(cur_result.name, cur_result.seeders))
continue
# check if leechers meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider,
'minleech') and cur_result.leechers not in (-1, None):
if int(cur_result.leechers) < int(cur_result.provider.minleech):
sickrage.app.log.info(
"Discarding torrent because it doesn't meet the minimum leechers: {}. Leechers: "
"{}".format(cur_result.name, cur_result.leechers))
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_ignore_words):
sickrage.app.log.info("Ignoring " + cur_result.name +
" based on ignored words filter: " +
show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_require_words):
sickrage.app.log.info("Ignoring " + cur_result.name +
" based on required words filter: " +
show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.app.log.info(
"Ignoring " + cur_result.name +
" because its not a valid scene release that we want")
continue
if hasattr(cur_result, 'size'):
if FailedHistory.hasFailed(cur_result.name, cur_result.size,
cur_result.provider.name):
sickrage.app.log.info(cur_result.name +
" has previously failed, rejecting it")
continue
# quality definition video file size constraints check
try:
if cur_result.size:
quality_size = sickrage.app.config.quality_sizes[
cur_result.quality]
file_size = float(cur_result.size / 1000000)
if file_size > quality_size:
raise Exception(
"Ignoring " + cur_result.name +
" with size: {} based on quality size filter: {}".
format(file_size, quality_size))
except Exception as e:
sickrage.app.log.info(str(e))
continue
# verify result content
if not cur_result.provider.private:
if cur_result.resultType in [
"nzb", "torrent"
] and not cur_result.provider.get_content(cur_result.url):
if sickrage.app.config.download_unverified_magnet_link and cur_result.url.startswith(
'magnet'):
# Attempt downloading unverified torrent magnet link
pass
else:
sickrage.app.log.info(
"Ignoring {} because we are unable to verify the download url"
.format(cur_result.name))
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality
or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower(
) or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower(
) and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower(
) and "x264" in cur_result.name.lower():
sickrage.app.log.info("Preferring " + cur_result.name +
" (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.app.log.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.app.log.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.app.log.debug("Picking the best result out of " +
str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.app.log.info("Quality of " + cur_result.name + " is " +
Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.app.log.debug(
cur_result.name +
" is a quality we know we don't want, rejecting it")
continue
# check if seeders and leechers meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider, 'minseed') and hasattr(
cur_result.provider, 'minleech'):
if cur_result.seeders not in (
-1, None) and cur_result.leechers not in (-1, None):
if int(cur_result.seeders) < int(
cur_result.provider.minseed) or int(
cur_result.leechers) < int(
cur_result.provider.minleech):
sickrage.app.log.info(
'Discarding torrent because it does not meet the minimum provider '
'setting S:{} L:{}. Result has S:{} L:{}',
cur_result.provider.minseed,
cur_result.provider.minleech, cur_result.seeders,
cur_result.leechers)
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_ignore_words):
sickrage.app.log.info("Ignoring " + cur_result.name +
" based on ignored words filter: " +
show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_require_words):
sickrage.app.log.info("Ignoring " + cur_result.name +
" based on required words filter: " +
show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.app.log.info(
"Ignoring " + cur_result.name +
" because its not a valid scene release that we want")
continue
if hasattr(cur_result, 'size'):
if sickrage.app.config.use_failed_downloads and FailedHistory.hasFailed(
cur_result.name, cur_result.size,
cur_result.provider.name):
sickrage.app.log.info(cur_result.name +
" has previously failed, rejecting it")
continue
# quality definition video file size constraints check
try:
quality_size = sickrage.app.config.quality_sizes[
cur_result.quality]
for file, file_size in cur_result.files.items():
if not file.decode('utf-8').endswith(tuple(video_exts)):
continue
file_size = float(file_size / 1000000)
if file_size > quality_size:
raise Exception(
"Ignoring " + cur_result.name +
" with size: {} based on quality size filter: {}".
format(file_size, quality_size))
except Exception as e:
sickrage.app.log.info(e.message)
continue
# verify result content
cur_result = _verify_result(cur_result)
if not cur_result.content:
sickrage.app.log.info(
"Ignoring " + cur_result.name +
" because it does not have valid download url")
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality
or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower(
) or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower(
) and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower(
) and "x264" in cur_result.name.lower():
sickrage.app.log.info("Preferring " + cur_result.name +
" (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.app.log.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.app.log.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.srCore.srLogger.debug("Picking the best result out of " + str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.srCore.srLogger.info(
"Quality of " + cur_result.name + " is " + Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.srCore.srLogger.debug(cur_result.name + " is a quality we know we don't want, rejecting it")
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_ignore_words):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " based on ignored words filter: " + show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_require_words):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " based on required words filter: " + show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.srCore.srLogger.info(
"Ignoring " + cur_result.name + " because its not a valid scene release that we want, ignoring it")
continue
if hasattr(cur_result, 'size'):
if sickrage.srCore.srConfig.USE_FAILED_DOWNLOADS and FailedHistory.hasFailed(cur_result.name,
cur_result.size,
cur_result.provider.name):
sickrage.srCore.srLogger.info(cur_result.name + " has previously failed, rejecting it")
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower() or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower() and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower() and "x264" in cur_result.name.lower():
sickrage.srCore.srLogger.info("Preferring " + cur_result.name + " (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.srCore.srLogger.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.srCore.srLogger.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.LOGGER.debug("Picking the best result out of " +
str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.LOGGER.info("Quality of " + cur_result.name + " is " +
Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.LOGGER.debug(
cur_result.name +
" is a quality we know we don't want, rejecting it")
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_ignore_words):
sickrage.LOGGER.info("Ignoring " + cur_result.name +
" based on ignored words filter: " +
show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(
cur_result.name, cur_result.show.rls_require_words):
sickrage.LOGGER.info("Ignoring " + cur_result.name +
" based on required words filter: " +
show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.LOGGER.info(
"Ignoring " + cur_result.name +
" because its not a valid scene release that we want, ignoring it"
)
continue
if hasattr(cur_result, 'size'):
if sickrage.USE_FAILED_DOWNLOADS and FailedHistory.hasFailed(
cur_result.name, cur_result.size,
cur_result.provider.name):
sickrage.LOGGER.info(cur_result.name +
" has previously failed, rejecting it")
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality
or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower(
) or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower(
) and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower(
) and "x264" in cur_result.name.lower():
sickrage.LOGGER.info("Preferring " + cur_result.name +
" (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.LOGGER.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.LOGGER.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.app.log.debug("Picking the best result out of " + str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.app.log.info(
"Quality of " + cur_result.name + " is " + Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.app.log.debug(cur_result.name + " is a quality we know we don't want, rejecting it")
continue
# check if seeders meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider, 'minseed') and cur_result.seeders not in (-1, None):
if int(cur_result.seeders) < min(cur_result.provider.minseed, 1):
sickrage.app.log.info("Discarding torrent because it doesn't meet the minimum seeders: {}. Seeders: "
"{}".format(cur_result.name, cur_result.seeders))
continue
# check if leechers meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider, 'minleech') and cur_result.leechers not in (-1, None):
if int(cur_result.leechers) < min(cur_result.provider.minleech, 0):
sickrage.app.log.info("Discarding torrent because it doesn't meet the minimum leechers: {}. Leechers: "
"{}".format(cur_result.name, cur_result.leechers))
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_ignore_words):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " based on ignored words filter: " + show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_require_words):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " based on required words filter: " + show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " because its not a valid scene release that we want")
continue
if hasattr(cur_result, 'size'):
if FailedHistory.hasFailed(cur_result.name, cur_result.size, cur_result.provider.name):
sickrage.app.log.info(cur_result.name + " has previously failed, rejecting it")
continue
# quality definition video file size constraints check
try:
if cur_result.size:
quality_size = sickrage.app.config.quality_sizes[cur_result.quality]
file_size = float(cur_result.size / 1000000)
if file_size > quality_size:
raise Exception(
"Ignoring " + cur_result.name + " with size: {} based on quality size filter: {}".format(
file_size, quality_size)
)
except Exception as e:
sickrage.app.log.info(str(e))
continue
# verify result content
if not cur_result.provider.private:
if cur_result.resultType in ["nzb", "torrent"] and not cur_result.provider.get_content(cur_result.url):
if sickrage.app.config.download_unverified_magnet_link and cur_result.url.startswith('magnet'):
# Attempt downloading unverified torrent magnet link
pass
else:
sickrage.app.log.info(
"Ignoring {} because we are unable to verify the download url".format(cur_result.name))
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower() or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower() and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower() and "x264" in cur_result.name.lower():
sickrage.app.log.info("Preferring " + cur_result.name + " (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.app.log.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.app.log.debug("No result picked.")
return bestResult
def pickBestResult(results, show):
"""
Find the best result out of a list of search results for a show
:param results: list of result objects
:param show: Shows we check for
:return: best result object
"""
results = results if isinstance(results, list) else [results]
sickrage.app.log.debug("Picking the best result out of " + str([x.name for x in results]))
bestResult = None
# find the best result for the current episode
for cur_result in results:
if show and cur_result.show is not show:
continue
# build the black And white list
if show.is_anime:
if not show.release_groups.is_valid(cur_result):
continue
sickrage.app.log.info(
"Quality of " + cur_result.name + " is " + Quality.qualityStrings[cur_result.quality])
anyQualities, bestQualities = Quality.splitQuality(show.quality)
if cur_result.quality not in anyQualities + bestQualities:
sickrage.app.log.debug(cur_result.name + " is a quality we know we don't want, rejecting it")
continue
# check if seeders and leechers meet out minimum requirements, disgard result if it does not
if hasattr(cur_result.provider, 'minseed') and hasattr(cur_result.provider, 'minleech'):
if cur_result.seeders not in (-1, None) and cur_result.leechers not in (-1, None):
if int(cur_result.seeders) < int(cur_result.provider.minseed) or int(cur_result.leechers) < int(cur_result.provider.minleech):
sickrage.app.log.info('Discarding torrent because it does not meet the minimum provider '
'setting S:{} L:{}. Result has S:{} L:{}',
cur_result.provider.minseed,
cur_result.provider.minleech,
cur_result.seeders,
cur_result.leechers)
continue
if show.rls_ignore_words and show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_ignore_words):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " based on ignored words filter: " + show.rls_ignore_words)
continue
if show.rls_require_words and not show_names.containsAtLeastOneWord(cur_result.name,
cur_result.show.rls_require_words):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " based on required words filter: " + show.rls_require_words)
continue
if not show_names.filterBadReleases(cur_result.name, parse=False):
sickrage.app.log.info(
"Ignoring " + cur_result.name + " because its not a valid scene release that we want")
continue
if hasattr(cur_result, 'size'):
if sickrage.app.config.use_failed_downloads and FailedHistory.hasFailed(cur_result.name,
cur_result.size,
cur_result.provider.name):
sickrage.app.log.info(cur_result.name + " has previously failed, rejecting it")
continue
# quality definition video file size constraints check
try:
quality_size = sickrage.app.config.quality_sizes[cur_result.quality]
for file, file_size in cur_result.files.items():
if not file.decode('utf-8').endswith(tuple(video_exts)):
continue
file_size = float(file_size / 1000000)
if file_size > quality_size:
raise Exception(
"Ignoring " + cur_result.name + " with size: {} based on quality size filter: {}".format(
file_size, quality_size)
)
except Exception as e:
sickrage.app.log.info(e.message)
continue
# verify result content
cur_result = _verify_result(cur_result)
if not cur_result.content:
sickrage.app.log.info(
"Ignoring " + cur_result.name + " because it does not have valid download url")
continue
if not bestResult:
bestResult = cur_result
elif cur_result.quality in bestQualities and (
bestResult.quality < cur_result.quality or bestResult.quality not in bestQualities):
bestResult = cur_result
elif cur_result.quality in anyQualities and bestResult.quality not in bestQualities and bestResult.quality < cur_result.quality:
bestResult = cur_result
elif bestResult.quality == cur_result.quality:
if "proper" in cur_result.name.lower() or "repack" in cur_result.name.lower():
bestResult = cur_result
elif "internal" in bestResult.name.lower() and "internal" not in cur_result.name.lower():
bestResult = cur_result
elif "xvid" in bestResult.name.lower() and "x264" in cur_result.name.lower():
sickrage.app.log.info("Preferring " + cur_result.name + " (x264 over xvid)")
bestResult = cur_result
if bestResult:
sickrage.app.log.debug("Picked " + bestResult.name + " as the best")
else:
sickrage.app.log.debug("No result picked.")
return bestResult