Update Main Gradio code

app.py

@@ -7,307 +7,426 @@ from pathlib import Path
 import time
 import aiohttp
 import asyncio
+import base64
+from dotenv import load_dotenv
 
-
+# --- Configuration ---
 # Set true if you're using huggingface inference API API https://huggingface.co/inference-api
 API_BACKEND = True
-# MODEL = 'facebook/wav2vec2-large-960h-lv60-self'
-# MODEL  = "facebook/wav2vec2-large-960h"
 MODEL = "facebook/wav2vec2-base-960h"
-# MODEL = "patrickvonplaten/wav2vec2-large-960h-lv60-self-4-gram"
+# MODEL = "facebook/wav2vec2-large-960h"
+# MODEL = "facebook/wav2vec2-large-960h-lv60-self"
+# MODEL = "patrickvonplaten/wav2vec2-large-960h-lv60-self-4-gram" # Example of different model
+API_URL = f'https://api-inference.huggingface.co/models/{MODEL}'
+RETRY_ATTEMPTS = 5  # Increased retry attempts for API calls
+RETRY_DELAY = 5  # Base delay in seconds before retrying API calls
+
+# --- Initialization ---
 if API_BACKEND:
-    from dotenv import load_dotenv
-    import base64
-    import asyncio
     load_dotenv(Path(".env"))
-
-    HF_TOKEN = os.environ["HF_TOKEN"]
+    HF_TOKEN = os.environ.get("HF_TOKEN")
+    if not HF_TOKEN:
+        raise ValueError("HF_TOKEN environment variable not set.")
     headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-    API_URL = f'https://api-inference.huggingface.co/models/{MODEL}'
-
 else:
     import torch
     from transformers import pipeline
 
     # is cuda available?
-    cuda = torch.device(
-        'cuda:0') if torch.cuda.is_available() else torch.device('cpu')
     device = 0 if torch.cuda.is_available() else -1
-    speech_recognizer = pipeline(
-        task="automatic-speech-recognition",
-        model=f'{MODEL}',
-        tokenizer=f'{MODEL}',
-        framework="pt",
-        device=device,
-    )
+    try:
+        speech_recognizer = pipeline(
+            task="automatic-speech-recognition",
+            model=MODEL,
+            tokenizer=MODEL,
+            framework="pt",
+            device=device,
+        )
+    except Exception as e:
+        raise RuntimeError(f"Error initializing local model {MODEL}: {e}")
 
 videos_out_path = Path("./videos_out")
 videos_out_path.mkdir(parents=True, exist_ok=True)
 
-samples_data = sorted(Path('examples').glob('*.json'))
+# Load samples data
+samples_data_files = sorted(Path('examples').glob('*.json'))
 SAMPLES = []
-for file in samples_data:
-    with open(file) as f:
-        sample = json.load(f)
-    SAMPLES.append(sample)
-VIDEOS = list(map(lambda x: [x['video']], SAMPLES))
+for file in samples_data_files:
+    try:
+        with open(file, 'r') as f:
+            sample = json.load(f)
+        SAMPLES.append(sample)
+    except (json.JSONDecodeError, FileNotFoundError) as e:
+        print(f"Error loading sample file {file}: {e}")
+
+VIDEOS = [[sample['video']] for sample in SAMPLES if 'video' in sample]
+
+# --- Helper Functions ---
+async def query_api(audio_bytes: bytes):
+    """
+    Query the Hugging Face Inference API for Automatic Speech Recognition.
+    Includes retry logic with exponential backoff.
+    """
+    payload = json.dumps({
+        "inputs": base64.b64encode(audio_bytes).decode("utf-8"),
+        "parameters": {
+            "return_timestamps": "char",
+            "chunk_length_s": 10,
+            "stride_length_s": [4, 2]
+        },
+        "options": {"use_gpu": False} # Set to True if you have a GPU and want to use it
+    }).encode("utf-8")
 
