\EchoScript : Multi-language transcription, Automatic language detection, Translation to English, Batch processing (multiple audio files), TXT export, SRT export, VTT export, CPU-only execution, Faster-Whisper (Model Initialization Improvement)

app.py

@@ -1,5 +1,7 @@
+```python
 import tempfile
 from pathlib import Path
+from zipfile import ZipFile
 
 import gradio as gr
 from faster_whisper import WhisperModel
@@ -9,7 +11,8 @@ MODEL_SIZE = "base"
 model = WhisperModel(
     MODEL_SIZE,
     device="cpu",
-    compute_type="int8"
+    compute_type="int8",
+    download_root="/tmp/whisper_models"
 )
 
 LANGUAGE_NAMES = {
@@ -20,104 +23,220 @@ LANGUAGE_NAMES = {
     "es": "Spanish",
     "it": "Italian",
     "pt": "Portuguese",
-    "nl": "Dutch"
+    "nl": "Dutch",
+    "ar": "Arabic",
+    "ru": "Russian",
+    "tr": "Turkish"
 }
 
 
-def transcribe(audio_file):
+def format_srt_timestamp(seconds):
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    millis = int((seconds - int(seconds)) * 1000)
+
+    return (
+        f"{hours:02}:{minutes:02}:{secs:02},{millis:03}"
+    )
 
-    if audio_file is None:
-        return "", "", None
 
-    segments, info = model.transcribe(
-        audio_file,
-        beam_size=5
+def format_vtt_timestamp(seconds):
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    millis = int((seconds - int(seconds)) * 1000)
+
+    return (
+        f"{hours:02}:{minutes:02}:{secs:02}.{millis:03}"
     )
 
-    transcript_lines = []
-    timestamp_lines = []
+
+def generate_srt(segments):
+    lines = []
+
+    for idx, segment in enumerate(segments, start=1):
+
+        start = format_srt_timestamp(segment.start)
+        end = format_srt_timestamp(segment.end)
+
+        lines.append(
+            f"{idx}\n"
+            f"{start} --> {end}\n"
+            f"{segment.text.strip()}\n"
+        )
+
+    return "\n".join(lines)
+
+
+def generate_vtt(segments):
+    lines = ["WEBVTT\n"]
 
     for segment in segments:
-        transcript_lines.append(segment.text)
 
-        timestamp_lines.append(
-            f"[{segment.start:.2f}s ? {segment.end:.2f}s] "
-            f"{segment.text}"
+        start = format_vtt_timestamp(segment.start)
+        end = format_vtt_timestamp(segment.end)
+
+        lines.append(
+            f"{start} --> {end}\n"
+            f"{segment.text.strip()}\n"
         )
 
-    transcript = "\n".join(transcript_lines)
+    return "\n".join(lines)
 
-    transcript_with_timestamps = "\n".join(
-        timestamp_lines
-    )
 
-    detected_language = LANGUAGE_NAMES.get(
-        info.language,
-        info.language
-    )
+def process_files(files, mode):
 
-    summary = (
-        f"Detected language: {detected_language}\n"
-        f"Confidence: {info.language_probability:.2%}"
-    )
+    if not files:
+        return "", None
+
+    tmp_dir = Path(tempfile.mkdtemp())
+
+    summary_lines = []
 
-    output_file = Path(tempfile.gettempdir()) / "transcript.txt"
+    zip_path = tmp_dir / "echoscript_results.zip"
 
-    with open(
-        output_file,
-        "w",
-        encoding="utf-8"
-    ) as f:
-        f.write(transcript_with_timestamps)
+    with ZipFile(zip_path, "w") as zipf:
+
+        for uploaded_file in files:
+
+            audio_path = uploaded_file
+
+            stem = Path(audio_path).stem
+
+            task = (
+                "transcribe"
+                if mode == "Transcribe"
+                else "translate"
+            )
+
+            segments_generator, info = model.transcribe(
+                audio_path,
+                task=task,
+                beam_size=5
+            )
+
+            segments = list(segments_generator)
+
+            transcript = "\n".join(
+                segment.text.strip()
+                for segment in segments
+            )
+
+            srt_content = generate_srt(segments)
+            vtt_content = generate_vtt(segments)
+
+            language = LANGUAGE_NAMES.get(
+                info.language,
+                info.language
+            )
+
+            summary_lines.append(
+                f"{stem}\n"
+                f"Language: {language}\n"
+                f"Confidence: {info.language_probability:.2%}\n"
+            )
+
+            txt_file = tmp_dir / f"{stem}.txt"
+            srt_file = tmp_dir / f"{stem}.srt"
+            vtt_file = tmp_dir / f"{stem}.vtt"
+
+            txt_file.write_text(
+                transcript,
+                encoding="utf-8"
+            )
+
+            srt_file.write_text(
+                srt_content,
+                encoding="utf-8"
+            )
+
+            vtt_file.write_text(
+                vtt_content,
+                encoding="utf-8"
+            )
+
+            zipf.write(
+                txt_file,
+                arcname=txt_file.name
+            )
+
+            zipf.write(
+                srt_file,
+                arcname=srt_file.name
+            )
+
+            zipf.write(
+                vtt_file,
+                arcname=vtt_file.name
+            )
 
     return (
-        summary,
-        transcript,
-        str(output_file)
+        "\n\n".join(summary_lines),
+        str(zip_path)
     )
 
 
-with gr.Blocks(title="EchoScript") as demo:
+with gr.Blocks(
+    title="EchoScript"
+) as demo:
 
     gr.Markdown(
         """
-        # EchoScript
+# EchoScript
+
+Transcribe audio files using Faster-Whisper.
+
+### Features
 
-        Upload an audio file and automatically
-        transcribe speech to text.
+- Automatic language detection
+- Multi-language transcription
+- Translation to English
+- Batch processing
+- TXT export
+- SRT subtitle export
+- VTT subtitle export
         """
     )
 
-    audio_input = gr.Audio(
-        type="filepath",
-        label="Upload Audio"
+    files_input = gr.Files(
+        label="Upload Audio Files"
     )
 
-    transcribe_button = gr.Button(
-        "Transcribe"
+    mode_input = gr.Dropdown(
+        choices=[
+            "Transcribe",
+            "Translate to English"
+        ],
+        value="Transcribe",
+        label="Mode"
     )
 
-    language_output = gr.Textbox(
-        label="Language Information"
+    run_button = gr.Button(
+        "Start Processing"
     )
 
-    transcript_output = gr.Textbox(
-        label="Transcript",
-        lines=20
+    summary_output = gr.Textbox(
+        label="Results",
+        lines=12
     )
 
     download_output = gr.File(
-        label="Download Transcript"
+        label="Download ZIP"
     )
 
-    transcribe_button.click(
-        fn=transcribe,
-        inputs=audio_input,
+    run_button.click(
+        fn=process_files,
+        inputs=[
+            files_input,
+            mode_input
+        ],
         outputs=[
-            language_output,
-            transcript_output,
+            summary_output,
             download_output
         ]
     )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()
+```