Update app.py

app.py

@@ -38,107 +38,128 @@ MODELS = {
 }
 
 def convert_audio_to_wav(audio_path):
-    wav_path = "converted_audio.wav"
-    command = ["ffmpeg", "-i", audio_path, "-ac", "1", "-ar", "16000", wav_path]
-    subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    return wav_path
+    try:
+        wav_path = "converted_audio.wav"
+        command = ["ffmpeg", "-i", audio_path, "-ac", "1", "-ar", "16000", wav_path]
+        subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return wav_path
+    except Exception as e:
+        raise RuntimeError(f"Error converting audio to WAV: {e}")
 
 def detect_language(audio_path):
-    speech, _ = librosa.load(audio_path, sr=16000, duration=30)
-    
-    processor = WhisperProcessor.from_pretrained("openai/whisper-base")
-    model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base")
-    
-    input_features = processor(speech, sampling_rate=16000, return_tensors="pt").input_features
-    predicted_ids = model.generate(input_features)
-    transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-    
-    langs = detect_langs(transcription)
-    
-    es_confidence = next((lang.prob for lang in langs if lang.lang == 'es'), 0)
-    pt_confidence = next((lang.prob for lang in langs if lang.lang == 'pt'), 0)
-    
-    if abs(es_confidence - pt_confidence) < 0.2:
-        return 'es'
-    
-    return max(langs, key=lambda x: x.prob).lang
+    try:
+        speech, _ = librosa.load(audio_path, sr=16000, duration=30)
+        
+        processor = WhisperProcessor.from_pretrained("openai/whisper-base")
+        model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base")
+        
+        input_features = processor(speech, sampling_rate=16000, return_tensors="pt").input_features
+        predicted_ids = model.generate(input_features)
+        transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+        
+        langs = detect_langs(transcription)
+        
+        es_confidence = next((lang.prob for lang in langs if lang.lang == 'es'), 0)
+        pt_confidence = next((lang.prob for lang in langs if lang.lang == 'pt'), 0)
+        
+        if abs(es_confidence - pt_confidence) < 0.2:
+            return 'es'
+        
+        return max(langs, key=lambda x: x.prob).lang
+    except Exception as e:
+        raise RuntimeError(f"Error detecting language: {e}")
 
 def diarize_audio(wav_audio):
-    pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization", use_auth_token=HUGGINGFACE_TOKEN)
-    diarization = pipeline(wav_audio)
-    return diarization
+    try:
+        pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization", use_auth_token=HUGGINGFACE_TOKEN)
+        diarization = pipeline(wav_audio)
+        return diarization
+    except Exception as e:
+        raise RuntimeError(f"Error in diarization: {e}")
 
 def transcribe_audio_stream(audio, model_name):
-    wav_audio = convert_audio_to_wav(audio)
-    speech, rate = librosa.load(wav_audio, sr=16000)
-    duration = len(speech) / rate
-    
-    transcriptions = []
-    
-    if "whisper" in model_name:
-        processor = WhisperProcessor.from_pretrained(model_name)
-        model = WhisperForConditionalGeneration.from_pretrained(model_name)
+    try:
+        wav_audio = convert_audio_to_wav(audio)
+        speech, rate = librosa.load(wav_audio, sr=16000)
+        duration = len(speech) / rate
         
-        chunk_duration = 30  # seconds
+        transcriptions = []
         
-        for i in range(0, int(duration), chunk_duration):
-            end = min(i + chunk_duration, duration)
-            chunk = speech[int(i * rate):int(end * rate)]
+        if "whisper" in model_name:
+            processor = WhisperProcessor.from_pretrained(model_name)
+            model = WhisperForConditionalGeneration.from_pretrained(model_name)
             
-            input_features = processor(chunk, sampling_rate=16000, return_tensors="pt").input_features
-            predicted_ids = model.generate(input_features)
-            transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+            chunk_duration = 30  # seconds
             