-total_inferences_since_reboot = 415
-total_cuts_since_reboot = 1539
+    async with aiohttp.ClientSession() as session:
+        for attempt in range(RETRY_ATTEMPTS):
+            print(f'Transcribing from API attempt {attempt + 1}/{RETRY_ATTEMPTS}')
+            try:
+                async with session.post(API_URL, headers=headers, data=payload) as response:
+                    print("API Response Status:", response.status)
+                    content_type = response.headers.get('Content-Type', '')
+
+                    if response.status == 200 and 'application/json' in content_type:
+                        return await response.json()
+                    elif response.status != 200 and 'application/json' in content_type:
+                         error_response = await response.json()
+                         if 'error' in error_response and 'estimated_time' in error_response:
+                             wait_time = error_response['estimated_time']
+                             print(f"Model loading, waiting for {wait_time} seconds...")
+                             await asyncio.sleep(wait_time + RETRY_DELAY) # Wait time + buffer
+                         elif 'error' in error_response:
+                            raise RuntimeError(f"API Error: {error_response['error']}")
+                         else:
+                            raise RuntimeError(f"Unknown API Error: {error_response}")
+                    else:
+                        response_text = await response.text()
+                        raise RuntimeError(f"Unexpected API response format (Status: {response.status}, Content-Type: {content_type}): {response_text}")
 
+            except aiohttp.ClientError as e:
+                print(f"AIOHTTP Client Error during API call: {e}")
+            except RuntimeError as e:
+                 print(f"Runtime error during API call: {e}")
 
-async def speech_to_text(video_file_path):
+            if attempt < RETRY_ATTEMPTS - 1:
+                wait_time = RETRY_DELAY * (2 ** attempt) # Exponential backoff
+                print(f"Retrying in {wait_time} seconds...")
+                await asyncio.sleep(wait_time)
+
+        raise RuntimeError(f"Failed to get transcription after {RETRY_ATTEMPTS} attempts.")
+
+
+def ping_telemetry(name: str):
     """
-    Takes a video path to convert to audio, transcribe audio channel to text and char timestamps
+    Send a telemetry ping to Hugging Face Spaces.
+    This is fire-and-forget and doesn't affect the main process flow.
+    """
+    url = f'https://huggingface.co/api/telemetry/spaces/radames/edit-video-by-editing-text/{name}'
+    print(f"Pinging telemetry: {url}")
 
-    Using https://huggingface.co/tasks/automatic-speech-recognition pipeline
+    async def send_ping():
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url) as response:
+                    print(f"Telemetry pong: {response.status}")
+        except aiohttp.ClientError as e:
+            print(f"Failed to send telemetry ping: {e}")
+    # Using asyncio.run_coroutine_threadsafe might be safer in a threaded Gradio environment,
+    # but requires managing an event loop in a separate thread.
+    # For simplicity here, we'll use create_task assuming an event loop is running (Gradio handles this).
+    asyncio.create_task(send_ping())
+
+
+# --- Main Gradio Functions ---
+async def speech_to_text(video_file_path):
+    """
+    Takes a video path to convert to audio, transcribe audio channel to text and char timestamps.
     """
-    global total_inferences_since_reboot
-    if (video_file_path == None):
-        raise ValueError("Error no video input")
+    if video_file_path is None:
+        raise gr.Error("Error: No video input provided.")
 
     video_path = Path(video_file_path)
+    if not video_path.exists():
+         raise gr.Error(f"Error: Video file not found at {video_file_path}")
+
     try:
         # convert video to audio 16k using PIPE to audio_memory
-        audio_memory, _ = ffmpeg.input(video_path).output(
-            '-', format="wav", ac=1, ar='16k').overwrite_output().global_args('-loglevel', 'quiet').run(capture_stdout=True)
+        # Use asyncio-compatible way or run in a separate thread if ffmpeg-python is blocking
+        loop = asyncio.get_running_loop()
+        audio_memory, _ = await loop.run_in_executor(
+            None, lambda: ffmpeg.input(video_path).output(
+                '-', format="wav", ac=1, ar='16k').overwrite_output().global_args('-loglevel', 'quiet').run(capture_stdout=True)
+        )
+
+    except ffmpeg.Error as e:
+         raise gr.Error(f"Error converting video to audio: {e.stderr.decode()}")
     except Exception as e:
