Update app.py

app.py

@@ -61,620 +61,635 @@ client = OpenAI(
 )
 hf_api_key = os.environ.get("hf_token")
 
-def silence(duration, fps=44100):
-    """
-    Returns a silent AudioClip of the specified duration.
-    """
-    return AudioArrayClip(np.zeros((int(fps*duration), 2)), fps=fps)
-
-def count_words_or_characters(text):
-    # Count non-Chinese words
-    non_chinese_words = len(re.findall(r'\b[a-zA-Z0-9]+\b', text))
+
+# def silence(duration, fps=44100):
+#     """
+#     Returns a silent AudioClip of the specified duration.
+#     """
+#     return AudioArrayClip(np.zeros((int(fps*duration), 2)), fps=fps)
+
+# def count_words_or_characters(text):
+#     # Count non-Chinese words
+#     non_chinese_words = len(re.findall(r'\b[a-zA-Z0-9]+\b', text))
     
-    # Count Chinese characters
-    chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', text))
+#     # Count Chinese characters
+#     chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', text))
     
-    return non_chinese_words + chinese_chars
+#     return non_chinese_words + chinese_chars
     
-# Define the passcode
-PASSCODE = "show_feedback_db"
-
-css = """
-/* Adjust row height */
-.dataframe-container tr {
-    height: 50px !important; 
-}
-
-/* Ensure text wrapping and prevent overflow */
-.dataframe-container td {
-    white-space: normal !important; 
-    word-break: break-word !important;
-}
-
-/* Set column widths */
-[data-testid="block-container"] .scrolling-dataframe th:nth-child(1), 
-[data-testid="block-container"] .scrolling-dataframe td:nth-child(1) {
-    width: 6%; /* Start column */
-}
-
-[data-testid="block-container"] .scrolling-dataframe th:nth-child(2), 
-[data-testid="block-container"] .scrolling-dataframe td:nth-child(2) {
-    width: 47%; /* Original text */
-}
-
-[data-testid="block-container"] .scrolling-dataframe th:nth-child(3), 
-[data-testid="block-container"] .scrolling-dataframe td:nth-child(3) {
-    width: 47%; /* Translated text */
-}
-
-[data-testid="block-container"] .scrolling-dataframe th:nth-child(4), 
-[data-testid="block-container"] .scrolling-dataframe td:nth-child(4) {
-    display: none !important;
-}
-"""
-
-# Function to save feedback or provide access to the database file
-def handle_feedback(feedback):
-    feedback = feedback.strip()  # Clean up leading/trailing whitespace
-    if not feedback:
-        return "Feedback cannot be empty.", None
-
-    if feedback == PASSCODE:
-        # Provide access to the feedback.db file
-        return "Access granted! Download the database file below.", "feedback.db"
-    else:
-        # Save feedback to the database
-        with sqlite3.connect("feedback.db") as conn:
-            cursor = conn.cursor()
-            cursor.execute("CREATE TABLE IF NOT EXISTS studio_feedback (id INTEGER PRIMARY KEY, comment TEXT)")
-            cursor.execute("INSERT INTO studio_feedback (comment) VALUES (?)", (feedback,))
-            conn.commit()
-        return "Thank you for your feedback!", None
-
-# Configure logging
-logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
-logger.info(f"MoviePy Version: {moviepy.__version__}")
-
-# def segment_background_audio(audio_path, output_path="background_segments.wav"):
-#     # Step 2: Initialize pyannote voice activity detection pipeline (you need Hugging Face token)
-#     pipeline = Pipeline.from_pretrained(
-#         "pyannote/voice-activity-detection",
-#         use_auth_token=hf_api_key
-#     )
-#     # Step 3: Run VAD to get speech segments
-#     vad_result = pipeline(audio_path)
-#     print(f"Detected speech segments: {vad_result}")
-
-#     # Step 4: Load full audio and subtract speech segments
-#     full_audio = AudioSegment.from_wav(audio_path)
-#     background_audio = AudioSegment.silent(duration=len(full_audio))
-
-#     for segment in vad_result.itersegments():
-#         start_ms = int(segment.start * 1000)
-#         end_ms = int(segment.end * 1000)
-#         # Remove speech by muting that portion
-#         background_audio = background_audio.overlay(AudioSegment.silent(duration=end_ms - start_ms), position=start_ms)
-
-#     # Step 5: Subtract background_audio from full_audio
-#     result_audio = full_audio.overlay(background_audio)
-
-#     # Step 6: Export non-speech segments
-#     result_audio.export(output_path, format="wav")
-#     print(f"Saved non-speech (background) audio to: {output_path}")
-
-#     return True
-
-def transcribe_video_with_speakers(video_path):
-    # Extract audio from video
-    video = VideoFileClip(video_path)
-    audio_path = "audio.wav"
-    video.audio.write_audiofile(audio_path)
-    logger.info(f"Audio extracted from video: {audio_path}")
-
-    # segment_result = segment_background_audio(audio_path)
-    # print(f"Saved non-speech (background) audio to local")
+# # Define the passcode
+# PASSCODE = "show_feedback_db"
+
+# css = """
+# /* Adjust row height */
+# .dataframe-container tr {
+#     height: 50px !important; 
+# }
+
+# /* Ensure text wrapping and prevent overflow */
+# .dataframe-container td {
+#     white-space: normal !important; 
+#     word-break: break-word !important;
+# }
+
+# /* Set column widths */
+# [data-testid="block-container"] .scrolling-dataframe th:nth-child(1), 
+# [data-testid="block-container"] .scrolling-dataframe td:nth-child(1) {
+#     width: 6%; /* Start column */
+# }
+
+# [data-testid="block-container"] .scrolling-dataframe th:nth-child(2), 
+# [data-testid="block-container"] .scrolling-dataframe td:nth-child(2) {
+#     width: 47%; /* Original text */
+# }
+
+# [data-testid="block-container"] .scrolling-dataframe th:nth-child(3), 
+# [data-testid="block-container"] .scrolling-dataframe td:nth-child(3) {
+#     width: 47%; /* Translated text */
+# }
+
+# [data-testid="block-container"] .scrolling-dataframe th:nth-child(4), 
+# [data-testid="block-container"] .scrolling-dataframe td:nth-child(4) {
+#     display: none !important;
+# }
+# """
+
+# # Function to save feedback or provide access to the database file
+# def handle_feedback(feedback):
+#     feedback = feedback.strip()  # Clean up leading/trailing whitespace
+#     if not feedback:
+#         return "Feedback cannot be empty.", None
+
+#     if feedback == PASSCODE:
+#         # Provide access to the feedback.db file
+#         return "Access granted! Download the database file below.", "feedback.db"
+#     else:
+#         # Save feedback to the database
+#         with sqlite3.connect("feedback.db") as conn:
+#             cursor = conn.cursor()
+#             cursor.execute("CREATE TABLE IF NOT EXISTS studio_feedback (id INTEGER PRIMARY KEY, comment TEXT)")
+#             cursor.execute("INSERT INTO studio_feedback (comment) VALUES (?)", (feedback,))
+#             conn.commit()
+#         return "Thank you for your feedback!", None
+
+# # Configure logging
+# logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
+# logger = logging.getLogger(__name__)
+# logger.info(f"MoviePy Version: {moviepy.__version__}")
+
+# # def segment_background_audio(audio_path, output_path="background_segments.wav"):
+# #     # Step 2: Initialize pyannote voice activity detection pipeline (you need Hugging Face token)
+# #     pipeline = Pipeline.from_pretrained(
+# #         "pyannote/voice-activity-detection",
+# #         use_auth_token=hf_api_key
+# #     )
+# #     # Step 3: Run VAD to get speech segments
+# #     vad_result = pipeline(audio_path)
+# #     print(f"Detected speech segments: {vad_result}")
+
+# #     # Step 4: Load full audio and subtract speech segments
+# #     full_audio = AudioSegment.from_wav(audio_path)
+# #     background_audio = AudioSegment.silent(duration=len(full_audio))
+
+# #     for segment in vad_result.itersegments():
+# #         start_ms = int(segment.start * 1000)
+# #         end_ms = int(segment.end * 1000)
+# #         # Remove speech by muting that portion
+# #         background_audio = background_audio.overlay(AudioSegment.silent(duration=end_ms - start_ms), position=start_ms)
+
+# #     # Step 5: Subtract background_audio from full_audio
+# #     result_audio = full_audio.overlay(background_audio)
+
+# #     # Step 6: Export non-speech segments
+# #     result_audio.export(output_path, format="wav")
+# #     print(f"Saved non-speech (background) audio to: {output_path}")
+
+# #     return True
+
+# def transcribe_video_with_speakers(video_path):
+#     # Extract audio from video
+#     video = VideoFileClip(video_path)
+#     audio_path = "audio.wav"
+#     video.audio.write_audiofile(audio_path)
+#     logger.info(f"Audio extracted from video: {audio_path}")
+
+#     # segment_result = segment_background_audio(audio_path)
+#     # print(f"Saved non-speech (background) audio to local")
     
