Upload 39 files

App_Function_Libraries/Gradio_UI/Audio_ingestion_tab.py

@@ -12,6 +12,9 @@ from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Chat_ui import update_user_prompt
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import whisper_models
 from App_Function_Libraries.Utils.Utils import cleanup_temp_files
+# Import metrics logging
+from App_Function_Libraries.Metrics.metrics_logger import log_counter, log_histogram
+from App_Function_Libraries.Metrics.logger_config import logger
 #
 #######################################################################################################################
 # Functions:

App_Function_Libraries/Gradio_UI/Live_Recording.py

@@ -0,0 +1,142 @@
+# Live_Recording.py
+# Description: Gradio UI for live audio recording and transcription.
+#
+# Import necessary modules and functions
+import logging
+import os
+import time
+
+# External Imports
+import gradio as gr
+# Local Imports
+from App_Function_Libraries.Audio.Audio_Transcription_Lib import (record_audio, speech_to_text, save_audio_temp,
+                                                                  stop_recording)
+from App_Function_Libraries.DB.DB_Manager import add_media_to_database
+from App_Function_Libraries.Metrics.metrics_logger import log_counter, log_histogram
+#
+#######################################################################################################################
+#
+# Functions:
+
+whisper_models = ["small", "medium", "small.en", "medium.en", "medium", "large", "large-v1", "large-v2", "large-v3",
+                  "distil-large-v2", "distil-medium.en", "distil-small.en"]
+
+def create_live_recording_tab():
+    with gr.Tab("Live Recording and Transcription"):
+        gr.Markdown("# Live Audio Recording and Transcription")
+        with gr.Row():
+            with gr.Column():
+                duration = gr.Slider(minimum=1, maximum=8000, value=15, label="Recording Duration (seconds)")
+                whisper_models_input = gr.Dropdown(choices=whisper_models, value="medium", label="Whisper Model")
+                vad_filter = gr.Checkbox(label="Use VAD Filter")
+                save_recording = gr.Checkbox(label="Save Recording")
+                save_to_db = gr.Checkbox(label="Save Transcription to Database(Must be checked to save - can be checked afer transcription)", value=False)
+                custom_title = gr.Textbox(label="Custom Title (for database)", visible=False)
+                record_button = gr.Button("Start Recording")
+                stop_button = gr.Button("Stop Recording")
+            with gr.Column():
+                output = gr.Textbox(label="Transcription", lines=10)
+                audio_output = gr.Audio(label="Recorded Audio", visible=False)
+
+        recording_state = gr.State(value=None)
+
+        def start_recording(duration):
+            log_counter("live_recording_start_attempt", labels={"duration": duration})
+            p, stream, audio_queue, stop_event, audio_thread = record_audio(duration)
+            log_counter("live_recording_start_success", labels={"duration": duration})
+            return (p, stream, audio_queue, stop_event, audio_thread)
+
+        def end_recording_and_transcribe(recording_state, whisper_model, vad_filter, save_recording, save_to_db, custom_title):
+            log_counter("live_recording_end_attempt", labels={"model": whisper_model})
+            start_time = time.time()
+
+            if recording_state is None:
+                log_counter("live_recording_end_error", labels={"error": "Recording hasn't started yet"})
+                return "Recording hasn't started yet.", None
+
+            p, stream, audio_queue, stop_event, audio_thread = recording_state
+            audio_data = stop_recording(p, stream, audio_queue, stop_event, audio_thread)
+
+            temp_file = save_audio_temp(audio_data)
+            segments = speech_to_text(temp_file, whisper_model=whisper_model, vad_filter=vad_filter)
+            transcription = "\n".join([segment["Text"] for segment in segments])
+
+            if save_recording:
+                log_counter("live_recording_saved", labels={"model": whisper_model})
+            else:
+                os.remove(temp_file)
+
+            end_time = time.time() - start_time
+            log_histogram("live_recording_end_duration", end_time, labels={"model": whisper_model})
+            log_counter("live_recording_end_success", labels={"model": whisper_model})
+            return transcription, temp_file if save_recording else None
+
+        def save_transcription_to_db(transcription, custom_title):
+            log_counter("save_transcription_to_db_attempt")
+            start_time = time.time()
+            if custom_title.strip() == "":
+                custom_title = "Self-recorded Audio"
+
+            try:
+                url = "self_recorded"
+                info_dict = {
+                    "title": custom_title,
+                    "uploader": "self-recorded",
+                    "webpage_url": url
+                }
+                segments = [{"Text": transcription}]
+                summary = ""
+                keywords = ["self-recorded", "audio"]
+                custom_prompt_input = ""
+                whisper_model = "self-recorded"
+                media_type = "audio"
+
+                result = add_media_to_database(
+                    url=url,
+                    info_dict=info_dict,
+                    segments=segments,
+                    summary=summary,
+                    keywords=keywords,
+                    custom_prompt_input=custom_prompt_input,
+                    whisper_model=whisper_model,
+                    media_type=media_type
+                )
+                end_time = time.time() - start_time
+                log_histogram("save_transcription_to_db_duration", end_time)
+                log_counter("save_transcription_to_db_success")
+                return f"Transcription saved to database successfully. {result}"
+            except Exception as e:
+                logging.error(f"Error saving transcription to database: {str(e)}")
+                log_counter("save_transcription_to_db_error", labels={"error": str(e)})
+                return f"Error saving transcription to database: {str(e)}"
+
+        def update_custom_title_visibility(save_to_db):
+            return gr.update(visible=save_to_db)
+
+        record_button.click(
+            fn=start_recording,
+            inputs=[duration],
+            outputs=[recording_state]
+        )
+
+        stop_button.click(
+            fn=end_recording_and_transcribe,
+            inputs=[recording_state, whisper_models_input, vad_filter, save_recording, save_to_db, custom_title],
+            outputs=[output, audio_output]
+        )
+
+        save_to_db.change(
+            fn=update_custom_title_visibility,
+            inputs=[save_to_db],
+            outputs=[custom_title]
+        )
+
+        gr.Button("Save to Database").click(
+            fn=save_transcription_to_db,
+            inputs=[output, custom_title],
+            outputs=gr.Textbox(label="Database Save Status")
+        )
+
+#
+# End of Functions
+########################################################################################################################

