Version 0.1

adjust.py

@@ -0,0 +1,126 @@
+from ui import *
+from pydub import AudioSegment
+from utils import load_groups_json
+from video_tool import add_subtitle_to_video
+import gradio as gr
+import os
+import utils
+import file_name
+
+min_duration_ms = 10000
+current_pos = 0
+
+speaker_to_name = {"Speaker": "Name"}
+speaker_to_sample = {"Speaker": "File"}
+
+sample_groups, _ = load_groups_json()
+
+
+def get_current():
+    name = list(speaker_to_name.values())[current_pos]
+    sample = list(speaker_to_sample.values())[current_pos]
+    return [name, sample]
+
+
+def prepare_output(input_file):
+    if input_file is None or not os.path.exists(input_file):
+        return
+
+    speakers = get_speakers(input_file)
+    adjust_speaker_update = adjust_speaker.update(
+        speakers[0], interactive=True)
+    adjust_audio_update = adjust_audio.update(speakers[1], interactive=True)
+    prev_button_update = prev_button.update(interactive=True)
+    next_button_update = next_button.update(interactive=True)
+    adjust_button_update = adjust_button.update(interactive=True)
+    # Return adjust speaker, adjust audio, previous, next, adjust button
+    return [adjust_speaker_update, adjust_audio_update, prev_button_update, next_button_update, adjust_button_update]
+
+
+def get_speakers(input_file):
+    if (input_file == None):
+        return [None, None]
+
+    global speaker_to_name
+    global speaker_to_sample
+
+    speaker_to_name = {}
+    speaker_to_sample = {}
+
+    for speaker in sample_groups:
+        for suffix in range(1, 100):
+            file_path = f"{speaker}-{suffix}.wav"
+            if os.path.exists(file_path):
+                audio_segment = AudioSegment.from_file(file_path)
+                if len(audio_segment) > min_duration_ms:
+                    print(f"Found file: {file_path}")
+                    print(
+                        f"File duration: {len(audio_segment) / 1000} seconds")
+                    break
+
+        temp_file_name = f"{speaker}-sample.wav"
+        audio_segment[:10 * 1000].export(temp_file_name, format="wav")
+        speaker_to_sample[speaker] = temp_file_name
+        speaker_to_name[speaker] = speaker
+    return get_current()
+
+
+def change_name(to_name):
+    current_speaker = sample_groups[current_pos]
+    speaker_to_name[current_speaker] = to_name
+    print(str(get_current()))
+
+
+def get_speakers_next(to_name):
+    change_name(to_name)
+    global current_pos
+    if (current_pos < len(sample_groups) - 1):
+        current_pos += 1
+    return get_current()
+
+
+def get_speakers_previous(to_name):
+    change_name(to_name)
+    global current_pos
+    if (current_pos > 0):
+        current_pos -= 1
+    return get_current()
+
+
+def start_adjust(to_name, progress=gr.Progress()):
+    change_name(to_name)
+
+    # Replacing texts
+    progress(0.4, desc=ui_lang["progress_adjust_speaker"])
+    transcribe_txt_list, subtitle_txt_list = utils.read_transcribe_subtitle_file(
+        False)
+    modified_transcribe = replace_text(transcribe_txt_list)
+    modified_subtitle = replace_text(subtitle_txt_list)
+    utils.write_transcribe_subtitle_file(
+        modified_transcribe, modified_subtitle, True)
+
+    # Adding subtitle to video
+    progress(0.8, desc=ui_lang["progress_add_subtitle"])
+    add_subtitle_to_video(
+        file_name.input_file, file_name.subtitle_adjusted_file, file_name.video_subtitle_file, file_name.start_time_for_adjustment, file_name.end_time_for_adjustment)
+
+    # Return video file link, transcribe string, transcribe.txt, subtitle.txt
+    transcribe_txt_list, _ = utils.read_transcribe_subtitle_file(True)
+    print(line for line in transcribe_txt_list)
+    transcribe_txt = "\n".join(transcribe_txt_list)
+    return [
+        file_name.video_subtitle_file,
+        transcribe_txt,
+        [file_name.transcribe_adjusted_file, file_name.subtitle_adjusted_file]
+    ]
+
+
+def replace_text(lines):
+    modified_lines = []
+    for line in lines:
+        for key, value in speaker_to_name.items():
+            line = line.replace(key, value)
+            print(f"Replacing {key} with {value}")
+        modified_lines.append(line)
+    print(modified_lines)
+    return modified_lines

