Upload 4 files

app.py

@@ -0,0 +1,136 @@
+import time
+import logging
+import os
+import gradio as gr
+from faster_whisper import WhisperModel
+from languages import get_language_names, get_language_from_name
+from subtitle_manager import Subtitle
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+last_model = None
+model = None
+
+def transcribe_webui_simple_progress(modelName, languageName, urlData, multipleFiles, microphoneData, task,
+                                    chunk_length, compute_type, beam_size, vad_filter, min_silence_duration_ms,
+                                    progress=gr.Progress()):
+    global last_model
+    global model
+
+    progress(0, desc="Loading Audio..")
+    logging.info(f"languageName:{languageName}")
+    logging.info(f"urlData:{urlData}")
+    logging.info(f"multipleFiles:{multipleFiles}")
+    logging.info(f"microphoneData:{microphoneData}")
+    logging.info(f"task: {task}")
+    logging.info(f"chunk_length: {chunk_length}")
+
+    if last_model == None or modelName != last_model:
+        logging.info("first or new model")
+        progress(0.1, desc="Loading Model..")
+        model = None
+        model = WhisperModel(modelName, device="cuda",compute_type=compute_type, cpu_threads=os.cpu_count(),)#device="auto", compute_type="float16"
+        print('loaded')
+    else:
+        logging.info("Model not changed")
+    last_model = modelName
+
+    srt_sub = Subtitle("srt")
+    # vtt_sub = Subtitle("vtt")
+    # txt_sub = Subtitle("txt")
+
+    files = []
+    if multipleFiles:
+        files+=multipleFiles
+    if urlData:
+        files.append(urlData)
+    if microphoneData:
+        files.append(microphoneData)
+    logging.info(files)
+
+    languageName = None if languageName == "Automatic Detection" else get_language_from_name(languageName).code
+
+    files_out = []
+    vtt=""
+    txt=""
+    for file in progress.tqdm(files, desc="Working..."):
+
+        start_time = time.time()
+        segments, info = model.transcribe(
+            file,
+            beam_size=beam_size,
+            vad_filter=vad_filter,
+            language=languageName,
+            vad_parameters=dict(min_silence_duration_ms=min_silence_duration_ms),
+            # max_new_tokens=128,
+            condition_on_previous_text=False,
+            chunk_length=chunk_length,
+            )
+
+        file_name = Path(file).stem
+        files_out_srt = srt_sub.write_subtitle(segments, file_name, modelName, progress)
+        # txt = txt_sub.get_subtitle(segments, progress)
+        logging.info(print(f"transcribe: {time.time() - start_time} sec."))
+        files_out += [files_out_srt]
+    
+    return files_out, vtt, txt
+
+
+with gr.Blocks(title="Fast Whisper WebUI") as demo:
+    description = "faster-whisper is a reimplementation of OpenAI's Whisper model using CTranslate2, which is a fast inference engine for Transformer models."
+    article = "Read the [documentation here](https://github.com/SYSTRAN/faster-whisper)."
+    whisper_models = [
+        "tiny", "tiny.en",
+        "base", "base.en",
+        "small", "small.en", "distil-small.en",
+        "medium", "medium.en", "distil-medium.en",
+        "large",
+        "large-v1",
+        "large-v2", "distil-large-v2",
+        "large-v3",
+    ]
+    compute_types = [
+        "auto", "default", "int8", "int8_float32",
+        "int8_float16", "int8_bfloat16", "int16",
+        "float16", "float32", "bfloat16"
+    ]
+
+
+    # settings
+    # cant put Dropdown in inputs
+    # with gr.Accordion("Settings", open=False):
+        # task = gr.Dropdown(choices=["transcribe", "translate"], label="Task", value="transcribe", interactive = True),
+        # chunk_length = gr.Number(label='chunk_length',value=30, interactive = True),
+        # compute_type = gr.Dropdown(label="compute_type", choices=compute_types, value="auto", interactive = True),
+        # beam_size = gr.Number(label='beam_size',value=5, interactive = True),
+        # vad_filter = gr.Checkbox(label='vad_filter',info='Use vad_filter', value=True),
+        # vad_min_silence_duration_ms = gr.Number(label='Vad min_silence_duration_ms',value=500, interactive = True),
+
+    gr.Interface(
+        fn=transcribe_webui_simple_progress,
+        description=description,
+        article=article,
+        inputs=[
+            gr.Dropdown(choices=whisper_models, value="distil-large-v2", label="Model", info="Select whisper model", interactive = True,),
+            gr.Dropdown(choices=["Automatic Detection"] + sorted(get_language_names()), value="Automatic Detection", label="Language", info="Select audio voice language", interactive = True,),
+            gr.Text(label="URL", info="(YouTube, etc.)", interactive = True),
+            gr.File(label="Upload Files", file_count="multiple"),
+            gr.Audio(sources=["microphone"], type="filepath", label="Microphone Input"),
+
+            gr.Dropdown(choices=["transcribe", "translate"], label="Task", value="transcribe", interactive = True),
+            gr.Number(label='chunk_length',value=30, interactive = True),
+            gr.Dropdown(label="compute_type", choices=compute_types, value="auto", interactive = True),
+            gr.Number(label='beam_size',value=5, interactive = True),
+            gr.Checkbox(label='vad_filter',info='Use vad_filter', value=True),
+            gr.Number(label='Vad min_silence_duration_ms',value=500, interactive = True),
+        ],
+        outputs=[
+            gr.File(label="Download"),
+            gr.Text(label="Transcription"), 
+            gr.Text(label="Segments"),
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+

languages.py

@@ -0,0 +1,146 @@
+class Language():
+    def __init__(self, code, name):
+        self.code = code
+        self.name = name
+
+    def __str__(self):
+        return "Language(code={}, name={})".format(self.code, self.name)
+
+LANGUAGES = [
+    Language('en', 'English'),
+    Language('zh', 'Chinese'),   
+    Language('de', 'German'),    
+    Language('es', 'Spanish'),   
+    Language('ru', 'Russian'),   
+    Language('ko', 'Korean'),    
+    Language('fr', 'French'),    
+    Language('ja', 'Japanese'),  
+    Language('pt', 'Portuguese'),
+    Language('tr', 'Turkish'),   
+    Language('pl', 'Polish'),    
+    Language('ca', 'Catalan'),   
+    Language('nl', 'Dutch'),     
+    Language('ar', 'Arabic'),
+    Language('sv', 'Swedish'),
+    Language('it', 'Italian'),
+    Language('id', 'Indonesian'),
+    Language('hi', 'Hindi'),
+    Language('fi', 'Finnish'),
+    Language('vi', 'Vietnamese'),
+    Language('he', 'Hebrew'),
+    Language('uk', 'Ukrainian'),
+    Language('el', 'Greek'),
+    Language('ms', 'Malay'),
+    Language('cs', 'Czech'),
+    Language('ro', 'Romanian'),
+    Language('da', 'Danish'),
+    Language('hu', 'Hungarian'),
+    Language('ta', 'Tamil'),
+    Language('no', 'Norwegian'),
+    Language('th', 'Thai'),
+    Language('ur', 'Urdu'),
+    Language('hr', 'Croatian'),
+    Language('bg', 'Bulgarian'),
+    Language('lt', 'Lithuanian'),
+    Language('la', 'Latin'),
+    Language('mi', 'Maori'),
+    Language('ml', 'Malayalam'),
+    Language('cy', 'Welsh'),
+    Language('sk', 'Slovak'),
+    Language('te', 'Telugu'),
+    Language('fa', 'Persian'),
+    Language('lv', 'Latvian'),
+    Language('bn', 'Bengali'),
+    Language('sr', 'Serbian'),
+    Language('az', 'Azerbaijani'),
+    Language('sl', 'Slovenian'),
+    Language('kn', 'Kannada'),
+    Language('et', 'Estonian'),
+    Language('mk', 'Macedonian'),
+    Language('br', 'Breton'),
+    Language('eu', 'Basque'),
+    Language('is', 'Icelandic'),
+    Language('hy', 'Armenian'),
+    Language('ne', 'Nepali'),
+    Language('mn', 'Mongolian'),
+    Language('bs', 'Bosnian'),
+    Language('kk', 'Kazakh'),
+    Language('sq', 'Albanian'),
+    Language('sw', 'Swahili'),
+    Language('gl', 'Galician'),
+    Language('mr', 'Marathi'),
+    Language('pa', 'Punjabi'),
+    Language('si', 'Sinhala'),
+    Language('km', 'Khmer'),
+    Language('sn', 'Shona'),
+    Language('yo', 'Yoruba'),
+    Language('so', 'Somali'),
+    Language('af', 'Afrikaans'),
+    Language('oc', 'Occitan'),
+    Language('ka', 'Georgian'),
+    Language('be', 'Belarusian'),
+    Language('tg', 'Tajik'),
+    Language('sd', 'Sindhi'),
+    Language('gu', 'Gujarati'),
+    Language('am', 'Amharic'),
+    Language('yi', 'Yiddish'),
+    Language('lo', 'Lao'),
+    Language('uz', 'Uzbek'),
+    Language('fo', 'Faroese'),
+    Language('ht', 'Haitian creole'),
+    Language('ps', 'Pashto'),
+    Language('tk', 'Turkmen'),
+    Language('nn', 'Nynorsk'),
+    Language('mt', 'Maltese'),
+    Language('sa', 'Sanskrit'),
+    Language('lb', 'Luxembourgish'),
+    Language('my', 'Myanmar'),
+    Language('bo', 'Tibetan'),
+    Language('tl', 'Tagalog'),
+    Language('mg', 'Malagasy'),
+    Language('as', 'Assamese'),
+    Language('tt', 'Tatar'),
+    Language('haw', 'Hawaiian'),
+    Language('ln', 'Lingala'),
+    Language('ha', 'Hausa'),
+    Language('ba', 'Bashkir'),
+    Language('jw', 'Javanese'),
+    Language('su', 'Sundanese')
+]
+
+_TO_LANGUAGE_CODE = {
+    **{language.code: language for language in LANGUAGES},
+    "burmese": "my",
+    "valencian": "ca",
+    "flemish": "nl",
+    "haitian": "ht",
+    "letzeburgesch": "lb",
+    "pushto": "ps",
+    "panjabi": "pa",
+    "moldavian": "ro",
+    "moldovan": "ro",
+    "sinhalese": "si",
+    "castilian": "es",
+}
+    
+_FROM_LANGUAGE_NAME = {
+    **{language.name.lower(): language for language in LANGUAGES}
+}
+
+def get_language_from_code(language_code, default=None) -> Language:
+    """Return the language name from the language code."""
+    return _TO_LANGUAGE_CODE.get(language_code, default)
+
+def get_language_from_name(language, default=None) -> Language:
+    """Return the language code from the language name."""
+    return _FROM_LANGUAGE_NAME.get(language.lower() if language else None, default)
+
+def get_language_names():
+    """Return a list of language names."""
+    return [language.name for language in LANGUAGES]
+
+if __name__ == "__main__":
+    # Test lookup
+    print(get_language_from_code('en'))
+    print(get_language_from_name('English'))
+    print(get_language_names())

requirements.txt

@@ -0,0 +1,2 @@
+gradio==4.16.0
+faster-whisper @ git+https://github.com/guillaumekln/faster-whisper@master

subtitle_manager.py

@@ -0,0 +1,57 @@
+import logging
+
+class Subtitle():
+    def __init__(self,ext="srt"):
+        sub_dict = {
+            "srt":{
+                "coma": ",",
+                "header": "",
+                "format": lambda i,start,end,text : f"{i + 1}\n{self.timeformat(start)} --> {self.timeformat(end if end != None else start)}\n{text}\n\n",
+            },
+            "vtt":{
+                "coma": ".",
+                "header": "WebVTT\n\n",
+                "format": lambda i,start,end,text : f"{self.timeformat(start)} --> {self.timeformat(end if end != None else start)}\n{text}\n\n",
+            },
+            "txt":{
+                "coma": "",
+                "header": "",
+                "format": lambda i,start,end,text : f"{text}\n",
+            },
+        }
+
+        self.ext = ext
+        self.coma = sub_dict[ext]["coma"]
+        self.header = sub_dict[ext]["header"]
+        self.format = sub_dict[ext]["format"]
+
+    def timeformat(self,time):
+        hours = time // 3600
+        minutes = (time - hours * 3600) // 60
+        seconds = time - hours * 3600 - minutes * 60
+        milliseconds = (time - int(time)) * 1000
+        return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}{self.coma}{int(milliseconds):03d}"
+    
+    def get_subtitle(self,segments, progress):
+        output = self.header
+        # for i, segment in enumerate(segments):
+        for i, segment in enumerate(progress.tqdm(segments, desc="Whisper working...")):
+            text = segment.text
+            if text.startswith(' '):
+                text = text[1:]
+            try:
+                result = self.format(i,segment.start, segment.end, text)
+                output += result
+                # logging.info(result)
+            except Exception as e:
+                logging.error(e,segment)
+        return output
+    
+    def write_subtitle(self, segments, output_file, model, progress):
+        # output_file = output_file.split('.')[0]
+        output_file += f".({model})."+self.ext
+        subtitle = self.get_subtitle(segments,progress)
+
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(subtitle)
+        return output_file