App_Function_Libraries/Gradio_UI/Podcast_tab.py

@@ -3,7 +3,6 @@
 #
 # Imports
 #
-#
 # External Imports
 import gradio as gr
 #
@@ -11,8 +10,6 @@ import gradio as gr
 from App_Function_Libraries.Audio.Audio_Files import process_podcast
 from App_Function_Libraries.DB.DB_Manager import load_preset_prompts
 from App_Function_Libraries.Gradio_UI.Gradio_Shared import whisper_models, update_user_prompt
-
-
 #
 ########################################################################################################################
 #

App_Function_Libraries/Gradio_UI/Video_transcription_tab.py

@@ -5,6 +5,7 @@
 import json
 import logging
 import os
+from datetime import datetime
 from typing import Dict, Any
 
 #
@@ -23,6 +24,8 @@ from App_Function_Libraries.Utils.Utils import convert_to_seconds, safe_read_fil
     create_download_directory, generate_unique_identifier, extract_text_from_segments
 from App_Function_Libraries.Video_DL_Ingestion_Lib import parse_and_expand_urls, extract_metadata, download_video
 from App_Function_Libraries.Benchmarks_Evaluations.ms_g_eval import run_geval
+# Import metrics logging
+from App_Function_Libraries.Metrics.metrics_logger import log_counter, log_histogram
 #
 #######################################################################################################################
 #
@@ -194,6 +197,8 @@ def create_video_transcription_tab():
                                                    timestamp_option, keep_original_video, summarize_recursively, overwrite_existing=False,
                                                    progress: gr.Progress = gr.Progress()) -> tuple:
                 try:
+                    # Start overall processing timer
+                    proc_start_time = datetime.utcnow()
                     # FIXME - summarize_recursively is not being used...
                     logging.info("Entering process_videos_with_error_handling")
                     logging.info(f"Received inputs: {inputs}")
@@ -245,11 +250,17 @@ def create_video_transcription_tab():
                     all_transcriptions = {}
                     all_summaries = ""
 