app.py

@@ -1,27 +1,62 @@
-from huggingface_hub import login
-from diarization import start_diarization
-from transcribe import start_transcribe
-import ffmpeg
+from ui import *
+from adjust import *
+from set_up import prepare_input
 import gradio as gr
 
+with gr.Blocks() as demo:
+    ui_lang_radio.render()
+    ui_lang_radio.change(change_lang, inputs=ui_lang_radio,
+                         outputs=comp_to_update)
 
-def prepare_input(input_file, progress=gr.Progress()):
-    output_file = "input.wav"
-    progress(0.2, desc="Preparing video")
-    ffmpeg.input(input_file).audio.output(
-        output_file, format="wav").run()
-    progress(0.4, desc="Acquiring diarization")
-    start_diarization(output_file)
-    progress(0.6, desc="Transcribing audio")
-    return start_transcribe(progress)
+    top_markdown.render()
+    with gr.Column():
+        with gr.Row():
+            with gr.Column():
+                input_video.render()
+                input_video.change(get_duration, input_video, [
+                    start_time, end_time])
+                with gr.Row():
+                    start_time.render()
+                    end_time.render()
+            with gr.Column():
+                lang_radio.render()
+                model_dropdown.render()
+                summary_checkbox.render()
+        start_button.render()
+        start_button.click(prepare_input,
+                           [input_video, start_time, end_time, lang_radio,
+                               model_dropdown, summary_checkbox],
+                           [output_video, output_transcribe, output_file])
 
+    bottom_markdown.render()
+    with gr.Row(equal_height=False):
+        with gr.Column():
+            output_video.render()
+            output_file.render()
+            output_file.change(prepare_output, inputs=output_file, outputs=[
+                adjust_speaker, adjust_audio, prev_button, next_button, adjust_button])
+        with gr.Column():
+            output_transcribe.render()
+            output_summary.render()
 
-video_interface = gr.Interface(
-    fn=prepare_input,
-    inputs=gr.Video(type="file"),
-    outputs="files",
-    title="Test 2"
-)
+    middle_markdown.render()
+    with gr.Row(equal_height=False):
+        adjust_audio.render()
+        adjust_speaker.render()
+    with gr.Row():
+        prev_button.render()
+        next_button.render()
+        prev_button.click(get_speakers_previous, inputs=[adjust_speaker], outputs=[
+                          adjust_speaker, adjust_audio])
+        next_button.click(get_speakers_next, inputs=[adjust_speaker], outputs=[
+                          adjust_speaker, adjust_audio])
+
+    adjust_button.render()
+    adjust_button.click(start_adjust, inputs=[adjust_speaker], outputs=[
+                        output_video, output_transcribe, output_file])
+
+    with gr.Accordion("Copyright"):
+        gr.Markdown("Created with OpenAI Whisper and Huggingface")
 
 if __name__ == "__main__":
-    video_interface.launch()
+    demo.queue().launch()

diarization.py

@@ -1,11 +1,14 @@
 from pyannote.audio import Pipeline
 from pydub import AudioSegment
 import gradio as gr
-import os
 import torch
 import json
+import gc
 
-hugging_face_token = os.environ["HUGGING_FACE_TOKEN"]
+gc.collect()
+torch.cuda.empty_cache()
+
+hugging_face_token = "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"
 pipeline = Pipeline.from_pretrained(
     'pyannote/speaker-diarization', use_auth_token=hugging_face_token)
 device = torch.device("cuda")
@@ -48,7 +51,7 @@ def audio_segmentation(input_file, speaker_groups_dict):
 
 
 def save_groups_json(sample_groups_list: list, speaker_groups_dict: dict):
