Apply i18n

app.py

@@ -41,8 +41,8 @@ class App:
             output_dir=os.path.join(self.args.output_dir, "translations")
         )
         self.default_params = load_yaml(DEFAULT_PARAMETERS_CONFIG_PATH)
-        print(f"Use \"{self.args.whisper_type}\" implementation")
-        print(f"Device \"{self.whisper_inf.device}\" is detected")
+        print(f"Use \"{self.args.whisper_type}\" implementation\n"
+              f"Device \"{self.whisper_inf.device}\" is detected")
 
     def create_whisper_parameters(self):
         whisper_params = self.default_params["whisper"]
@@ -52,23 +52,28 @@ class App:
 
         with gr.Row():
             dd_model = gr.Dropdown(choices=self.whisper_inf.available_models, value=whisper_params["model_size"],
-                                   label="Model")
+                                   label=_("Model"))
             dd_lang = gr.Dropdown(choices=[AUTOMATIC_DETECTION] + self.whisper_inf.available_langs,
-                                  value=whisper_params["lang"], label="Language")
-            dd_file_format = gr.Dropdown(choices=["SRT", "WebVTT", "txt"], value="SRT", label="File Format")
+                                  value=AUTOMATIC_DETECTION if whisper_params["lang"] == AUTOMATIC_DETECTION.unwrap()
+                                  else whisper_params["lang"], label=_("Language"))
+            dd_file_format = gr.Dropdown(choices=["SRT", "WebVTT", "txt"], value="SRT", label=_("File Format"))
         with gr.Row():