+                    # Start timing
+                    # FIXME - utcnow() is deprecated and scheduled for removal in a future version. Use timezone-aware objects to represent datetimes in UTC: datetime.datetime.now(datetime.UTC).
+                    start_proc = datetime.utcnow()
+
                     for i in range(0, len(all_inputs), batch_size):
                         batch = all_inputs[i:i + batch_size]
                         batch_results = []
 
                         for input_item in batch:
+                            # Start individual video processing timer
+                            video_start_time = datetime.utcnow()
                             try:
                                 start_seconds = convert_to_seconds(start_time)
                                 end_seconds = convert_to_seconds(end_time) if end_time else None
@@ -318,6 +329,14 @@ def create_video_transcription_tab():
                                     batch_results.append(
                                         (input_item, error_message, "Error", video_metadata, None, None))
                                     errors.append(f"Error processing {input_item}: {error_message}")
+
+                                    # Log failure metric
+                                    log_counter(
+                                        metric_name="videos_failed_total",
+                                        labels={"whisper_model": whisper_model, "api_name": api_name},
+                                        value=1
+                                    )
+
                                 else:
                                     url, transcription, summary, json_file, summary_file, result_metadata = result
                                     if transcription is None:
@@ -325,13 +344,56 @@ def create_video_transcription_tab():
                                         batch_results.append(
                                             (input_item, error_message, "Error", result_metadata, None, None))
                                         errors.append(error_message)
+
+                                        # Log failure metric
+                                        log_counter(
+                                            metric_name="videos_failed_total",
+                                            labels={"whisper_model": whisper_model, "api_name": api_name},
+                                            value=1
+                                        )
+
                                     else:
                                         batch_results.append(
                                             (input_item, transcription, "Success", result_metadata, json_file,
                                              summary_file))
 
+                                        # Log success metric
+                                        log_counter(
+                                            metric_name="videos_processed_total",
+                                            labels={"whisper_model": whisper_model, "api_name": api_name},
+                                            value=1
+                                        )
+
+                                        # Calculate processing time
+                                        video_end_time = datetime.utcnow()
+                                        processing_time = (video_end_time - video_start_time).total_seconds()
+                                        log_histogram(
+                                            metric_name="video_processing_time_seconds",
+                                            value=processing_time,
+                                            labels={"whisper_model": whisper_model, "api_name": api_name}
+                                        )
+
+                                        # Log transcription and summary metrics
+                                        if transcription:
+                                            log_counter(
+                                                metric_name="transcriptions_generated_total",
+                                                labels={"whisper_model": whisper_model},
+                                                value=1
+                                            )
+                                        if summary:
+                                            log_counter(
+                                                metric_name="summaries_generated_total",
+                                                labels={"whisper_model": whisper_model},
+                                                value=1
+                                            )
 
                             except Exception as e:
+                                # Log failure
+                                log_counter(
+                                    metric_name="videos_failed_total",
+                                    labels={"whisper_model": whisper_model, "api_name": api_name},
+                                    value=1
+                                )
                                 error_message = f"Error processing {input_item}: {str(e)}"
                                 logging.error(error_message, exc_info=True)
                                 batch_results.append((input_item, error_message, "Error", {}, None, None))
@@ -409,6 +471,16 @@ def create_video_transcription_tab():
                     error_summary = "\n".join(errors) if errors else "No errors occurred."
 
                     total_inputs = len(all_inputs)
+
+                    # End overall processing timer
+                    proc_end_time = datetime.utcnow()
+                    total_processing_time = (proc_end_time - proc_start_time).total_seconds()
+                    log_histogram(
+                        metric_name="total_processing_time_seconds",
+                        value=total_processing_time,
+                        labels={"whisper_model": whisper_model, "api_name": api_name}
+                    )
+
                     return (
                         f"Processed {total_inputs} videos. {len(errors)} errors occurred.",
                         error_summary,
@@ -418,6 +490,14 @@ def create_video_transcription_tab():
                     )
                 except Exception as e:
                     logging.error(f"Unexpected error in process_videos_with_error_handling: {str(e)}", exc_info=True)
+
+                    # Log unexpected failure metric
+                    log_counter(
+                        metric_name="videos_failed_total",
+                        labels={"whisper_model": whisper_model, "api_name": api_name},
+                        value=1
+                    )
+
                     return (
                         f"An unexpected error occurred: {str(e)}",
                         str(e),