-    with open("sample_groups.json", "w") as json_file_sample:
+    with open("sample_groups.json", "w", encoding="utf-8") as json_file_sample:
         json.dump(sample_groups_list, json_file_sample)
-    with open("speaker_groups.json", "w") as json_file_speaker:
+    with open("speaker_groups.json", "w", encoding="utf-8") as json_file_speaker:
         json.dump(speaker_groups_dict, json_file_speaker)

file_name.py

@@ -0,0 +1,15 @@
+
+def get_title():
+    return input_file[:-4]
+
+
+input_file = ""
+audio_file = "input.wav"
+transcribe_file = "transcribe.txt"
+subtitle_file = "subtitle.srt"
+transcribe_adjusted_file = "transcribe_adjusted.txt"
+subtitle_adjusted_file = "subtitle_adjusted.srt"
+video_subtitle_file = f"output_{get_title()}.mp4"
+
+start_time_for_adjustment = "00:00:00"
+end_time_for_adjustment = "00:10:00"

lang_ui.py

@@ -0,0 +1,102 @@
+english_ui = {
+    "top_markdown": """
+        ## Transcribe
+        Insert your video and set the options for transcribing
+    """,
+    "middle_markdown": """
+        ## Adjustment
+        Listen to the clips below and type in the name according to the speaker's sound. After that, please click the 'Adjust Speaker' button to adjust the result above accordingly. 
+    """,
+    "bottom_markdown": """
+        ## Result
+        The following is the result of the transcribe
+    """,
+
+    "input_video_warning": "Please submit a video",
+    "start_time_warning": "Please provide a correct start time",
+    "end_time_warning": "Please provide a correct end time",
+    "lang_radio_warning": "Please choose a language for the video",
+    "model_dropdown_warning": "Please choose a model size for the video",
+
+    "input_video_label": "Insert video",
+    "start_time_label": "Start time",
+    "end_time_label": "End time",
+    "lang_radio_choices": ["English", "Indonesian", "Automatic"],
+    "lang_radio_label": "Language",
+    "lang_radio_info": "What language do they speak in the video?",
+    "model_dropdown_choices": ["tiny", "base", "small", "medium", "large"],
+    "model_dropdown_label": "Model size",
+    "model_dropdown_info": "The higher the model, the more accurate the transcript will be but the process will take longer",
+    "summary_checkbox_label": "Use summary",
+    "summary_checkbox_info": "Do you need a summary of the transcribe? Note: Result might be inaccurate",
+    "start_button_value": "Start Transcribing",
+
+    "adjust_speaker_value": "Speaker name",
+    "prev_button_value": "Previous Speaker",
+    "next_button_value": "Next Speaker",
+    "adjust_button_value": "Adjust Speaker",
+
+    "output_video_label": "Video with subtitle",
+    "output_transcribe_label": "Transcribe result",
+
+    "progress_starting_process": "Starting process",
+    "progress_preparing_video": "Preparing video",
+    "progress_acquiring_diarization": "Acquiring diarization",
+    "progress_transcribing_audio": "Transcribing audio",
+    "progress_adjust_speaker": "Adjusting speakers",
+    "progress_add_subtitle": "Adding subtitle on video"
+}
+
+indonesia_ui = {
+    "top_markdown": """
+        ## Transkrip
+        Masukkan video dan sesuaikan opsi untuk transkrip
+    """,
+    "middle_markdown": """
+        ## Penyesuaian
+        Dengarkan cuplikan suara pembicara dan ubah nama sesuai suara pembicara. Setelah itu, silahkan tekan tombol 'Sesuaikan Pembicara' untuk menyesuaikan nama pembicara pada hasil di atas
+    """,
+    "bottom_markdown": """
+        ## Hasil
+        Berikut hasil akhir dari transkrip
+    """,
+
+    "input_video_warning": "Mohon masukkan video",
+    "start_time_warning": "Mohon berikan waktu mulai yang sesuai",
+    "end_time_warning": "Mohon berikan waktu selesai yang sesuai",
+    "lang_radio_warning": "Mohon pilih bahasa yang digunakan dalam video",
+    "model_dropdown_warning": "Mohon pilih ukuran model yang digunakan untuk video",
+
+    "input_video_label": "Masukkan video",
+    "start_time_label": "Waktu mulai",
+    "end_time_label": "Waktu selesai",
+    "lang_radio_choices": ["Bahasa Inggris", "Bahasa Indonesia", "Otomatis"],
+    "lang_radio_label": "Bahasa",
+    "lang_radio_info": "Bahasa apa yang digunakan dalam video?",
+    "model_dropdown_choices": ["mungil", "dasar", "kecil", "sedang", "besar"],
+    "model_dropdown_label": "Ukuran model",
+    "model_dropdown_info": "Semakin tinggi modelnya, semakin akurat transkripnya namun prosesnya akan membutuhkan waktu yang lebih lama",
+    "summary_checkbox_label": "Gunakan kesimpulan",
+    "summary_checkbox_info": "Apakah anda memerlukan kesimpulan dari transkrip? Hasil mungkin tidak sepenuhnya akurat",
+    "start_button_value": "Mulai Transkrip",
+
+    "adjust_speaker_value": "Nama pembicara",
+    "prev_button_value": "Pembicara Sebelumnya",
+    "next_button_value": "Pembicara Selanjutnya",
+    "adjust_button_value": "Sesuaikan Pembicara",
+
+    "output_video_label": "Video dengan subtitle",
+    "output_transcribe_label": "Hasil transkrip",
+
+    "progress_starting_process": "Memulai proses",
+    "progress_preparing_video": "Mempersiapkan video",
+    "progress_acquiring_diarization": "Mengenali pembicara",
+    "progress_transcribing_audio": "Mendapatkan transkrip suara",
+    "progress_adjust_speaker": "Menyesuaikan pembicara",
+    "progress_add_subtitle": "Menambahkan subtitle pada video"
+}
+
+
+def get_ui_lang(index):
+    selectable_ui_lang = [english_ui, indonesia_ui]
+    return selectable_ui_lang[index]

