Update app.py

app.py

@@ -8,37 +8,38 @@ from dotenv import load_dotenv
 from tempfile import NamedTemporaryFile
 import math
 from docx import Document
+import time
 from transformers import WhisperProcessor, WhisperForConditionalGeneration
 
-# Load environment variables from .env file (if needed)
+# Load environment variables from .env file (if needed for other config)
 load_dotenv()
 
+# Create a placeholder for status messages
+status_placeholder = st.empty()
+
+# Display status while loading the model
+status_placeholder.info("Loading Whisper model from Hugging Face...")
+
 @st.cache_resource
 def load_whisper_model():
     """
     Load the Whisper model and processor from Hugging Face.
-    You can change the model variant ("openai/whisper-base" is used here).
+    Change 'openai/whisper-base' to another variant if needed.
     """
-    model_name = "openai/whisper-base"  # Options: "tiny", "base", "small", "medium", "large"
+    model_name = "openai/whisper-base"
     processor = WhisperProcessor.from_pretrained(model_name)
     model = WhisperForConditionalGeneration.from_pretrained(model_name)
     return processor, model
 
 processor, model = load_whisper_model()
 
+status_placeholder.info("Whisper model loaded successfully!")
+
 def split_audio_on_silence(audio_file_path, min_silence_len=500, silence_thresh=-40, keep_silence=250):
     """
     Split an audio file into chunks using silence detection.
-    
-    Args:
-        audio_file_path (str): Path to the audio file.
-        min_silence_len (int): Minimum length of silence (in ms) required for a split.
-        silence_thresh (int): The volume (in dBFS) below which is considered silence.
-        keep_silence (int): Amount of silence (in ms) to retain at the beginning and end of each chunk.
-    
-    Returns:
-        list: List of AudioSegment chunks.
     """
+    status_placeholder.info("Splitting audio on silence...")
     audio = AudioSegment.from_file(audio_file_path)
     chunks = split_on_silence(
         audio, 
@@ -46,72 +47,66 @@ def split_audio_on_silence(audio_file_path, min_silence_len=500, silence_thresh=
         silence_thresh=silence_thresh,
         keep_silence=keep_silence
     )
+    status_placeholder.info(f"Audio split into {len(chunks)} chunks.")
     return chunks
 
 def transcribe(audio_file):
     """
     Transcribe an audio file using the locally loaded Whisper model from Hugging Face.
-    
-    Args:
-        audio_file (str): Path to the audio file.
-    
-    Returns:
-        str: Transcribed text.
+    This uses librosa to load and resample the audio as required.
     """
-    # Load audio using librosa, resampling to 16000 Hz as required by Whisper
+    # Load audio with librosa at 16kHz (as required by Whisper)
     speech, sr = librosa.load(audio_file, sr=16000)
     input_features = processor(speech, sampling_rate=16000, return_tensors="pt").input_features
-    # Generate transcription
     predicted_ids = model.generate(input_features)
     transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
     return transcription
 
+def transcribe_chunk(chunk, index, min_length_ms=100):
+    """
+    Transcribe an individual audio chunk.
+    """
+    if len(chunk) < min_length_ms:
+        st.warning(f"Chunk {index} is too short to be processed.")
+        return (index, "")
+    # Save chunk temporarily as a WAV file
+    with NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio_file:
+        chunk.export(temp_audio_file.name, format="wav")
+        temp_audio_file_path = temp_audio_file.name
+    status_placeholder.info(f"Transcribing chunk {index}...")
+    transcription = transcribe(temp_audio_file_path)
+    os.remove(temp_audio_file_path)
+    st.write(f"Transcription for chunk {index}: {transcription}")
+    return (index, transcription)
+
 def process_audio_chunks(audio_chunks):
     """
-    Process and transcribe each audio chunk.
-    
-    Args:
-        audio_chunks (list): List of AudioSegment chunks.
-    
-    Returns:
-        str: Combined transcription from all chunks.
+    Process and transcribe each audio chunk in sequence.
+    Reports the total time taken.
     """
     transcriptions = []
-    min_length_ms = 100  # Minimum length required (0.1 seconds)
-    
+    min_length_ms = 100  # minimum duration for processing
+    start_transcription = time.time()
     for i, chunk in enumerate(audio_chunks):
-        if len(chunk) < min_length_ms:
-            st.warning(f"Chunk {i} is too short to be processed.")
-            continue
-        
-        with NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio_file:
-            chunk.export(temp_audio_file.name, format="wav")
-            temp_audio_file_path = temp_audio_file.name
-        
-        transcription = transcribe(temp_audio_file_path)
-        if transcription:
-            transcriptions.append(transcription)
-            st.write(f"Transcription for chunk {i}: {transcription}")
-        
-        os.remove(temp_audio_file_path)
-    return " ".join(transcriptions)
+        index, text = transcribe_chunk(chunk, i, min_length_ms)
+        transcriptions.append((index, text))
+    transcriptions.sort(key=lambda x: x[0])
+    total_time = time.time() - start_transcription
+    status_placeholder.info(f"All chunks transcribed in {total_time:.2f} seconds.")
+    combined = " ".join([text for idx, text in transcriptions])
+    return combined
 
 def save_transcription_to_docx(transcription, audio_file_path):
     """
     Save the transcription as a .docx file.
-    
-    Args:
-        transcription (str): Transcribed text.
-        audio_file_path (str): Path to the original audio file for naming purposes.
-    
-    Returns:
-        str: Path to the saved .docx file.
     """
     base_name = os.path.splitext(os.path.basename(audio_file_path))[0]
     output_file_name = f"{base_name}_full_transcription.docx"
+    status_placeholder.info("Saving transcription to DOCX...")
     doc = Document()
     doc.add_paragraph(transcription)
     doc.save(output_file_name)
+    status_placeholder.info("Transcription saved as DOCX.")
     return output_file_name
 
 st.title("Audio Transcription with Whisper (Local via Hugging Face)")
@@ -131,21 +126,17 @@ if uploaded_file is not None and st.session_state.transcription is None:
     with open(temp_audio_file, "wb") as f:
         f.write(uploaded_file.getbuffer())
     
-    # Split and process audio using silence detection
-    with st.spinner('Transcribing...'):
-        audio_chunks = split_audio_on_silence(
-            temp_audio_file, 
-            min_silence_len=500,
-            silence_thresh=-40,
-            keep_silence=250
-        )
+    processing_start = time.time()
+    with st.spinner('Processing audio...'):
+        audio_chunks = split_audio_on_silence(temp_audio_file)
         transcription = process_audio_chunks(audio_chunks)
         if transcription:
             st.session_state.transcription = transcription
             st.success('Transcription complete!')
             output_docx_file = save_transcription_to_docx(transcription, uploaded_file.name)
             st.session_state.output_docx_file = output_docx_file
-    
+    processing_duration = time.time() - processing_start
+    status_placeholder.info(f"Total processing time: {processing_duration:.2f} seconds.")
     if os.path.exists(temp_audio_file):
         os.remove(temp_audio_file)