-        raise RuntimeError("Error converting video to audio")
+        raise gr.Error(f"An unexpected error occurred during audio conversion: {e}")
+
+
+    ping_telemetry("speech_to_text")
 
-    ping("speech_to_text")
-    last_time = time.time()
     if API_BACKEND:
-        # Using Inference API https://huggingface.co/inference-api
-        # try twice, because the model must be loaded
-        for i in range(10):
-            for tries in range(4):
-                print(f'Transcribing from API attempt {tries}')
-                try:
-                    inference_reponse = await query_api(audio_memory)
-                    print(inference_reponse)
-                    transcription = inference_reponse["text"].lower()
-                    timestamps = [[chunk["text"].lower(), chunk["timestamp"][0], chunk["timestamp"][1]]
-                                  for chunk in inference_reponse['chunks']]
-
-                    total_inferences_since_reboot += 1
-                    print("\n\ntotal_inferences_since_reboot: ",
-                          total_inferences_since_reboot, "\n\n")
-                    return (transcription, transcription, timestamps)
-                except Exception as e:
-                    print(e)
-                    if 'error' in inference_reponse and 'estimated_time' in inference_reponse:
-                        wait_time = inference_reponse['estimated_time']
-                        print("Waiting for model to load....", wait_time)
-                        # wait for loading model
-                        # 5 seconds plus for certanty
-                        await asyncio.sleep(wait_time + 5.0)
-                    elif 'error' in inference_reponse:
-                        raise RuntimeError("Error Fetching API",
-                                           inference_reponse['error'])
-                    else:
-                        break
-            else:
-                raise RuntimeError(inference_reponse, "Error Fetching API")
-    else:
+        try:
+            inference_response = await query_api(audio_memory)
+            print("Inference Response:", inference_response)
+            if not isinstance(inference_response, dict) or 'text' not in inference_response or 'chunks' not in inference_response:
+                 raise RuntimeError(f"Unexpected API response structure: {inference_response}")
+
+            transcription = inference_response["text"].lower()
+            # Ensure timestamps have the correct structure and handle potential None values
+            timestamps = [[chunk.get("text", "").lower(), chunk.get("timestamp", [None, None])[0], chunk.get("timestamp", [None, None])[1]]
+                          for chunk in inference_response.get('chunks', []) if isinstance(chunk, dict)]
 
+            # Filter out timestamps with None values if necessary, or handle them downstream
+            timestamps = [ts for ts in timestamps if ts[1] is not None and ts[2] is not None]
+
+
+            return (transcription, transcription, timestamps)
+
+        except Exception as e:
+            raise gr.Error(f"Error fetching transcription from API: {e}")
+
+    else:
         try:
-            print(f'Transcribing via local model')
-            output = speech_recognizer(
-                audio_memory, return_timestamps="char",  chunk_length_s=10, stride_length_s=(4, 2))
+            print(f'Transcribing via local model {MODEL}')
+            # Run blocking model inference in an executor
+            loop = asyncio.get_running_loop()
+            output = await loop.run_in_executor(
+                None, lambda: speech_recognizer(
+                    audio_memory, return_timestamps="char", chunk_length_s=10, stride_length_s=(4, 2))
+            )
+
+            if not isinstance(output, dict) or 'text' not in output or 'chunks' not in output:
+                 raise RuntimeError(f"Unexpected model output structure: {output}")
 
             transcription = output["text"].lower()
