feat: Include Transformers implementation, paragraphs, and pdf output

Dockerfile

@@ -1,6 +1,10 @@
 FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
 
-RUN apt-get update && apt-get install -y apt-utils
+# Set environment variable to avoid interactive prompts
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Weasyprint is necessary for pdf printing
+RUN apt-get update && apt-get install -y apt-utils weasyprint 
 
 RUN apt-get install -y python3.11 python3.11-venv python3-pip
 
@@ -66,7 +70,4 @@ RUN sed -i 's/\r$//' /odtp/odtp-component-client/odtp-app.sh
 RUN sed -i 's/\r$//' /odtp/odtp-component-client/startup.sh
 RUN sed -i 's/\r$//' /odtp/odtp-app/app.sh
 
-#ENTRYPOINT ["bash", "/odtp/odtp-component-client/startup.sh"]
-ENTRYPOINT [ "python3", "/odtp/odtp-app/gradio_app.py" ]
-
-# Create command to run the app that goes to an entrypoint basically the startup mode. Also I in order to work with an API I need some interface with an s3 to make it work?
+ENTRYPOINT ["bash", "/odtp/odtp-component-client/startup.sh"]

app/app.py

@@ -1,19 +1,186 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, TextIO, List
+import whisper
+from whisper import Whisper
+import torch
+from math import floor, ceil
+
+from transformers import pipeline
+import numpy as np
+import librosa
+import torch
+from math import floor, ceil
+
 import os
 import argparse
-from typing import Any, Optional, TextIO, List
 from pyannote.audio import Pipeline, Audio
-import whisper
 from whisper.utils import WriteSRT, WriteVTT
-from whisper import Whisper
-import torch
-from math import ceil, floor
+
 import soundfile as sf
 import librosa
 import json
 from dataclasses import dataclass, asdict
-from typing import List
 from jsonschema import validate, ValidationError
 
+import createpdf
+import paragraphsCreator
+
+from pydub import AudioSegment
+from pytube import YouTube
+
+
+
+
+
+class ASRFacade(ABC):
+    """Abstract base class to define an interface for transcription."""
+
+    @abstractmethod
+    def load_audio(self, file_path: str):
+        pass
+
+    @abstractmethod
+    def transcribe(
+        self,
+        start: float,
+        end: float,
+        options: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """Transcribe a portion of audio from start to end time in seconds."""
+        pass
+
+
+
+
+class WhisperFacade(ASRFacade):
+    wmodel: Whisper
+    audio: Any  # The loaded audio array from Whisper
+
+    def __init__(self, model: str, *, quantize=False) -> None:
+        print("Initialize Whisper")
+        whisper_model = whisper.load_model(model)
+        if quantize:
+            print("Quantize")
+            DTYPE = torch.qint8
+            qmodel: Whisper = torch.quantization.quantize_dynamic(
+                whisper_model, {torch.nn.Linear}, dtype=DTYPE
+            )
+            del whisper_model
+            self.wmodel = qmodel
+        else:
+            self.wmodel = whisper_model
+
+    def load_audio(self, file_path: str):
+        self.audio = whisper.load_audio(file_path)
+
+    def _set_timing_for(self, segment: dict[str, float], offset: float) -> None:
+        # Keep this logic the same
+        s = segment
+        s['start'] += offset 
+        s['end']   += offset
+        if 'words' in s:
+            for w in s['words']:
+                w['start'] += offset
+                w['end'] += offset
+
+    def transcribe(
+        self,
+        start: float,
+        end: float,
+        options: dict[str, Any]
+    ) -> dict[str, Any]:
+        SAMPLE_RATE = 16_000
+        start_index = floor(start * SAMPLE_RATE)
+        end_index   = ceil(end * SAMPLE_RATE)
+
+        audio_segment = self.audio[start_index:end_index]
+        result = whisper.transcribe(self.wmodel, audio_segment, **options)
+
+        for s in result['segments']:
+            self._set_timing_for(segment=s, offset=start)
+
+        return result
+
+
+class TransformersFacade(ASRFacade):
+    """Use a Hugging Face ASR pipeline instead of Whisper."""
+
+    def __init__(self, model_name: str):
+        print(f"Initialize Transformers pipeline with model {model_name}")
+        self.asr_pipeline = pipeline("automatic-speech-recognition", model=model_name)
+        self.sr = 16000
+        self.audio_data = None  # We'll store the loaded waveform here
+
+    def load_audio(self, file_path: str):
+        # We'll load audio into a single waveform at 16 kHz
+        print(f"Loading audio for Transformers from {file_path}")
+        waveform, sr = librosa.load(file_path, sr=self.sr, mono=True)
+        self.audio_data = waveform
+        print(f"Audio loaded: shape={waveform.shape}, sample_rate={sr}")
+
+    def transcribe(
+        self,
+        start: float,
+        end: float,
+        options: dict[str, Any]
+    ) -> dict[str, Any]:
+        """
+        We want to return a structure with 'segments' just like Whisper does.
+        We'll treat the entire chunk as a single forward pass to the pipeline.
+        If you prefer more advanced chunking or word-level timestamps, you can expand this.
+        """
+        start_sample = floor(start * self.sr)
+        end_sample   = ceil(end * self.sr)
+        audio_segment = self.audio_data[start_sample:end_sample]
+
+        # The pipeline can handle direct numpy arrays.
+        # Some HF pipelines let you pass 'return_timestamps=True' in generate(), but that may vary by model.
+        # We'll do a straightforward approach here:
+        transcription = self.asr_pipeline(audio_segment)#, sampling_rate=self.sr)
+
+        # We want to unify the output structure with whisper-like dict.
+        # Example result for consistency:
+        result = {
+            "language": "ca",  # or fetch from pipeline if available
+            "segments": [
+                {
+                    "id": 0,
+                    "start": start,
+                    "end": end,
+                    "text": transcription["text"],
+                    # If you want words/tokens, you can parse them here if your model supports it
+                }
+            ]
+        }
+        return result
+
+def create_asr_facade(model_name: str, quantize: bool = False) -> ASRFacade:
+    """Factory function to return either a Whisper or Transformers facade."""
+    # Example: if user requests 'base-ca', we switch to Transformers
+    if model_name in ['tiny.en', 
+                        'tiny', 
+                        'base.en', 
+                        'base', 
+                        'small.en', 
+                        'small', 
+                        'medium.en', 
+                        'medium', 
+                        'large-v1', 
+                        'large-v2', 
+                        'large-v3', 
+                        'large', 
+                        'large-v3-turbo', 
+                        'turbo']:
+        return WhisperFacade(model=model_name, quantize=quantize)
+    else:
+        print(f"Trying to use Transformers model from {model_name}")
+        return TransformersFacade(model_name=model_name)
+        
+    
+
+
+
+#############################################################################
 
 @dataclass
 class Segment:
@@ -229,9 +396,12 @@ class SegmentsJSONWriter(AppendResultsMixin):
             else:
                 f.write(',\n')
             for idx, segment in enumerate(segments):
-                if idx > 0:
-                    f.write(',\n')
-                json.dump(asdict(segment), f, ensure_ascii=False, indent=2)
+                if segment:  # Check if the segment is not empty
+                    if idx > 0:
+                        f.write(',\n')
+
+                    segment.text = segment.text.strip()
+                    json.dump(asdict(segment), f, ensure_ascii=False, indent=2)
             self.first_call = False
 
     def finalize(self):
@@ -244,57 +414,6 @@ class SegmentsJSONWriter(AppendResultsMixin):
         with open(self.output_path, 'a', encoding='utf-8') as f:
             f.write('\n]}\n')
 
-class WhisperFacade:
-    wmodel: Whisper
-
-    def __init__(self, model:str, *, quantize=False) -> None:
-        """Load the Whisper model and optionally quantize."""
-        print("Initialize whisper")
-        whisper_model = whisper.load_model(model)
-        if quantize:
-            print("Quantize")
-            DTYPE = torch.qint8
-            qmodel: Whisper = torch.quantization.quantize_dynamic(
-                        whisper_model, {torch.nn.Linear}, dtype=DTYPE)
-            del whisper_model
-            self.wmodel = qmodel
-        else:
-            self.wmodel = whisper_model
-
-    def _set_timing_for(self, segment: dict[str, float],  # simplified typing
-                        offset: float) -> None:
-        """For speech fragments in different parts of an audio file, patch the 
-        whisper segment and word timing using the offset (typically the diarization offset)
-        in seconds. This makes the timing accurate for subtitles when multiple 
-        calls to whisper are used for various parts of the audio.
-        """
-        s = segment
-        s['start'] += offset 
-        s['end']   += offset
-        # Update word start/stop times, if present
-        if 'words' in s:
-            w: dict[str, float] # simplified typing
-            for w in s['words']: # type: ignore
-                w['start'] += offset
-                w['end'] += offset
-
-    def load_audio(self, file_path: str):
-        self.audio = whisper.load_audio(file_path)
-    
-    def transcribe(self, *, start: float, end: float, options: dict[str, Any] ) -> dict[str, Any]:
-        """Transcribe from start time to end time (both in seconds)."""
-        SAMPLE_RATE = 16_000 # 16kHz audio
-        start_index = floor(start * SAMPLE_RATE)
-        end_index = ceil(end * SAMPLE_RATE)
-        audio_segment = self.audio[start_index:end_index]
-        result = whisper.transcribe(self.wmodel, audio_segment, **options)
-        #
-        segments = result['segments']
-        s: dict[str, float] # simplified typing
-        for s in segments: # type: ignore
-            self._set_timing_for(segment=s, offset=start)
-        return result
-
 def clip_audio(audio_file_path, sample_rate, start, end, output_path):
     # Ensure the output directory exists
     os.makedirs(os.path.dirname(output_path), exist_ok=True)
@@ -309,45 +428,107 @@ def clip_audio(audio_file_path, sample_rate, start, end, output_path):
     # Write the audio segment to the output path
     sf.write(output_path, waveform[start_sample:end_sample], sr, format='WAV')
 
+def convert_mpx_to_wav(file_path):
+    if file_path.lower().endswith('.mp3'):
+        # Load the MP3 file
+        audio = AudioSegment.from_mp3(file_path)
+
+    elif file_path.lower().endswith('.mp4'):
+        audio = AudioSegment.from_mp4(file_path)
+
+    else:
+        raise ValueError("Input file must be an MP3 or MP4 file")
+        
+    # Define the output path
+    wav_file_path = os.path.splitext(file_path)[0] + '.wav'
+    
+    # Export as WAV
+    audio.export(wav_file_path, format='wav')
+    
+    return wav_file_path
+
+    
+def download_youtube_video(url, output_path='downloads'):
+    if url.startswith('http://') or url.startswith('https://'):
+        yt = YouTube(url)
+        video = yt.streams.filter(only_audio=True).first()
+        if not os.path.exists(output_path):
+            os.makedirs(output_path)
+        output_file = video.download(output_path)
+        base, ext = os.path.splitext(output_file)
+        new_file = base + '.mp4'
+        os.rename(output_file, new_file)
+        return new_file
+    else:
+        raise ValueError("The provided URL is not a valid HTTP link")
+
+
+
 def main(args):
     diarization, _, sample_rate = diarize_audio(args.hf_token, args.input_file)
-    model = WhisperFacade(model=args.model, quantize=args.quantize)
-    model.load_audio(args.input_file)
-    #
+
+
+    if args.input_file.startswith('http://') or args.input_file.startswith('https://'):
+        file_path = download_youtube_video(args.input_file, output_path=os.path.dirname(args.output_file))
+        file_path = convert_mpx_to_wav(file_path)
+    elif args.input_file.lower().endswith('.mp3'):
+        file_path = convert_mpx_to_wav(args.input_file)
+    elif args.input_file.lower().endswith('.wav'):
+        file_path = args.input_file
+    elif args.input_file.lower().endswith('.mp4'):
+        file_path = convert_mpx_to_wav(args.input_file)
+    else:
+        raise ValueError("Input file must be an MP3, WAV or MP4 file")
+
+    # Create the correct ASR facade
+    asr_model = create_asr_facade(args.model, quantize=args.quantize)
+    asr_model.load_audio(args.input_file)
+    
     writer = WriteSRTIncremental() 
     writer_json = SegmentsJSONWriter()
-    whisper_options = {"verbose": None, "word_timestamps": False, 
-                       "task": args.task, "suppress_tokens": ""}
+    
+    # Whisper-like transcription options
+    whisper_options = {
+        "verbose": None,
+        "word_timestamps": False,
+        "task": args.task,
+        "suppress_tokens": ""
+    }
     if args.language:
+        # This is only relevant for Whisper. For Transformers,
+        # you might specify a different approach or ignore it.
         whisper_options["language"] = args.language
-    writer_options = {"max_line_width":55, "max_line_count":2, "word_timestamps": False}
-    if args.verbose=="True":
+
+    writer_options = {
+        "max_line_width": 55,
+        "max_line_count": 2,
+        "word_timestamps": False
+    }
+
+    if args.verbose == "True":
         print("Process diarized blocks")
+
     
-    # Group consecutive segments of the same speaker
     grouped_segments = []
     current_speaker = None
-    current_start = None
-    current_end = None
+    current_start   = None
+    current_end     = None
 
     for turn, _, speaker in diarization.itertracks(yield_label=True):
         if args.verbose=="True":
             print(speaker)
-        if turn.end - turn.start < 0.5:  # Suppress short utterances (pyannote artifact)
-            if args.verbose=="True":
-                print(f"start={turn.start:.1f}s stop={turn.end:.1f}s IGNORED")
+        if turn.end - turn.start < 0.5:
+            # ignore short utterances
             continue
-
         if speaker == current_speaker:
             current_end = turn.end
         else:
             if current_speaker is not None:
                 grouped_segments.append((current_start, current_end, current_speaker))
             current_speaker = speaker
-            current_start = turn.start
-            current_end = turn.end
+            current_start    = turn.start
+            current_end      = turn.end
 
-    # Append the last segment
     if current_speaker is not None:
         grouped_segments.append((current_start, current_end, current_speaker))
 
@@ -355,14 +536,33 @@ def main(args):
     for start, end, speaker in grouped_segments:
         clip_path = f"/tmp/speaker_{speaker}_start_{start:.1f}_end_{end:.1f}.wav"
         clip_audio(args.input_file, sample_rate, start, end, clip_path)
-        result = model.transcribe(start=start, end=end, options=whisper_options)
-        language = result['language']
+        
+        # Important: we call asr_model instead of model
+        result = asr_model.transcribe(start=start, end=end, options=whisper_options)
+        language = result.get('language', args.language or 'unknown')
+        
         if args.verbose=="True":
             print(f"start={start:.1f}s stop={end:.1f}s lang={language} {speaker}")
+
+        # Use your existing logic to write SRT, JSON, etc.
         writer(result, args.output_file, speaker, start, writer_options)
-        writer_json(generate_segments(result['segments'],  speaker, language), args.output_json_file)
+        writer_json(generate_segments(result['segments'], speaker, language), args.output_json_file)
+
     writer_json.finalize()
 
+    # If you want to validate JSON, paragraphs, PDF creation, etc.
+    paragraphsCreator.process_paragraphs(
+        args.output_json_file,
+        args.output_paragraphs_json_file,
+        3
+    )
+    createpdf.convert_json_to_pdf(
+        args.output_paragraphs_json_file,
+        args.output_md_file,
+        args.output_pdf_file
+    )
+
+
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description="Diarization and Whisper Transcription CLI")
     parser.add_argument('--model', type=str, required=True, help="Whisper model to use")
@@ -372,7 +572,10 @@ if __name__ == '__main__':
     parser.add_argument('--language', type=str, required=False, help="Language to use for transcription or translation")
     parser.add_argument('--input-file', type=str, required=True, help="Input audio file")
     parser.add_argument('--output-file', type=str, required=True, help="Output file for the results (SRT or VTT)")
-    parser.add_argument('--output-json-file', type=str, required=True, help="Output file for the results (SRT or VTT)")
+    parser.add_argument('--output-json-file', type=str, required=True, help="Output json file.")
+    parser.add_argument('--output-paragraphs-json-file', type=str, required=True, help="Output paragraphs file")
+    parser.add_argument('--output-md-file', type=str, required=True, help="Output markdown file")
+    parser.add_argument('--output-pdf-file', type=str, required=True, help="Output pdf file")
     parser.add_argument('--verbose', type=str, required=False, help="Printing status")
 
     args = parser.parse_args()

app/app.sh

@@ -33,18 +33,28 @@
 #########################################################
 
 if [ -n "$LANGUAGE" ]; then
-    python3 /odtp/odtp-app/app.py --model $MODEL --quantize --hf-token $HF_TOKEN --task $TASK --language $LANGUAGE --input-file /odtp/odtp-input/$INPUT_FILE --output-file /odtp/odtp-output/$OUTPUT_FILE.translate.srt --output-json-file /odtp/odtp-output/$OUTPUT_FILE.translate.json
+    python3 /odtp/odtp-app/app.py \
+    --model $MODEL \
+    --quantize \
+    --hf-token $HF_TOKEN \
+    --task $TASK \
+    --language $LANGUAGE \
+    --input-file /odtp/odtp-input/$INPUT_FILE \
+    --output-file /odtp/odtp-output/$OUTPUT_FILE.srt \
+    --output-json-file /odtp/odtp-output/$OUTPUT_FILE.json \
+    --output-paragraphs-json-file /odtp/odtp-output/$OUTPUT_FILE-paragraphs.json \
+    --output-md-file /odtp/odtp-output/$OUTPUT_FILE.md \
+    --output-pdf-file /odtp/odtp-output/$OUTPUT_FILE.pdf
 else
-    python3 /odtp/odtp-app/app.py --model $MODEL --quantize --hf-token $HF_TOKEN --task $TASK --input-file /odtp/odtp-input/$INPUT_FILE --output-file /odtp/odtp-output/$OUTPUT_FILE.srt --output-json-file /odtp/odtp-output/$OUTPUT_FILE.json 
+    python3 /odtp/odtp-app/app.py \
+    --model $MODEL \
+    --quantize \
+    --hf-token $HF_TOKEN \
+    --task $TASK \
+    --input-file /odtp/odtp-input/$INPUT_FILE \
+    --output-file /odtp/odtp-output/$OUTPUT_FILE.srt \
+    --output-json-file /odtp/odtp-output/$OUTPUT_FILE.json \
+    --output-paragraphs-json-file /odtp/odtp-output/$OUTPUT_FILE-paragraphs.json \
+    --output-md-file /odtp/odtp-output/$OUTPUT_FILE.md \
+    --output-pdf-file /odtp/odtp-output/$OUTPUT_FILE.pdf
 fi
-
-#########################################################
-# 5. OUTPUT FOLDER MANAGEMENT
-# The selected output files generated should be placed in the output folder
-#########################################################
-
-# cp -r /odtp/odtp-workdir/output/* /odtp/odtp-output
-
-############################################################################################
-# END OF MANUAL USER APP
-############################################################################################

app/createpdf.py

@@ -0,0 +1,289 @@
+import json
+import os
+import argparse
+from md2pdf.core import md2pdf
+
+def json_to_markdown(json_data, filename):
+    """
+    Convert JSON data into a Markdown string.
+
+    :param json_data: List of dictionaries each containing
+                      "start", "end", "text", "speaker", "language"
+    :param filename:  The name of the JSON file (used as the main title)
+    :return: A string of valid Markdown
+    """
+
+    # Title
+    title = filename.replace("-paragraphs.json", "")
+    md_output = f"# {title}\n\n"
+
+    # Transcription Header
+    md_output += "## Transcription\n\n"
+
+    # Build the content for each contribution
+    for entry in json_data:
+        speaker = entry.get("speaker", "Unknown Speaker")
+        language = entry.get("language", "Unknown Language")
+        start = entry.get("start", "")
+        end = entry.get("end", "")
+        text = entry.get("text", "")
+
+        # Speaker-language heading
+        md_output += f"### {speaker} - {language}\n\n"
+
+        # Table for start/end times
+        md_output += "| start       | end         |\n"
+        md_output += "|-------------|-------------|\n"
+        md_output += f"| {start} | {end} |\n\n"
+
+        # Add the text below the table
+        md_output += f"{text}\n\n"
+
+    return md_output
+
+
+def save_markdown_to_file(markdown_text, output_md_path):
+    """
+    Save the Markdown text to a file.
+
+    :param markdown_text: The Markdown content as a string.
+    :param output_md_path: The path (including filename) where the .md should be saved.
+    """
+    with open(output_md_path, 'w', encoding='utf-8') as md_file:
+        md_file.write(markdown_text)
+
+
+def markdown_to_pdf(markdown_text, output_pdf_path):
+    """
+    Convert a Markdown string to a PDF using md2pdf.
+
+    :param markdown_text: The Markdown text to convert.
+    :param output_pdf_path: The path (including filename) where the PDF should be saved.
+    """
+    # Custom CSS (adapt as you like)
+    custom_css = r"""
+@font-face {
+  font-family: "Bitstream Vera Serif Bold";
+  src: url("https://mdn.github.io/css-examples/web-fonts/VeraSeBd.ttf");
+}
+
+body {
+  margin: 0 auto;
+  background-color: white;
+  font-family: "Bitstream Vera Serif Bold";
+  color: #333333;
+  line-height: 1;
+  max-width: 800px;
+  padding: 30px;
+  font-size: 12px;
+}
+
+p {
+  line-height: 150%;
+  max-width: 960px;
+  font-weight: 400;
+  color: #333333;
+}
+
+h1,
+h2,
+h3,
+h4 {
+  font-weight: 400;
+}
+
+h2,
+h3,
+h4,
+h5,
+p {
+  margin-bottom: 25px;
+  padding: 0;
+}
+
+h1 {
+  margin-bottom: 10px;
+  font-size: 300%;
+  padding: 0px;
+}
+
+h2 {
+  font-size: 150%;
+}
+
+h3 {
+  font-size: 120%;
+}
+
+h4 {
+  font-size: 100%;
+}
+
+h5 {
+  font-size: 80%;
+  font-weight: 100;
+}
+
+h6 {
+  font-size: 80%;
+  font-weight: 100;
+  color: red;
+}
+
+a {
+  color: grey;
+  margin: 0;
+  padding: 0;
+  vertical-align: baseline;
+}
+
+a:hover {
+  text-decoration: blink;
+  color: green;
+}
+
+a:visited {
+  color: black;
+}
+
+ul,
+ol {
+  padding: 0;
+  margin: 0px 0px 0px 50px;
+}
+
+ul {
+  list-style-type: square;
+  list-style-position: inside;
+}
+
+li {
+  line-height: 150%;
+}
+
+li ul,
+li ul {
+  margin-left: 24px;
+}
+
+pre {
+  padding: 0px 24px;
+  max-width: 800px;
+  white-space: pre-wrap;
+}
+
+code {
+  font-family: Consolas, Monaco, Andale Mono, monospace;
+  line-height: 1.5;
+  font-size: 13px;
+}
+
+aside {
+  display: block;
+  float: right;
+  width: 390px;
+}
+
+blockquote {
+  border-left: 0.5em solid #eee;
+  padding: 0 1em;
+  margin-left: 0;
+  max-width: 476px;
+}
+
+blockquote cite {
+  line-height: 20px;
+  color: #bfbfbf;
+}
+
+blockquote cite:before {
+  content: "\2014 \00A0";
+}
+
+blockquote p {
+  color: #666;
+  max-width: 460px;
+}
+
+hr {
+  text-align: left;
+  margin: 0 auto 0 0;
+  color: #999;
+}
+
+/* Table styling for the start/end times */
+table {
+  border-collapse: collapse;
+  width: 100%;
+  margin-bottom: 15px;
+}
+table, th, td {
+  border: 1px solid #333;
+  padding: 6px;
+}
+th {
+  background-color: #eee;
+  text-align: left;
+}
+"""
+
+    # Convert Markdown to PDF directly from a string
+    md2pdf(output_pdf_path,
+        md_content=markdown_text,  # We pass the markdown text as "raw"
+        css_file_path=None,           # If you have an external .css file, you can pass its path here
+        base_url=None       # If you have images or relative links
+    )
+
+    # If we want the custom CSS from a file, we can write it to a temporary file:
+    # Optionally, you could do something like this:
+    #
+    # with open("custom_style.css", "w", encoding="utf-8") as css_file:
+    #     css_file.write(custom_css)
+    #
+    # md2pdf(output_pdf_path,
+    #     raw=markdown_text,
+    #     css="custom_style.css",  # pass the CSS file path
+    #     extras=[],
+    #     base_url=None
+    # )
+
+
+def parse_args():
+    """
+    Parse command-line arguments using argparse.
+    """
+    parser = argparse.ArgumentParser(
+        description="Convert a JSON-based transcription to Markdown and then to PDF using md2pdf."
+    )
+    parser.add_argument("input_filename",
+                        help="Path to the JSON file containing transcription data.")
+    parser.add_argument("--output_md",
+                        default="transcription.md",
+                        help="Output Markdown file name (default: transcription.md)")
+    parser.add_argument("--output_pdf",
+                        default="transcription.pdf",
+                        help="Output PDF file name (default: transcription.pdf)")
+    return parser.parse_args()
+
+def convert_json_to_pdf(input_filename, output_md="transcription.md", output_pdf="transcription.pdf"):
+    # 1. Read JSON data
+    with open(input_filename, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    # 2. Convert JSON to Markdown
+    markdown_output = json_to_markdown(data, os.path.basename(input_filename))
+
+    # 3. Save Markdown to a .md file (optional)
+    save_markdown_to_file(markdown_output, output_md)
+    print(f"Markdown saved to: {output_md}")
+
+    # 4. Convert Markdown to PDF using md2pdf
+    markdown_to_pdf(markdown_output, output_pdf)
+    print(f"PDF generated and saved to: {output_pdf}")
+
+def main():
+    args = parse_args()
+    convert_json_to_pdf(args.input_filename, args.output_md, args.output_pdf)
+
+if __name__ == '__main__':
+    main()

app/gradio_app.py

@@ -22,7 +22,7 @@ def cleanup_temp(temp_dir):
     """Remove temporary folder structure"""
     shutil.rmtree(temp_dir)
 
-def process_audio(audio_file, model, task, language, hf_token):
+def process_audio(audio_file, model, task, language, hf_token=None):
     """Process audio file with Whisper and Pyannote"""
     # Create temp structure
     temp_dir = create_temp_structure()
@@ -97,7 +97,7 @@ with gr.Blocks() as demo:
                 label="Upload Audio File (WAV format)"
             )
             model = gr.Dropdown(
-                choices=["tiny", "base", "small", "medium", "large", "large-v2"],
+                choices=["tiny", "base", "small", "medium", "large", "large-v2", "large-v3", "large-v3-turbo", "softcatala/whisper-base-ca", "projecte-aina/whisper-large-v3-ca-3catparla"],
                 value="base",
                 label="Whisper Model"
             )
@@ -107,13 +107,14 @@ with gr.Blocks() as demo:
                 label="Task"
             )
             language = gr.Dropdown(
-                choices=["auto", "en", "es", "fr", "de", "it", "pt", "nl", "ja", "zh", "ru"],
+                choices=["auto", "en", "es", "ca", "fr", "de", "it", "pt", "nl", "ja", "zh", "ru"],
                 value="auto",
                 label="Source Language"
             )
             hf_token = gr.Textbox(
                 label="Hugging Face Token",
-                type="password"
+                type="password",
+                placeholder="Leave blank if not applicable"
             )
             submit_btn = gr.Button("Process Audio")
             
@@ -145,15 +146,17 @@ with gr.Blocks() as demo:
         outputs=[information, srt_output, json_output, srt_download, json_download]
     )
 
+import argparse
+
 if __name__ == "__main__":
-    demo.launch(
+    parser = argparse.ArgumentParser(description="Launch Gradio app with optional sharing.")
+    parser.add_argument('--share', action='store_true', help="Enable sharing the app with a public URL.")
+    args = parser.parse_args()
+
+    demo.queue().launch(
         server_name="0.0.0.0",  # More secure default for development
         server_port=7860,         # Default Gradio port
-        share=False,              # Disable temporary public URL
+        share=args.share,              # Disable temporary public URL
         show_error=True,          # Show detailed error messages
         debug=True               # Enable debug mode for development
-    )
-
-
-
-# TODO: Slow printing on the command.
+    )