-    # Set up device
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    logger.info(f"Using device: {device}")
+#     # Set up device
+#     device = "cuda" if torch.cuda.is_available() else "cpu"
+#     logger.info(f"Using device: {device}")
     
-    try:
-        # Load a medium model with float32 for broader compatibility
-        model = whisperx.load_model("medium", device=device, compute_type="float32")
-        logger.info("WhisperX model loaded")
+#     try:
+#         # Load a medium model with float32 for broader compatibility
+#         model = whisperx.load_model("medium", device=device, compute_type="float32")
+#         logger.info("WhisperX model loaded")
     
-        # Transcribe
-        result = model.transcribe(audio_path, chunk_size=5, print_progress = True)
-        logger.info("Audio transcription completed")
-
-        # Get the detected language
-        detected_language = result["language"]
-        logger.debug(f"Detected language: {detected_language}")
-        # Alignment
-        model_a, metadata = whisperx.load_align_model(language_code=result["language"], device=device)
-        result = whisperx.align(result["segments"], model_a, metadata, audio_path, device)
-        logger.info("Transcription alignment completed")
+#         # Transcribe
+#         result = model.transcribe(audio_path, chunk_size=5, print_progress = True)
+#         logger.info("Audio transcription completed")
+
+#         # Get the detected language
+#         detected_language = result["language"]
+#         logger.debug(f"Detected language: {detected_language}")
+#         # Alignment
+#         model_a, metadata = whisperx.load_align_model(language_code=result["language"], device=device)
+#         result = whisperx.align(result["segments"], model_a, metadata, audio_path, device)
+#         logger.info("Transcription alignment completed")
     
-        # Diarization (works independently of Whisper model size)
-        diarize_model = whisperx.DiarizationPipeline(use_auth_token=hf_api_key, device=device)
-        diarize_segments = diarize_model(audio_path)
-        logger.info("Speaker diarization completed")
+#         # Diarization (works independently of Whisper model size)
+#         diarize_model = whisperx.DiarizationPipeline(use_auth_token=hf_api_key, device=device)
+#         diarize_segments = diarize_model(audio_path)
+#         logger.info("Speaker diarization completed")
     
-        # Assign speakers
-        result = whisperx.assign_word_speakers(diarize_segments, result)
-        logger.info("Speakers assigned to transcribed segments")
+#         # Assign speakers
+#         result = whisperx.assign_word_speakers(diarize_segments, result)
+#         logger.info("Speakers assigned to transcribed segments")
     