-            timestamps = [[chunk["text"].lower(), chunk["timestamp"][0].tolist(), chunk["timestamp"][1].tolist()]
-                          for chunk in output['chunks']]
-            total_inferences_since_reboot += 1
+            # Ensure timestamps have the correct structure and handle potential None/list values
+            timestamps = [[chunk.get("text", "").lower(),
+                           chunk.get("timestamp", [None, None])[0] if not isinstance(chunk.get("timestamp", [None, None])[0], list) else chunk.get("timestamp", [None, None])[0][0],
+                           chunk.get("timestamp", [None, None])[1] if not isinstance(chunk.get("timestamp", [None, None])[1], list) else chunk.get("timestamp", [None, None])[1][0]
+                           ]
+                          for chunk in output.get('chunks', []) if isinstance(chunk, dict)]
+
+            # Filter out timestamps with None values if necessary, or handle them downstream
+            timestamps = [ts for ts in timestamps if ts[1] is not None and ts[2] is not None]
+
 
-            print("\n\ntotal_inferences_since_reboot: ",
-                  total_inferences_since_reboot, "\n\n")
             return (transcription, transcription, timestamps)
+
         except Exception as e:
-            raise RuntimeError("Error Running inference with local model", e)
+            raise gr.Error(f"Error running inference with local model: {e}")
 
 
 async def cut_timestamps_to_video(video_in, transcription, text_in, timestamps):
     """
     Given original video input, text transcript + timestamps,
-    and edit ext cuts video segments into a single video
+    and edited text cuts video segments into a single video
     """
-    global total_cuts_since_reboot
+    if video_in is None or text_in is None or transcription is None or timestamps is None:
+        raise gr.Error("Inputs undefined. Please provide video, transcription, and edited text.")
+
+    if not Path(video_in).exists():
+         raise gr.Error(f"Error: Video file not found at {video_in}")
 
-    video_path = Path(video_in)
-    video_file_name = video_path.stem
-    if (video_in == None or text_in == None or transcription == None):
-        raise ValueError("Inputs undefined")
 
     d = Differ()
     # compare original transcription with edit text
-    diff_chars = d.compare(transcription, text_in)
-    # remove all text aditions from diff
-    filtered = list(filter(lambda x: x[0] != '+', diff_chars))
-
-    # filter timestamps to be removed
-    # timestamps_to_cut = [b for (a,b) in zip(filtered, timestamps_var) if a[0]== '-' ]
-    # return diff tokes and cutted video!!
-
-    # groupping character timestamps so there are less cuts
-    idx = 0
-    grouped = {}
-    for (a, b) in zip(filtered, timestamps):
-        if a[0] != '-':
-            if idx in grouped:
-                grouped[idx].append(b)
+    diff_chars = list(d.compare(transcription, text_in))
+
+    # Map filtered characters back to original timestamps
+    # This requires careful indexing or alignment
+    # A more robust approach might involve aligning the diff output with the original timestamps
+    # based on character positions. For simplicity here, we'll assume a direct mapping after filtering
+    # which might not be accurate if additions/deletions significantly alter the text structure.
+    # A better approach would be to process the diff and the original timestamps in parallel.
+
+    # Let's refine the logic to align diff with timestamps more accurately.
+    # We'll iterate through the diff and the timestamps simultaneously.
+    filtered_timestamps = []
+    timestamp_idx = 0
+    for diff_line in diff_chars:
+        # Lines starting with '-' are deletions, '+' are additions, '?' are changes (we ignore), ' ' are unchanged.
+        if diff_line.startswith('-') or diff_line.startswith(' '):
+            # If it's a deletion or unchanged, it corresponds to an original timestamp
+            if timestamp_idx < len(timestamps):
+                filtered_timestamps.append((diff_line, timestamps[timestamp_idx]))
+                timestamp_idx += 1
+        # Additions ('+') do not correspond to original timestamps, so we skip incrementing timestamp_idx
+
+    # filter timestamps to be removed (those marked with '-')
+    timestamps_to_keep = [ts_info for diff_line, ts_info in filtered_timestamps if not diff_line.startswith('-')]
+
+
+    # groupping character timestamps to keep into continuous segments
+    grouped_segments = []
+    if timestamps_to_keep:
+        current_segment = [timestamps_to_keep[0]]
+        for i in range(1, len(timestamps_to_keep)):
+            # Check if the current timestamp's start time is close to the previous timestamp's end time
+            # This threshold might need adjustment based on the granularity of timestamps
+            if timestamps_to_keep[i][1] - current_segment[-1][2] < 0.1: # 0.1 seconds threshold
+                current_segment.append(timestamps_to_keep[i])
             else:
-                grouped[idx] = []
-                grouped[idx].append(b)
-        else:
-            idx += 1
-
-    # after grouping, gets the lower and upter start and time for each group
-    timestamps_to_cut = [[v[0][1], v[-1][2]] for v in grouped.values()]
-
-    between_str = '+'.join(
-        map(lambda t: f'between(t,{t[0]},{t[1]})', timestamps_to_cut))
-
-    if timestamps_to_cut:
-        video_file = ffmpeg.input(video_in)
-        video = video_file.video.filter(
-            "select", f'({between_str})').filter("setpts", "N/FRAME_RATE/TB")
-        audio = video_file.audio.filter(
-            "aselect", f'({between_str})').filter("asetpts", "N/SR/TB")
-
-        output_video = f'./videos_out/{video_file_name}.mp4'
-        ffmpeg.concat(video, audio, v=1, a=1).output(
-            output_video).overwrite_output().global_args('-loglevel', 'quiet').run()
-    else:
-        output_video = video_in
+                grouped_segments.append(current_segment)
+                current_segment = [timestamps_to_keep[i]]
+        grouped_segments.append(current_segment) # Add the last segment
 
-    tokens = [(token[2:], token[0] if token[0] != " " else None)
-              for token in filtered]
+    # after grouping, gets the lower start and upper end time for each group
+    cut_intervals = [[segment[0][1], segment[-1][2]] for segment in grouped_segments]
 
-    total_cuts_since_reboot += 1
-    ping("video_cuts")
-    print("\n\ntotal_cuts_since_reboot: ", total_cuts_since_reboot, "\n\n")
-    return (tokens, output_video)
 
+    video_path = Path(video_in)
+    video_file_name = video_path.stem
+    output_video_path = videos_out_path / f"{video_file_name}_cut.mp4" # Use _cut suffix to avoid overwriting original
 
-async def query_api(audio_bytes: bytes):
-    """
-    Query for Huggingface Inference API for Automatic Speech Recognition task
-    """
-    payload = json.dumps({
-        "inputs": base64.b64encode(audio_bytes).decode("utf-8"),
-        "parameters": {
-            "return_timestamps": "char",
-            "chunk_length_s": 10,
-            "stride_length_s": [4, 2]
-        },
-        "options": {"use_gpu": False}
-    }).encode("utf-8")
-    async with aiohttp.ClientSession() as session:
-        async with session.post(API_URL, headers=headers, data=payload) as response:
-            print("API Response: ", response.status)
-            if response.headers['Content-Type'] == 'application/json':
-                return await response.json()
-            elif response.headers['Content-Type'] == 'application/octet-stream':
-                return await response.read()
-            elif response.headers['Content-Type'] == 'text/plain':
-                return await response.text()
-            else:
-                raise RuntimeError("Error Fetching API")
+    if cut_intervals:
+        input_video_stream = ffmpeg.input(video_in)
 
+        # Create select filters for video and audio based on cut intervals
+        video_filters = []
+        audio_filters = []
+        for i, interval in enumerate(cut_intervals):
+            video_filters.append(f'select=\'between(t,{interval[0]},{interval[1]})\'')
+            audio_filters.append(f'aselect=\'between(t,{interval[0]},{interval[1]})\'')
 
-def ping(name):
-    url = f'https://huggingface.co/api/telemetry/spaces/radames/edit-video-by-editing-text/{name}'
-    print("ping: ", url)
+        # Join filters with commas and add setpts
+        video_filter_str = ','.join(video_filters) + ',setpts=N/FRAME_RATE/TB'
+        audio_filter_str = ','.join(audio_filters) + ',asetpts=N/SR/TB'
 
-    async def req():
-        async with aiohttp.ClientSession() as session:
-            async with session.get(url) as response:
-                print("pong: ", response.status)
-    asyncio.create_task(req())
+        video_stream = input_video_stream.video.filter_complex(video_filter_str)
+        audio_stream = input_video_stream.audio.filter_complex(audio_filter_str)
 
+        try:
+             # Use asyncio-compatible way or run in a separate thread
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(
+                None, lambda: ffmpeg.concat(video_stream, audio_stream, v=1, a=1).output(
+                    str(output_video_path), preset='fast', crf=23 # Use reasonable encoding settings
+                    ).overwrite_output().global_args('-loglevel', 'quiet').run()
+            )
+
+        except ffmpeg.Error as e:
+            raise gr.Error(f"Error cutting video: {e.stderr.decode()}")
+        except Exception as e:
+             raise gr.Error(f"An unexpected error occurred during video cutting: {e}")
 
-# ---- Gradio Layout -----
-video_in = gr.Video(label="Video file", elem_id="video-container")
-text_in = gr.Textbox(label="Transcription", lines=10, interactive=True)
-video_out = gr.Video(label="Video Out")
-diff_out = gr.HighlightedText(label="Cuts Diffs", combine_adjacent=True)
-examples = gr.Dataset(components=[video_in], samples=VIDEOS, type="index")
+    else:
+        # If no intervals to keep, output an empty video or handle as an error
+        # For now, let's return the original video path and indicate no cuts were made.
+        # Depending on requirements, creating an empty video might be better.
+        output_video_path = Path(video_in) # No cuts, so output is the original video
+        print("No text was kept, returning original video.")
+
+
+    # Generate diff output for display
+    # The diff_chars list already contains the diff with markers ('-', '+', ' ')
+    # We can directly use this for the highlighted text output
+    diff_output_tokens = [(token[2:], token[0] if token[0] != ' ' else None)
+                          for token in diff_chars]
+
+    ping_telemetry("video_cuts")
+
+    return (diff_output_tokens, str(output_video_path))
+
+
+def load_example(id):
+    """Loads example video and transcription."""
+    if 0 <= id < len(SAMPLES):
+        sample = SAMPLES[id]
+        video = sample.get('video')
+        transcription = sample.get('transcription', '').lower()
+        timestamps = sample.get('timestamps', [])
+        if video is None:
+             raise gr.Error(f"Example at index {id} is missing video path.")
+        return (video, transcription, transcription, timestamps)
+    else:
+        raise gr.Error(f"Invalid example index: {id}")
 
+
+# --- Gradio Layout ---
 css = """
 #cut_btn, #reset_btn { align-self:stretch; }
-#\\31 3 { max-width: 540px; }
+#\\31 3 { max-width: 540px; } /* Consider making this more general or dynamic */
 .output-markdown {max-width: 65ch !important;}
 #video-container{
     max-width: 40rem;
 }
 """
 with gr.Blocks(css=css) as demo:
-    transcription_var = gr.State()
-    timestamps_var = gr.State()
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("""
-            # Edit Video By Editing Text
-            This project is a quick proof of concept of a simple video editor where the edits
-            are made by editing the audio transcription.
-            Using the [Huggingface Automatic Speech Recognition Pipeline](https://huggingface.co/tasks/automatic-speech-recognition)
-            with a fine tuned [Wav2Vec2 model using Connectionist Temporal Classification (CTC)](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self)
-            you can predict not only the text transcription but also the [character or word base timestamps](https://huggingface.co/docs/transformers/v4.19.2/en/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline.__call__.return_timestamps)
-            """)
+    # Using States to hold transcription and timestamps across interactions
+    transcription_var = gr.State(value="")
+    timestamps_var = gr.State(value=[])
+    video_in = gr.Video(label="Video file", elem_id="video-container")
+    text_in = gr.Textbox(label="Transcription", lines=10, interactive=True)
+    video_out = gr.Video(label="Video Out", interactive=False) # Output video should not be edited directly
+    diff_out = gr.HighlightedText(label="Cuts Diffs", combine_adjacent=True, show_legend=True) # Added legend
+
+    gr.Markdown("""
+    # Edit Video By Editing Text
+    This project is a quick proof of concept of a simple video editor where the edits
+    are made by editing the audio transcription.
+    Using the [Huggingface Automatic Speech Recognition Pipeline](https://huggingface.co/tasks/automatic-speech-recognition)
+    with a fine tuned [Wav2Vec2 model using Connectionist Temporal Classification (CTC)](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self)
+    you can predict not only the text transcription but also the [character or word base timestamps](https://huggingface.co/docs/transformers/v4.19.2/en/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline.__call__.return_timestamps)
+    """)
 
     with gr.Row():
