Spaces:

chompionsawelo
/

whisper_transcribe

Runtime error

App Files Files Community

chompionsawelo commited on Sep 8, 2023

Commit

59e1d08

1 Parent(s): 80086c5

Huge changes

Browse files

Files changed (21) hide show

.gitignore +1 -1
.vscode/PythonImportHelper-v2-Completion.json +1115 -0
app.py +25 -21
file_name.py +0 -19
adjust.py → main/adjust.py +61 -55
diarization.py → main/diarization.py +8 -6
set_up.py → main/set_up.py +49 -46
main/summary.py +30 -0
transcribe.py → main/transcribe.py +27 -13
requirements.txt +3 -1
tool/ffmpeg_tool.py +41 -0
tool/file_name.py +19 -0
tool/gdrive_tool.py +18 -0
tool/json_tool.py +15 -0
tool/text_file_tool.py +47 -0
ui.py +0 -157
lang_ui.py → ui/lang_dictionary.py +33 -15
ui/lang_setting.py +85 -0
ui/ui_component.py +66 -0
utils.py +0 -46
video_tool.py +0 -34

.gitignore CHANGED Viewed

	@@ -1 +1 @@
1	- __pycache__


1	+ __pycache__

.vscode/PythonImportHelper-v2-Completion.json ADDED Viewed

	@@ -0,0 +1,1115 @@

