Migrate to gradio 4.x

app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import pathlib
 
 import gradio as gr
 import numpy as np
@@ -17,26 +18,20 @@ from lang_list import (
     TEXT_SOURCE_LANGUAGE_NAMES,
 )
 
-snapshot_download(repo_id="meta-private/M4Tv2", repo_type="model", local_dir="models")
+if not pathlib.Path("models").exists():
+    snapshot_download(repo_id="meta-private/M4Tv2", repo_type="model", local_dir="models")
 
-DESCRIPTION = """# SeamlessM4T
+DESCRIPTION = """\
+# SeamlessM4T
 
 [SeamlessM4T](https://github.com/facebookresearch/seamless_communication) is designed to provide high-quality
 translation, allowing people from different linguistic communities to communicate effortlessly through speech and text.
-
 This unified model enables multiple tasks like Speech-to-Speech (S2ST), Speech-to-Text (S2TT), Text-to-Speech (T2ST)
 translation and more, without relying on multiple separate models.
 """
 
 CACHE_EXAMPLES = os.getenv("CACHE_EXAMPLES") == "1" and torch.cuda.is_available()
 
-TASK_NAMES = [
-    "S2ST (Speech to Speech translation)",
-    "S2TT (Speech to Text translation)",
-    "T2ST (Text to Speech translation)",
-    "T2TT (Text to Text translation)",
-    "ASR (Automatic Speech Recognition)",
-]
 AUDIO_SAMPLE_RATE = 16000.0
 MAX_INPUT_AUDIO_LENGTH = 60  # in seconds
 DEFAULT_TARGET_LANGUAGE = "French"
@@ -55,388 +50,314 @@ translator = Translator(
 )
 
 
-def predict(
-    task_name: str,
-    audio_source: str,
-    input_audio_mic: str | None,
-    input_audio_file: str | None,
-    input_text: str | None,
-    source_language: str | None,
-    target_language: str,
-) -> tuple[tuple[int, np.ndarray] | None, str]:
-    task_name = task_name.split()[0]
-    source_language_code = LANGUAGE_NAME_TO_CODE[source_language] if source_language else None
-    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
+def preprocess_audio(input_audio: str) -> None:
+    arr, org_sr = torchaudio.load(input_audio)
+    new_arr = torchaudio.functional.resample(arr, orig_freq=org_sr, new_freq=AUDIO_SAMPLE_RATE)
+    max_length = int(MAX_INPUT_AUDIO_LENGTH * AUDIO_SAMPLE_RATE)
+    if new_arr.shape[1] > max_length:
+        new_arr = new_arr[:, :max_length]
+        gr.Warning(f"Input audio is too long. Only the first {MAX_INPUT_AUDIO_LENGTH} seconds is used.")
+    torchaudio.save(input_audio, new_arr, sample_rate=int(AUDIO_SAMPLE_RATE))
 
-    if task_name in ["S2ST", "S2TT", "ASR"]:
-        if audio_source == "microphone":
-            input_data = input_audio_mic
-        else:
-            input_data = input_audio_file
-
-        arr, org_sr = torchaudio.load(input_data)
-        new_arr = torchaudio.functional.resample(arr, orig_freq=org_sr, new_freq=AUDIO_SAMPLE_RATE)
-        max_length = int(MAX_INPUT_AUDIO_LENGTH * AUDIO_SAMPLE_RATE)
-        if new_arr.shape[1] > max_length:
-            new_arr = new_arr[:, :max_length]
-            gr.Warning(f"Input audio is too long. Only the first {MAX_INPUT_AUDIO_LENGTH} seconds is used.")
-        torchaudio.save(input_data, new_arr, sample_rate=int(AUDIO_SAMPLE_RATE))
-    else:
-        input_data = input_text
+
+def run_s2st(input_audio: str, target_language: str) -> tuple[tuple[int, np.ndarray] | None, str]:
+    preprocess_audio(input_audio)
+    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
     out_texts, out_audios = translator.predict(
-        input=input_data,
-        task_str=task_name,
+        input=input_audio,
+        task_str="S2ST",
         tgt_lang=target_language_code,
-        src_lang=source_language_code,
     )
     out_text = str(out_texts[0])
-
-    if task_name in ["S2ST", "T2ST"]:
-        out_wav = out_audios.audio_wavs[0]
-        return (int(AUDIO_SAMPLE_RATE), out_wav.cpu().detach().numpy()), out_text
-    else:
-        return None, out_text
-
-
-def process_s2st_example(input_audio_file: str, target_language: str) -> tuple[tuple[int, np.ndarray] | None, str]:
-    return predict(
-        task_name="S2ST",
-        audio_source="file",
-        input_audio_mic=None,
-        input_audio_file=input_audio_file,
-        input_text=None,
-        source_language=None,
-        target_language=target_language,
-    )
+    out_wav = out_audios.audio_wavs[0].cpu().detach().numpy()
+    return (int(AUDIO_SAMPLE_RATE), out_wav), out_text
 
 
-def process_s2tt_example(input_audio_file: str, target_language: str) -> tuple[tuple[int, np.ndarray] | None, str]:
-    return predict(
-        task_name="S2TT",
-        audio_source="file",
-        input_audio_mic=None,
-        input_audio_file=input_audio_file,
-        input_text=None,
-        source_language=None,
-        target_language=target_language,
-    )
-
-
-def process_t2st_example(
-    input_text: str, source_language: str, target_language: str
-) -> tuple[tuple[int, np.ndarray] | None, str]:
-    return predict(
-        task_name="T2ST",
-        audio_source="",
-        input_audio_mic=None,
-        input_audio_file=None,
-        input_text=input_text,
-        source_language=source_language,
-        target_language=target_language,
+def run_s2tt(input_audio: str, target_language: str) -> str:
+    preprocess_audio(input_audio)
+    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
+    out_texts, _ = translator.predict(
+        input=input_audio,
+        task_str="S2TT",
+        tgt_lang=target_language_code,
     )
+    return str(out_texts[0])
 
 
-def process_t2tt_example(
-    input_text: str, source_language: str, target_language: str
-) -> tuple[tuple[int, np.ndarray] | None, str]:
-    return predict(
-        task_name="T2TT",
-        audio_source="",
-        input_audio_mic=None,
-        input_audio_file=None,
-        input_text=input_text,
-        source_language=source_language,
-        target_language=target_language,
+def run_t2st(input_text: str, source_language: str, target_language: str) -> tuple[tuple[int, np.ndarray] | None, str]:
+    source_language_code = LANGUAGE_NAME_TO_CODE[source_language]
+    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
+    out_texts, out_audios = translator.predict(
+        input=input_text,
+        task_str="T2ST",
+        tgt_lang=target_language_code,
+        src_lang=source_language_code,
     )
+    out_text = str(out_texts[0])
+    out_wav = out_audios.audio_wavs[0].cpu().detach().numpy()
+    return (int(AUDIO_SAMPLE_RATE), out_wav), out_text
 
 
-def process_asr_example(input_audio_file: str, target_language: str) -> tuple[tuple[int, np.ndarray] | None, str]:
-    return predict(
-        task_name="ASR",
-        audio_source="file",
-        input_audio_mic=None,
-        input_audio_file=input_audio_file,
-        input_text=None,
-        source_language=None,
-        target_language=target_language,
+def run_t2tt(input_text: str, source_language: str, target_language: str) -> str:
+    source_language_code = LANGUAGE_NAME_TO_CODE[source_language]
+    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
+    out_texts, _ = translator.predict(
+        input=input_text,
+        task_str="T2TT",
+        tgt_lang=target_language_code,
+        src_lang=source_language_code,
     )
+    return str(out_texts[0])
 
 
-def update_audio_ui(audio_source: str) -> tuple[dict, dict]:
-    mic = audio_source == "microphone"
-    return (
-        gr.update(visible=mic, value=None),  # input_audio_mic
-        gr.update(visible=not mic, value=None),  # input_audio_file
+def run_asr(input_audio: str, target_language: str) -> str:
+    preprocess_audio(input_audio)
+    target_language_code = LANGUAGE_NAME_TO_CODE[target_language]
+    out_texts, _ = translator.predict(
+        input=input_audio,
+        task_str="ASR",
+        tgt_lang=target_language_code,
     )
+    return str(out_texts[0])
 
 
-def update_input_ui(task_name: str) -> tuple[dict, dict, dict, dict]:
-    task_name = task_name.split()[0]
-    if task_name == "S2ST":
-        return (
-            gr.update(visible=True),  # audio_box
-            gr.update(visible=False),  # input_text
-            gr.update(visible=False),  # source_language
-            gr.update(
-                visible=True, choices=S2ST_TARGET_LANGUAGE_NAMES, value=DEFAULT_TARGET_LANGUAGE
-            ),  # target_language
-        )
-    elif task_name == "S2TT":
-        return (
-            gr.update(visible=True),  # audio_box
-            gr.update(visible=False),  # input_text
-            gr.update(visible=False),  # source_language
-            gr.update(
-                visible=True, choices=S2TT_TARGET_LANGUAGE_NAMES, value=DEFAULT_TARGET_LANGUAGE
-            ),  # target_language
-        )
-    elif task_name == "T2ST":
-        return (
-            gr.update(visible=False),  # audio_box
-            gr.update(visible=True),  # input_text
-            gr.update(visible=True),  # source_language
-            gr.update(
-                visible=True, choices=S2ST_TARGET_LANGUAGE_NAMES, value=DEFAULT_TARGET_LANGUAGE
-            ),  # target_language
-        )
-    elif task_name == "T2TT":
-        return (
-            gr.update(visible=False),  # audio_box
-            gr.update(visible=True),  # input_text
-            gr.update(visible=True),  # source_language
-            gr.update(
-                visible=True, choices=T2TT_TARGET_LANGUAGE_NAMES, value=DEFAULT_TARGET_LANGUAGE
-            ),  # target_language
+with gr.Blocks() as demo_s2st:
+    with gr.Group():
+        target_language = gr.Dropdown(
+            label="Target language",
+            choices=S2ST_TARGET_LANGUAGE_NAMES,
+            value=DEFAULT_TARGET_LANGUAGE,
         )
-    elif task_name == "ASR":
-        return (
-            gr.update(visible=True),  # audio_box
-            gr.update(visible=False),  # input_text
-            gr.update(visible=False),  # source_language
-            gr.update(
-                visible=True, choices=S2TT_TARGET_LANGUAGE_NAMES, value=DEFAULT_TARGET_LANGUAGE
-            ),  # target_language
+        input_audio = gr.Audio(label="Input speech", type="filepath")
+        btn = gr.Button("Translate")
+        output_audio = gr.Audio(
+            label="Translated speech",
+            autoplay=False,
+            streaming=False,
+            type="numpy",
         )
-    else:
-        raise ValueError(f"Unknown task: {task_name}")
+        output_text = gr.Textbox(label="Translated text")
+
+    gr.Examples(
+        examples=[
+            ["assets/sample_input.mp3", "French"],
+            ["assets/sample_input.mp3", "Mandarin Chinese"],
+            ["assets/sample_input_2.mp3", "Hindi"],
+            ["assets/sample_input_2.mp3", "Spanish"],
+        ],
+        inputs=[input_audio, target_language],
+        outputs=[output_audio, output_text],
+        fn=run_s2st,
+        cache_examples=CACHE_EXAMPLES,
+        api_name=False,
+    )
 
+    btn.click(
+        fn=run_s2st,
+        inputs=[input_audio, target_language],
+        outputs=[output_audio, output_text],
+        api_name="s2st",
+    )
 
-def update_output_ui(task_name: str) -> tuple[dict, dict]:
-    task_name = task_name.split()[0]
-    if task_name in ["S2ST", "T2ST"]:
-        return (
-            gr.update(visible=True, value=None),  # output_audio
-            gr.update(value=None),  # output_text
-        )
-    elif task_name in ["S2TT", "T2TT", "ASR"]:
-        return (
-            gr.update(visible=False, value=None),  # output_audio
-            gr.update(value=None),  # output_text
+with gr.Blocks() as demo_s2tt:
+    with gr.Group():
+        target_language = gr.Dropdown(
+            label="Target language",
+            choices=S2TT_TARGET_LANGUAGE_NAMES,
+            value=DEFAULT_TARGET_LANGUAGE,
         )
-    else:
-        raise ValueError(f"Unknown task: {task_name}")
-
-
-def update_example_ui(task_name: str) -> tuple[dict, dict, dict, dict, dict]:
-    task_name = task_name.split()[0]
-    return (
-        gr.update(visible=task_name == "S2ST"),  # s2st_example_row
-        gr.update(visible=task_name == "S2TT"),  # s2tt_example_row
-        gr.update(visible=task_name == "T2ST"),  # t2st_example_row
-        gr.update(visible=task_name == "T2TT"),  # t2tt_example_row
-        gr.update(visible=task_name == "ASR"),  # asr_example_row
+        input_audio = gr.Audio(label="Input speech", type="filepath")
+        btn = gr.Button("Translate")
+        output_text = gr.Textbox(label="Translated text")
+
+    gr.Examples(
+        examples=[
+            ["assets/sample_input.mp3", "French"],
+            ["assets/sample_input.mp3", "Mandarin Chinese"],
+            ["assets/sample_input_2.mp3", "Hindi"],
+            ["assets/sample_input_2.mp3", "Spanish"],
+        ],
+        inputs=[input_audio, target_language],
+        outputs=output_text,
+        fn=run_s2tt,
+        cache_examples=CACHE_EXAMPLES,
+        api_name=False,
     )
 
-
-with gr.Blocks(css="style.css") as demo:
-    gr.Markdown(DESCRIPTION)
-    gr.DuplicateButton(
-        value="Duplicate Space for private use",
-        elem_id="duplicate-button",
-        visible=os.getenv("SHOW_DUPLICATE_BUTTON") == "1",
+    btn.click(
+        fn=run_s2tt,
+        inputs=[input_audio, target_language],
+        outputs=output_text,
+        api_name="s2tt",
     )
+
+with gr.Blocks() as demo_t2st:
     with gr.Group():
-        task_name = gr.Dropdown(
-            label="Task",
-            choices=TASK_NAMES,
-            value=TASK_NAMES[0],
-        )
         with gr.Row():
             source_language = gr.Dropdown(
                 label="Source language",
                 choices=TEXT_SOURCE_LANGUAGE_NAMES,
                 value="English",
-                visible=False,
             )
             target_language = gr.Dropdown(
                 label="Target language",
-                choices=S2ST_TARGET_LANGUAGE_NAMES,
+                choices=T2TT_TARGET_LANGUAGE_NAMES,
                 value=DEFAULT_TARGET_LANGUAGE,
             )
-        with gr.Row() as audio_box:
-            audio_source = gr.Radio(
-                label="Audio source",
-                choices=["file", "microphone"],
-                value="file",
-            )
-            input_audio_mic = gr.Audio(
-                label="Input speech",
-                type="filepath",
-                source="microphone",
-                visible=False,
-            )
-            input_audio_file = gr.Audio(
-                label="Input speech",
-                type="filepath",
-                source="upload",
-                visible=True,
-            )
-        input_text = gr.Textbox(label="Input text", visible=False)
+        input_text = gr.Textbox(label="Input text")
         btn = gr.Button("Translate")
-        with gr.Column():
-            output_audio = gr.Audio(
-                label="Translated speech",
-                autoplay=False,
-                streaming=False,
-                type="numpy",
-            )
-            output_text = gr.Textbox(label="Translated text")
-
-    with gr.Row(visible=True) as s2st_example_row:
-        s2st_examples = gr.Examples(
-            examples=[
-                ["assets/sample_input.mp3", "French"],
-                ["assets/sample_input.mp3", "Mandarin Chinese"],
-                ["assets/sample_input_2.mp3", "Hindi"],
-                ["assets/sample_input_2.mp3", "Spanish"],
-            ],
-            inputs=[input_audio_file, target_language],
-            outputs=[output_audio, output_text],
-            fn=process_s2st_example,
-            cache_examples=CACHE_EXAMPLES,
+        output_audio = gr.Audio(
+            label="Translated speech",
+            autoplay=False,
+            streaming=False,
+            type="numpy",
         )
-    with gr.Row(visible=False) as s2tt_example_row:
-        s2tt_examples = gr.Examples(
-            examples=[
-                ["assets/sample_input.mp3", "French"],
-                ["assets/sample_input.mp3", "Mandarin Chinese"],
-                ["assets/sample_input_2.mp3", "Hindi"],
-                ["assets/sample_input_2.mp3", "Spanish"],
+        output_text = gr.Textbox(label="Translated text")
+
+    gr.Examples(
+        examples=[
+            [
+                "My favorite animal is the elephant.",
+                "English",
+                "French",
             ],
-            inputs=[input_audio_file, target_language],
-            outputs=[output_audio, output_text],
-            fn=process_s2tt_example,
-            cache_examples=CACHE_EXAMPLES,
-        )
-    with gr.Row(visible=False) as t2st_example_row:
-        t2st_examples = gr.Examples(
-            examples=[
-                ["My favorite animal is the elephant.", "English", "French"],
-                ["My favorite animal is the elephant.", "English", "Mandarin Chinese"],
-                [
-                    "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
-                    "English",
-                    "Hindi",
-                ],
-                [
-                    "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
-                    "English",
-                    "Spanish",
-                ],
+            [
+                "My favorite animal is the elephant.",
+                "English",
+                "Mandarin Chinese",
             ],
-            inputs=[input_text, source_language, target_language],
-            outputs=[output_audio, output_text],
-            fn=process_t2st_example,
-            cache_examples=CACHE_EXAMPLES,
-        )
-    with gr.Row(visible=False) as t2tt_example_row:
-        t2tt_examples = gr.Examples(
-            examples=[
-                ["My favorite animal is the elephant.", "English", "French"],
-                ["My favorite animal is the elephant.", "English", "Mandarin Chinese"],
-                [
-                    "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
-                    "English",
-                    "Hindi",
-                ],
-                [
-                    "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
-                    "English",
-                    "Spanish",
-                ],
+            [
+                "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
+                "English",
+                "Hindi",
             ],
-            inputs=[input_text, source_language, target_language],
-            outputs=[output_audio, output_text],
-            fn=process_t2tt_example,
-            cache_examples=CACHE_EXAMPLES,
-        )
-    with gr.Row(visible=False) as asr_example_row:
-        asr_examples = gr.Examples(
-            examples=[
-                ["assets/sample_input.mp3", "English"],
-                ["assets/sample_input_2.mp3", "English"],
+            [
+                "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
+                "English",
+                "Spanish",
             ],
-            inputs=[input_audio_file, target_language],
-            outputs=[output_audio, output_text],
-            fn=process_asr_example,
-            cache_examples=CACHE_EXAMPLES,
-        )
-
-    audio_source.change(
-        fn=update_audio_ui,
-        inputs=audio_source,
-        outputs=[
-            input_audio_mic,
-            input_audio_file,
         ],
-        queue=False,
+        inputs=[input_text, source_language, target_language],
+        outputs=[output_audio, output_text],
+        fn=run_t2st,
+        cache_examples=CACHE_EXAMPLES,
         api_name=False,
     )
-    task_name.change(
-        fn=update_input_ui,
-        inputs=task_name,
-        outputs=[
-            audio_box,
-            input_text,
-            source_language,
-            target_language,
-        ],
-        queue=False,
-        api_name=False,
-    ).then(
-        fn=update_output_ui,
-        inputs=task_name,
+
+    gr.on(
+        triggers=[input_text.submit, btn.click],
+        fn=run_t2st,
+        inputs=[input_text, source_language, target_language],
         outputs=[output_audio, output_text],
-        queue=False,
+        api_name="t2st",
+    )
+
+with gr.Blocks() as demo_t2tt:
+    with gr.Group():
+        with gr.Row():
+            source_language = gr.Dropdown(
+                label="Source language",
+                choices=TEXT_SOURCE_LANGUAGE_NAMES,
+                value="English",
+            )
+            target_language = gr.Dropdown(
+                label="Target language",
+                choices=T2TT_TARGET_LANGUAGE_NAMES,
+                value=DEFAULT_TARGET_LANGUAGE,
+            )
+        input_text = gr.Textbox(label="Input text")
+        btn = gr.Button("Translate")
+        output_text = gr.Textbox(label="Translated text")
+
+    gr.Examples(
+        examples=[
+            [
+                "My favorite animal is the elephant.",
+                "English",
+                "French",
+            ],
+            [
+                "My favorite animal is the elephant.",
+                "English",
+                "Mandarin Chinese",
+            ],
+            [
+                "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
+                "English",
+                "Hindi",
+            ],
+            [
+                "Meta AI's Seamless M4T model is democratising spoken communication across language barriers",
+                "English",
+                "Spanish",
+            ],
+        ],
+        inputs=[input_text, source_language, target_language],
+        outputs=output_text,
+        fn=run_t2tt,
+        cache_examples=CACHE_EXAMPLES,
         api_name=False,
-    ).then(
-        fn=update_example_ui,
-        inputs=task_name,
-        outputs=[
-            s2st_example_row,
-            s2tt_example_row,
-            t2st_example_row,
-            t2tt_example_row,
-            asr_example_row,
+    )
+
+    gr.on(
+        triggers=[input_text.submit, btn.click],
+        fn=run_t2tt,
+        inputs=[input_text, source_language, target_language],
+        outputs=output_text,
+        api_name="t2tt",
+    )
+
+with gr.Blocks() as demo_asr:
+    with gr.Group():
+        target_language = gr.Dropdown(
+            label="Target language",
+            choices=S2ST_TARGET_LANGUAGE_NAMES,
+            value=DEFAULT_TARGET_LANGUAGE,
+        )
+        input_audio = gr.Audio(label="Input speech", type="filepath")
+        btn = gr.Button("Translate")
+        output_text = gr.Textbox(label="Translated text")
+
+    gr.Examples(
+        examples=[
+            ["assets/sample_input.mp3", "English"],
+            ["assets/sample_input_2.mp3", "English"],
         ],
-        queue=False,
+        inputs=[input_audio, target_language],
+        outputs=output_text,
+        fn=run_asr,
+        cache_examples=CACHE_EXAMPLES,
         api_name=False,
     )
 
     btn.click(
-        fn=predict,
-        inputs=[
-            task_name,
-            audio_source,
-            input_audio_mic,
-            input_audio_file,
-            input_text,
-            source_language,
-            target_language,
-        ],
-        outputs=[output_audio, output_text],
-        api_name="run",
+        fn=run_asr,
+        inputs=[input_audio, target_language],
+        outputs=output_text,
+        api_name="asr",
+    )
+
+
+with gr.Blocks(css="style.css") as demo:
+    gr.Markdown(DESCRIPTION)
+    gr.DuplicateButton(
+        value="Duplicate Space for private use",
+        elem_id="duplicate-button",
+        visible=os.getenv("SHOW_DUPLICATE_BUTTON") == "1",
     )
 
+    with gr.Tabs():
+        with gr.Tab(label="S2ST"):
+            demo_s2st.render()
+        with gr.Tab(label="S2TT"):
+            demo_s2tt.render()
+        with gr.Tab(label="T2ST"):
+            demo_t2st.render()
+        with gr.Tab(label="T2TT"):
+            demo_t2tt.render()
+        with gr.Tab(label="ASR"):
+            demo_asr.render()
+
+
 if __name__ == "__main__":
     demo.queue(max_size=50).launch()

requirements.txt

@@ -1,4 +1,4 @@
-gradio==3.50.2
+gradio==4.3.0
 omegaconf==2.3.0
 torch==2.1.0
 torchaudio==2.1.0

style.css

@@ -9,7 +9,7 @@ h1 {
   border-radius: 100vh;
 }
 
-#component-0 {
+.contain {
   max-width: 730px;
   margin: auto;
   padding-top: 1.5rem;