-    except Exception as e:
-        logger.error(f"❌ WhisperX pipeline failed: {e}")
-
-    # Extract timestamps, text, and speaker IDs
-    transcript_with_speakers = [
-        {
-            "start": segment["start"],
-            "end": segment["end"],
-            "text": segment["text"],
-            "speaker": segment["speaker"]
-        }
-        for segment in result["segments"]
-    ]
-
-    # Collect audio for each speaker
-    speaker_audio = {}
-    for segment in result["segments"]:
-        speaker = segment["speaker"]
-        if speaker not in speaker_audio:
-            speaker_audio[speaker] = []
-        speaker_audio[speaker].append((segment["start"], segment["end"]))
-
-    # Collapse and truncate speaker audio
-    speaker_sample_paths = {}
-    audio_clip = AudioFileClip(audio_path)
-    for speaker, segments in speaker_audio.items():
-        speaker_clips = [audio_clip.subclip(start, end) for start, end in segments]
-        combined_clip = concatenate_audioclips(speaker_clips)
-        truncated_clip = combined_clip.subclip(0, min(30, combined_clip.duration))
-        sample_path = f"speaker_{speaker}_sample.wav"
-        truncated_clip.write_audiofile(sample_path)
-        speaker_sample_paths[speaker] = sample_path
-        logger.info(f"Created sample for {speaker}: {sample_path}")
-
-    # Clean up
-    video.close()
-    audio_clip.close()
-    os.remove(audio_path)
-
-    return transcript_with_speakers, detected_language
-
-# Function to get the appropriate translation model based on target language
-def get_translation_model(source_language, target_language):
-    """
-    Get the translation model based on the source and target language.
-
-    Parameters:
-    - target_language (str): The language to translate the content into (e.g., 'es', 'fr').
-    - source_language (str): The language of the input content (default is 'en' for English).
+#     except Exception as e:
+#         logger.error(f"❌ WhisperX pipeline failed: {e}")
+
+#     # Extract timestamps, text, and speaker IDs
+#     transcript_with_speakers = [
+#         {
+#             "start": segment["start"],
+#             "end": segment["end"],
+#             "text": segment["text"],
+#             "speaker": segment["speaker"]
+#         }
+#         for segment in result["segments"]
+#     ]
+
+#     # Collect audio for each speaker
+#     speaker_audio = {}
+#     for segment in result["segments"]:
+#         speaker = segment["speaker"]
+#         if speaker not in speaker_audio:
+#             speaker_audio[speaker] = []
+#         speaker_audio[speaker].append((segment["start"], segment["end"]))
+
+#     # Collapse and truncate speaker audio
+#     speaker_sample_paths = {}
+#     audio_clip = AudioFileClip(audio_path)
+#     for speaker, segments in speaker_audio.items():
+#         speaker_clips = [audio_clip.subclip(start, end) for start, end in segments]
+#         combined_clip = concatenate_audioclips(speaker_clips)
+#         truncated_clip = combined_clip.subclip(0, min(30, combined_clip.duration))
+#         sample_path = f"speaker_{speaker}_sample.wav"
+#         truncated_clip.write_audiofile(sample_path)
+#         speaker_sample_paths[speaker] = sample_path
+#         logger.info(f"Created sample for {speaker}: {sample_path}")
+
+#     # Clean up
+#     video.close()
+#     audio_clip.close()
+#     os.remove(audio_path)
+
+#     return transcript_with_speakers, detected_language
+
+# # Function to get the appropriate translation model based on target language
+# def get_translation_model(source_language, target_language):
+#     """
+#     Get the translation model based on the source and target language.
+
+#     Parameters:
+#     - target_language (str): The language to translate the content into (e.g., 'es', 'fr').
+#     - source_language (str): The language of the input content (default is 'en' for English).
     
-    Returns:
-    - str: The translation model identifier.
-    """
-    # List of allowable languages
-    allowable_languages = ["en", "es", "fr", "zh", "de", "it", "pt", "ja", "ko", "ru"]
-
-    # Validate source and target languages
-    if source_language not in allowable_languages:
-        logger.debug(f"Invalid source language '{source_language}'. Supported languages are: {', '.join(allowable_languages)}")
-        # Return a default model if source language is invalid
-        source_language = "en"  # Default to 'en'
-
-    if target_language not in allowable_languages:
-        logger.debug(f"Invalid target language '{target_language}'. Supported languages are: {', '.join(allowable_languages)}")
-        # Return a default model if target language is invalid
-        target_language = "zh"  # Default to 'zh'
-
-    if source_language == target_language:
-        source_language = "en"  # Default to 'en'
-        target_language = "zh"  # Default to 'zh'
-
-    # Return the model using string concatenation
-    return f"Helsinki-NLP/opus-mt-{source_language}-{target_language}"
-
-def translate_single_entry(entry, translator):
-    original_text = entry["text"]
-    translated_text = translator(original_text)[0]['translation_text']
-    return {
-        "start": entry["start"],
-        "original": original_text,
-        "translated": translated_text,
-        "end": entry["end"],
-        "speaker": entry["speaker"]
-    }
-
-def translate_text(transcription_json, source_language, target_language):
-    # Load the translation model for the specified target language
-    translation_model_id = get_translation_model(source_language, target_language)
-    logger.debug(f"Translation model: {translation_model_id}")
-    translator = pipeline("translation", model=translation_model_id)
-
-    # Use ThreadPoolExecutor to parallelize translations
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        # Submit all translation tasks and collect results
-        translate_func = lambda entry: translate_single_entry(entry, translator)
-        translated_json = list(executor.map(translate_func, transcription_json))
-
-    # Sort the translated_json by start time
-    translated_json.sort(key=lambda x: x["start"])
-
-    # Log the components being added to translated_json
-    for entry in translated_json:
-        logger.debug("Added to translated_json: start=%s, original=%s, translated=%s, end=%s, speaker=%s",
-                     entry["start"], entry["original"], entry["translated"], entry["end"], entry["speaker"])
-
-    return translated_json
-
-def update_translations(file, edited_table, mode):
-    """
-    Update the translations based on user edits in the Gradio Dataframe.
-    """
-    output_video_path = "output_video.mp4"
-    logger.debug(f"Editable Table: {edited_table}")
-
-    if file is None:
-        logger.info("No file uploaded. Please upload a video/audio file.")
-        return None, [], None, "No file uploaded. Please upload a video/audio file."
+#     Returns:
+#     - str: The translation model identifier.
+#     """
+#     # List of allowable languages
+#     allowable_languages = ["en", "es", "fr", "zh", "de", "it", "pt", "ja", "ko", "ru"]
+
+#     # Validate source and target languages
+#     if source_language not in allowable_languages:
+#         logger.debug(f"Invalid source language '{source_language}'. Supported languages are: {', '.join(allowable_languages)}")
+#         # Return a default model if source language is invalid
+#         source_language = "en"  # Default to 'en'
+
+#     if target_language not in allowable_languages:
+#         logger.debug(f"Invalid target language '{target_language}'. Supported languages are: {', '.join(allowable_languages)}")
+#         # Return a default model if target language is invalid
+#         target_language = "zh"  # Default to 'zh'
+
+#     if source_language == target_language:
+#         source_language = "en"  # Default to 'en'
+#         target_language = "zh"  # Default to 'zh'
+
+#     # Return the model using string concatenation
+#     return f"Helsinki-NLP/opus-mt-{source_language}-{target_language}"
+
+# def translate_single_entry(entry, translator):
+#     original_text = entry["text"]
+#     translated_text = translator(original_text)[0]['translation_text']
+#     return {
+#         "start": entry["start"],
+#         "original": original_text,
+#         "translated": translated_text,
+#         "end": entry["end"],
+#         "speaker": entry["speaker"]
+#     }
+
+# def translate_text(transcription_json, source_language, target_language):
+#     # Load the translation model for the specified target language
+#     translation_model_id = get_translation_model(source_language, target_language)
+#     logger.debug(f"Translation model: {translation_model_id}")
+#     translator = pipeline("translation", model=translation_model_id)
+
+#     # Use ThreadPoolExecutor to parallelize translations
+#     with concurrent.futures.ThreadPoolExecutor() as executor:
+#         # Submit all translation tasks and collect results
+#         translate_func = lambda entry: translate_single_entry(entry, translator)
+#         translated_json = list(executor.map(translate_func, transcription_json))
+
+#     # Sort the translated_json by start time
+#     translated_json.sort(key=lambda x: x["start"])
+
+#     # Log the components being added to translated_json
+#     for entry in translated_json:
+#         logger.debug("Added to translated_json: start=%s, original=%s, translated=%s, end=%s, speaker=%s",
+#                      entry["start"], entry["original"], entry["translated"], entry["end"], entry["speaker"])
+
+#     return translated_json
+
+# def update_translations(file, edited_table, mode):
+#     """
+#     Update the translations based on user edits in the Gradio Dataframe.
+#     """
+#     output_video_path = "output_video.mp4"
+#     logger.debug(f"Editable Table: {edited_table}")
+
+#     if file is None:
+#         logger.info("No file uploaded. Please upload a video/audio file.")
+#         return None, [], None, "No file uploaded. Please upload a video/audio file."
         