set_up.py

@@ -0,0 +1,65 @@
+from ui import *
+from diarization import start_diarization
+from transcribe import start_transcribe
+from video_tool import convert_video_to_audio, add_subtitle_to_video
+import gradio as gr
+import re
+import os
+import file_name
+import utils
+
+
+def prepare_input(input_file, start_time, end_time, lang, model_size, use_summary, progress=gr.Progress()):
+    gr.Info(ui_lang["progress_starting_process"])
+
+    if input_file is None or not os.path.exists(input_file):
+        gr.Warning(ui_lang["input_video_warning"])
+        return [None, None, [None, None]]
+    if validate_time_format(start_time) is False:
+        gr.Warning(ui_lang["start_time_warning"])
+        return [None, None, [None, None]]
+    if validate_time_format(end_time) is False:
+        gr.Warning(ui_lang["end_time_warning"])
+        return [None, None, [None, None]]
+    if lang is None:
+        gr.Warning(ui_lang["lang_radio_warning"])
+        return [None, None, [None, None]]
+    if model_size is None:
+        gr.Warning(ui_lang["model_dropdown_warning"])
+        return [None, None, [None, None]]
+
+    file_name.input_file = input_file
+    file_name.start_time_for_adjustment = start_time
+    file_name.end_time_for_adjustment = end_time
+
+    # Convert video to audio
+    progress(0.2, desc=ui_lang["progress_preparing_video"])
+    convert_video_to_audio(
+        input_file, file_name.audio_file, start_time, end_time)
+
+    # Start diarization
+    progress(0.4, desc=ui_lang["progress_acquiring_diarization"])
+    start_diarization(file_name.audio_file)
+
+    # Start transcribing
+    progress(0.6, desc=ui_lang["progress_transcribing_audio"])
+    start_transcribe(lang, model_size, progress)
+
+    # Add subtitle to video
+    progress(0.8, desc=ui_lang["progress_add_subtitle"])
+    add_subtitle_to_video(input_file, file_name.subtitle_file,
+                          file_name.video_subtitle_file, start_time, end_time)
+
+    # Return video file link, transcribe string, transcribe.txt, subtitle.txt
+    transcribe_txt_list, _ = utils.read_transcribe_subtitle_file(False)
+    transcribe_txt = "\n".join(transcribe_txt_list)
+    return [
+        file_name.video_subtitle_file,
+        transcribe_txt,
+        [file_name.transcribe_file, file_name.subtitle_file]
+    ]
+
+
+def validate_time_format(input_string):
+    pattern = re.compile(r'^\d{2}:\d{2}:\d{2}$')
+    return pattern.match(input_string) is not None