+[
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "current_ui_lang",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "isExtraImport": true,
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "isExtraImport": true,
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "AudioSegment",
+        "importPath": "pydub",
+        "description": "pydub",
+        "isExtraImport": true,
+        "detail": "pydub",
+        "documentation": {}
+    },
+    {
+        "label": "AudioSegment",
+        "importPath": "pydub",
+        "description": "pydub",
+        "isExtraImport": true,
+        "detail": "pydub",
+        "documentation": {}
+    },
+    {
+        "label": "load_groups_json",
+        "importPath": "tool.json_tool",
+        "description": "tool.json_tool",
+        "isExtraImport": true,
+        "detail": "tool.json_tool",
+        "documentation": {}
+    },
+    {
+        "label": "load_groups_json",
+        "importPath": "tool.json_tool",
+        "description": "tool.json_tool",
+        "isExtraImport": true,
+        "detail": "tool.json_tool",
+        "documentation": {}
+    },
+    {
+        "label": "os",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "os",
+        "description": "os",
+        "detail": "os",
+        "documentation": {}
+    },
+    {
+        "label": "gradio",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "gradio",
+        "description": "gradio",
+        "detail": "gradio",
+        "documentation": {}
+    },
+    {
+        "label": "tool.text_file_tool",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "tool.text_file_tool",
+        "description": "tool.text_file_tool",
+        "detail": "tool.text_file_tool",
+        "documentation": {}
+    },
+    {
+        "label": "Pipeline",
+        "importPath": "pyannote.audio",
+        "description": "pyannote.audio",
+        "isExtraImport": true,
+        "detail": "pyannote.audio",
+        "documentation": {}
+    },
+    {
+        "label": "torch",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "torch",
+        "description": "torch",
+        "detail": "torch",
+        "documentation": {}
+    },
+    {
+        "label": "json",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "json",
+        "description": "json",
+        "detail": "json",
+        "documentation": {}
+    },
+    {
+        "label": "gc",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "gc",
+        "description": "gc",
+        "detail": "gc",
+        "documentation": {}
+    },
+    {
+        "label": "start_diarization",
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "isExtraImport": true,
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "start_transcribe",
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "isExtraImport": true,
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "tool.ffmpeg_tool",
+        "description": "tool.ffmpeg_tool",
+        "isExtraImport": true,
+        "detail": "tool.ffmpeg_tool",
+        "documentation": {}
+    },
+    {
+        "label": "re",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "re",
+        "description": "re",
+        "detail": "re",
+        "documentation": {}
+    },
+    {
+        "label": "openai",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "openai",
+        "description": "openai",
+        "detail": "openai",
+        "documentation": {}
+    },
+    {
+        "label": "tiktoken",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "tiktoken",
+        "description": "tiktoken",
+        "detail": "tiktoken",
+        "documentation": {}
+    },
+    {
+        "label": "WhisperModel",
+        "importPath": "faster_whisper",
+        "description": "faster_whisper",
+        "isExtraImport": true,
+        "detail": "faster_whisper",
+        "documentation": {}
+    },
+    {
+        "label": "ffmpeg",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "ffmpeg",
+        "description": "ffmpeg",
+        "detail": "ffmpeg",
+        "documentation": {}
+    },
+    {
+        "label": "gdown",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "gdown",
+        "description": "gdown",
+        "detail": "gdown",
+        "documentation": {}
+    },
+    {
+        "label": "get_ui_dict",
+        "importPath": "ui.lang_dictionary",
+        "description": "ui.lang_dictionary",
+        "isExtraImport": true,
+        "detail": "ui.lang_dictionary",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "ui.lang_setting",
+        "description": "ui.lang_setting",
+        "isExtraImport": true,
+        "detail": "ui.lang_setting",
+        "documentation": {}
+    },
+    {
+        "label": "*",
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "isExtraImport": true,
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "prepare_input",
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "isExtraImport": true,
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "prepare_video_subtitle",
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "isExtraImport": true,
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "get_summary",
+        "importPath": "main.summary",
+        "description": "main.summary",
+        "isExtraImport": true,
+        "detail": "main.summary",
+        "documentation": {}
+    },
+    {
+        "label": "get_video_from_url",
+        "importPath": "tool.gdrive_tool",
+        "description": "tool.gdrive_tool",
+        "isExtraImport": true,
+        "detail": "tool.gdrive_tool",
+        "documentation": {}
+    },
+    {
+        "label": "get_current_sample_file",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")\n    name = list(speaker_to_name.values())[current_pos]\n    sample = list(speaker_to_sample_file.values())[current_pos]\n    print(f\"CURRENT: {name} {sample}\")\n    return [name, sample]\ndef get_sample_file_for_speakers():",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "get_sample_file_for_speakers",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def get_sample_file_for_speakers():\n    global sample_groups\n    global speaker_to_name\n    global speaker_to_sample_file\n    sample_groups, _ = load_groups_json()\n    print(f\"SAMPLE GROUP: {sample_groups}\")\n    speaker_to_name = {}\n    speaker_to_sample_file = {}\n    for speaker in sample_groups:\n        for suffix in range(1, 100):",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "prepare_output",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def prepare_output(input_file):\n    if input_file is None or not os.path.exists(input_file):\n        raise gr.Error(current_ui_lang[\"input_video_warning\"])\n    speakers = get_sample_file_for_speakers()\n    download_video_update = download_video_subtitle_button.update(\n        interactive=True)\n    adjust_speaker_update = adjust_speaker.update(\n        speakers[0], interactive=True)\n    adjust_audio_update = adjust_audio.update(\n        speakers[1], interactive=True)",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "change_name",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def change_name(to_name):\n    global sample_groups\n    global speaker_to_name\n    global current_pos\n    current_speaker = sample_groups[current_pos]\n    speaker_to_name[current_speaker] = to_name\n    print(str(get_current_sample_file()))\ndef get_speakers_next(to_name):\n    change_name(to_name)\n    global sample_groups",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "get_speakers_next",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def get_speakers_next(to_name):\n    change_name(to_name)\n    global sample_groups\n    global current_pos\n    if (current_pos < len(sample_groups) - 1):\n        current_pos += 1\n    return get_current_sample_file()\ndef get_speakers_previous(to_name):\n    change_name(to_name)\n    global current_pos",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "get_speakers_previous",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def get_speakers_previous(to_name):\n    change_name(to_name)\n    global current_pos\n    if (current_pos > 0):\n        current_pos -= 1\n    return get_current_sample_file()\ndef start_adjust(to_name, progress=gr.Progress()):\n    change_name(to_name)\n    # Replacing texts\n    progress(0.4, desc=current_ui_lang[\"progress_adjust_speaker\"])",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "start_adjust",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def start_adjust(to_name, progress=gr.Progress()):\n    change_name(to_name)\n    # Replacing texts\n    progress(0.4, desc=current_ui_lang[\"progress_adjust_speaker\"])\n    transcribe_txt_list, subtitle_txt_list = text_file_tool.read_transcribe_subtitle_file(\n        False)\n    modified_transcribe = replace_text(transcribe_txt_list)\n    modified_subtitle = replace_text(subtitle_txt_list)\n    text_file_tool.write_transcribe_subtitle_file(\n        modified_transcribe, modified_subtitle, True)",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "replace_text",
+        "kind": 2,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "def replace_text(lines):\n    modified_lines = []\n    for line in lines:\n        for key, value in speaker_to_name.items():\n            line = line.replace(key, value)\n            print(f\"Replacing {key} with {value}\")\n        modified_lines.append(line)\n    print(modified_lines)\n    return modified_lines",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "min_duration_ms",
+        "kind": 5,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "min_duration_ms = 10000\ncurrent_pos = 0\nspeaker_to_name = {\"Speaker\": \"Name\"}\nspeaker_to_sample_file = {\"Speaker\": \"File\"}\nsample_groups = []\ndef get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "current_pos",
+        "kind": 5,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "current_pos = 0\nspeaker_to_name = {\"Speaker\": \"Name\"}\nspeaker_to_sample_file = {\"Speaker\": \"File\"}\nsample_groups = []\ndef get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")\n    name = list(speaker_to_name.values())[current_pos]",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "speaker_to_name",
+        "kind": 5,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "speaker_to_name = {\"Speaker\": \"Name\"}\nspeaker_to_sample_file = {\"Speaker\": \"File\"}\nsample_groups = []\ndef get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")\n    name = list(speaker_to_name.values())[current_pos]\n    sample = list(speaker_to_sample_file.values())[current_pos]",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "speaker_to_sample_file",
+        "kind": 5,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "speaker_to_sample_file = {\"Speaker\": \"File\"}\nsample_groups = []\ndef get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")\n    name = list(speaker_to_name.values())[current_pos]\n    sample = list(speaker_to_sample_file.values())[current_pos]\n    print(f\"CURRENT: {name} {sample}\")",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "sample_groups",
+        "kind": 5,
+        "importPath": "main.adjust",
+        "description": "main.adjust",
+        "peekOfCode": "sample_groups = []\ndef get_current_sample_file():\n    global speaker_to_name\n    global speaker_to_sample_file\n    print(f\"GET CURRENT speaker_to_name: {speaker_to_name}\")\n    print(f\"GET CURRENT speaker_to_sample: {speaker_to_sample_file}\")\n    name = list(speaker_to_name.values())[current_pos]\n    sample = list(speaker_to_sample_file.values())[current_pos]\n    print(f\"CURRENT: {name} {sample}\")\n    return [name, sample]",
+        "detail": "main.adjust",
+        "documentation": {}
+    },
+    {
+        "label": "start_diarization",
+        "kind": 2,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "def start_diarization(input_file):\n    diarization = pipeline(input_file)\n    sample_groups = []\n    speaker_groups = {}\n    for turn, _, speaker in diarization.itertracks(yield_label=True):\n        if (speaker not in sample_groups):\n            sample_groups.append(str(speaker))\n        suffix = 1\n        file_name = f\"{speaker}-{suffix}\"\n        while file_name in speaker_groups:",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "audio_segmentation",
+        "kind": 2,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "def audio_segmentation(input_file, speaker_groups_dict):\n    audioSegment = AudioSegment.from_wav(input_file)\n    for speaker in speaker_groups_dict:\n        time = speaker_groups_dict[speaker]\n        audioSegment[time[0]*1000: time[1] *\n                     1000].export(f\"{speaker}.wav\", format='wav')\n        print(f\"group {speaker}: {time[0]*1000}--{time[1]*1000}\")\ndef save_groups_json(input_file, sample_groups_list: list, speaker_groups_dict: dict):\n    with open(dir_sample_groups_json, \"w\", encoding=\"utf-8\") as json_file_sample:\n        json.dump(sample_groups_list, json_file_sample)",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "save_groups_json",
+        "kind": 2,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "def save_groups_json(input_file, sample_groups_list: list, speaker_groups_dict: dict):\n    with open(dir_sample_groups_json, \"w\", encoding=\"utf-8\") as json_file_sample:\n        json.dump(sample_groups_list, json_file_sample)\n    with open(dir_speaker_groups_json, \"w\", encoding=\"utf-8\") as json_file_speaker:\n        json.dump(speaker_groups_dict, json_file_speaker)",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "hugging_face_token",
+        "kind": 5,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "hugging_face_token = \"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\"\npipeline = Pipeline.from_pretrained(\n    'pyannote/speaker-diarization', use_auth_token=hugging_face_token)\nuse_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\npipeline.to(use_device)\ndef start_diarization(input_file):\n    diarization = pipeline(input_file)\n    sample_groups = []\n    speaker_groups = {}\n    for turn, _, speaker in diarization.itertracks(yield_label=True):",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "pipeline",
+        "kind": 5,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "pipeline = Pipeline.from_pretrained(\n    'pyannote/speaker-diarization', use_auth_token=hugging_face_token)\nuse_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\npipeline.to(use_device)\ndef start_diarization(input_file):\n    diarization = pipeline(input_file)\n    sample_groups = []\n    speaker_groups = {}\n    for turn, _, speaker in diarization.itertracks(yield_label=True):\n        if (speaker not in sample_groups):",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "use_device",
+        "kind": 5,
+        "importPath": "main.diarization",
+        "description": "main.diarization",
+        "peekOfCode": "use_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\npipeline.to(use_device)\ndef start_diarization(input_file):\n    diarization = pipeline(input_file)\n    sample_groups = []\n    speaker_groups = {}\n    for turn, _, speaker in diarization.itertracks(yield_label=True):\n        if (speaker not in sample_groups):\n            sample_groups.append(str(speaker))\n        suffix = 1",
+        "detail": "main.diarization",
+        "documentation": {}
+    },
+    {
+        "label": "prepare_input",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def prepare_input(input_file, start_time, end_time, lang, model_size, progress=gr.Progress()):\n    gr.Info(current_ui_lang[\"progress_starting_process\"])\n    check_input_video_settings(input_file, start_time, end_time)\n    if lang is None:\n        raise gr.Error(current_ui_lang[\"lang_radio_warning\"])\n    if model_size is None:\n        raise gr.Error(current_ui_lang[\"model_dropdown_warning\"])\n    print(f\"SOURCE: {input_file}\")\n    # Convert video to audio\n    progress(0.2, desc=current_ui_lang[\"progress_preparing_video\"])",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "prepare_video_subtitle",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def prepare_video_subtitle(input_file, start_time, end_time):\n    check_input_video_settings(input_file, start_time, end_time)\n    gr.Info(current_ui_lang[\"progress_add_subtitle\"])\n    # Add subtitle to video\n    add_subtitle_to_video()\n    # Return to output files\n    return [dir_base_transcribe_file, dir_base_subtitle_file, dir_video_subtitle_file]\ndef check_input_video_settings(input_file, start_time, end_time):\n    if input_file is None or not os.path.exists(input_file):\n        raise gr.Error(current_ui_lang[\"input_video_warning\"])",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "check_input_video_settings",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def check_input_video_settings(input_file, start_time, end_time):\n    if input_file is None or not os.path.exists(input_file):\n        raise gr.Error(current_ui_lang[\"input_video_warning\"])\n    if validate_time_format(start_time) is False:\n        raise gr.Error(current_ui_lang[\"start_time_warning\"])\n    if validate_time_format(end_time) is False:\n        raise gr.Error(current_ui_lang[\"end_time_warning\"])\n    if (check_if_time_invalid(start_time, end_time)):\n        raise gr.Error(current_ui_lang[\"time_invalid\"])\ndef validate_time_format(input_string):",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "validate_time_format",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def validate_time_format(input_string):\n    pattern = re.compile(r'^\\d{2}:\\d{2}:\\d{2}$')\n    return pattern.match(input_string) is not None\ndef check_if_time_invalid(start_time, end_time):\n    start = get_total_seconds(start_time)\n    end = get_total_seconds(end_time)\n    return start >= end\ndef get_total_seconds(time_string):\n    hours, minutes, seconds = map(int, time_string.split(\":\"))\n    total_seconds = hours * 3600 + minutes * 60 + seconds",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "check_if_time_invalid",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def check_if_time_invalid(start_time, end_time):\n    start = get_total_seconds(start_time)\n    end = get_total_seconds(end_time)\n    return start >= end\ndef get_total_seconds(time_string):\n    hours, minutes, seconds = map(int, time_string.split(\":\"))\n    total_seconds = hours * 3600 + minutes * 60 + seconds\n    return total_seconds",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "get_total_seconds",
+        "kind": 2,
+        "importPath": "main.set_up",
+        "description": "main.set_up",
+        "peekOfCode": "def get_total_seconds(time_string):\n    hours, minutes, seconds = map(int, time_string.split(\":\"))\n    total_seconds = hours * 3600 + minutes * 60 + seconds\n    return total_seconds",
+        "detail": "main.set_up",
+        "documentation": {}
+    },
+    {
+        "label": "get_summary",
+        "kind": 2,
+        "importPath": "main.summary",
+        "description": "main.summary",
+        "peekOfCode": "def get_summary(lang_choice: int):\n    transcribe_list = text_file_tool.read_simple_transcribe_file()\n    transcribe = \"\\n\".join(transcribe_list)\n    encoding = tiktoken.get_encoding(\"cl100k_base\")\n    token_num = len(encoding.encode(transcribe))\n    print(f\"Token number is {token_num}\")\n    language = [\"English\", \"Bahasa Indonesia\", \"Any\"]\n    result = openai.ChatCompletion.create(\n        model=\"gpt-3.5-turbo\" if token_num < 4097 else \"gpt-3.5-turbo-16k\",\n        messages=[",
+        "detail": "main.summary",
+        "documentation": {}
+    },
+    {
+        "label": "openai.api_key",
+        "kind": 5,
+        "importPath": "main.summary",
+        "description": "main.summary",
+        "peekOfCode": "openai.api_key = \"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\"\ndef get_summary(lang_choice: int):\n    transcribe_list = text_file_tool.read_simple_transcribe_file()\n    transcribe = \"\\n\".join(transcribe_list)\n    encoding = tiktoken.get_encoding(\"cl100k_base\")\n    token_num = len(encoding.encode(transcribe))\n    print(f\"Token number is {token_num}\")\n    language = [\"English\", \"Bahasa Indonesia\", \"Any\"]\n    result = openai.ChatCompletion.create(\n        model=\"gpt-3.5-turbo\" if token_num < 4097 else \"gpt-3.5-turbo-16k\",",
+        "detail": "main.summary",
+        "documentation": {}
+    },
+    {
+        "label": "start_transcribe",
+        "kind": 2,
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "peekOfCode": "def start_transcribe(lang_choice: int, model_size_choice: int, progress):\n    print(\n        f\"Starting transcribing with model size {model_size[model_size_choice]} for language {model_lang_list[lang_choice]}\")\n    model = WhisperModel(model_size[model_size_choice])\n    _, speaker_groups = load_groups_json()\n    subtitle_txt_list = []\n    transcribe_txt_list = []\n    simple_transcribe_txt_list = []\n    for speaker, _ in zip(speaker_groups, progress.tqdm(speaker_groups, desc=current_ui_lang[\"progress_transcribing_audio\"])):\n        # Transcribe and save temp file",
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "time_str_subtitle",
+        "kind": 2,
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "peekOfCode": "def time_str_subtitle(t):\n    return '{0:02d}:{1:02d}:{2:06.3f}'.format(round(t // 3600),\n                                              round(t % 3600 // 60),\n                                              t % 60)\ndef time_str(t):\n    return '{0:02d}:{1:02d}:{2:02d}'.format(round(t // 3600),\n                                            round(t % 3600 // 60),\n                                            round(t % 60))",
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "time_str",
+        "kind": 2,
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "peekOfCode": "def time_str(t):\n    return '{0:02d}:{1:02d}:{2:02d}'.format(round(t // 3600),\n                                            round(t % 3600 // 60),\n                                            round(t % 60))",
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "model_lang_list",
+        "kind": 5,
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "peekOfCode": "model_lang_list = ['en', 'id', None]\nmodel_size = [\"tiny\", \"base\", \"small\", \"medium\", \"large-v2\"]\ndef start_transcribe(lang_choice: int, model_size_choice: int, progress):\n    print(\n        f\"Starting transcribing with model size {model_size[model_size_choice]} for language {model_lang_list[lang_choice]}\")\n    model = WhisperModel(model_size[model_size_choice])\n    _, speaker_groups = load_groups_json()\n    subtitle_txt_list = []\n    transcribe_txt_list = []\n    simple_transcribe_txt_list = []",
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "model_size",
+        "kind": 5,
+        "importPath": "main.transcribe",
+        "description": "main.transcribe",
+        "peekOfCode": "model_size = [\"tiny\", \"base\", \"small\", \"medium\", \"large-v2\"]\ndef start_transcribe(lang_choice: int, model_size_choice: int, progress):\n    print(\n        f\"Starting transcribing with model size {model_size[model_size_choice]} for language {model_lang_list[lang_choice]}\")\n    model = WhisperModel(model_size[model_size_choice])\n    _, speaker_groups = load_groups_json()\n    subtitle_txt_list = []\n    transcribe_txt_list = []\n    simple_transcribe_txt_list = []\n    for speaker, _ in zip(speaker_groups, progress.tqdm(speaker_groups, desc=current_ui_lang[\"progress_transcribing_audio\"])):",
+        "detail": "main.transcribe",
+        "documentation": {}
+    },
+    {
+        "label": "convert_video_to_audio",
+        "kind": 2,
+        "importPath": "tool.ffmpeg_tool",
+        "description": "tool.ffmpeg_tool",
+        "peekOfCode": "def convert_video_to_audio(input_file, start_time, end_time):\n    print(\"CONVERTING VIDEO TO AUDIO\")\n    print(f\"INPUT: {input_file}\")\n    print(f\"OUTPUT: {dir_cut_audio_file}\")\n    (\n        ffmpeg\n        .input(input_file)\n        .output(dir_cut_audio_file, ss=start_time, to=end_time, format=\"wav\", acodec='pcm_s16le')\n        .run(overwrite_output=True)\n    )",
+        "detail": "tool.ffmpeg_tool",
+        "documentation": {}
+    },
+    {
+        "label": "cut_video",
+        "kind": 2,
+        "importPath": "tool.ffmpeg_tool",
+        "description": "tool.ffmpeg_tool",
+        "peekOfCode": "def cut_video(input_file, start_time, end_time):\n    print(\"CUTTING VIDEO\")\n    print(f\"INPUT: {input_file}\")\n    print(f\"OUTPUT: {dir_cut_video_file}\")\n    (\n        ffmpeg\n        .input(input_file)\n        .output(dir_cut_video_file, ss=start_time, to=end_time, acodec='copy', vcodec='copy')\n        .run(overwrite_output=True)\n    )",
+        "detail": "tool.ffmpeg_tool",
+        "documentation": {}
+    },
+    {
+        "label": "add_subtitle_to_video",
+        "kind": 2,
+        "importPath": "tool.ffmpeg_tool",
+        "description": "tool.ffmpeg_tool",
+        "peekOfCode": "def add_subtitle_to_video():\n    print(\"ADDING SUBTITLE\")\n    print(f\"SUBTITLE: {dir_adjusted_subtitle_file}\")\n    print(f\"OUTPUT: {dir_video_subtitle_file}\")\n    (\n        ffmpeg\n        .input(dir_cut_video_file)\n        .output(dir_video_subtitle_file, vf=f'subtitles={dir_adjusted_subtitle_file}', acodec='copy')\n        .run(overwrite_output=True)\n    )",
+        "detail": "tool.ffmpeg_tool",
+        "documentation": {}
+    },
+    {
+        "label": "dir_download_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_download_file = \"download_video.mp4\"\ndir_cut_audio_file = \"cut_audio.wav\"\ndir_cut_video_file = \"cut_video.mp4\"\n# BASE FILE CREATED ONLY ONCE\ndir_base_subtitle_file = \"subtitle.srt\"\ndir_base_transcribe_file = \"transcribe.txt\"\ndir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_cut_audio_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_cut_audio_file = \"cut_audio.wav\"\ndir_cut_video_file = \"cut_video.mp4\"\n# BASE FILE CREATED ONLY ONCE\ndir_base_subtitle_file = \"subtitle.srt\"\ndir_base_transcribe_file = \"transcribe.txt\"\ndir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_cut_video_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_cut_video_file = \"cut_video.mp4\"\n# BASE FILE CREATED ONLY ONCE\ndir_base_subtitle_file = \"subtitle.srt\"\ndir_base_transcribe_file = \"transcribe.txt\"\ndir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_base_subtitle_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_base_subtitle_file = \"subtitle.srt\"\ndir_base_transcribe_file = \"transcribe.txt\"\ndir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_base_transcribe_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_base_transcribe_file = \"transcribe.txt\"\ndir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_adjusted_subtitle_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_adjusted_subtitle_file = \"subtitle_adjusted.srt\"\ndir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_adjusted_transcribe_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_adjusted_transcribe_file = \"transcribe_adjusted.txt\"\ndir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_video_subtitle_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_video_subtitle_file = \"video_subtitle.mp4\"\ndir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_sample_groups_json",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_sample_groups_json = \"sample_groups.json\"\ndir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_speaker_groups_json",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_speaker_groups_json = \"speaker_groups.json\"\ndir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "dir_simple_transcribe_file",
+        "kind": 5,
+        "importPath": "tool.file_name",
+        "description": "tool.file_name",
+        "peekOfCode": "dir_simple_transcribe_file = \"simple_transcribe.txt\"",
+        "detail": "tool.file_name",
+        "documentation": {}
+    },
+    {
+        "label": "get_video_from_url",
+        "kind": 2,
+        "importPath": "tool.gdrive_tool",
+        "description": "tool.gdrive_tool",
+        "peekOfCode": "def get_video_from_url(url):\n    # Download video from google drive with shareable link\n    gr.Info(current_ui_lang[\"get_video_start_info\"])\n    download_result = gdown.download(\n        url, dir_download_file, quiet=False, fuzzy=True)\n    # Raise error if failed\n    if (download_result is None):\n        raise gr.Error(current_ui_lang[\"get_video_fail_info\"])\n    gr.Info(current_ui_lang[\"get_video_finished_info\"])\n    return dir_download_file",
+        "detail": "tool.gdrive_tool",
+        "documentation": {}
+    },
+    {
+        "label": "load_groups_json",
+        "kind": 2,
+        "importPath": "tool.json_tool",
+        "description": "tool.json_tool",
+        "peekOfCode": "def load_groups_json():\n    if not os.path.exists(dir_sample_groups_json) or not os.path.exists(dir_speaker_groups_json):\n        print(\"JSON file doesn't exist\")\n        return [], {}\n    with open(dir_sample_groups_json, \"r\", encoding=\"utf-8\") as json_file_sample:\n        sample_groups_list: list = json.load(json_file_sample)\n    with open(dir_speaker_groups_json, \"r\", encoding=\"utf-8\") as json_file_speaker:\n        speaker_groups_dict: dict = json.load(json_file_speaker)\n    return sample_groups_list, speaker_groups_dict",
+        "detail": "tool.json_tool",
+        "documentation": {}
+    },
+    {
+        "label": "write_simple_transcribe_file",
+        "kind": 2,
+        "importPath": "tool.text_file_tool",
+        "description": "tool.text_file_tool",
+        "peekOfCode": "def write_simple_transcribe_file(simple_transcribe_txt_list: list):\n    with open(dir_simple_transcribe_file, \"w\", encoding=\"utf-8\") as file:\n        file.writelines(simple_transcribe_txt_list)\ndef read_simple_transcribe_file():\n    with open(dir_simple_transcribe_file, \"r\", encoding=\"utf-8\") as file:\n        simple_transcribe_txt_list = file.readlines()\n    return simple_transcribe_txt_list\ndef write_transcribe_subtitle_file(transcribe_txt_list: list, subtitle_txt_list: list, write_adjusted_file: bool):\n    transcribe = dir_base_transcribe_file\n    subtitle = dir_base_subtitle_file",
+        "detail": "tool.text_file_tool",
+        "documentation": {}
+    },
+    {
+        "label": "read_simple_transcribe_file",
+        "kind": 2,
+        "importPath": "tool.text_file_tool",
+        "description": "tool.text_file_tool",
+        "peekOfCode": "def read_simple_transcribe_file():\n    with open(dir_simple_transcribe_file, \"r\", encoding=\"utf-8\") as file:\n        simple_transcribe_txt_list = file.readlines()\n    return simple_transcribe_txt_list\ndef write_transcribe_subtitle_file(transcribe_txt_list: list, subtitle_txt_list: list, write_adjusted_file: bool):\n    transcribe = dir_base_transcribe_file\n    subtitle = dir_base_subtitle_file\n    if write_adjusted_file:\n        transcribe = dir_adjusted_transcribe_file\n        subtitle = dir_adjusted_subtitle_file",
+        "detail": "tool.text_file_tool",
+        "documentation": {}
+    },
+    {
+        "label": "write_transcribe_subtitle_file",
+        "kind": 2,
+        "importPath": "tool.text_file_tool",
+        "description": "tool.text_file_tool",
+        "peekOfCode": "def write_transcribe_subtitle_file(transcribe_txt_list: list, subtitle_txt_list: list, write_adjusted_file: bool):\n    transcribe = dir_base_transcribe_file\n    subtitle = dir_base_subtitle_file\n    if write_adjusted_file:\n        transcribe = dir_adjusted_transcribe_file\n        subtitle = dir_adjusted_subtitle_file\n    with open(transcribe, \"w\", encoding=\"utf-8\") as file:\n        file.writelines(transcribe_txt_list)\n    with open(subtitle, \"w\", encoding=\"utf-8\") as file:\n        file.writelines(subtitle_txt_list)",
+        "detail": "tool.text_file_tool",
+        "documentation": {}
+    },
+    {
+        "label": "read_transcribe_subtitle_file",
+        "kind": 2,
+        "importPath": "tool.text_file_tool",
+        "description": "tool.text_file_tool",
+        "peekOfCode": "def read_transcribe_subtitle_file(read_adjusted_file: bool):\n    transcribe = dir_base_transcribe_file\n    subtitle = dir_base_subtitle_file\n    if read_adjusted_file:\n        transcribe = dir_adjusted_transcribe_file\n        subtitle = dir_adjusted_subtitle_file\n    if not os.path.exists(transcribe):\n        raise gr.Error(current_ui_lang[\"file_not_exist\"] + \": Transcribe\")\n    if not os.path.exists(subtitle):\n        raise gr.Error(current_ui_lang[\"file_not_exist\"] + \": Subtitle\")",
+        "detail": "tool.text_file_tool",
+        "documentation": {}
+    },
+    {
+        "label": "get_ui_dict",
+        "kind": 2,
+        "importPath": "ui.lang_dictionary",
+        "description": "ui.lang_dictionary",
+        "peekOfCode": "def get_ui_dict(index):\n    selectable_ui_lang = [english_ui, indonesia_ui]\n    return selectable_ui_lang[index]\nenglish_ui = {\n    \"top_markdown\": \"\"\"\n        ## Transcribe\n        Insert your video and set the options for transcribing\n    \"\"\",\n    \"middle_markdown\": \"\"\"\n        ## Adjustment",
+        "detail": "ui.lang_dictionary",
+        "documentation": {}
+    },
+    {
+        "label": "english_ui",
+        "kind": 5,
+        "importPath": "ui.lang_dictionary",
+        "description": "ui.lang_dictionary",
+        "peekOfCode": "english_ui = {\n    \"top_markdown\": \"\"\"\n        ## Transcribe\n        Insert your video and set the options for transcribing\n    \"\"\",\n    \"middle_markdown\": \"\"\"\n        ## Adjustment\n        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. \n    \"\"\",\n    \"bottom_markdown\": \"\"\"",
+        "detail": "ui.lang_dictionary",
+        "documentation": {}
+    },
+    {
+        "label": "indonesia_ui",
+        "kind": 5,
+        "importPath": "ui.lang_dictionary",
+        "description": "ui.lang_dictionary",
+        "peekOfCode": "indonesia_ui = {\n    \"top_markdown\": \"\"\"\n        ## Transkrip\n        Masukkan video dan sesuaikan opsi untuk transkrip\n    \"\"\",\n    \"middle_markdown\": \"\"\"\n        ## Penyesuaian\n        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\n    \"\"\",\n    \"bottom_markdown\": \"\"\"",
+        "detail": "ui.lang_dictionary",
+        "documentation": {}
+    },
+    {
+        "label": "change_lang",
+        "kind": 2,
+        "importPath": "ui.lang_setting",
+        "description": "ui.lang_setting",
+        "peekOfCode": "def change_lang(input):\n    # Change language function\n    global current_ui_lang\n    current_ui_lang = get_ui_dict(input)\n    print(f\"Change language to {available_ui_lang[input]}\")\n    return [\n        # Top\n        top_markdown.update(\n            current_ui_lang[\"top_markdown\"]),\n        input_url.update(",
+        "detail": "ui.lang_setting",
+        "documentation": {}
+    },
+    {
+        "label": "comp_to_update",
+        "kind": 5,
+        "importPath": "ui.lang_setting",
+        "description": "ui.lang_setting",
+        "peekOfCode": "comp_to_update = [\n    top_markdown,\n    input_url,\n    url_download_button,\n    input_video,\n    start_time,\n    end_time,\n    lang_radio,\n    model_dropdown,\n    start_button,",
+        "detail": "ui.lang_setting",
+        "documentation": {}
+    },
+    {
+        "label": "ui_lang_index",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "ui_lang_index = 1\navailable_ui_lang = [\"English\", \"Bahasa Indonesia\"]\ncurrent_ui_lang = get_ui_dict(ui_lang_index)\nlang_radio_choice = 1\nmodel_dropdown_choice = 2\n# Transcribe components\nui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "available_ui_lang",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "available_ui_lang = [\"English\", \"Bahasa Indonesia\"]\ncurrent_ui_lang = get_ui_dict(ui_lang_index)\nlang_radio_choice = 1\nmodel_dropdown_choice = 2\n# Transcribe components\nui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "current_ui_lang",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "current_ui_lang = get_ui_dict(ui_lang_index)\nlang_radio_choice = 1\nmodel_dropdown_choice = 2\n# Transcribe components\nui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "lang_radio_choice",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "lang_radio_choice = 1\nmodel_dropdown_choice = 2\n# Transcribe components\nui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)\nurl_download_button = gr.Button(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "model_dropdown_choice",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "model_dropdown_choice = 2\n# Transcribe components\nui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)\nurl_download_button = gr.Button(\n    current_ui_lang[\"download_button_value\"], size='sm', interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "ui_lang_radio",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "ui_lang_radio = gr.Radio(\n    available_ui_lang, type=\"index\", value=available_ui_lang[ui_lang_index], interactive=True, show_label=False)\ntop_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)\nurl_download_button = gr.Button(\n    current_ui_lang[\"download_button_value\"], size='sm', interactive=True)\ninput_video = gr.Video(\n    label=current_ui_lang[\"input_video_label\"], interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "top_markdown",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "top_markdown = gr.Markdown(\n    current_ui_lang[\"top_markdown\"])\ninput_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)\nurl_download_button = gr.Button(\n    current_ui_lang[\"download_button_value\"], size='sm', interactive=True)\ninput_video = gr.Video(\n    label=current_ui_lang[\"input_video_label\"], interactive=True)\nstart_time = gr.Textbox(\n    \"00:00:00\", max_lines=1, placeholder=\"00:00:00\", label=current_ui_lang[\"start_time_label\"], interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "input_url",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "input_url = gr.Textbox(\n    max_lines=1, label=current_ui_lang[\"input_url_label\"], info=current_ui_lang[\"input_url_info\"], interactive=True)\nurl_download_button = gr.Button(\n    current_ui_lang[\"download_button_value\"], size='sm', interactive=True)\ninput_video = gr.Video(\n    label=current_ui_lang[\"input_video_label\"], interactive=True)\nstart_time = gr.Textbox(\n    \"00:00:00\", max_lines=1, placeholder=\"00:00:00\", label=current_ui_lang[\"start_time_label\"], interactive=True)\nend_time = gr.Textbox(\n    \"00:15:00\", max_lines=1, placeholder=\"99:99:99\", label=current_ui_lang[\"end_time_label\"], interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "url_download_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "url_download_button = gr.Button(\n    current_ui_lang[\"download_button_value\"], size='sm', interactive=True)\ninput_video = gr.Video(\n    label=current_ui_lang[\"input_video_label\"], interactive=True)\nstart_time = gr.Textbox(\n    \"00:00:00\", max_lines=1, placeholder=\"00:00:00\", label=current_ui_lang[\"start_time_label\"], interactive=True)\nend_time = gr.Textbox(\n    \"00:15:00\", max_lines=1, placeholder=\"99:99:99\", label=current_ui_lang[\"end_time_label\"], interactive=True)\nlang_radio = gr.Radio(\n    current_ui_lang[\"lang_radio_choices\"], label=current_ui_lang[\"lang_radio_label\"], info=current_ui_lang[\"lang_radio_info\"], type='index', interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "input_video",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "input_video = gr.Video(\n    label=current_ui_lang[\"input_video_label\"], interactive=True)\nstart_time = gr.Textbox(\n    \"00:00:00\", max_lines=1, placeholder=\"00:00:00\", label=current_ui_lang[\"start_time_label\"], interactive=True)\nend_time = gr.Textbox(\n    \"00:15:00\", max_lines=1, placeholder=\"99:99:99\", label=current_ui_lang[\"end_time_label\"], interactive=True)\nlang_radio = gr.Radio(\n    current_ui_lang[\"lang_radio_choices\"], label=current_ui_lang[\"lang_radio_label\"], info=current_ui_lang[\"lang_radio_info\"], type='index', interactive=True)\nmodel_dropdown = gr.Dropdown(\n    current_ui_lang[\"model_dropdown_choices\"], label=current_ui_lang[\"model_dropdown_label\"], info=current_ui_lang[\"model_dropdown_info\"], type='index', interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "start_time",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "start_time = gr.Textbox(\n    \"00:00:00\", max_lines=1, placeholder=\"00:00:00\", label=current_ui_lang[\"start_time_label\"], interactive=True)\nend_time = gr.Textbox(\n    \"00:15:00\", max_lines=1, placeholder=\"99:99:99\", label=current_ui_lang[\"end_time_label\"], interactive=True)\nlang_radio = gr.Radio(\n    current_ui_lang[\"lang_radio_choices\"], label=current_ui_lang[\"lang_radio_label\"], info=current_ui_lang[\"lang_radio_info\"], type='index', interactive=True)\nmodel_dropdown = gr.Dropdown(\n    current_ui_lang[\"model_dropdown_choices\"], label=current_ui_lang[\"model_dropdown_label\"], info=current_ui_lang[\"model_dropdown_info\"], type='index', interactive=True)\nstart_button = gr.Button(\n    current_ui_lang[\"start_button_value\"], variant=\"primary\", interactive=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "end_time",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "end_time = gr.Textbox(\n    \"00:15:00\", max_lines=1, placeholder=\"99:99:99\", label=current_ui_lang[\"end_time_label\"], interactive=True)\nlang_radio = gr.Radio(\n    current_ui_lang[\"lang_radio_choices\"], label=current_ui_lang[\"lang_radio_label\"], info=current_ui_lang[\"lang_radio_info\"], type='index', interactive=True)\nmodel_dropdown = gr.Dropdown(\n    current_ui_lang[\"model_dropdown_choices\"], label=current_ui_lang[\"model_dropdown_label\"], info=current_ui_lang[\"model_dropdown_info\"], type='index', interactive=True)\nstart_button = gr.Button(\n    current_ui_lang[\"start_button_value\"], variant=\"primary\", interactive=True)\n# Adjust components\nmiddle_markdown = gr.Markdown(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "lang_radio",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "lang_radio = gr.Radio(\n    current_ui_lang[\"lang_radio_choices\"], label=current_ui_lang[\"lang_radio_label\"], info=current_ui_lang[\"lang_radio_info\"], type='index', interactive=True)\nmodel_dropdown = gr.Dropdown(\n    current_ui_lang[\"model_dropdown_choices\"], label=current_ui_lang[\"model_dropdown_label\"], info=current_ui_lang[\"model_dropdown_info\"], type='index', interactive=True)\nstart_button = gr.Button(\n    current_ui_lang[\"start_button_value\"], variant=\"primary\", interactive=True)\n# Adjust components\nmiddle_markdown = gr.Markdown(\n    current_ui_lang[\"middle_markdown\"])\nadjust_audio = gr.Audio(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "model_dropdown",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "model_dropdown = gr.Dropdown(\n    current_ui_lang[\"model_dropdown_choices\"], label=current_ui_lang[\"model_dropdown_label\"], info=current_ui_lang[\"model_dropdown_info\"], type='index', interactive=True)\nstart_button = gr.Button(\n    current_ui_lang[\"start_button_value\"], variant=\"primary\", interactive=True)\n# Adjust components\nmiddle_markdown = gr.Markdown(\n    current_ui_lang[\"middle_markdown\"])\nadjust_audio = gr.Audio(\n    interactive=False)\nadjust_speaker = gr.Textbox(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "start_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "start_button = gr.Button(\n    current_ui_lang[\"start_button_value\"], variant=\"primary\", interactive=True)\n# Adjust components\nmiddle_markdown = gr.Markdown(\n    current_ui_lang[\"middle_markdown\"])\nadjust_audio = gr.Audio(\n    interactive=False)\nadjust_speaker = gr.Textbox(\n    label=current_ui_lang[\"adjust_speaker_value\"], interactive=False)\nprev_button = gr.Button(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "middle_markdown",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "middle_markdown = gr.Markdown(\n    current_ui_lang[\"middle_markdown\"])\nadjust_audio = gr.Audio(\n    interactive=False)\nadjust_speaker = gr.Textbox(\n    label=current_ui_lang[\"adjust_speaker_value\"], interactive=False)\nprev_button = gr.Button(\n    current_ui_lang[\"prev_button_value\"], interactive=False)\nnext_button = gr.Button(\n    current_ui_lang[\"next_button_value\"], interactive=False)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "adjust_audio",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "adjust_audio = gr.Audio(\n    interactive=False)\nadjust_speaker = gr.Textbox(\n    label=current_ui_lang[\"adjust_speaker_value\"], interactive=False)\nprev_button = gr.Button(\n    current_ui_lang[\"prev_button_value\"], interactive=False)\nnext_button = gr.Button(\n    current_ui_lang[\"next_button_value\"], interactive=False)\nadjust_button = gr.Button(\n    current_ui_lang[\"adjust_button_value\"], variant=\"primary\", interactive=False)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "adjust_speaker",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "adjust_speaker = gr.Textbox(\n    label=current_ui_lang[\"adjust_speaker_value\"], interactive=False)\nprev_button = gr.Button(\n    current_ui_lang[\"prev_button_value\"], interactive=False)\nnext_button = gr.Button(\n    current_ui_lang[\"next_button_value\"], interactive=False)\nadjust_button = gr.Button(\n    current_ui_lang[\"adjust_button_value\"], variant=\"primary\", interactive=False)\n# Result components\nbottom_markdown = gr.Markdown(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "prev_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "prev_button = gr.Button(\n    current_ui_lang[\"prev_button_value\"], interactive=False)\nnext_button = gr.Button(\n    current_ui_lang[\"next_button_value\"], interactive=False)\nadjust_button = gr.Button(\n    current_ui_lang[\"adjust_button_value\"], variant=\"primary\", interactive=False)\n# Result components\nbottom_markdown = gr.Markdown(\n    current_ui_lang[\"bottom_markdown\"])\noutput_video = gr.Video(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "next_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "next_button = gr.Button(\n    current_ui_lang[\"next_button_value\"], interactive=False)\nadjust_button = gr.Button(\n    current_ui_lang[\"adjust_button_value\"], variant=\"primary\", interactive=False)\n# Result components\nbottom_markdown = gr.Markdown(\n    current_ui_lang[\"bottom_markdown\"])\noutput_video = gr.Video(\n    label=current_ui_lang[\"output_video_label\"], interactive=False)\ndownload_video_subtitle_button = gr.Button(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "adjust_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "adjust_button = gr.Button(\n    current_ui_lang[\"adjust_button_value\"], variant=\"primary\", interactive=False)\n# Result components\nbottom_markdown = gr.Markdown(\n    current_ui_lang[\"bottom_markdown\"])\noutput_video = gr.Video(\n    label=current_ui_lang[\"output_video_label\"], interactive=False)\ndownload_video_subtitle_button = gr.Button(\n    current_ui_lang[\"download_video_button_value\"], interactive=False, size='sm')\noutput_file = gr.File(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "bottom_markdown",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "bottom_markdown = gr.Markdown(\n    current_ui_lang[\"bottom_markdown\"])\noutput_video = gr.Video(\n    label=current_ui_lang[\"output_video_label\"], interactive=False)\ndownload_video_subtitle_button = gr.Button(\n    current_ui_lang[\"download_video_button_value\"], interactive=False, size='sm')\noutput_file = gr.File(\n    file_count=\"multiple\", interactive=False)\noutput_transcribe = gr.Textbox(\n    label=current_ui_lang[\"output_transcribe_label\"], interactive=False, show_copy_button=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "output_video",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "output_video = gr.Video(\n    label=current_ui_lang[\"output_video_label\"], interactive=False)\ndownload_video_subtitle_button = gr.Button(\n    current_ui_lang[\"download_video_button_value\"], interactive=False, size='sm')\noutput_file = gr.File(\n    file_count=\"multiple\", interactive=False)\noutput_transcribe = gr.Textbox(\n    label=current_ui_lang[\"output_transcribe_label\"], interactive=False, show_copy_button=True)\n# Summary components\nsummary_markdown = gr.Markdown(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "download_video_subtitle_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "download_video_subtitle_button = gr.Button(\n    current_ui_lang[\"download_video_button_value\"], interactive=False, size='sm')\noutput_file = gr.File(\n    file_count=\"multiple\", interactive=False)\noutput_transcribe = gr.Textbox(\n    label=current_ui_lang[\"output_transcribe_label\"], interactive=False, show_copy_button=True)\n# Summary components\nsummary_markdown = gr.Markdown(\n    current_ui_lang[\"summary_markdown\"])\nsummary_button = gr.Button(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "output_file",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "output_file = gr.File(\n    file_count=\"multiple\", interactive=False)\noutput_transcribe = gr.Textbox(\n    label=current_ui_lang[\"output_transcribe_label\"], interactive=False, show_copy_button=True)\n# Summary components\nsummary_markdown = gr.Markdown(\n    current_ui_lang[\"summary_markdown\"])\nsummary_button = gr.Button(\n    current_ui_lang[\"summary_button_value\"], variant=\"primary\", interactive=False)\noutput_summary = gr.Textbox(",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "output_transcribe",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "output_transcribe = gr.Textbox(\n    label=current_ui_lang[\"output_transcribe_label\"], interactive=False, show_copy_button=True)\n# Summary components\nsummary_markdown = gr.Markdown(\n    current_ui_lang[\"summary_markdown\"])\nsummary_button = gr.Button(\n    current_ui_lang[\"summary_button_value\"], variant=\"primary\", interactive=False)\noutput_summary = gr.Textbox(\n    label=current_ui_lang[\"output_summary_label\"], interactive=False, show_copy_button=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "summary_markdown",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "summary_markdown = gr.Markdown(\n    current_ui_lang[\"summary_markdown\"])\nsummary_button = gr.Button(\n    current_ui_lang[\"summary_button_value\"], variant=\"primary\", interactive=False)\noutput_summary = gr.Textbox(\n    label=current_ui_lang[\"output_summary_label\"], interactive=False, show_copy_button=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "summary_button",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "summary_button = gr.Button(\n    current_ui_lang[\"summary_button_value\"], variant=\"primary\", interactive=False)\noutput_summary = gr.Textbox(\n    label=current_ui_lang[\"output_summary_label\"], interactive=False, show_copy_button=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    },
+    {
+        "label": "output_summary",
+        "kind": 5,
+        "importPath": "ui.ui_component",
+        "description": "ui.ui_component",
+        "peekOfCode": "output_summary = gr.Textbox(\n    label=current_ui_lang[\"output_summary_label\"], interactive=False, show_copy_button=True)",
+        "detail": "ui.ui_component",
+        "documentation": {}
+    }
+]

app.py CHANGED Viewed

@@ -1,7 +1,11 @@
-from ui import *
-from adjust import *
-from set_up import prepare_input, prepare_video_subtitle
 import gradio as gr
 with gr.Blocks() as demo:
     ui_lang_radio.render()
@@ -17,24 +21,17 @@ with gr.Blocks() as demo:
                 url_download_button.click(
                     get_video_from_url, input_url, input_video)
                 input_video.render()
-                # input_video.clear(clear_duration, outputs=[
-                #     start_time, end_time])
-                # input_video_button.render()
-                # input_video_button.click(get_duration, input_video, [
-                #     start_time, end_time])
             with gr.Column():
                 with gr.Row():
                     start_time.render()
                     end_time.render()
                 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], [output_transcribe, output_file])
-            .success(prepare_output, inputs=input_video, outputs=[adjust_speaker, adjust_audio, prev_button, next_button, adjust_button])
-            .success(prepare_video_subtitle, inputs=[input_video, start_time, end_time], outputs=output_video)
         )
     bottom_markdown.render()
@@ -42,10 +39,14 @@ with gr.Blocks() as demo:
         with gr.Column():
             output_video.render()
             output_file.render()
         with gr.Column():
             output_transcribe.render()
-            # output_summary.render()
     middle_markdown.render()
     with gr.Row(equal_height=False):
@@ -54,20 +55,23 @@ with gr.Blocks() as demo:
     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=[input_video, adjust_speaker], outputs=[output_transcribe, output_file])
-        .success(start_adjust_subtitle, inputs=[input_video, start_time, end_time], outputs=output_video)
-    )
     with gr.Accordion("Copyright"):
-        gr.Markdown("OpenAI Whisper, Pyannote & Huggingface")
 if __name__ == "__main__":
     demo.queue(concurrency_count=2, max_size=2).launch(

 import gradio as gr
+from ui.ui_component import *
+from ui.lang_setting import *
+from main.adjust import *
+from main.set_up import prepare_input, prepare_video_subtitle
+from main.summary import get_summary
+from tool.gdrive_tool import get_video_from_url
 with gr.Blocks() as demo:
     ui_lang_radio.render()
                 url_download_button.click(
                     get_video_from_url, input_url, input_video)
                 input_video.render()
             with gr.Column():
                 with gr.Row():
                     start_time.render()
                     end_time.render()
                 lang_radio.render()
                 model_dropdown.render()
         start_button.render()
         (
             start_button
+            .click(prepare_input, [input_video, start_time, end_time, lang_radio, model_dropdown], [output_transcribe, output_file, output_video])
+            .success(prepare_output, inputs=input_video, outputs=[download_video_subtitle_button, adjust_speaker, adjust_audio, prev_button, next_button, adjust_button, summary_button])
         )
     bottom_markdown.render()
         with gr.Column():
             output_video.render()
             output_file.render()
+            download_video_subtitle_button.render()
+            (
+                download_video_subtitle_button
+                .click(prepare_video_subtitle, inputs=[input_video, start_time, end_time], outputs=output_file)
+            )
         with gr.Column():
             output_transcribe.render()
     middle_markdown.render()
     with gr.Row(equal_height=False):
     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_transcribe, output_file, output_video])
+    summary_markdown.render()
+    output_summary.render()
+    summary_button.render()
+    summary_button.click(get_summary, inputs=lang_radio,
+                         outputs=output_summary)
     with gr.Accordion("Copyright"):
+        gr.Markdown("OpenAI Whisper, OpenAI GPT, Pyannote & Huggingface")
 if __name__ == "__main__":
     demo.queue(concurrency_count=2, max_size=2).launch(

file_name.py DELETED Viewed

@@ -1,19 +0,0 @@
-import os
-current_working_directory = os.getcwd()
-download_file = f"{current_working_directory}/download_video.mp4"
-audio_file = f"{current_working_directory}/input.wav"
-transcribe_file = f"{current_working_directory}/transcribe.txt"
-cut_video_file = "cut_video.mp4"
-subtitle_file = f"{current_working_directory}/subtitle.srt"
-base_subtitle_file = "subtitle.srt"
-subtitle_adjusted_file = f"{current_working_directory}/subtitle_adjusted.srt"
-base_subtitle_adjusted_file = "subtitle_adjusted.srt"
-transcribe_adjusted_file = f"{current_working_directory}/transcribe_adjusted.txt"
-video_subtitle_file = f"{current_working_directory}/output.mp4"
-sample_groups_json = f"{current_working_directory}/sample_groups.json"
-speaker_groups_json = f"{current_working_directory}/speaker_groups.json"

adjust.py → main/adjust.py RENAMED Viewed

@@ -1,58 +1,44 @@
-from ui import *
-from file_name 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
 min_duration_ms = 10000
 current_pos = 0
 speaker_to_name = {"Speaker": "Name"}
-speaker_to_sample = {"Speaker": "File"}
 sample_groups = []
-def get_current():
     global speaker_to_name
-    global speaker_to_sample
     print(f"GET CURRENT speaker_to_name: {speaker_to_name}")
-    print(f"GET CURRENT speaker_to_sample: {speaker_to_sample}")
     name = list(speaker_to_name.values())[current_pos]
-    sample = list(speaker_to_sample.values())[current_pos]
     print(f"CURRENT: {name} {sample}")
     return [name, sample]
-def prepare_output(input_file):
-    if input_file is None or not os.path.exists(input_file):
-        return [None, None, None, None, None]
-    speakers = get_speakers()
-    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():
     global sample_groups
     global speaker_to_name
-    global speaker_to_sample
     sample_groups, _ = load_groups_json()
     print(f"SAMPLE GROUP: {sample_groups}")
     speaker_to_name = {}
-    speaker_to_sample = {}
     for speaker in sample_groups:
         for suffix in range(1, 100):
@@ -61,17 +47,43 @@ def get_speakers():
                 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
         print(f"speaker_to_name: {speaker_to_name}")
-        print(f"speaker_to_sample: {speaker_to_sample}")
-    return get_current()
 def change_name(to_name):
@@ -81,7 +93,7 @@ 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):
@@ -90,7 +102,7 @@ def get_speakers_next(to_name):
     global current_pos
     if (current_pos < len(sample_groups) - 1):
         current_pos += 1
-    return get_current()
 def get_speakers_previous(to_name):
@@ -98,37 +110,31 @@ def get_speakers_previous(to_name):
     global current_pos
     if (current_pos > 0):
         current_pos -= 1
-    return get_current()
-def start_adjust_subtitle(input_file, start_time, end_time, progress=gr.Progress()):
-    # Adding subtitle to video
-    progress(0.8, desc=ui_lang["progress_add_subtitle"])
-    add_subtitle_to_video(
-        input_file, base_subtitle_adjusted_file, video_subtitle_file, start_time, end_time)
-    return video_subtitle_file
-def start_adjust(input_file, 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(input_file,
-                                                                                 False)
     modified_transcribe = replace_text(transcribe_txt_list)
     modified_subtitle = replace_text(subtitle_txt_list)
-    utils.write_transcribe_subtitle_file(
-        input_file, modified_transcribe, modified_subtitle, True)
-    # Return video file link, transcribe string, transcribe.txt, subtitle.txt
-    transcribe_txt_list, _ = utils.read_transcribe_subtitle_file(
-        input_file, True)
     print(line for line in transcribe_txt_list)
     transcribe_txt = "\n".join(transcribe_txt_list)
     return [
         transcribe_txt,
-        [transcribe_adjusted_file, subtitle_adjusted_file]
     ]

+from ui.ui_component import *
+from tool.file_name import *
 from pydub import AudioSegment
+from tool.json_tool import load_groups_json
 import os
+import gradio as gr
+import tool.text_file_tool as text_file_tool
 min_duration_ms = 10000
 current_pos = 0
 speaker_to_name = {"Speaker": "Name"}
+speaker_to_sample_file = {"Speaker": "File"}
 sample_groups = []
+def get_current_sample_file():
     global speaker_to_name
+    global speaker_to_sample_file
     print(f"GET CURRENT speaker_to_name: {speaker_to_name}")
+    print(f"GET CURRENT speaker_to_sample: {speaker_to_sample_file}")
     name = list(speaker_to_name.values())[current_pos]
+    sample = list(speaker_to_sample_file.values())[current_pos]
     print(f"CURRENT: {name} {sample}")
     return [name, sample]
+def get_sample_file_for_speakers():
     global sample_groups
     global speaker_to_name
+    global speaker_to_sample_file
     sample_groups, _ = load_groups_json()
     print(f"SAMPLE GROUP: {sample_groups}")
     speaker_to_name = {}
+    speaker_to_sample_file = {}
     for speaker in sample_groups:
         for suffix in range(1, 100):
                 audio_segment = AudioSegment.from_file(file_path)
                 if len(audio_segment) > min_duration_ms:
                     print(f"Found file: {file_path}")
+                    print(f"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_file[speaker] = temp_file_name
         speaker_to_name[speaker] = speaker
         print(f"speaker_to_name: {speaker_to_name}")
+        print(f"speaker_to_sample: {speaker_to_sample_file}")
+    return get_current_sample_file()
+def prepare_output(input_file):
+    if input_file is None or not os.path.exists(input_file):
+        raise gr.Error(current_ui_lang["input_video_warning"])
+    speakers = get_sample_file_for_speakers()
+    download_video_update = download_video_subtitle_button.update(
+        interactive=True)
+    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)
+    summary_button_update = summary_button.update(
+        interactive=True
+    )
+    # Return download button, adjust speaker, adjust audio, previous, next, adjust button
+    return [download_video_update, adjust_speaker_update, adjust_audio_update, prev_button_update, next_button_update, adjust_button_update, summary_button_update]
 def change_name(to_name):
     current_speaker = sample_groups[current_pos]
     speaker_to_name[current_speaker] = to_name
+    print(str(get_current_sample_file()))
 def get_speakers_next(to_name):
     global current_pos
     if (current_pos < len(sample_groups) - 1):
         current_pos += 1
+    return get_current_sample_file()
 def get_speakers_previous(to_name):
     global current_pos
     if (current_pos > 0):
         current_pos -= 1
+    return get_current_sample_file()
+def start_adjust(to_name, progress=gr.Progress()):
     change_name(to_name)
     # Replacing texts
+    progress(0.4, desc=current_ui_lang["progress_adjust_speaker"])
+    transcribe_txt_list, subtitle_txt_list = text_file_tool.read_transcribe_subtitle_file(
+        False)
     modified_transcribe = replace_text(transcribe_txt_list)
     modified_subtitle = replace_text(subtitle_txt_list)
+    text_file_tool.write_transcribe_subtitle_file(
+        modified_transcribe, modified_subtitle, True)
+    # Get complete transcribe into string
+    transcribe_txt_list, _ = text_file_tool.read_transcribe_subtitle_file(True)
     print(line for line in transcribe_txt_list)
     transcribe_txt = "\n".join(transcribe_txt_list)
+    # Return to output textbox, output files, and output video
     return [
         transcribe_txt,
+        [dir_adjusted_transcribe_file, dir_adjusted_subtitle_file],
+        [dir_cut_video_file, dir_adjusted_subtitle_file]
     ]

diarization.py → main/diarization.py RENAMED Viewed

@@ -1,6 +1,6 @@
 from pyannote.audio import Pipeline
 from pydub import AudioSegment
-from file_name import *
 import torch
 import json
 import gc
@@ -9,11 +9,13 @@ import os
 gc.collect()
 torch.cuda.empty_cache()
-hugging_face_token = os.environ["HUGGING_FACE_TOKEN"]
 pipeline = Pipeline.from_pretrained(
     'pyannote/speaker-diarization', use_auth_token=hugging_face_token)
-device = torch.device("cuda")
-pipeline.to(device)
 def start_diarization(input_file):
@@ -52,7 +54,7 @@ def audio_segmentation(input_file, speaker_groups_dict):
 def save_groups_json(input_file, sample_groups_list: list, speaker_groups_dict: dict):
-    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", encoding="utf-8") as json_file_speaker:
         json.dump(speaker_groups_dict, json_file_speaker)

 from pyannote.audio import Pipeline
 from pydub import AudioSegment
+from tool.file_name import *
 import torch
 import json
 import gc
 gc.collect()
 torch.cuda.empty_cache()
+# FIXME REMEMBER TO DELETE ENVIRON BEFORE COMMIT
+# hugging_face_token = os.environ["HUGGING_FACE_TOKEN"]
+hugging_face_token = "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"
 pipeline = Pipeline.from_pretrained(
     'pyannote/speaker-diarization', use_auth_token=hugging_face_token)
+use_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+pipeline.to(use_device)
 def start_diarization(input_file):
 def save_groups_json(input_file, sample_groups_list: list, speaker_groups_dict: dict):
+    with open(dir_sample_groups_json, "w", encoding="utf-8") as json_file_sample:
         json.dump(sample_groups_list, json_file_sample)
+    with open(dir_speaker_groups_json, "w", encoding="utf-8") as json_file_speaker:
         json.dump(speaker_groups_dict, json_file_speaker)

set_up.py → main/set_up.py RENAMED Viewed

@@ -1,73 +1,76 @@
-from ui import *
-from file_name import *
-from diarization import start_diarization
-from transcribe import start_transcribe
-from video_tool import convert_video_to_audio, add_subtitle_to_video
-from datetime import datetime
 import gradio as gr
 import re
 import os
-import utils
-def prepare_video_subtitle(input_file, start_time, end_time, progress=gr.Progress()):
-    if input_file is None or not os.path.exists(input_file):
-        raise gr.Error(ui_lang["input_video_warning"])
-    if validate_time_format(start_time) is False:
-        raise gr.Error(ui_lang["start_time_warning"])
-    if validate_time_format(end_time) is False:
-        raise gr.Error(ui_lang["end_time_warning"])
-    if (check_if_time_invalid(start_time, end_time)):
-        raise gr.Error(ui_lang["time_invalid"])
-    # Add subtitle to video
-    progress(0.8, desc=ui_lang["progress_add_subtitle"])
-    add_subtitle_to_video(input_file, base_subtitle_file,
-                          video_subtitle_file, start_time, end_time)
-    return video_subtitle_file
 def prepare_input(input_file, start_time, end_time, lang, model_size, progress=gr.Progress()):
-    gr.Info(ui_lang["progress_starting_process"])
-    if input_file is None or not os.path.exists(input_file):
-        raise gr.Error(ui_lang["input_video_warning"])
-    if validate_time_format(start_time) is False:
-        raise gr.Error(ui_lang["start_time_warning"])
-    if validate_time_format(end_time) is False:
-        raise gr.Error(ui_lang["end_time_warning"])
-    if (check_if_time_invalid(start_time, end_time)):
-        raise gr.Error(ui_lang["time_invalid"])
     if lang is None:
-        raise gr.Error(ui_lang["lang_radio_warning"])
     if model_size is None:
-        raise gr.Error(ui_lang["model_dropdown_warning"])
     print(f"SOURCE: {input_file}")
-    print(f"AUDIO FILE: {audio_file}")
     # Convert video to audio
-    progress(0.2, desc=ui_lang["progress_preparing_video"])
-    convert_video_to_audio(
-        input_file, audio_file, start_time, end_time)
     # Start diarization
-    progress(0.4, desc=ui_lang["progress_acquiring_diarization"])
-    start_diarization(audio_file)
     # Start transcribing
-    progress(0.6, desc=ui_lang["progress_transcribing_audio"])
-    start_transcribe(input_file, lang, model_size, progress)
-    # Return video file link, transcribe string, transcribe.txt, subtitle.txt
-    transcribe_txt_list, _ = utils.read_transcribe_subtitle_file(
-        input_file, False)
     transcribe_txt = "\n".join(transcribe_txt_list)
     return [
         transcribe_txt,
-        [transcribe_file, 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

+from ui.ui_component import *
+from tool.file_name import *
+from main.diarization import start_diarization
+from main.transcribe import start_transcribe
+from tool.ffmpeg_tool import *
 import gradio as gr
 import re
 import os
+import tool.text_file_tool as text_file_tool
 def prepare_input(input_file, start_time, end_time, lang, model_size, progress=gr.Progress()):
+    gr.Info(current_ui_lang["progress_starting_process"])
+    check_input_video_settings(input_file, start_time, end_time)
     if lang is None:
+        raise gr.Error(current_ui_lang["lang_radio_warning"])
     if model_size is None:
+        raise gr.Error(current_ui_lang["model_dropdown_warning"])
     print(f"SOURCE: {input_file}")
     # Convert video to audio
+    progress(0.2, desc=current_ui_lang["progress_preparing_video"])
+    convert_video_to_audio(input_file, start_time, end_time)
     # Start diarization
+    progress(0.4, desc=current_ui_lang["progress_acquiring_diarization"])
+    start_diarization(dir_cut_audio_file)
     # Start transcribing
+    progress(0.6, desc=current_ui_lang["progress_transcribing_audio"])
+    start_transcribe(lang, model_size, progress)
+    # Cutting video
+    progress(0.8, desc=current_ui_lang["progress_cutting_video"])
+    cut_video(input_file, start_time, end_time)
+    # Get complete transcribe into string
+    transcribe_txt_list, _ = text_file_tool.read_transcribe_subtitle_file(
+        False)
     transcribe_txt = "\n".join(transcribe_txt_list)
+    # Return to output textbox, output files, and output video
     return [
         transcribe_txt,
+        [dir_adjusted_transcribe_file, dir_adjusted_subtitle_file],
+        [dir_cut_video_file, dir_adjusted_subtitle_file]
     ]
+def prepare_video_subtitle(input_file, start_time, end_time):
+    check_input_video_settings(input_file, start_time, end_time)
+    gr.Info(current_ui_lang["progress_add_subtitle"])
+    # Add subtitle to video
+    add_subtitle_to_video()
+    # Return to output files
+    return [dir_base_transcribe_file, dir_base_subtitle_file, dir_video_subtitle_file]
+def check_input_video_settings(input_file, start_time, end_time):
+    if input_file is None or not os.path.exists(input_file):
+        raise gr.Error(current_ui_lang["input_video_warning"])
+    if validate_time_format(start_time) is False:
+        raise gr.Error(current_ui_lang["start_time_warning"])
+    if validate_time_format(end_time) is False:
+        raise gr.Error(current_ui_lang["end_time_warning"])
+    if (check_if_time_invalid(start_time, end_time)):
+        raise gr.Error(current_ui_lang["time_invalid"])
 def validate_time_format(input_string):
     pattern = re.compile(r'^\d{2}:\d{2}:\d{2}$')
     return pattern.match(input_string) is not None

main/summary.py ADDED Viewed

	@@ -0,0 +1,30 @@

+import openai
+import tiktoken
+import tool.text_file_tool as text_file_tool
+# FIXME REMEMBER TO DELETE ENVIRON BEFORE COMMIT
+# openai.api_key = os.environ["OPEN_AI_KEY"]
+openai.api_key = "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"
+def get_summary(lang_choice: int):
+    transcribe_list = text_file_tool.read_simple_transcribe_file()
+    transcribe = "\n".join(transcribe_list)
+    encoding = tiktoken.get_encoding("cl100k_base")
+    token_num = len(encoding.encode(transcribe))
+    print(f"Token number is {token_num}")
+    language = ["English", "Bahasa Indonesia", "Any"]
+    result = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo" if token_num < 4097 else "gpt-3.5-turbo-16k",
+        messages=[
+            {"role": "system", "content": "You will make summary from dialogues in a meeting. The summary will only mention core point of the meeting"},
+            {"role": "user", "content": "Please provide the dialogue"},
+            {"role": "assistant", "content": transcribe},
+            {"role": "user",
+                "content": f"Write summary for the given meeting dialogue in {language[lang_choice]}"}
+        ]
+    )
+    return result["choices"][0]["message"]["content"]

transcribe.py → main/transcribe.py RENAMED Viewed

@@ -1,9 +1,9 @@
 from faster_whisper import WhisperModel
-from utils import load_groups_json
 import torch
 import gc
-from ui import *
-import utils
 gc.collect()
 torch.cuda.empty_cache()
@@ -12,29 +12,28 @@ model_lang_list = ['en', 'id', None]
 model_size = ["tiny", "base", "small", "medium", "large-v2"]
-def start_transcribe(input_file, 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_list = []
     transcribe_txt_list = []
-    for speaker, _ in zip(speaker_groups, progress.tqdm(speaker_groups, desc=ui_lang["progress_transcribing_audio"])):
         # Transcribe and save temp file
         audiof = f"{speaker}.wav"
-        print(f"Loading {audiof}")
         segments, _ = model.transcribe(
             audio=audiof, language=model_lang_list[lang_choice], word_timestamps=True)
         segments_list = list(segments)
         speaker_txt_list = []
         shift = speaker_groups[speaker][0] + 1
-        print(
-            f"Current starting point: {shift}s or {time_str_subtitle(shift)}")
         name = str(speaker)[:10]
         for segment in segments_list:
             start = time_str_subtitle(segment.start + shift)
@@ -43,18 +42,33 @@ def start_transcribe(input_file, lang_choice: int, model_size_choice: int, progr
             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)
         speaker_txt = " ".join(speaker_txt_list)
         transcribe_txt_list.append(
             f"[{time_str(shift)}]\n[{name}] {speaker_txt}\n")
-    utils.write_transcribe_subtitle_file(
-        input_file, transcribe_txt_list, subtitle_txt_list, False)
 def time_str_subtitle(t):
     return '{0:02d}:{1:02d}:{2:06.3f}'.format(round(t // 3600),
                                               round(t % 3600 // 60),
                                               t % 60)

 from faster_whisper import WhisperModel
+from tool.json_tool import load_groups_json
+from ui.ui_component import *
 import torch
 import gc
+import tool.text_file_tool as text_file_tool
 gc.collect()
 torch.cuda.empty_cache()
 model_size = ["tiny", "base", "small", "medium", "large-v2"]
+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])
     _, speaker_groups = load_groups_json()
     subtitle_txt_list = []
     transcribe_txt_list = []
+    simple_transcribe_txt_list = []
+    for speaker, _ in zip(speaker_groups, progress.tqdm(speaker_groups, desc=current_ui_lang["progress_transcribing_audio"])):
         # Transcribe and save temp file
         audiof = f"{speaker}.wav"
         segments, _ = model.transcribe(
             audio=audiof, language=model_lang_list[lang_choice], word_timestamps=True)
         segments_list = list(segments)
         speaker_txt_list = []
         shift = speaker_groups[speaker][0] + 1
+        print(f"Starting point: {shift}s or {time_str_subtitle(shift)}")
         name = str(speaker)[:10]
         for segment in segments_list:
             start = time_str_subtitle(segment.start + shift)
             segment_txt = segment.text
             speaker_txt_list.append(segment_txt)
+            # TODO CHECK FOR TRIPLE QUOTES
             subtitle = f"{len(subtitle_txt_list) + 1}\n{start} --> {end}\n[{name}] {segment_txt}\n\n"
             subtitle_txt_list.append(subtitle)
         speaker_txt = " ".join(speaker_txt_list)
         transcribe_txt_list.append(
             f"[{time_str(shift)}]\n[{name}] {speaker_txt}\n")
+        simple_transcribe_txt_list.append(f"{speaker_txt}\n")
+    # Write simple transcribe for summary later
+    text_file_tool.write_simple_transcribe_file(
+        simple_transcribe_txt_list)
+    # Write to base as main
+    text_file_tool.write_transcribe_subtitle_file(
+        transcribe_txt_list, subtitle_txt_list, False)
+    # Write to adjusted as fallout
+    text_file_tool.write_transcribe_subtitle_file(
+        transcribe_txt_list, subtitle_txt_list, True)
 def time_str_subtitle(t):
     return '{0:02d}:{1:02d}:{2:06.3f}'.format(round(t // 3600),
                                               round(t % 3600 // 60),
                                               t % 60)
+def time_str(t):
+    return '{0:02d}:{1:02d}:{2:02d}'.format(round(t // 3600),
+                                            round(t % 3600 // 60),
+                                            round(t % 60))

requirements.txt CHANGED Viewed

@@ -4,4 +4,6 @@ pyannote-audio @ git+https://github.com/pyannote/pyannote-audio.git
 pydub
 transformers
 torch
-faster-whisper

 pydub
 transformers
 torch
+faster-whisper
+tiktoken
+openai

tool/ffmpeg_tool.py ADDED Viewed

	@@ -0,0 +1,41 @@

+from tool.file_name import *
+import ffmpeg
+def convert_video_to_audio(input_file, start_time, end_time):
+    print("CONVERTING VIDEO TO AUDIO")
+    print(f"INPUT: {input_file}")
+    print(f"OUTPUT: {dir_cut_audio_file}")
+    (
+        ffmpeg
+        .input(input_file)
+        .output(dir_cut_audio_file, ss=start_time, to=end_time, format="wav", acodec='pcm_s16le')
+        .run(overwrite_output=True)
+    )
+def cut_video(input_file, start_time, end_time):
+    print("CUTTING VIDEO")
+    print(f"INPUT: {input_file}")
+    print(f"OUTPUT: {dir_cut_video_file}")
+    (
+        ffmpeg
+        .input(input_file)
+        .output(dir_cut_video_file, ss=start_time, to=end_time, acodec='copy', vcodec='copy')
+        .run(overwrite_output=True)
+    )
+def add_subtitle_to_video():
+    print("ADDING SUBTITLE")
+    print(f"SUBTITLE: {dir_adjusted_subtitle_file}")
+    print(f"OUTPUT: {dir_video_subtitle_file}")
+    (
+        ffmpeg
+        .input(dir_cut_video_file)
+        .output(dir_video_subtitle_file, vf=f'subtitles={dir_adjusted_subtitle_file}', acodec='copy')
+        .run(overwrite_output=True)
+    )

tool/file_name.py ADDED Viewed

	@@ -0,0 +1,19 @@

+# import os
+# TODO DEACTIVATE WORKING DIR FOR A WHILE
+# current_working_directory = os.getcwd()
+dir_download_file = "download_video.mp4"
+dir_cut_audio_file = "cut_audio.wav"
+dir_cut_video_file = "cut_video.mp4"
+# BASE FILE CREATED ONLY ONCE
+dir_base_subtitle_file = "subtitle.srt"
+dir_base_transcribe_file = "transcribe.txt"
+dir_adjusted_subtitle_file = "subtitle_adjusted.srt"
+dir_adjusted_transcribe_file = "transcribe_adjusted.txt"
+dir_video_subtitle_file = "video_subtitle.mp4"
+dir_sample_groups_json = "sample_groups.json"
+dir_speaker_groups_json = "speaker_groups.json"
+dir_simple_transcribe_file = "simple_transcribe.txt"

tool/gdrive_tool.py ADDED Viewed

	@@ -0,0 +1,18 @@

+from tool.file_name import *
+from ui.ui_component import current_ui_lang
+import gradio as gr
+import gdown
+def get_video_from_url(url):
+    # Download video from google drive with shareable link
+    gr.Info(current_ui_lang["get_video_start_info"])
+    download_result = gdown.download(
+        url, dir_download_file, quiet=False, fuzzy=True)
+    # Raise error if failed
+    if (download_result is None):
+        raise gr.Error(current_ui_lang["get_video_fail_info"])
+    gr.Info(current_ui_lang["get_video_finished_info"])
+    return dir_download_file

tool/json_tool.py ADDED Viewed

	@@ -0,0 +1,15 @@

+from tool.file_name import *
+import os
+import json
+def load_groups_json():
+    if not os.path.exists(dir_sample_groups_json) or not os.path.exists(dir_speaker_groups_json):
+        print("JSON file doesn't exist")
+        return [], {}
+    with open(dir_sample_groups_json, "r", encoding="utf-8") as json_file_sample:
+        sample_groups_list: list = json.load(json_file_sample)
+    with open(dir_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

tool/text_file_tool.py ADDED Viewed

	@@ -0,0 +1,47 @@

+from tool.file_name import *
+from ui.ui_component import *
+import gradio as gr
+import os
+def write_simple_transcribe_file(simple_transcribe_txt_list: list):
+    with open(dir_simple_transcribe_file, "w", encoding="utf-8") as file:
+        file.writelines(simple_transcribe_txt_list)
+def read_simple_transcribe_file():
+    with open(dir_simple_transcribe_file, "r", encoding="utf-8") as file:
+        simple_transcribe_txt_list = file.readlines()
+    return simple_transcribe_txt_list
+def write_transcribe_subtitle_file(transcribe_txt_list: list, subtitle_txt_list: list, write_adjusted_file: bool):
+    transcribe = dir_base_transcribe_file
+    subtitle = dir_base_subtitle_file
+    if write_adjusted_file:
+        transcribe = dir_adjusted_transcribe_file
+        subtitle = dir_adjusted_subtitle_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(read_adjusted_file: bool):
+    transcribe = dir_base_transcribe_file
+    subtitle = dir_base_subtitle_file
+    if read_adjusted_file:
+        transcribe = dir_adjusted_transcribe_file
+        subtitle = dir_adjusted_subtitle_file
+    if not os.path.exists(transcribe):
+        raise gr.Error(current_ui_lang["file_not_exist"] + ": Transcribe")
+    if not os.path.exists(subtitle):
+        raise gr.Error(current_ui_lang["file_not_exist"] + ": Subtitle")
+    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

ui.py DELETED Viewed

@@ -1,157 +0,0 @@
-from lang_ui import get_ui_lang
-import gradio as gr
-import file_name
-import ffmpeg
-import gdown
-import time
-# 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"])
-input_url = gr.Textbox(
-    max_lines=1, label=ui_lang["input_url_label"], info=ui_lang["input_url_info"], interactive=True)
-url_download_button = gr.Button(
-    ui_lang["download_button_value"], size='sm', interactive=True)
-input_video = gr.Video(
-    label=ui_lang["input_video_label"], interactive=True)
-# input_video_button = gr.Button(
-#     ui_lang["input_video_button_value"], interactive=True)
-start_time = gr.Textbox("00:00:00", max_lines=1, placeholder="00:00:00",
-                        label=ui_lang["start_time_label"], interactive=True)
-end_time = gr.Textbox("00:00:00", max_lines=1, placeholder="99:99:99",
-                      label=ui_lang["end_time_label"], interactive=True)
-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)
-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)
-def time_str(t):
-    return '{0:02d}:{1:02d}:{2:02d}'.format(round(t // 3600),
-                                            round(t % 3600 // 60),
-                                            round(t % 60))
-def get_video_from_url(url):
-    gr.Info(ui_lang["get_video_start_info"])
-    download_result = gdown.download(
-        url, file_name.download_file, quiet=False, fuzzy=True)
-    if (download_result is None):
-        raise gr.Error(ui_lang["get_video_fail_info"])
-    gr.Info(ui_lang["get_video_finished_info"])
-    return file_name.download_file
-# def clear_duration():
-#     return [
-#         start_time.update(None, interactive=False),
-#         end_time.update(None, interactive=False)
-#     ]
-# def get_duration(input_file):
-#     print("Checking file")
-#     if input_file is None:
-#         raise gr.Error(ui_lang["input_video_warning"])
-#     print("Getting duration & Waiting")
-#     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_url.update(
-            label=ui_lang["input_url_label"], info=ui_lang["input_url_info"]),
-        url_download_button.update(
-            ui_lang["download_button_value"]),
-        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"]),
-        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_url, url_download_button, input_video, start_time, end_time, lang_radio, model_dropdown, start_button, middle_markdown, adjust_speaker, prev_button, next_button, adjust_button, bottom_markdown, output_video, output_transcribe]

lang_ui.py → ui/lang_dictionary.py RENAMED Viewed

@@ -1,3 +1,8 @@
 english_ui = {
     "top_markdown": """
         ## Transcribe
@@ -11,6 +16,10 @@ english_ui = {
         ## Result
         The following is the result of the transcribe
     """,
     "get_video_start_info": "Start downloading",
     "get_video_fail_info": "Failed to download, please make sure the link can be accessed by 'Anyone with the link'",
@@ -30,14 +39,12 @@ english_ui = {
     "input_video_button_value": "Process 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",
@@ -47,13 +54,20 @@ english_ui = {
     "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 = {
@@ -69,6 +83,10 @@ indonesia_ui = {
         ## Hasil
         Berikut hasil akhir dari transkrip
     """,
     "get_video_start_info": "Mulai mengunduh",
     "get_video_fail_info": "Gagal mengunduh, pastikan tautan dapat diakses oleh 'Siapa saja yang memiliki link'",
@@ -88,14 +106,12 @@ indonesia_ui = {
     "input_video_button_value": "Proses 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. Disarankan untuk menggunakan model 'besar'",
-    "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",
@@ -105,16 +121,18 @@ indonesia_ui = {
     "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]

+def get_ui_dict(index):
+    selectable_ui_lang = [english_ui, indonesia_ui]
+    return selectable_ui_lang[index]
 english_ui = {
     "top_markdown": """
         ## Transcribe
         ## Result
         The following is the result of the transcribe
     """,
+    "summary_markdown": """
+        ## Summary
+        You can find the summary of the whole conversation through this dialog
+    """,
     "get_video_start_info": "Start downloading",
     "get_video_fail_info": "Failed to download, please make sure the link can be accessed by 'Anyone with the link'",
     "input_video_button_value": "Process Video",
     "start_time_label": "Start time",
     "end_time_label": "End time",
+    "lang_radio_choices": ["English", "Bahasa Indonesia", "Other / Lainnya"],
     "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",
     "start_button_value": "Start Transcribing",
     "adjust_speaker_value": "Speaker name",
     "output_video_label": "Video with subtitle",
     "output_transcribe_label": "Transcribe result",
+    "download_video_button_value": "Get Video with Subtitle",
+    "summary_button_value": "Create Summary",
+    "output_summary_label": "Summary",
     "progress_starting_process": "Starting process",
     "progress_preparing_video": "Preparing video",
     "progress_acquiring_diarization": "Acquiring diarization",
     "progress_transcribing_audio": "Transcribing audio",
+    "progress_cutting_video": "Cutting video",
     "progress_adjust_speaker": "Adjusting speakers",
+    "progress_add_subtitle": "Adding subtitle on video",
+    "file_not_exist": "File doesn't exist",
 }
 indonesia_ui = {
         ## Hasil
         Berikut hasil akhir dari transkrip
     """,
+    "summary_markdown": """
+        ## Kesimpulan
+        Anda dapat menemukan kesimpulan dari keseluruhan percakapan melalui dialog berikut
+    """,
     "get_video_start_info": "Mulai mengunduh",
     "get_video_fail_info": "Gagal mengunduh, pastikan tautan dapat diakses oleh 'Siapa saja yang memiliki link'",
     "input_video_button_value": "Proses Video",
     "start_time_label": "Waktu mulai",
     "end_time_label": "Waktu selesai",
+    "lang_radio_choices": ["English", "Bahasa Indonesia", "Other / Lainnya"],
     "lang_radio_label": "Bahasa",
     "lang_radio_info": "Bahasa apa yang digunakan dalam video?",
+    "model_dropdown_choices": ["tiny", "base", "small", "medium", "large"],
     "model_dropdown_label": "Ukuran model",
+    "model_dropdown_info": "Semakin tinggi modelnya, semakin akurat transkripnya. Disarankan untuk menggunakan model 'large'",
     "start_button_value": "Mulai Transkrip",
     "adjust_speaker_value": "Nama pembicara",
     "output_video_label": "Video dengan subtitle",
     "output_transcribe_label": "Hasil transkrip",
+    "download_video_button_value": "Dapatkan File Video dengan Subtitle",
+    "summary_button_value": "Buat Kesimpulan",
+    "output_summary_label": "Kesimpulan",
     "progress_starting_process": "Memulai proses",
     "progress_preparing_video": "Mempersiapkan video",
     "progress_acquiring_diarization": "Mengenali pembicara",
     "progress_transcribing_audio": "Mendapatkan transkrip suara",
+    "progress_cutting_video": "Memotong video",
     "progress_adjust_speaker": "Menyesuaikan pembicara",
+    "progress_add_subtitle": "Menambahkan subtitle pada video",
+    "file_not_exist": "Catatan tidak ditemukan",
+}

ui/lang_setting.py ADDED Viewed

	@@ -0,0 +1,85 @@

+from ui.ui_component import *
+def change_lang(input):
+    # Change language function
+    global current_ui_lang
+    current_ui_lang = get_ui_dict(input)
+    print(f"Change language to {available_ui_lang[input]}")
+    return [
+        # Top
+        top_markdown.update(
+            current_ui_lang["top_markdown"]),
+        input_url.update(
+            label=current_ui_lang["input_url_label"], info=current_ui_lang["input_url_info"]),
+        url_download_button.update(
+            current_ui_lang["download_button_value"]),
+        input_video.update(
+            label=current_ui_lang["input_video_label"]),
+        start_time.update(
+            label=current_ui_lang["start_time_label"]),
+        end_time.update(
+            label=current_ui_lang["end_time_label"]),
+        lang_radio.update(
+            choices=current_ui_lang["lang_radio_choices"], value=None, label=current_ui_lang["lang_radio_label"], info=current_ui_lang["lang_radio_info"],),
+        model_dropdown.update(
+            choices=current_ui_lang["model_dropdown_choices"], value=None, label=current_ui_lang["model_dropdown_label"], info=current_ui_lang["model_dropdown_info"]),
+        start_button.update(
+            current_ui_lang["start_button_value"]),
+        # Middle
+        middle_markdown.update(
+            current_ui_lang["middle_markdown"]),
+        adjust_speaker.update(
+            label=current_ui_lang["adjust_speaker_value"]),
+        prev_button.update(
+            current_ui_lang["prev_button_value"]),
+        next_button.update(
+            current_ui_lang["next_button_value"]),
+        adjust_button.update(
+            current_ui_lang["adjust_button_value"]),
+        # Bottom
+        bottom_markdown.update(
+            current_ui_lang["bottom_markdown"]),
+        output_video.update(
+            label=current_ui_lang["output_video_label"]),
+        download_video_subtitle_button.update(
+            current_ui_lang["download_video_button_value"]),
+        output_transcribe.update(
+            label=current_ui_lang["output_transcribe_label"]),
+        # Summary
+        summary_markdown.update(
+            current_ui_lang["summary_markdown"]),
+        summary_button.update(
+            current_ui_lang["summary_button_value"]),
+        output_summary.update(
+            label=current_ui_lang["output_summary_label"]),
+    ]
+# comp_to_update and change_lang return must always be equal
+comp_to_update = [
+    top_markdown,
+    input_url,
+    url_download_button,
+    input_video,
+    start_time,
+    end_time,
+    lang_radio,
+    model_dropdown,
+    start_button,
+    middle_markdown,
+    adjust_speaker,
+    prev_button,
+    next_button,
+    adjust_button,
+    bottom_markdown,
+    output_video,
+    download_video_subtitle_button,
+    output_transcribe,
+    summary_markdown,
+    summary_button,
+    output_summary,
+]

ui/ui_component.py ADDED Viewed

	@@ -0,0 +1,66 @@

+from ui.lang_dictionary import get_ui_dict
+import gradio as gr
+# Display available langauges and set default UI language
+ui_lang_index = 1
+available_ui_lang = ["English", "Bahasa Indonesia"]
+current_ui_lang = get_ui_dict(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(
+    current_ui_lang["top_markdown"])
+input_url = gr.Textbox(
+    max_lines=1, label=current_ui_lang["input_url_label"], info=current_ui_lang["input_url_info"], interactive=True)
+url_download_button = gr.Button(
+    current_ui_lang["download_button_value"], size='sm', interactive=True)
+input_video = gr.Video(
+    label=current_ui_lang["input_video_label"], interactive=True)
+start_time = gr.Textbox(
+    "00:00:00", max_lines=1, placeholder="00:00:00", label=current_ui_lang["start_time_label"], interactive=True)
+end_time = gr.Textbox(
+    "00:15:00", max_lines=1, placeholder="99:99:99", label=current_ui_lang["end_time_label"], interactive=True)
+lang_radio = gr.Radio(
+    current_ui_lang["lang_radio_choices"], label=current_ui_lang["lang_radio_label"], info=current_ui_lang["lang_radio_info"], type='index', interactive=True)
+model_dropdown = gr.Dropdown(
+    current_ui_lang["model_dropdown_choices"], label=current_ui_lang["model_dropdown_label"], info=current_ui_lang["model_dropdown_info"], type='index', interactive=True)
+start_button = gr.Button(
+    current_ui_lang["start_button_value"], variant="primary", interactive=True)
+# Adjust components
+middle_markdown = gr.Markdown(
+    current_ui_lang["middle_markdown"])
+adjust_audio = gr.Audio(
+    interactive=False)
+adjust_speaker = gr.Textbox(
+    label=current_ui_lang["adjust_speaker_value"], interactive=False)
+prev_button = gr.Button(
+    current_ui_lang["prev_button_value"], interactive=False)
+next_button = gr.Button(
+    current_ui_lang["next_button_value"], interactive=False)
+adjust_button = gr.Button(
+    current_ui_lang["adjust_button_value"], variant="primary", interactive=False)
+# Result components
+bottom_markdown = gr.Markdown(
+    current_ui_lang["bottom_markdown"])
+output_video = gr.Video(
+    label=current_ui_lang["output_video_label"], interactive=False)
+download_video_subtitle_button = gr.Button(
+    current_ui_lang["download_video_button_value"], interactive=False, size='sm')
+output_file = gr.File(
+    file_count="multiple", interactive=False)
+output_transcribe = gr.Textbox(
+    label=current_ui_lang["output_transcribe_label"], interactive=False, show_copy_button=True)
+# Summary components
+summary_markdown = gr.Markdown(
+    current_ui_lang["summary_markdown"])
+summary_button = gr.Button(
+    current_ui_lang["summary_button_value"], variant="primary", interactive=False)
+output_summary = gr.Textbox(
+    label=current_ui_lang["output_summary_label"], interactive=False, show_copy_button=True)

utils.py DELETED Viewed

@@ -1,46 +0,0 @@
-import json
-from file_name import *
-import os
-def load_groups_json():
-    if not os.path.exists(sample_groups_json) or not os.path.exists(speaker_groups_json):
-        print("JSON file doesn't exist")
-        return [], {}
-    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(input_file, transcribe_txt_list: list, subtitle_txt_list: list, adjustment: bool):
-    transcribe = transcribe_file
-    subtitle = subtitle_file
-    if adjustment:
-        transcribe = transcribe_adjusted_file
-        subtitle = 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(input_file, adjustment: bool):
-    transcribe = transcribe_file
-    subtitle = subtitle_file
-    if adjustment:
-        transcribe = transcribe_adjusted_file
-        subtitle = subtitle_adjusted_file
-    if not os.path.exists(transcribe) or not os.path.exists(subtitle):
-        print("Transcribe or subtitle file doesn't exist")
-        return [], []
-    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 DELETED Viewed

@@ -1,34 +0,0 @@
-import ffmpeg
-import file_name
-def convert_video_to_audio(input_file, output_file, start_time, end_time):
-    print(f"INPUT: {input_file}")
-    print(f"OUTPUT: {output_file}")
-    (
-        ffmpeg
-        .input(input_file)
-        .output(output_file, ss=start_time, to=end_time, format="wav", acodec='pcm_s16le')
-        .run(overwrite_output=True)
-    )
-def add_subtitle_to_video(input_file, subtitle_file, output_file, start_time, end_time):
-    print(f"INPUT: {input_file}")
-    print(f"SUBTITLE: {subtitle_file}")
-    print(f"OUTPUT: {output_file}")
-    (
-        ffmpeg
-        .input(input_file)
-        .output(file_name.cut_video_file, ss=start_time, to=end_time, acodec='copy', vcodec='copy')
-        .run(overwrite_output=True)
-    )
-    (
-        ffmpeg
-        .input(file_name.cut_video_file)
-        .output(output_file, vf=f'subtitles={subtitle_file}', acodec='copy')
-        .run(overwrite_output=True)
-    )