-            cb_translate = gr.Checkbox(value=whisper_params["is_translate"], label="Translate to English?",
+            cb_translate = gr.Checkbox(value=whisper_params["is_translate"], label=_("Translate to English?"),
                                        interactive=True)
         with gr.Row():
-            cb_timestamp = gr.Checkbox(value=whisper_params["add_timestamp"], label="Add a timestamp to the end of the filename",
+            cb_timestamp = gr.Checkbox(value=whisper_params["add_timestamp"],
+                                       label=_("Add a timestamp to the end of the filename"),
                                        interactive=True)
 
-        with gr.Accordion("Advanced Parameters", open=False):
-            nb_beam_size = gr.Number(label="Beam Size", value=whisper_params["beam_size"], precision=0, interactive=True,
+        with gr.Accordion(_("Advanced Parameters"), open=False):
+            nb_beam_size = gr.Number(label="Beam Size", value=whisper_params["beam_size"], precision=0,
+                                     interactive=True,
                                      info="Beam size to use for decoding.")
-            nb_log_prob_threshold = gr.Number(label="Log Probability Threshold", value=whisper_params["log_prob_threshold"], interactive=True,
+            nb_log_prob_threshold = gr.Number(label="Log Probability Threshold",
+                                              value=whisper_params["log_prob_threshold"], interactive=True,
                                               info="If the average log probability over sampled tokens is below this value, treat as failed.")
-            nb_no_speech_threshold = gr.Number(label="No Speech Threshold", value=whisper_params["no_speech_threshold"], interactive=True,
+            nb_no_speech_threshold = gr.Number(label="No Speech Threshold", value=whisper_params["no_speech_threshold"],
+                                               interactive=True,
                                                info="If the no speech probability is higher than this value AND the average log probability over sampled tokens is below 'Log Prob Threshold', consider the segment as silent.")
             dd_compute_type = gr.Dropdown(label="Compute Type", choices=self.whisper_inf.available_compute_types,
                                           value=self.whisper_inf.current_compute_type, interactive=True,
@@ -78,10 +83,12 @@ class App:
                                    info="Number of candidates when sampling with non-zero temperature.")
             nb_patience = gr.Number(label="Patience", value=whisper_params["patience"], interactive=True,
                                     info="Beam search patience factor.")
-            cb_condition_on_previous_text = gr.Checkbox(label="Condition On Previous Text", value=whisper_params["condition_on_previous_text"],
+            cb_condition_on_previous_text = gr.Checkbox(label="Condition On Previous Text",
+                                                        value=whisper_params["condition_on_previous_text"],
                                                         interactive=True,
                                                         info="Condition on previous text during decoding.")
-            sld_prompt_reset_on_temperature = gr.Slider(label="Prompt Reset On Temperature", value=whisper_params["prompt_reset_on_temperature"],
+            sld_prompt_reset_on_temperature = gr.Slider(label="Prompt Reset On Temperature",
+                                                        value=whisper_params["prompt_reset_on_temperature"],
                                                         minimum=0, maximum=1, step=0.01, interactive=True,
                                                         info="Resets prompt if temperature is above this value."
                                                              " Arg has effect only if 'Condition On Previous Text' is True.")
@@ -90,7 +97,8 @@ class App:
             sd_temperature = gr.Slider(label="Temperature", value=whisper_params["temperature"], minimum=0.0,
                                        step=0.01, maximum=1.0, interactive=True,
                                        info="Temperature for sampling. It can be a tuple of temperatures, which will be successively used upon failures according to either `Compression Ratio Threshold` or `Log Prob Threshold`.")
-            nb_compression_ratio_threshold = gr.Number(label="Compression Ratio Threshold", value=whisper_params["compression_ratio_threshold"],
+            nb_compression_ratio_threshold = gr.Number(label="Compression Ratio Threshold",
+                                                       value=whisper_params["compression_ratio_threshold"],
                                                        interactive=True,
                                                        info="If the gzip compression ratio is above this value, treat as failed.")
             nb_chunk_length = gr.Number(label="Chunk Length (s)", value=lambda: whisper_params["chunk_length"],
@@ -99,9 +107,11 @@ class App:
             with gr.Group(visible=isinstance(self.whisper_inf, FasterWhisperInference)):
                 nb_length_penalty = gr.Number(label="Length Penalty", value=whisper_params["length_penalty"],
                                               info="Exponential length penalty constant.")
-                nb_repetition_penalty = gr.Number(label="Repetition Penalty", value=whisper_params["repetition_penalty"],
+                nb_repetition_penalty = gr.Number(label="Repetition Penalty",
+                                                  value=whisper_params["repetition_penalty"],
                                                   info="Penalty applied to the score of previously generated tokens (set > 1 to penalize).")
-                nb_no_repeat_ngram_size = gr.Number(label="No Repeat N-gram Size", value=whisper_params["no_repeat_ngram_size"],
+                nb_no_repeat_ngram_size = gr.Number(label="No Repeat N-gram Size",
+                                                    value=whisper_params["no_repeat_ngram_size"],
                                                     precision=0,
                                                     info="Prevent repetitions of n-grams with this size (set 0 to disable).")
                 tb_prefix = gr.Textbox(label="Prefix", value=lambda: whisper_params["prefix"],
@@ -110,48 +120,55 @@ class App:
                                                 info="Suppress blank outputs at the beginning of the sampling.")
                 tb_suppress_tokens = gr.Textbox(label="Suppress Tokens", value=whisper_params["suppress_tokens"],
                                                 info="List of token IDs to suppress. -1 will suppress a default set of symbols as defined in the model config.json file.")
-                nb_max_initial_timestamp = gr.Number(label="Max Initial Timestamp", value=whisper_params["max_initial_timestamp"],
+                nb_max_initial_timestamp = gr.Number(label="Max Initial Timestamp",
+                                                     value=whisper_params["max_initial_timestamp"],
                                                      info="The initial timestamp cannot be later than this.")
                 cb_word_timestamps = gr.Checkbox(label="Word Timestamps", value=whisper_params["word_timestamps"],
                                                  info="Extract word-level timestamps using the cross-attention pattern and dynamic time warping, and include the timestamps for each word in each segment.")
-                tb_prepend_punctuations = gr.Textbox(label="Prepend Punctuations", value=whisper_params["prepend_punctuations"],
+                tb_prepend_punctuations = gr.Textbox(label="Prepend Punctuations",
+                                                     value=whisper_params["prepend_punctuations"],
                                                      info="If 'Word Timestamps' is True, merge these punctuation symbols with the next word.")
-                tb_append_punctuations = gr.Textbox(label="Append Punctuations", value=whisper_params["append_punctuations"],
+                tb_append_punctuations = gr.Textbox(label="Append Punctuations",
+                                                    value=whisper_params["append_punctuations"],
                                                     info="If 'Word Timestamps' is True, merge these punctuation symbols with the previous word.")
                 nb_max_new_tokens = gr.Number(label="Max New Tokens", value=lambda: whisper_params["max_new_tokens"],
                                               precision=0,
                                               info="Maximum number of new tokens to generate per-chunk. If not set, the maximum will be set by the default max_length.")
                 nb_hallucination_silence_threshold = gr.Number(label="Hallucination Silence Threshold (sec)",
-                                                               value=lambda: whisper_params["hallucination_silence_threshold"],
+                                                               value=lambda: whisper_params[
+                                                                   "hallucination_silence_threshold"],
                                                                info="When 'Word Timestamps' is True, skip silent periods longer than this threshold (in seconds) when a possible hallucination is detected.")
                 tb_hotwords = gr.Textbox(label="Hotwords", value=lambda: whisper_params["hotwords"],
                                          info="Hotwords/hint phrases to provide the model with. Has no effect if prefix is not None.")
-                nb_language_detection_threshold = gr.Number(label="Language Detection Threshold", value=lambda: whisper_params["language_detection_threshold"],
+                nb_language_detection_threshold = gr.Number(label="Language Detection Threshold",
+                                                            value=lambda: whisper_params[
+                                                                "language_detection_threshold"],
                                                             info="If the maximum probability of the language tokens is higher than this value, the language is detected.")
-                nb_language_detection_segments = gr.Number(label="Language Detection Segments", value=lambda: whisper_params["language_detection_segments"],
+                nb_language_detection_segments = gr.Number(label="Language Detection Segments",
+                                                           value=lambda: whisper_params["language_detection_segments"],
                                                            precision=0,
                                                            info="Number of segments to consider for the language detection.")
             with gr.Group(visible=isinstance(self.whisper_inf, InsanelyFastWhisperInference)):
                 nb_batch_size = gr.Number(label="Batch Size", value=whisper_params["batch_size"], precision=0)
 
-        with gr.Accordion("Background Music Remover Filter", open=False):
-            cb_bgm_separation = gr.Checkbox(label="Enable Background Music Remover Filter", value=uvr_params["is_separate_bgm"],
+        with gr.Accordion(_("Background Music Remover Filter"), open=False):
+            cb_bgm_separation = gr.Checkbox(label=_("Enable Background Music Remover Filter"),
+                                            value=uvr_params["is_separate_bgm"],
                                             interactive=True,
-                                            info="Enabling this will remove background music by submodel before"
-                                                 " transcribing ")
-            dd_uvr_device = gr.Dropdown(label="Device", value=self.whisper_inf.music_separator.device,
+                                            info=_("Enabling this will remove background music"))
+            dd_uvr_device = gr.Dropdown(label=_("Device"), value=self.whisper_inf.music_separator.device,
                                         choices=self.whisper_inf.music_separator.available_devices)
-            dd_uvr_model_size = gr.Dropdown(label="Model", value=uvr_params["model_size"],
+            dd_uvr_model_size = gr.Dropdown(label=_("Model"), value=uvr_params["model_size"],
                                             choices=self.whisper_inf.music_separator.available_models)
             nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"], precision=0)
-            cb_uvr_save_file = gr.Checkbox(label="Save separated files to output", value=uvr_params["save_file"])
-            cb_uvr_enable_offload = gr.Checkbox(label="Offload sub model after removing background music",
+            cb_uvr_save_file = gr.Checkbox(label=_("Save separated files to output"), value=uvr_params["save_file"])
+            cb_uvr_enable_offload = gr.Checkbox(label=_("Offload sub model after removing background music"),
                                                 value=uvr_params["enable_offload"])
 
-        with gr.Accordion("Voice Detection Filter", open=False):
-            cb_vad_filter = gr.Checkbox(label="Enable Silero VAD Filter", value=vad_params["vad_filter"],
+        with gr.Accordion(_("Voice Detection Filter"), open=False):
+            cb_vad_filter = gr.Checkbox(label=_("Enable Silero VAD Filter"), value=vad_params["vad_filter"],
                                         interactive=True,
-                                        info="Enable this to transcribe only detected voice parts by submodel.")
+                                        info=_("Enable this to transcribe only detected voice"))
             sd_threshold = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Speech Threshold",
                                      value=vad_params["threshold"],
                                      info="Lower it to be more sensitive to small sounds.")
@@ -168,15 +185,11 @@ class App:
             nb_speech_pad_ms = gr.Number(label="Speech Padding (ms)", precision=0, value=vad_params["speech_pad_ms"],
                                          info="Final speech chunks are padded by this time each side")
 
-        with gr.Accordion("Diarization", open=False):
-            cb_diarize = gr.Checkbox(label="Enable Diarization", value=diarization_params["is_diarize"])
-            tb_hf_token = gr.Text(label="HuggingFace Token", value=diarization_params["hf_token"],
-                                  info="This is only needed the first time you download the model. If you already have"
-                                       " models, you don't need to enter. To download the model, you must manually go "
-                                       "to \"https://huggingface.co/pyannote/speaker-diarization-3.1\" and "
-                                       "\"https://huggingface.co/pyannote/segmentation-3.0\" and agree to"
-                                       " their requirement.")
-            dd_diarization_device = gr.Dropdown(label="Device",
+        with gr.Accordion(_("Diarization"), open=False):
+            cb_diarize = gr.Checkbox(label=_("Enable Diarization"), value=diarization_params["is_diarize"])
+            tb_hf_token = gr.Text(label=_("HuggingFace Token"), value=diarization_params["hf_token"],
+                                  info=_("This is only needed the first time you download the model"))
+            dd_diarization_device = gr.Dropdown(label=_("Device"),
                                                 choices=self.whisper_inf.diarizer.get_available_device(),
                                                 value=self.whisper_inf.diarizer.get_device())
 
@@ -295,15 +308,19 @@ class App:
 
                     with gr.TabItem(_("T2T Translation")):  # tab 4
                         with gr.Row():
-                            file_subs = gr.Files(type="filepath", label="Upload Subtitle Files to translate here")
+                            file_subs = gr.Files(type="filepath", label=_("Upload Subtitle Files to translate here"))
 
                         with gr.TabItem(_("DeepL API")):  # sub tab1
                             with gr.Row():
-                                tb_api_key = gr.Textbox(label=_("Your Auth Key (API KEY)"), value=deepl_params["api_key"])
+                                tb_api_key = gr.Textbox(label=_("Your Auth Key (API KEY)"),
+                                                        value=deepl_params["api_key"])
                             with gr.Row():
-                                dd_source_lang = gr.Dropdown(label=_("Source Language"), value=deepl_params["source_lang"],
+                                dd_source_lang = gr.Dropdown(label=_("Source Language"),
+                                                             value=AUTOMATIC_DETECTION if deepl_params["source_lang"] == AUTOMATIC_DETECTION.unwrap()
+                                                             else deepl_params["source_lang"],
                                                              choices=list(self.deepl_api.available_source_langs.keys()))
-                                dd_target_lang = gr.Dropdown(label=_("Target Language"), value=deepl_params["target_lang"],
+                                dd_target_lang = gr.Dropdown(label=_("Target Language"),
+                                                             value=deepl_params["target_lang"],
                                                              choices=list(self.deepl_api.available_target_langs.keys()))
                             with gr.Row():
                                 cb_is_pro = gr.Checkbox(label=_("Pro User?"), value=deepl_params["is_pro"])
@@ -323,17 +340,20 @@ class App:
                                               cb_is_pro, cb_timestamp],
                                       outputs=[tb_indicator, files_subtitles])
 
-                        btn_openfolder.click(fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "translations")),
-                                             inputs=None,
-                                             outputs=None)
+                        btn_openfolder.click(
+                            fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "translations")),
+                            inputs=None,
+                            outputs=None)
 
                         with gr.TabItem(_("NLLB")):  # sub tab2
                             with gr.Row():
                                 dd_model_size = gr.Dropdown(label=_("Model"), value=nllb_params["model_size"],
                                                             choices=self.nllb_inf.available_models)
-                                dd_source_lang = gr.Dropdown(label=_("Source Language"), value=nllb_params["source_lang"],
+                                dd_source_lang = gr.Dropdown(label=_("Source Language"),
+                                                             value=nllb_params["source_lang"],
                                                              choices=self.nllb_inf.available_source_langs)
-                                dd_target_lang = gr.Dropdown(label=_("Target Language"), value=nllb_params["target_lang"],
+                                dd_target_lang = gr.Dropdown(label=_("Target Language"),
+                                                             value=nllb_params["target_lang"],
                                                              choices=self.nllb_inf.available_target_langs)
                             with gr.Row():
                                 nb_max_length = gr.Number(label="Max Length Per Line", value=nllb_params["max_length"],
@@ -356,17 +376,19 @@ class App:
                                               nb_max_length, cb_timestamp],
                                       outputs=[tb_indicator, files_subtitles])
 
-                        btn_openfolder.click(fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "translations")),
-                                             inputs=None,
-                                             outputs=None)
+                        btn_openfolder.click(
+                            fn=lambda: self.open_folder(os.path.join(self.args.output_dir, "translations")),
+                            inputs=None,
+                            outputs=None)
 
                     with gr.TabItem(_("BGM Separation")):
-                        files_audio = gr.Files(type="filepath", label="Upload Audio Files to separate background music")
+                        files_audio = gr.Files(type="filepath", label=_("Upload Audio Files to separate background music"))
                         dd_uvr_device = gr.Dropdown(label=_("Device"), value=self.whisper_inf.music_separator.device,
                                                     choices=self.whisper_inf.music_separator.available_devices)
                         dd_uvr_model_size = gr.Dropdown(label=_("Model"), value=uvr_params["model_size"],
                                                         choices=self.whisper_inf.music_separator.available_models)
-                        nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"], precision=0)
+                        nb_uvr_segment_size = gr.Number(label="Segment Size", value=uvr_params["segment_size"],
+                                                        precision=0)
                         cb_uvr_save_file = gr.Checkbox(label=_("Save separated files to output"),
                                                        value=True, visible=False)
                         btn_run = gr.Button(_("SEPARATE BACKGROUND MUSIC"), variant="primary")
@@ -390,7 +412,7 @@ class App:
                         btn_open_vocals_folder.click(inputs=None,
                                                      outputs=None,
                                                      fn=lambda: self.open_folder(os.path.join(
-                                                        self.args.output_dir, "UVR", "vocals"
+                                                         self.args.output_dir, "UVR", "vocals"
                                                      )))
 
         # Launch the app with optional gradio settings
@@ -424,10 +446,10 @@ class App:
             return gr.Checkbox(visible=True, value=False, label="Translate to English?", interactive=True)
 
 
-# Create the parser for command-line arguments
 parser = argparse.ArgumentParser()
 parser.add_argument('--whisper_type', type=str, default="faster-whisper",
-                    help='A type of the whisper implementation between: ["whisper", "faster-whisper", "insanely-fast-whisper"]')
+                    choices=["whisper", "faster-whisper", "insanely-fast-whisper"],
+                    help='A type of the whisper implementation (Github repo name)')
 parser.add_argument('--share', type=str2bool, default=False, nargs='?', const=True, help='Gradio share value')
 parser.add_argument('--server_name', type=str, default=None, help='Gradio server host')
 parser.add_argument('--server_port', type=int, default=None, help='Gradio server port')
@@ -436,8 +458,10 @@ parser.add_argument('--username', type=str, default=None, help='Gradio authentic
 parser.add_argument('--password', type=str, default=None, help='Gradio authentication password')
 parser.add_argument('--theme', type=str, default=None, help='Gradio Blocks theme')
 parser.add_argument('--colab', type=str2bool, default=False, nargs='?', const=True, help='Is colab user or not')
-parser.add_argument('--api_open', type=str2bool, default=False, nargs='?', const=True, help='Enable api or not in Gradio')
-parser.add_argument('--inbrowser', type=str2bool, default=True, nargs='?', const=True, help='Whether to automatically start Gradio app or not')
+parser.add_argument('--api_open', type=str2bool, default=False, nargs='?', const=True,
+                    help='Enable api or not in Gradio')
+parser.add_argument('--inbrowser', type=str2bool, default=True, nargs='?', const=True,
+                    help='Whether to automatically start Gradio app or not')
 parser.add_argument('--whisper_model_dir', type=str, default=WHISPER_MODELS_DIR,
                     help='Directory path of the whisper model')
 parser.add_argument('--faster_whisper_model_dir', type=str, default=FASTER_WHISPER_MODELS_DIR,