transcribe.py

@@ -1,59 +1,58 @@
 from faster_whisper import WhisperModel
+from utils import load_groups_json
 import torch
 import gc
-import json
+import file_name
+import utils
 
 gc.collect()
 torch.cuda.empty_cache()
 
-model = WhisperModel("medium", device="cuda", compute_type="int8_float16")
+model_lang_list = ['en', 'id', None]
+model_size = ["tiny", "base", "small", "medium", "large"]
 
 
-def start_transcribe(progress):
+def start_transcribe(lang_choice: int, model_size_choice: int, progress):
+
+    print(
+        f"Starting transcribing with model size {model_size[model_size_choice]} for language {model_lang_list[lang_choice]}")
+
+    model = WhisperModel(
+        model_size[model_size_choice], device="cuda", compute_type="int8_float16")
     _, speaker_groups = load_groups_json()
 
-    subtitle_txt = []
+    subtitle_txt_list = []
+    transcribe_txt_list = []
     for speaker, _ in zip(speaker_groups, progress.tqdm(speaker_groups, desc="Transcribing")):
         # Transcribe and save temp file
         audiof = f"{speaker}.wav"
         print(f"Loading {audiof}")
         segments, _ = model.transcribe(
-            audio=audiof, language='id', word_timestamps=True)
+            audio=audiof, language=model_lang_list[lang_choice], word_timestamps=True)
         segments_list = list(segments)
 
-        text_list_to_print = []
+        speaker_txt_list = []
+        shift = speaker_groups[speaker][0] + 1
+        print(f"Current starting point: {shift}s or {time_str(shift)}")
         for segment in segments_list:
-            start = timeStr(segment.start)
-            end = timeStr(segment.end)
+            start = time_str(segment.start + shift)
+            end = time_str(segment.end + shift)
+
             name = str(speaker)[:10]
