def list_subtitles(self,
rating_key,
item_type,
part_id,
language,
skip_wrong_fps=True,
metadata=None,
scanned_parts=None,
air_date_cutoff=None):
if not metadata:
metadata = get_plex_metadata(rating_key, part_id, item_type)
if not metadata:
return
providers = config.get_providers(
media_type="series" if item_type == "episode" else "movies")
if not scanned_parts:
scanned_parts = scan_videos([metadata],
ignore_all=True,
providers=providers)
if not scanned_parts:
Log.Error(u"%s: Couldn't list available subtitles for %s",
self.name, rating_key)
return
video, plex_part = scanned_parts.items()[0]
refine_video(video, refiner_settings=config.refiner_settings)
if air_date_cutoff is not None and metadata["item"].year and \
metadata["item"].year + air_date_cutoff < datetime.date.today().year:
Log.Debug(
"Skipping searching for subtitles: %s, it aired over %s year(s) ago.",
rating_key, air_date_cutoff)
return
config.init_subliminal_patches()
provider_settings = config.provider_settings
if not skip_wrong_fps:
provider_settings["opensubtitles"]["skip_wrong_fps"] = False
if item_type == "episode":
min_score = 240
if video.is_special:
min_score = 180
else:
min_score = 60
languages = {Language.fromietf(language)}
available_subs = list_all_subtitles(
[video],
languages,
providers=providers,
provider_configs=provider_settings,
pool_class=config.provider_pool,
throttle_callback=config.provider_throttle,
language_hook=language_hook)
use_hearing_impaired = Prefs['subtitles.search.hearingImpaired'] in (
"prefer", "force HI")
# sort subtitles by score
unsorted_subtitles = []
for s in available_subs[video]:
Log.Debug(u"%s: Starting score computation for %s", self.name, s)
try:
matches = s.get_matches(video)
except AttributeError:
Log.Error(u"%s: Match computation failed for %s: %s",
self.name, s, traceback.format_exc())
continue
# skip wrong season/episodes
if item_type == "episode":
can_verify_series = True
if not s.hash_verifiable and "hash" in matches:
can_verify_series = False
if can_verify_series and not {"series", "season", "episode"
}.issubset(matches):
if "series" not in matches:
s.wrong_series = True
else:
s.wrong_season_ep = True
unsorted_subtitles.append(
(s,
compute_score(matches,
s,
video,
hearing_impaired=use_hearing_impaired),
matches))
scored_subtitles = sorted(unsorted_subtitles,
key=operator.itemgetter(1),
reverse=True)
subtitles = []
for subtitle, score, matches in scored_subtitles:
# check score
if score < min_score and not subtitle.wrong_series:
Log.Info(u'%s: Score %d is below min_score (%d)', self.name,
score, min_score)
continue
subtitle.score = score
subtitle.matches = matches
subtitle.part_id = part_id
subtitle.item_type = item_type
subtitles.append(subtitle)
return subtitles
def manual_search(path, profile_id, providers, sceneName, title, media_type):
logging.debug('BAZARR Manually searching subtitles for this file: ' + path)
final_subtitles = []
pool = _get_pool(media_type, profile_id)
language_set, initial_language_set = _get_language_obj(
profile_id=profile_id)
also_forced = any([x.forced for x in initial_language_set])
_set_forced_providers(also_forced=also_forced, pool=pool)
if providers:
video = get_video(force_unicode(path),
title,
sceneName,
providers=providers,
media_type=media_type)
else:
logging.info("BAZARR All providers are throttled")
return None
if video:
handler = series_score if media_type == "series" else movie_score
try:
if providers:
subtitles = list_all_subtitles([video], language_set, pool)
if 'subscene' in providers:
s_pool = _init_pool("movie", profile_id, {"subscene"})
subscene_language_set = set()
for language in language_set:
if language.forced:
subscene_language_set.add(language)
if len(subscene_language_set):
s_pool.provider_configs['subscene'] = {}
s_pool.provider_configs['subscene'][
'only_foreign'] = True
subtitles_subscene = list_all_subtitles(
[video], subscene_language_set, s_pool)
s_pool.provider_configs['subscene'][
'only_foreign'] = False
subtitles[video] += subtitles_subscene[video]
else:
subtitles = []
logging.info("BAZARR All providers are throttled")
return None
except Exception:
logging.exception(
"BAZARR Error trying to get Subtitle list from provider for this file: "
+ path)
else:
subtitles_list = []
minimum_score = settings.general.minimum_score
minimum_score_movie = settings.general.minimum_score_movie
for s in subtitles[video]:
try:
matches = s.get_matches(video)
except AttributeError:
continue
# skip wrong season/episodes
if media_type == "series":
can_verify_series = True
if not s.hash_verifiable and "hash" in matches:
can_verify_series = False
if can_verify_series and not {
"series", "season", "episode"
}.issubset(matches):
logging.debug(
f"BAZARR Skipping {s}, because it doesn't match our series/episode"
)
continue
initial_hi = None
initial_hi_match = False
for language in initial_language_set:
if s.language.basename == language.basename and \
s.language.forced == language.forced and \
s.language.hi == language.hi:
initial_hi = language.hi
initial_hi_match = True
break
if not initial_hi_match:
initial_hi = None
_, max_score, scores = _get_scores(media_type,
minimum_score_movie,
minimum_score)
score, score_without_hash = compute_score(
matches,
s,
video,
hearing_impaired=initial_hi,
score_obj=handler)
if 'hash' not in matches:
not_matched = scores - matches
s.score = score_without_hash
else:
s.score = score
not_matched = set()
if s.hearing_impaired == initial_hi:
matches.add('hearing_impaired')
else:
not_matched.add('hearing_impaired')
releases = []
if hasattr(s, 'release_info'):
if s.release_info is not None:
for s_item in s.release_info.split(','):
if s_item.strip():
releases.append(s_item)
if s.uploader and s.uploader.strip():
s_uploader = s.uploader.strip()
else:
s_uploader = None
subtitles_list.append(
dict(score=round((score / max_score * 100), 2),
orig_score=score,
score_without_hash=score_without_hash,
forced=str(s.language.forced),
language=str(s.language.basename),
hearing_impaired=str(s.hearing_impaired),
provider=s.provider_name,
subtitle=codecs.encode(
pickle.dumps(s.make_picklable()),
"base64").decode(),
url=s.page_link,
matches=list(matches),
dont_matches=list(not_matched),
release_info=releases,
uploader=s_uploader))
final_subtitles = sorted(
subtitles_list,
key=lambda x: (x['orig_score'], x['score_without_hash']),
reverse=True)
logging.debug('BAZARR ' + str(len(final_subtitles)) +
" Subtitles have been found for this file: " + path)
logging.debug('BAZARR Ended searching Subtitles for this file: ' +
path)
subliminal.region.backend.sync()
return final_subtitles
def list_subtitles(self,
rating_key,
item_type,
part_id,
language,
skip_wrong_fps=True,
metadata=None,
scanned_parts=None):
if not metadata:
metadata = get_plex_metadata(rating_key, part_id, item_type)
if not metadata:
return
if not scanned_parts:
scanned_parts = scan_videos(
[metadata],
kind="series" if item_type == "episode" else "movie",
ignore_all=True)
if not scanned_parts:
Log.Error(u"%s: Couldn't list available subtitles for %s",
self.name, rating_key)
return
video, plex_part = scanned_parts.items()[0]
config.init_subliminal_patches()
provider_settings = config.provider_settings.copy()
if not skip_wrong_fps:
provider_settings = config.provider_settings.copy()
provider_settings["opensubtitles"]["skip_wrong_fps"] = False
if item_type == "episode":
min_score = 240
if video.is_special:
min_score = 180
else:
min_score = 60
available_subs = list_all_subtitles(scanned_parts,
{Language.fromietf(language)},
providers=config.providers,
provider_configs=provider_settings,
pool_class=config.provider_pool)
use_hearing_impaired = Prefs['subtitles.search.hearingImpaired'] in (
"prefer", "force HI")
# sort subtitles by score
unsorted_subtitles = []
for s in available_subs[video]:
Log.Debug(u"%s: Starting score computation for %s", self.name, s)
try:
matches = s.get_matches(video)
except AttributeError:
Log.Error(u"%s: Match computation failed for %s: %s",
self.name, s, traceback.format_exc())
continue
unsorted_subtitles.append(
(s,
compute_score(matches,
s,
video,
hearing_impaired=use_hearing_impaired),
matches))
scored_subtitles = sorted(unsorted_subtitles,
key=operator.itemgetter(1),
reverse=True)
subtitles = []
for subtitle, score, matches in scored_subtitles:
# check score
if score < min_score:
Log.Info(u'%s: Score %d is below min_score (%d)', self.name,
score, min_score)
continue
subtitle.score = score
subtitle.matches = matches
subtitle.part_id = part_id
subtitle.item_type = item_type
subtitles.append(subtitle)
return subtitles
def manual_search(path, language, hi, providers, providers_auth, sceneName,
title, media_type):
logging.debug('BAZARR Manually searching subtitles for this file: ' + path)
final_subtitles = []
if hi == "True":
hi = True
else:
hi = False
language_set = set()
for lang in ast.literal_eval(language):
lang = alpha3_from_alpha2(lang)
if lang == 'pob':
language_set.add(Language('por', 'BR'))
else:
language_set.add(Language(lang))
use_scenename = settings.general.getboolean('use_scenename')
minimum_score = settings.general.minimum_score
minimum_score_movie = settings.general.minimum_score_movie
use_postprocessing = settings.general.getboolean('use_postprocessing')
postprocessing_cmd = settings.general.postprocessing_cmd
video = get_video(path,
title,
sceneName,
use_scenename,
providers=providers,
media_type=media_type)
if video:
min_score, max_score, scores = get_scores(
video,
media_type,
min_score_movie_perc=int(minimum_score_movie),
min_score_series_perc=int(minimum_score))
try:
if providers:
subtitles = list_subtitles([video],
language_set,
providers=providers,
provider_configs=providers_auth,
pool_class=provider_pool(),
throttle_callback=provider_throttle,
language_hook=None) # fixme
else:
subtitles = []
logging.info("BAZARR All providers are throttled")
except Exception as e:
logging.exception(
"BAZARR Error trying to get subtitle list from provider for this file: "
+ path)
else:
subtitles_list = []
for s in subtitles[video]:
try:
matches = s.get_matches(video)
except AttributeError:
continue
# skip wrong season/episodes
if media_type == "series":
can_verify_series = True
if not s.hash_verifiable and "hash" in matches:
can_verify_series = False
if can_verify_series and not {
"series", "season", "episode"
}.issubset(matches):
logging.debug(
u"BAZARR Skipping %s, because it doesn't match our series/episode",
s)
continue
score = compute_score(matches, s, video, hearing_impaired=hi)
not_matched = scores - matches
s.score = score
# if score < min_score:
# continue
subtitles_list.append(
dict(score=round((score / max_score * 100), 2),
language=alpha2_from_alpha3(s.language.alpha3),
hearing_impaired=str(s.hearing_impaired),
provider=s.provider_name,
subtitle=codecs.encode(
pickle.dumps(s.make_picklable()),
"base64").decode(),
url=s.page_link,
matches=list(matches),
dont_matches=list(not_matched)))
final_subtitles = sorted(subtitles_list,
key=lambda x: x['score'],
reverse=True)
logging.debug('BAZARR ' + str(len(final_subtitles)) +
" subtitles have been found for this file: " + path)
logging.debug('BAZARR Ended searching subtitles for this file: ' +
path)
return final_subtitles