-    try:
-        start_time = time.time()  # Start the timer
-
-        # Convert the edited_table (list of lists) back to list of dictionaries
-        updated_translations = [
-            {
-                "start": row["start"],  # Access by column name
-                "original": row["original"],
-                "translated": row["translated"],
-                "end": row["end"]
-            }
-            for _, row in edited_table.iterrows()
-        ]
-
-        # Call the function to process the video with updated translations
-        add_transcript_voiceover(file.name, updated_translations, output_video_path, mode=="Transcription with Voiceover")
-
-        # Calculate elapsed time
-        elapsed_time = time.time() - start_time
-        elapsed_time_display = f"Updates applied successfully in {elapsed_time:.2f} seconds."
-
-        return output_video_path, elapsed_time_display
-
-    except Exception as e:
-        raise ValueError(f"Error updating translations: {e}")
-
-def create_subtitle_clip_pil(text, start_time, end_time, video_width, video_height, font_path):
-    try:
-        subtitle_width = int(video_width * 0.8)
-        subtitle_font_size = int(video_height // 20)
-        font = ImageFont.truetype(font_path, subtitle_font_size)
-
-        dummy_img = Image.new("RGBA", (subtitle_width, 1), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(dummy_img)
-
-        lines = []
-        line = ""
-        for word in text.split():
-            test_line = f"{line} {word}".strip()
-            bbox = draw.textbbox((0, 0), test_line, font=font)
-            w = bbox[2] - bbox[0]
-            if w <= subtitle_width - 10:
-                line = test_line
-            else:
-                lines.append(line)
-                line = word
-        lines.append(line)
-
-        line_heights = [draw.textbbox((0, 0), l, font=font)[3] - draw.textbbox((0, 0), l, font=font)[1] for l in lines]
-        total_height = sum(line_heights) + (len(lines) - 1) * 5
-        img = Image.new("RGBA", (subtitle_width, total_height), (0, 0, 0, 0))
-        draw = ImageDraw.Draw(img)
-
-        y = 0
-        for idx, line in enumerate(lines):
-            bbox = draw.textbbox((0, 0), line, font=font)
-            w = bbox[2] - bbox[0]
-            draw.text(((subtitle_width - w) // 2, y), line, font=font, fill="yellow")
-            y += line_heights[idx] + 5
+#     try:
+#         start_time = time.time()  # Start the timer
+
+#         # Convert the edited_table (list of lists) back to list of dictionaries
+#         updated_translations = [
+#             {
+#                 "start": row["start"],  # Access by column name
+#                 "original": row["original"],
+#                 "translated": row["translated"],
+#                 "end": row["end"]
+#             }
+#             for _, row in edited_table.iterrows()
+#         ]
+
+#         # Call the function to process the video with updated translations
+#         add_transcript_voiceover(file.name, updated_translations, output_video_path, mode=="Transcription with Voiceover")
+
+#         # Calculate elapsed time
+#         elapsed_time = time.time() - start_time
+#         elapsed_time_display = f"Updates applied successfully in {elapsed_time:.2f} seconds."
+
+#         return output_video_path, elapsed_time_display
+
+#     except Exception as e:
+#         raise ValueError(f"Error updating translations: {e}")
+
+# def create_subtitle_clip_pil(text, start_time, end_time, video_width, video_height, font_path):
+#     try:
+#         subtitle_width = int(video_width * 0.8)
+#         subtitle_font_size = int(video_height // 20)
+#         font = ImageFont.truetype(font_path, subtitle_font_size)
+
+#         dummy_img = Image.new("RGBA", (subtitle_width, 1), (0, 0, 0, 0))
+#         draw = ImageDraw.Draw(dummy_img)
+
+#         lines = []
+#         line = ""
+#         for word in text.split():
+#             test_line = f"{line} {word}".strip()
+#             bbox = draw.textbbox((0, 0), test_line, font=font)
+#             w = bbox[2] - bbox[0]
+#             if w <= subtitle_width - 10:
+#                 line = test_line
+#             else:
+#                 lines.append(line)
+#                 line = word
+#         lines.append(line)
+
+#         line_heights = [draw.textbbox((0, 0), l, font=font)[3] - draw.textbbox((0, 0), l, font=font)[1] for l in lines]
+#         total_height = sum(line_heights) + (len(lines) - 1) * 5
+#         img = Image.new("RGBA", (subtitle_width, total_height), (0, 0, 0, 0))
+#         draw = ImageDraw.Draw(img)
+
+#         y = 0
+#         for idx, line in enumerate(lines):
+#             bbox = draw.textbbox((0, 0), line, font=font)
+#             w = bbox[2] - bbox[0]
+#             draw.text(((subtitle_width - w) // 2, y), line, font=font, fill="yellow")
+#             y += line_heights[idx] + 5
             
-        img_np = np.array(img)  # <- ✅ Fix: convert to NumPy
-        txt_clip = ImageClip(img_np).set_start(start_time).set_duration(end_time - start_time).set_position("bottom").set_opacity(0.8)
-        return txt_clip
-    except Exception as e:
-        logger.error(f"\u274c Failed to create subtitle clip: {e}")
-        return None
-
-def process_entry(entry, i, video_width, video_height, add_voiceover, target_language, font_path, speaker_sample_paths=None):
-    logger.debug(f"Processing entry {i}: {entry}")
-    error_message = None
-
-    try:
-        txt_clip = create_subtitle_clip_pil(entry["translated"], entry["start"], entry["end"], video_width, video_height, font_path)
-    except Exception as e:
-        error_message = f"❌ Failed to create subtitle clip for entry {i}: {e}"
-        logger.error(error_message)
-        txt_clip = None
-
-    audio_segment = None
-    if add_voiceover:
-        try:
-            segment_audio_path = f"segment_{i}_voiceover.wav"
-            desired_duration = entry["end"] - entry["start"]
-            speaker = entry.get("speaker", "default")
-            speaker_wav_path = f"speaker_{speaker}_sample.wav"
-
-            output_path, status_msg, tts_error = generate_voiceover_clone([entry], desired_duration, target_language, speaker_wav_path, segment_audio_path)
-
-            if tts_error:
-                error_message = error_message + " | " + tts_error if error_message else tts_error
-
-            if not output_path or not os.path.exists(segment_audio_path):
-                raise FileNotFoundError(f"Voiceover file not generated at: {segment_audio_path}")
-
-            audio_clip = AudioFileClip(segment_audio_path)
-            logger.debug(f"Audio clip duration: {audio_clip.duration}, Desired duration: {desired_duration}")
-
-            if audio_clip.duration < desired_duration:
-                silence_duration = desired_duration - audio_clip.duration
-                audio_clip = concatenate_audioclips([audio_clip, silence(duration=silence_duration)])
-                logger.info(f"Padded audio with {silence_duration} seconds of silence.")
-
-            audio_segment = audio_clip.set_start(entry["start"]).set_duration(desired_duration)
-
-        except Exception as e:
-            err = f"❌ Failed to generate audio segment for entry {i}: {e}"
-            logger.error(err)
-            error_message = error_message + " | " + err if error_message else err
-            audio_segment = None
-
-    return i, txt_clip, audio_segment, error_message
+#         img_np = np.array(img)  # <- ✅ Fix: convert to NumPy
+#         txt_clip = ImageClip(img_np).set_start(start_time).set_duration(end_time - start_time).set_position("bottom").set_opacity(0.8)
+#         return txt_clip
+#     except Exception as e:
+#         logger.error(f"\u274c Failed to create subtitle clip: {e}")
+#         return None
+
+# def process_entry(entry, i, video_width, video_height, add_voiceover, target_language, font_path, speaker_sample_paths=None):
+#     logger.debug(f"Processing entry {i}: {entry}")
+#     error_message = None
+
+#     try:
+#         txt_clip = create_subtitle_clip_pil(entry["translated"], entry["start"], entry["end"], video_width, video_height, font_path)
+#     except Exception as e:
+#         error_message = f"❌ Failed to create subtitle clip for entry {i}: {e}"
+#         logger.error(error_message)
+#         txt_clip = None
+
+#     audio_segment = None
+#     if add_voiceover:
+#         try:
+#             segment_audio_path = f"segment_{i}_voiceover.wav"
+#             desired_duration = entry["end"] - entry["start"]
+#             speaker = entry.get("speaker", "default")
+#             speaker_wav_path = f"speaker_{speaker}_sample.wav"
+
+#             output_path, status_msg, tts_error = generate_voiceover_clone([entry], desired_duration, target_language, speaker_wav_path, segment_audio_path)
+
+#             if tts_error:
+#                 error_message = error_message + " | " + tts_error if error_message else tts_error
+
+#             if not output_path or not os.path.exists(segment_audio_path):
+#                 raise FileNotFoundError(f"Voiceover file not generated at: {segment_audio_path}")
+
+#             audio_clip = AudioFileClip(segment_audio_path)
+#             logger.debug(f"Audio clip duration: {audio_clip.duration}, Desired duration: {desired_duration}")
+
+#             if audio_clip.duration < desired_duration:
+#                 silence_duration = desired_duration - audio_clip.duration
+#                 audio_clip = concatenate_audioclips([audio_clip, silence(duration=silence_duration)])
+#                 logger.info(f"Padded audio with {silence_duration} seconds of silence.")
+
+#             audio_segment = audio_clip.set_start(entry["start"]).set_duration(desired_duration)
+
+#         except Exception as e:
+#             err = f"❌ Failed to generate audio segment for entry {i}: {e}"
+#             logger.error(err)
+#             error_message = error_message + " | " + err if error_message else err
+#             audio_segment = None
+
+#     return i, txt_clip, audio_segment, error_message
     
-def add_transcript_voiceover(video_path, translated_json, output_path, add_voiceover=False, target_language="en", speaker_sample_paths=None):
-    video = VideoFileClip(video_path)
-    font_path = "./NotoSansSC-Regular.ttf"
-
-    text_clips = []
-    audio_segments = []
-    error_messages = []
-
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        futures = [executor.submit(process_entry, entry, i, video.w, video.h, add_voiceover, target_language, font_path, speaker_sample_paths)
-                   for i, entry in enumerate(translated_json)]
-
-        results = []
-        for future in concurrent.futures.as_completed(futures):
-            try:
-                i, txt_clip, audio_segment, error = future.result()
-                results.append((i, txt_clip, audio_segment))
-                if error:
-                    error_messages.append(f"[Entry {i}] {error}")
-            except Exception as e:
-                err = f"❌ Unexpected error in future result: {e}"
-                logger.error(err)
-                error_messages.append(err)
-
-    # Sort by entry index to ensure order
-    results.sort(key=lambda x: x[0])
-    text_clips = [clip for _, clip, _ in results if clip]
-    if add_voiceover:
-        audio_segments = [segment for _, _, segment in results if segment]
-
-    final_video = CompositeVideoClip([video] + text_clips)
-
-    if add_voiceover:
-        if audio_segments:
-            final_audio = CompositeAudioClip(audio_segments).set_duration(video.duration)
-            final_video = final_video.set_audio(final_audio)
-        else:
-            logger.warning("⚠️ No audio segments available. Adding silent fallback.")
-            silent_audio = AudioClip(lambda t: 0, duration=video.duration)
-            final_video = final_video.set_audio(silent_audio)
-
-    logger.info(f"Saving the final video to: {output_path}")
-    final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
-
-    logger.info("Video processing completed successfully.")
-
-    # Optional: return errors
-    if error_messages:
-        logger.warning("⚠️ Errors encountered during processing:")
-        for msg in error_messages:
-            logger.warning(msg)
-
-    return error_messages
-
-# Initialize TTS model only once (outside the function)
-tts = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2")
-
-def generate_voiceover_clone(translated_json, desired_duration, target_language, speaker_wav_path, output_audio_path):
-    try:
-        full_text = " ".join(entry["translated"] for entry in translated_json if "translated" in entry and entry["translated"].strip())
-        if not full_text.strip():
-            msg = "❌ Translated text is empty."
-            logger.error(msg)
-            return None, msg, msg
-
-        if not speaker_wav_path or not os.path.exists(speaker_wav_path):
-            msg = f"❌ Speaker audio not found: {speaker_wav_path}"
-            logger.error(msg)
-            return None, msg, msg
-
-        # # Truncate text based on max token assumption (~60 tokens)
-        # MAX_TTS_TOKENS = 60
-        # tokens = full_text.split()  # crude token count
-        # if len(tokens) > MAX_TTS_TOKENS:
-        #     logger.warning(f"⚠️ Text too long for TTS model ({len(tokens)} tokens). Truncating to {MAX_TTS_TOKENS} tokens.")
-        #     full_text = " ".join(tokens[:MAX_TTS_TOKENS])
-
-        speed_tts = calibrated_speed(full_text, desired_duration)
-        tts.tts_to_file(
-            text=full_text,
-            speaker_wav=speaker_wav_path,
-            language=target_language,
-            file_path=output_audio_path,
-            speed=speed_tts,
-            split_sentences=True
-        )
-
-        if not os.path.exists(output_audio_path):
-            msg = f"❌ Voiceover file not generated at: {output_audio_path}"
-            logger.error(msg)
-            return None, msg, msg
-
-        msg = "✅ Voice cloning completed successfully."
-        logger.info(msg)
-        return output_audio_path, msg, None
-
-    except Exception as e:
-        err_msg = f"❌ An error occurred: {str(e)}"
-        logger.error("❌ Error during voice cloning:")
-        logger.error(traceback.format_exc())
-        return None, err_msg, err_msg
-
-def calibrated_speed(text, desired_duration):
-    """
-    Compute a speed factor to help TTS fit audio into desired duration,
-    using a simple truncated linear function of characters per second.
-    """
-    char_count = len(text.strip())
-    if char_count == 0 or desired_duration <= 0:
-        return 1.0  # fallback
-
-    cps = char_count / desired_duration  # characters per second
-
-    # Truncated linear mapping
-    if cps < 10:
-        return 1.0
-    elif cps > 25:
-        return 1.4
-    else:
-        # Linearly scale between cps 10 -> 25 and speed 1.0 -> 1.3
-        slope = (1.4 - 1.0) / (25 - 10)
-        return 1.0 + slope * (cps - 10)
-
-
-def upload_and_manage(file, target_language, mode="transcription"):
-    if file is None:
-        logger.info("No file uploaded. Please upload a video/audio file.")
-        return None, [], None, "No file uploaded. Please upload a video/audio file."
-
-    try:
-        start_time = time.time()  # Start the timer
-        logger.info(f"Started processing file: {file.name}")
-
-        # Define paths for audio and output files
-        audio_path = "audio.wav"
-        output_video_path = "output_video.mp4"
-        voiceover_path = "voiceover.wav"
-        logger.info(f"Using audio path: {audio_path}, output video path: {output_video_path}, voiceover path: {voiceover_path}")
-
-        # Step 1: Transcribe audio from uploaded media file and get timestamps
-        logger.info("Transcribing audio...")
-        transcription_json, source_language = transcribe_video_with_speakers(file.name)
-        logger.info(f"Transcription completed. Detected source language: {source_language}")
-
-        # Step 2: Translate the transcription
-        logger.info(f"Translating transcription from {source_language} to {target_language}...")
-        translated_json = translate_text(transcription_json, source_language, target_language)
-        logger.info(f"Translation completed. Number of translated segments: {len(translated_json)}")
-
-        # Step 3: Add transcript to video based on timestamps
-        logger.info("Adding translated transcript to video...")
-        add_transcript_voiceover(file.name, translated_json, output_video_path, mode == "Transcription with Voiceover", target_language)
-        logger.info(f"Transcript added to video. Output video saved at {output_video_path}")
-
-        # Convert translated JSON into a format for the editable table
-        logger.info("Converting translated JSON into editable table format...")
-        editable_table = [
-            [float(entry["start"]), entry["original"], entry["translated"], float(entry["end"]), entry["speaker"]]
-            for entry in translated_json
-        ]
-
-        # Calculate elapsed time
-        elapsed_time = time.time() - start_time
-        elapsed_time_display = f"Processing completed in {elapsed_time:.2f} seconds."
-        logger.info(f"Processing completed in {elapsed_time:.2f} seconds.")
-
-        return translated_json, editable_table, output_video_path, elapsed_time_display
-
-    except Exception as e:
-        logger.error(f"An error occurred: {str(e)}")
-        return None, [], None, f"An error occurred: {str(e)}"
-# Gradio Interface with Tabs
-def build_interface():
-    with gr.Blocks(css=css) as demo:
-        gr.Markdown("## Video Localization")
-        with gr.Row():
-            with gr.Column(scale=4):
-                file_input = gr.File(label="Upload Video/Audio File")
-                language_input = gr.Dropdown(["en", "es", "fr", "zh"], label="Select Language")  # Language codes
-                process_mode = gr.Radio(choices=["Transcription", "Transcription with Voiceover"], label="Choose Processing Type", value="Transcription")
-                submit_button = gr.Button("Post and Process")
-                editable_translations = gr.State(value=[])
-
-            with gr.Column(scale=8):
-                gr.Markdown("## Edit Translations")
+# def add_transcript_voiceover(video_path, translated_json, output_path, add_voiceover=False, target_language="en", speaker_sample_paths=None):
+#     video = VideoFileClip(video_path)
+#     font_path = "./NotoSansSC-Regular.ttf"
+
+#     text_clips = []
+#     audio_segments = []
+#     error_messages = []
+
+#     with concurrent.futures.ThreadPoolExecutor() as executor:
+#         futures = [executor.submit(process_entry, entry, i, video.w, video.h, add_voiceover, target_language, font_path, speaker_sample_paths)
+#                    for i, entry in enumerate(translated_json)]
+
+#         results = []
+#         for future in concurrent.futures.as_completed(futures):
+#             try:
+#                 i, txt_clip, audio_segment, error = future.result()
+#                 results.append((i, txt_clip, audio_segment))
+#                 if error:
+#                     error_messages.append(f"[Entry {i}] {error}")
+#             except Exception as e:
+#                 err = f"❌ Unexpected error in future result: {e}"
+#                 logger.error(err)
+#                 error_messages.append(err)
+
+#     # Sort by entry index to ensure order
+#     results.sort(key=lambda x: x[0])
+#     text_clips = [clip for _, clip, _ in results if clip]
+#     if add_voiceover:
+#         audio_segments = [segment for _, _, segment in results if segment]
+
+#     final_video = CompositeVideoClip([video] + text_clips)
+
+#     if add_voiceover:
+#         if audio_segments:
+#             final_audio = CompositeAudioClip(audio_segments).set_duration(video.duration)
+#             final_video = final_video.set_audio(final_audio)
+#         else:
+#             logger.warning("⚠️ No audio segments available. Adding silent fallback.")
+#             silent_audio = AudioClip(lambda t: 0, duration=video.duration)
+#             final_video = final_video.set_audio(silent_audio)
+
+#     logger.info(f"Saving the final video to: {output_path}")
+#     final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
+
+#     logger.info("Video processing completed successfully.")
+
+#     # Optional: return errors
+#     if error_messages:
+#         logger.warning("⚠️ Errors encountered during processing:")
+#         for msg in error_messages:
+#             logger.warning(msg)
+
+#     return error_messages
+
+# # Initialize TTS model only once (outside the function)
+# tts = TTS(model_name="tts_models/multilingual/multi-dataset/xtts_v2")
+
+# def generate_voiceover_clone(translated_json, desired_duration, target_language, speaker_wav_path, output_audio_path):
+#     try:
+#         full_text = " ".join(entry["translated"] for entry in translated_json if "translated" in entry and entry["translated"].strip())
+#         if not full_text.strip():
+#             msg = "❌ Translated text is empty."
+#             logger.error(msg)
+#             return None, msg, msg
+
+#         if not speaker_wav_path or not os.path.exists(speaker_wav_path):
+#             msg = f"❌ Speaker audio not found: {speaker_wav_path}"
+#             logger.error(msg)
+#             return None, msg, msg
+
+#         # # Truncate text based on max token assumption (~60 tokens)
+#         # MAX_TTS_TOKENS = 60
+#         # tokens = full_text.split()  # crude token count
+#         # if len(tokens) > MAX_TTS_TOKENS:
+#         #     logger.warning(f"⚠️ Text too long for TTS model ({len(tokens)} tokens). Truncating to {MAX_TTS_TOKENS} tokens.")
+#         #     full_text = " ".join(tokens[:MAX_TTS_TOKENS])
+
+#         speed_tts = calibrated_speed(full_text, desired_duration)
+#         tts.tts_to_file(
+#             text=full_text,
+#             speaker_wav=speaker_wav_path,
+#             language=target_language,
+#             file_path=output_audio_path,
+#             speed=speed_tts,
+#             split_sentences=True
+#         )
+
+#         if not os.path.exists(output_audio_path):
+#             msg = f"❌ Voiceover file not generated at: {output_audio_path}"
+#             logger.error(msg)
+#             return None, msg, msg
+
+#         msg = "✅ Voice cloning completed successfully."
+#         logger.info(msg)
+#         return output_audio_path, msg, None
+
+#     except Exception as e:
+#         err_msg = f"❌ An error occurred: {str(e)}"
+#         logger.error("❌ Error during voice cloning:")
+#         logger.error(traceback.format_exc())
+#         return None, err_msg, err_msg
+
+# def calibrated_speed(text, desired_duration):
+#     """
+#     Compute a speed factor to help TTS fit audio into desired duration,
+#     using a simple truncated linear function of characters per second.
+#     """
+#     char_count = len(text.strip())
+#     if char_count == 0 or desired_duration <= 0:
+#         return 1.0  # fallback
+
+#     cps = char_count / desired_duration  # characters per second
+
+#     # Truncated linear mapping
+#     if cps < 10:
+#         return 1.0
+#     elif cps > 25:
+#         return 1.4
+#     else:
+#         # Linearly scale between cps 10 -> 25 and speed 1.0 -> 1.3
+#         slope = (1.4 - 1.0) / (25 - 10)
+#         return 1.0 + slope * (cps - 10)
+
+
+# def upload_and_manage(file, target_language, mode="transcription"):
+#     if file is None:
+#         logger.info("No file uploaded. Please upload a video/audio file.")
+#         return None, [], None, "No file uploaded. Please upload a video/audio file."
+
+#     try:
+#         start_time = time.time()  # Start the timer
+#         logger.info(f"Started processing file: {file.name}")
+
+#         # Define paths for audio and output files
+#         audio_path = "audio.wav"
+#         output_video_path = "output_video.mp4"
+#         voiceover_path = "voiceover.wav"
+#         logger.info(f"Using audio path: {audio_path}, output video path: {output_video_path}, voiceover path: {voiceover_path}")
+
+#         # Step 1: Transcribe audio from uploaded media file and get timestamps
+#         logger.info("Transcribing audio...")
+#         transcription_json, source_language = transcribe_video_with_speakers(file.name)
+#         logger.info(f"Transcription completed. Detected source language: {source_language}")
+
+#         # Step 2: Translate the transcription
+#         logger.info(f"Translating transcription from {source_language} to {target_language}...")
+#         translated_json = translate_text(transcription_json, source_language, target_language)
+#         logger.info(f"Translation completed. Number of translated segments: {len(translated_json)}")
+
+#         # Step 3: Add transcript to video based on timestamps
+#         logger.info("Adding translated transcript to video...")
+#         add_transcript_voiceover(file.name, translated_json, output_video_path, mode == "Transcription with Voiceover", target_language)
+#         logger.info(f"Transcript added to video. Output video saved at {output_video_path}")
+
+#         # Convert translated JSON into a format for the editable table
+#         logger.info("Converting translated JSON into editable table format...")
+#         editable_table = [
+#             [float(entry["start"]), entry["original"], entry["translated"], float(entry["end"]), entry["speaker"]]
+#             for entry in translated_json
+#         ]
+
+#         # Calculate elapsed time
+#         elapsed_time = time.time() - start_time
+#         elapsed_time_display = f"Processing completed in {elapsed_time:.2f} seconds."
+#         logger.info(f"Processing completed in {elapsed_time:.2f} seconds.")
+
+#         return translated_json, editable_table, output_video_path, elapsed_time_display
+
+#     except Exception as e:
+#         logger.error(f"An error occurred: {str(e)}")
+#         return None, [], None, f"An error occurred: {str(e)}"
+# # Gradio Interface with Tabs
+# def build_interface():
+#     with gr.Blocks(css=css) as demo:
+#         gr.Markdown("## Video Localization")
+#         with gr.Row():
+#             with gr.Column(scale=4):
+#                 file_input = gr.File(label="Upload Video/Audio File")
+#                 language_input = gr.Dropdown(["en", "es", "fr", "zh"], label="Select Language")  # Language codes
+#                 process_mode = gr.Radio(choices=["Transcription", "Transcription with Voiceover"], label="Choose Processing Type", value="Transcription")
+#                 submit_button = gr.Button("Post and Process")
+#                 editable_translations = gr.State(value=[])
+
+#             with gr.Column(scale=8):
+#                 gr.Markdown("## Edit Translations")
                 
-                # Editable JSON Data
-                editable_table = gr.Dataframe(
-                    value=[],  # Default to an empty list to avoid undefined values
-                    headers=["start", "original", "translated", "end", "speaker"],
-                    datatype=["number", "str", "str", "number", "str"],
-                    row_count=1,  # Initially empty
-                    col_count=5,
-                    interactive=[False, True, True, False, False],  # Control editability
-                    label="Edit Translations",
-                    wrap=True  # Enables text wrapping if supported
-                )
-                save_changes_button = gr.Button("Save Changes")
-                processed_video_output = gr.File(label="Download Processed Video", interactive=True)  # Download button
-                elapsed_time_display = gr.Textbox(label="Elapsed Time", lines=1, interactive=False)
-
-            with gr.Column(scale=1):
-                gr.Markdown("**Feedback**")
-                feedback_input = gr.Textbox(
-                    placeholder="Leave your feedback here...",
-                    label=None,
-                    lines=3,
-                )
-                feedback_btn = gr.Button("Submit Feedback")
-                response_message = gr.Textbox(label=None, lines=1, interactive=False)
-                db_download = gr.File(label="Download Database File", visible=False)
+#                 # Editable JSON Data
+#                 editable_table = gr.Dataframe(
+#                     value=[],  # Default to an empty list to avoid undefined values
+#                     headers=["start", "original", "translated", "end", "speaker"],
+#                     datatype=["number", "str", "str", "number", "str"],
+#                     row_count=1,  # Initially empty
+#                     col_count=5,
+#                     interactive=[False, True, True, False, False],  # Control editability
+#                     label="Edit Translations",
+#                     wrap=True  # Enables text wrapping if supported
+#                 )
+#                 save_changes_button = gr.Button("Save Changes")
+#                 processed_video_output = gr.File(label="Download Processed Video", interactive=True)  # Download button
+#                 elapsed_time_display = gr.Textbox(label="Elapsed Time", lines=1, interactive=False)
+
+#             with gr.Column(scale=1):
+#                 gr.Markdown("**Feedback**")
+#                 feedback_input = gr.Textbox(
+#                     placeholder="Leave your feedback here...",
+#                     label=None,
+#                     lines=3,
+#                 )
+#                 feedback_btn = gr.Button("Submit Feedback")
+#                 response_message = gr.Textbox(label=None, lines=1, interactive=False)
+#                 db_download = gr.File(label="Download Database File", visible=False)
             
-                # Link the feedback handling
-                def feedback_submission(feedback):
-                    message, file_path = handle_feedback(feedback)
-                    if file_path:
-                        return message, gr.update(value=file_path, visible=True)
-                    return message, gr.update(visible=False)            
-
-            save_changes_button.click(
-                update_translations, 
-                inputs=[file_input, editable_table, process_mode],
-                outputs=[processed_video_output, elapsed_time_display]
-            )
-
-            submit_button.click(
-                upload_and_manage, 
-                inputs=[file_input, language_input, process_mode], 
-                outputs=[editable_translations, editable_table, processed_video_output, elapsed_time_display]
-            )
-
-            # Connect submit button to save_feedback_db function
-            feedback_btn.click(
-                feedback_submission, 
-                inputs=[feedback_input], 
-                outputs=[response_message, db_download]
-            )
-
-    return demo
-
-# Launch the Gradio interface
-demo = build_interface()
-demo.launch()
+#                 # Link the feedback handling
+#                 def feedback_submission(feedback):
+#                     message, file_path = handle_feedback(feedback)
+#                     if file_path:
+#                         return message, gr.update(value=file_path, visible=True)
+#                     return message, gr.update(visible=False)            
+
+#             save_changes_button.click(
+#                 update_translations, 
+#                 inputs=[file_input, editable_table, process_mode],
+#                 outputs=[processed_video_output, elapsed_time_display]
+#             )
+
+#             submit_button.click(
+#                 upload_and_manage, 
+#                 inputs=[file_input, language_input, process_mode], 
+#                 outputs=[editable_translations, editable_table, processed_video_output, elapsed_time_display]
+#             )
+
+#             # Connect submit button to save_feedback_db function
+#             feedback_btn.click(
+#                 feedback_submission, 
+#                 inputs=[feedback_input], 
+#                 outputs=[response_message, db_download]
+#             )
+
+#     return demo
+
+# # Launch the Gradio interface
+# demo = build_interface()
+# demo.launch()
+
+import gradio as gr
+
+def dummy_func(x):
+    return x, "Success"
+
+with gr.Blocks() as demo:
+    inp = gr.Textbox()
+    out1 = gr.Textbox()
+    out2 = gr.Textbox()
+    btn = gr.Button("Run")
+    btn.click(dummy_func, inputs=inp, outputs=[out1, out2])
+
+demo.launch()