-            text = segment.text
-            subtitle_txt.append(
-                f"{len(subtitle_txt) + 1}\n{start} --> {end}\n[{name}] {text}\n\n")
-            # Appending text for each segment to print
-            text_list_to_print.append(text)
-
-        # Print full text for each speaker turn
-        text = "\n".join(text_list_to_print)
-        print(text)
-        # Append to complete transcribe file
-        with open("transcribe.txt", "a") as file:
-            file.write(f"[{name}] {text}\n")
-
-    # Appending subtitle txt for each segment
-    with open("subtitle.srt", "w") as file:
-        file.writelines(subtitle_txt)
-    return ["transcribe.txt", "subtitle.srt"]
-
-
-def timeStr(t):
-    return '{0:02d}:{1:02d}:{2:06.2f}'.format(round(t // 3600),
-                                              round(t % 3600 // 60),
-                                              t % 60)
+            segment_txt = segment.text
+            speaker_txt_list.append(segment_txt)
 
+            subtitle = f"{len(subtitle_txt_list) + 1}\n{start} --> {end}\n[{name}] {segment_txt}\n\n"
+            subtitle_txt_list.append(subtitle)
 
-def load_groups_json():
-    with open("sample_groups.json", "r") as json_file_sample:
-        sample_groups_list: list = json.load(json_file_sample)
-    with open("speaker_groups.json", "r") as json_file_speaker:
-        speaker_groups_dict: dict = json.load(json_file_speaker)
-    return sample_groups_list, speaker_groups_dict
+        speaker_txt = " ".join(speaker_txt_list)
+        transcribe_txt_list.append(f"[{name}] {speaker_txt}\n")
+
+    utils.write_transcribe_subtitle_file(
+        transcribe_txt_list, subtitle_txt_list, False)
+
+
+def time_str(t):
+    return '{0:02d}:{1:02d}:{2:06.3f}'.format(round(t // 3600),
+                                              round(t % 3600 // 60),
+                                              t % 60)

ui.py

@@ -0,0 +1,130 @@
+from lang_ui import get_ui_lang
+import gradio as gr
+import ffmpeg
+
+# Display available langauges and set default UI language
+ui_lang_index = 1
+available_ui_lang = ["English", "Bahasa Indonesia"]
+ui_lang = get_ui_lang(ui_lang_index)
+
+lang_radio_choice = 1
+model_dropdown_choice = 2
+
+# Transcribe components
+ui_lang_radio = gr.Radio(
+    available_ui_lang, type="index", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)
+top_markdown = gr.Markdown(
+    ui_lang["top_markdown"])
+# TODO Add video by link
+input_video = gr.Video(
+    label=ui_lang["input_video_label"], interactive=True)
+start_time = gr.Textbox(
+    max_lines=1, placeholder="00:00:00", label=ui_lang["start_time_label"], interactive=False)
+end_time = gr.Textbox(
+    max_lines=1, placeholder="01:00:00", label=ui_lang["end_time_label"], interactive=False)
+# TODO Use custom language
+lang_radio = gr.Radio(
+    ui_lang["lang_radio_choices"], label=ui_lang["lang_radio_label"], info=ui_lang["lang_radio_info"], type='index', interactive=True)
+model_dropdown = gr.Dropdown(
+    ui_lang["model_dropdown_choices"], label=ui_lang["model_dropdown_label"], info=ui_lang["model_dropdown_info"], type='index', interactive=True)
+summary_checkbox = gr.Checkbox(
+    label=ui_lang["summary_checkbox_label"], info=ui_lang["summary_checkbox_info"], interactive=False, visible=False)
+start_button = gr.Button(
+    ui_lang["start_button_value"], variant="primary", interactive=True)
+
+# Adjust components
+middle_markdown = gr.Markdown(
+    ui_lang["middle_markdown"])
+adjust_audio = gr.Audio(interactive=False)
+adjust_speaker = gr.Textbox(
+    label=ui_lang["adjust_speaker_value"], interactive=False)
+prev_button = gr.Button(ui_lang["prev_button_value"], interactive=False)
+next_button = gr.Button(ui_lang["next_button_value"], interactive=False)
+adjust_button = gr.Button(
+    ui_lang["adjust_button_value"], variant="primary", interactive=False)
+
+# Result components
+bottom_markdown = gr.Markdown(
+    ui_lang["bottom_markdown"]
+)
+output_video = gr.Video(label=ui_lang["output_video_label"], interactive=False)
+output_file = gr.File(file_count="multiple", interactive=False)
+output_transcribe = gr.Textbox(
+    label=ui_lang["output_transcribe_label"], interactive=False, show_copy_button=True)
+output_summary = gr.Textbox(
+    interactive=False, show_copy_button=True, visible=False)
+
+
+def time_str(t):
+    return '{0:02d}:{1:02d}:{2:02d}'.format(round(t // 3600),
+                                            round(t % 3600 // 60),
+                                            round(t % 60))
+
+
+def get_duration(input_file):
+    print("Checking file")
+    if input_file is None:
+        gr.Warning(ui_lang["input_video_warning"])
+        return [
+            start_time.update(None, interactive=False),
+            end_time.update(None, interactive=False)
+        ]
+    print("Getting duration")
+    info_json = ffmpeg.probe(input_file)
+    print("Probing finished")
+    duration_seconds = float(info_json['format']['duration'])
+    duration_formatted = time_str(duration_seconds)
+    return [
+        start_time.update("00:00:00", interactive=True),
+        end_time.update(duration_formatted, interactive=True)
+    ]
+
+
+# Change language function
+
+
+def change_lang(input):
+    global ui_lang
+    ui_lang = get_ui_lang(input)
+    print(f"Change language to {available_ui_lang[input]}")
+    return [
+        # Top
+        top_markdown.update(
+            ui_lang["top_markdown"]),
+        input_video.update(
+            label=ui_lang["input_video_label"]),
+        start_time.update(
+            label=ui_lang["start_time_label"]),
+        end_time.update(
+            label=ui_lang["end_time_label"]),
+        lang_radio.update(
+            choices=ui_lang["lang_radio_choices"], value=None, label=ui_lang["lang_radio_label"], info=ui_lang["lang_radio_info"],),
+        model_dropdown.update(
+            choices=ui_lang["model_dropdown_choices"], value=None, label=ui_lang["model_dropdown_label"], info=ui_lang["model_dropdown_info"]),
+        summary_checkbox.update(
+            label=ui_lang["summary_checkbox_label"], info=ui_lang["summary_checkbox_info"]),
+        start_button.update(
+            ui_lang["start_button_value"]),
+
+        # Middle
+        middle_markdown.update(
+            ui_lang["middle_markdown"]),
+        adjust_speaker.update(label=ui_lang["adjust_speaker_value"]),
+        prev_button.update(
+            ui_lang["prev_button_value"]),
+        next_button.update(
+            ui_lang["next_button_value"]),
+        adjust_button.update(
+            ui_lang["adjust_button_value"]),
+
+        # Bottom
+        bottom_markdown.update(
+            ui_lang["bottom_markdown"]),
+        output_video.update(label=ui_lang["output_video_label"]),
+        output_transcribe.update(label=ui_lang["output_transcribe_label"]),
+    ]
+
+
+# comp_to_update and change_lang return must always be in equal number
+comp_to_update = [
+    top_markdown, input_video, start_time, end_time, lang_radio, model_dropdown, summary_checkbox, start_button, middle_markdown, adjust_speaker, prev_button, next_button, adjust_button, bottom_markdown, output_video, output_transcribe]

utils.py

@@ -0,0 +1,37 @@
+import json
+import file_name
+
+
+def load_groups_json():
+    with open("sample_groups.json", "r", encoding="utf-8") as json_file_sample:
+        sample_groups_list: list = json.load(json_file_sample)
+    with open("speaker_groups.json", "r", encoding="utf-8") as json_file_speaker:
+        speaker_groups_dict: dict = json.load(json_file_speaker)
+    return sample_groups_list, speaker_groups_dict
+
+
+def write_transcribe_subtitle_file(transcribe_txt_list: list, subtitle_txt_list: list, adjustment: bool):
+    transcribe = file_name.transcribe_file
+    subtitle = file_name.subtitle_file
+    if adjustment:
+        transcribe = file_name.transcribe_adjusted_file
+        subtitle = file_name.subtitle_adjusted_file
+
+    with open(transcribe, "w", encoding="utf-8") as file:
+        file.writelines(transcribe_txt_list)
+    with open(subtitle, "w", encoding="utf-8") as file:
+        file.writelines(subtitle_txt_list)
+
+
+def read_transcribe_subtitle_file(adjustment: bool):
+    transcribe = file_name.transcribe_file
+    subtitle = file_name.subtitle_file
+    if adjustment:
+        transcribe = file_name.transcribe_adjusted_file
+        subtitle = file_name.subtitle_adjusted_file
+
+    with open(transcribe, "r", encoding="utf-8") as file:
+        transcribe_txt_list = file.readlines()
+    with open(subtitle, "r", encoding="utf-8") as file:
+        subtitle_txt_list = file.readlines()
+    return transcribe_txt_list, subtitle_txt_list

video_tool.py

@@ -0,0 +1,11 @@
+import ffmpeg
+
+
+def convert_video_to_audio(input_file, output_file, start_time, end_time):
+    ffmpeg.input(input_file, ss=start_time, to=end_time).audio.output(
+        output_file, format="wav").run(overwrite_output=True)
+
+
+def add_subtitle_to_video(input_file, subtitle_file, output_file, start_time, end_time):
+    ffmpeg.input(input_file, ss=start_time, to=end_time).output(
+        output_file, vf='subtitles=' + subtitle_file, preset='ultrafast', acodec='copy').run(overwrite_output=True)