app/paragraphsCreator.py

@@ -0,0 +1,79 @@
+import json
+import sys
+
+def seconds_to_hhmmss(seconds):
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    seconds = seconds % 60
+    return f"{int(hours):02}:{int(minutes):02}:{int(seconds):02}"
+
+
+def create_paragraphs(annotations, min_gap=4):
+    paragraphs = []
+    current_paragraph = {}
+    prev_end_time = None
+    prev_speaker = None
+
+    for item in annotations:
+        start_time = item["start"]
+        end_time = item["end"]
+        transcript = item["text"]
+        speaker = item["speaker"]
+        language = item["language"]
+
+        # Start a new paragraph if timestamp gap exceeds min_gap or speaker changes
+        if (
+            prev_end_time is not None
+            and (
+                start_time - prev_end_time > min_gap
+                or speaker != prev_speaker
+                or (current_paragraph and language != current_paragraph["language"])
+            )
+        ):
+            paragraphs.append(current_paragraph)
+            current_paragraph = []
+
+        if current_paragraph:
+            current_paragraph["text"] += " " + transcript
+            current_paragraph["end"] = seconds_to_hhmmss(end_time)
+        else:
+            current_paragraph = {
+                "start": seconds_to_hhmmss(start_time),
+                "end": seconds_to_hhmmss(end_time),
+                "text": transcript,
+                "speaker": speaker,
+                "language": language
+            }
+
+        prev_end_time = end_time
+        prev_speaker = speaker
+
+    if current_paragraph:
+        paragraphs.append(current_paragraph)
+
+    return paragraphs
+
+def process_paragraphs(input_file, output_file, min_gap):
+    with open(input_file, 'r') as f:
+        json_data = json.load(f)
+
+    annotations = json_data["segments"]
+
+    result = create_paragraphs(annotations, min_gap)
+
+    with open(output_file, 'w') as f:
+        json.dump(result, f, indent=4)
+
+def main():
+    if len(sys.argv) != 4:
+        print("Usage: python paragraphsCreator.py <input_json_file> <output_json_file> <min_gap>")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2]
+    min_gap = int(sys.argv[3])
+
+    process_paragraphs(input_file, output_file, min_gap)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,9 +1,13 @@
 --extra-index-url https://download.pytorch.org/whl/cu121
-torch
-torchaudio
-openai-whisper
-pyannote.audio
-soundfile
-librosa
-jsonschema
-gradio
+torch==2.5.1
+torchaudio==2.5.1
+openai-whisper==20240930
+pyannote.audio==3.3.2
+soundfile==0.12.1
+librosa==0.10.2.post1
+jsonschema==4.23.0
+gradio==5.5.0
+numpy==1.24.4
+md2pdf==1.0.1
+transformers==4.48.0
+pytube