wip

bazarr/subtitles/download.py

@@ -40,10 +40,6 @@ def generate_subtitles(path, languages, audio_language, sceneName, title, media_
     providers = pool.providers
 
     language_set = _get_language_obj(languages=languages)
-    hi_required = "force HI" if any([x.hi for x in language_set]) else False
-    also_forced = any([x.forced for x in language_set])
-    forced_required = all([x.forced for x in language_set])
-    _set_forced_providers(pool=pool, also_forced=also_forced, forced_required=forced_required)
 
     video = get_video(force_unicode(path), title, sceneName, providers=providers, media_type=media_type)
 
@@ -59,6 +55,9 @@ def generate_subtitles(path, languages, audio_language, sceneName, title, media_
             if forced_minimum_score:
                 min_score = int(forced_minimum_score) + 1
             for language in language_set:
+                # check if language appears more than one time which means that the languages profile requires normal
+                # and hi subtitles (also)
+                also_hi = len(set([x.hi for x in language_set if x.alpha3 == language.alpha3 and not x.forced])) > 1
                 # confirm if language is still missing or if cutoff has been reached
                 if check_if_still_required and language not in check_missing_languages(path, media_type):
                     # cutoff has been reached
@@ -66,11 +65,13 @@ def generate_subtitles(path, languages, audio_language, sceneName, title, media_
                                   f"has been reached during this search.")
                     continue
                 else:
+                    hi_required = "force HI" if language.hi else "force non-HI"
+                    _set_forced_providers(pool=pool, also_forced=language.forced, forced_required=language.forced)
                     downloaded_subtitles = download_best_subtitles(videos={video},
                                                                    languages={language},
                                                                    pool_instance=pool,
                                                                    min_score=int(min_score),
-                                                                   hearing_impaired=hi_required,
+                                                                   hearing_impaired=False if also_hi else hi_required,
                                                                    compute_score=ComputeScore(get_scores()))
 
                 if downloaded_subtitles:

bazarr/subtitles/indexer/series.py

@@ -235,7 +235,11 @@ def list_missing_subtitles(no=None, epno=None, send_event=True):
                 # get difference between desired and existing subtitles
                 missing_subtitles_list = []
                 for item in desired_subtitles_list:
-                    if item['hi'] == 'never':
+                    if item['forced'] == 'True':
+                        desired_item = {'language': item['language'], 'forced': item['forced'], 'hi': 'False'}
+                        if desired_item not in actual_subtitles_list:
+                            missing_subtitles_list.append(desired_item)
+                    elif item['hi'] == 'never':
                         desired_item = {'language': item['language'], 'forced': item['forced'], 'hi': 'False'}
                         if desired_item not in actual_subtitles_list:
                             missing_subtitles_list.append(desired_item)

bazarr/subtitles/manual.py

@@ -31,9 +31,9 @@ def manual_search(path, profile_id, providers, sceneName, title, media_type):
 
     pool = _get_pool(media_type, profile_id)
 
-    language_set, initial_language_set, original_format = _get_language_obj(profile_id=profile_id)
-    also_forced = any([x.forced for x in initial_language_set])
-    forced_required = all([x.forced for x in initial_language_set])
+    language_set, original_format = _get_language_obj(profile_id=profile_id)
+    also_forced = any([x.forced for x in language_set])
+    forced_required = all([x.forced for x in language_set])
     compute_score = ComputeScore(get_scores())
     _set_forced_providers(pool=pool, also_forced=also_forced, forced_required=forced_required)
 
@@ -71,6 +71,10 @@ def manual_search(path, profile_id, providers, sceneName, title, media_type):
             minimum_score_movie = settings.general.minimum_score_movie
 
             for s in subtitles[video]:
+                if s.language not in language_set:
+                    # HI may not be matching what was requested
+                    continue
+
                 try:
                     matches = s.get_matches(video)
                 except AttributeError:
@@ -89,20 +93,8 @@ def manual_search(path, profile_id, providers, sceneName, title, media_type):
                             logging.debug("BAZARR Ignoring invalid subtitles")
                         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, score_without_hash = compute_score(matches, s, video, hearing_impaired=s.language.hi)
                 if 'hash' not in matches:
                     not_matched = scores - matches
                     s.score = score_without_hash
@@ -110,11 +102,6 @@ def manual_search(path, profile_id, providers, sceneName, title, media_type):
                     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:
@@ -229,7 +216,6 @@ def manual_download_subtitle(path, audio_language, hi, forced, subtitle, provide
 
 
 def _get_language_obj(profile_id):
-    initial_language_set = set()
     language_set = set()
 
     profile = get_profiles_list(profile_id=int(profile_id))
@@ -246,22 +232,13 @@ def _get_language_obj(profile_id):
         lang_obj = _get_lang_obj(lang)
 
         if forced == "True":
-            lang_obj = Language.rebuild(lang_obj, forced=True)
-
-        if hi == "True":
-            lang_obj = Language.rebuild(lang_obj, hi=True)
-
-        initial_language_set.add(lang_obj)
-
-    language_set = initial_language_set.copy()
-    for language in language_set.copy():
-        lang_obj_for_hi = language
-        if not language.forced and not language.hi:
-            lang_obj_hi = Language.rebuild(lang_obj_for_hi, hi=True)
-        elif not language.forced and language.hi:
-            lang_obj_hi = Language.rebuild(lang_obj_for_hi, hi=False)
+            language_set.add(Language.rebuild(lang_obj, forced=True))
+        elif hi == "only":
+            language_set.add(Language.rebuild(lang_obj, hi=True))
+        elif hi == "also":
+            language_set.add(lang_obj)
+            language_set.add(Language.rebuild(lang_obj, hi=True))
         else:
-            continue
-        language_set.add(lang_obj_hi)
+            language_set.add(lang_obj)
 
-    return language_set, initial_language_set, original_format
+    return language_set, original_format

frontend/src/pages/Settings/Languages/table.tsx

@@ -195,8 +195,10 @@ interface ItemProps {
 const ItemBadge: FunctionComponent<ItemProps> = ({ cutoff, item }) => {
   const text = useMemo(() => {
     let result = item.language;
-    if (item.hi === "True") {
+    if (item.hi === "only") {
       result += ":HI";
+    } else if (item.hi === "also") {
+      result += " | " + result + ":HI";
     } else if (item.forced === "True") {
       result += ":Forced";
     }