-
-        examples.render()
-
-        def load_example(id):
-            video = SAMPLES[id]['video']
-            transcription = SAMPLES[id]['transcription'].lower()
-            timestamps = SAMPLES[id]['timestamps']
-
-            return (video, transcription, transcription, timestamps)
-
+        # Examples section
+        examples = gr.Dataset(components=[video_in], samples=VIDEOS, type="index", label="Examples")
         examples.click(
             load_example,
             inputs=[examples],
             outputs=[video_in, text_in, transcription_var, timestamps_var],
-            queue=False)
+            queue=False # Set to False if you want immediate loading without waiting in queue
+        )
+
     with gr.Row():
         with gr.Column():
             video_in.render()
             transcribe_btn = gr.Button("Transcribe Audio")
-            transcribe_btn.click(speech_to_text, [video_in], [
-                text_in, transcription_var, timestamps_var])
+            transcribe_btn.click(
+                speech_to_text,
+                inputs=[video_in],
+                outputs=[text_in, transcription_var, timestamps_var]
+                # No queue=False here as transcription can take time
+            )
 
-    with gr.Row():
-        gr.Markdown("""
-        ### Now edit as text
-        After running the video transcription, you can make cuts to the text below (only cuts, not additions!)""")
+    gr.Markdown("""
+    ### Now edit as text
+    After running the video transcription, you can make cuts to the text below (only cuts, not additions!)""")
 
     with gr.Row():
         with gr.Column():
             text_in.render()
             with gr.Row():
                 cut_btn = gr.Button("Cut to video", elem_id="cut_btn")
-                # send audio path and hidden variables
-                cut_btn.click(cut_timestamps_to_video, [
-                    video_in, transcription_var, text_in, timestamps_var], [diff_out, video_out])
+                cut_btn.click(
+                    cut_timestamps_to_video,
+                    inputs=[video_in, transcription_var, text_in, timestamps_var],
+                    outputs=[diff_out, video_out]
+                    # No queue=False here as video cutting can take time
+                )
 
                 reset_transcription = gr.Button(
-                    "Reset to last trascription", elem_id="reset_btn")
+                    "Reset to last transcription", elem_id="reset_btn")
                 reset_transcription.click(
-                    lambda x: x, transcription_var, text_in)
+                    lambda x: x, # Simple lambda to return the input state
+                    inputs=[transcription_var],
+                    outputs=[text_in],
+                    queue=False # Immediate reset
+                )
         with gr.Column():
             video_out.render()
             diff_out.render()
-    with gr.Row():
-        gr.Markdown("""
-        #### Video Credits
-
-        1. [Cooking](https://vimeo.com/573792389)
-        1. [Shia LaBeouf "Just Do It"](https://www.youtube.com/watch?v=n2lTxIk_Dr0)
-        1. [Mark Zuckerberg & Yuval Noah Harari in Conversation](https://www.youtube.com/watch?v=Boj9eD0Wug8)
-        """)
-demo.queue()
+
+    gr.Markdown("""
+    #### Video Credits
+    1. [Cooking](https://vimeo.com/573792389)
+    2. [Shia LaBeouf "Just Do It"](https://www.youtube.com/watch?v=n2lTxIk_Dr0)
+    3. [Mark Zuckerberg & Yuval Noah Harari in Conversation](https://www.youtube.com/watch?v=Boj9eD0Wug8)
+    """)
+
+demo.queue() # Enable queuing for handling multiple users
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    # debug=True is useful during development
+    # share=True to create a public link (use cautiously)
+    demo.launch(debug=True)