-            progress = min(100, (end / duration) * 100)
-            timestamp = i
-            transcriptions.append((timestamp, transcription, progress))
-            yield transcriptions, progress
-    else:
-        transcriber = pipeline("automatic-speech-recognition", model=model_name)
-        
-        chunk_duration = 10  # seconds
-        
-        for i in range(0, int(duration), chunk_duration):
-            end = min(i + chunk_duration, duration)
-            chunk = speech[int(i * rate):int(end * rate)]
-            result = transcriber(chunk)
+            for i in range(0, int(duration), chunk_duration):
+                end = min(i + chunk_duration, duration)
+                chunk = speech[int(i * rate):int(end * rate)]
+                
+                input_features = processor(chunk, sampling_rate=16000, return_tensors="pt").input_features
+                predicted_ids = model.generate(input_features)
+                transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
+                
+                progress = min(100, (end / duration) * 100)
+                timestamp = i
+                transcriptions.append((timestamp, transcription, progress))
+                yield transcriptions, progress
+        else:
+            transcriber = pipeline("automatic-speech-recognition", model=model_name)
             
-            progress = min(100, (end / duration) * 100)
-            timestamp = i
-            transcriptions.append((timestamp, result["text"], progress))
-            yield transcriptions, progress
+            chunk_duration = 10  # seconds
+            
+            for i in range(0, int(duration), chunk_duration):
+                end = min(i + chunk_duration, duration)
+                chunk = speech[int(i * rate):int(end * rate)]
+                result = transcriber(chunk)
+                
+                progress = min(100, (end / duration) * 100)
+                timestamp = i
+                transcriptions.append((timestamp, result["text"], progress))
+                yield transcriptions, progress
+    except Exception as e:
+        raise RuntimeError(f"Error in transcription: {e}")
 
 def merge_diarization_with_transcription(transcriptions, diarization, rate):
-    speaker_transcriptions = []
-    for segment in diarization.itertracks(yield_label=True):
-        start, end, speaker = segment
-        start_time = start / rate
-        end_time = end / rate
-        text_segment = ""
-        for ts, text, _ in transcriptions:
-            if start_time <= ts <= end_time:
-                text_segment += text + " "
-        speaker_transcriptions.append((start_time, end_time, speaker, text_segment.strip()))
-    return speaker_transcriptions
+    try:
+        speaker_transcriptions = []
+        for segment in diarization.itertracks(yield_label=True):
+            start, end, speaker = segment
+            start_time = start / rate
+            end_time = end / rate
+            text_segment = ""
+            for ts, text, _ in transcriptions:
+                if start_time <= ts <= end_time:
+                    text_segment += text + " "
+            speaker_transcriptions.append((start_time, end_time, speaker, text_segment.strip()))
+        return speaker_transcriptions
+    except Exception as e:
+        raise RuntimeError(f"Error merging diarization with transcription: {e}")
 
 def detect_and_select_model(audio):
-    wav_audio = convert_audio_to_wav(audio)
-    language = detect_language(wav_audio)
-    model_options = MODELS.get(language, MODELS["en"])
-    return language, model_options
+    try:
+        wav_audio = convert_audio_to_wav(audio)
+        language = detect_language(wav_audio)
+        model_options = MODELS.get(language, MODELS["en"])
+        return language, model_options
+    except Exception as e:
+        raise RuntimeError(f"Error detecting and selecting model: {e}")
 
 def save_transcription(transcriptions, file_format):
-    if file_format == "txt":
-        file_path = "/tmp/transcription.txt"
-        with open(file_path, "w") as f:
-            for start, end, speaker, text in transcriptions:
-                f.write(f"[{start:.2f}-{end:.2f}] {speaker}: {text}\n")
-        return file_path
-    elif file_format == "json":
-        file_path = "/tmp/transcription.json"
-        with open(file_path, "w") as f:
-            json.dump(transcriptions, f)
-        return file_path
+    try:
+        if file_format == "txt":
+            file_path = "/tmp/transcription.txt"
+            with open(file_path, "w") as f:
+                for start, end, speaker, text in transcriptions:
+                    f.write(f"[{start:.2f}-{end:.2f}] {speaker}: {text}\n")
+            return file_path
+        elif file_format == "json":
+            file_path = "/tmp/transcription.json"
+            with open(file_path, "w") as f:
+                json.dump(transcriptions, f)
+            return file_path
+    except Exception as e:
+        raise RuntimeError(f"Error saving transcription: {e}")
 
 def combined_interface(audio):
     try: