Update app.py

app.py

@@ -557,16 +557,18 @@ def calculate_similarity(text1, text2):
     matcher = SequenceMatcher(None, clean1, clean2)
     return matcher.ratio() * 100
 
-
 @app.route("/evaluate", methods=["POST"])
 def evaluate_pronunciation():
+    request_id = f"req-{id(request)}"  # Create unique ID for this request
+    logger.info(f"[{request_id}] 🆕 Starting new pronunciation evaluation request")
+    
     if asr_model is None or asr_processor is None:
-        logger.error("❌ Evaluation endpoint called but ASR models aren't loaded")
+        logger.error(f"[{request_id}] ❌ Evaluation endpoint called but ASR models aren't loaded")
         return jsonify({"error": "ASR model not available"}), 503
 
     try:
         if "audio" not in request.files:
-            logger.warning("⚠️ Evaluation request missing audio file")
+            logger.warning(f"[{request_id}] ⚠️ Evaluation request missing audio file")
             return jsonify({"error": "No audio file uploaded"}), 400
 
         audio_file = request.files["audio"]
@@ -575,64 +577,70 @@ def evaluate_pronunciation():
 
         # Validate reference locator
         if not reference_locator:
-            logger.warning("⚠️ No reference locator provided")
+            logger.warning(f"[{request_id}] ⚠️ No reference locator provided")
             return jsonify({"error": "Reference locator is required"}), 400
 
         # Construct full reference directory path
         reference_dir = os.path.join(REFERENCE_AUDIO_DIR, reference_locator)
-        logger.info(f"📁 Reference directory path: {reference_dir}")
+        logger.info(f"[{request_id}] 📁 Reference directory path: {reference_dir}")
 
         if not os.path.exists(reference_dir):
-            logger.warning(f"⚠️ Reference directory not found: {reference_dir}")
+            logger.warning(f"[{request_id}] ⚠️ Reference directory not found: {reference_dir}")
             return jsonify({"error": f"Reference audio directory not found: {reference_locator}"}), 404
 
         reference_files = glob.glob(os.path.join(reference_dir, "*.wav"))
-        logger.info(f"📁 Reference files found: {len(reference_files)}")
+        logger.info(f"[{request_id}] 📁 Found {len(reference_files)} reference files")
 
         if not reference_files:
-            logger.warning(f"⚠️ No reference audio files found in {reference_dir}")
+            logger.warning(f"[{request_id}] ⚠️ No reference audio files found in {reference_dir}")
             return jsonify({"error": f"No reference audio found for {reference_locator}"}), 404
 
-        # Log actual file paths for debugging
-        for ref_file in reference_files:
-            logger.debug(f"📁 Reference file: {ref_file}")
-
         lang_code = LANGUAGE_CODES.get(language, language)
-        logger.info(f"🔄 Evaluating pronunciation for reference: {reference_locator} with language code: {lang_code}")
+        logger.info(f"[{request_id}] 🔄 Evaluating pronunciation for reference: {reference_locator} with language code: {lang_code}")
 
+        # Create a request-specific temp directory to avoid conflicts
+        temp_dir = os.path.join(OUTPUT_DIR, f"temp_{request_id}")
+        os.makedirs(temp_dir, exist_ok=True)
+        
         # Save the uploaded file temporarily
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
-            temp_audio.write(audio_file.read())
-            user_audio_path = temp_audio.name
-            logger.debug(f"📁 User audio saved to {user_audio_path}")
+        user_audio_path = os.path.join(temp_dir, "user_audio_input.wav")
+        with open(user_audio_path, 'wb') as f:
+            f.write(audio_file.read())
+        logger.debug(f"[{request_id}] 📁 User audio saved to {user_audio_path}")
 
         # Convert to WAV if necessary and ensure correct format
         try:
-            logger.info(f"🔄 Processing user audio file")
+            logger.info(f"[{request_id}] 🔄 Processing user audio file")
             # First try using pydub for consistent processing
             audio = AudioSegment.from_file(user_audio_path)
             audio = audio.set_frame_rate(SAMPLE_RATE).set_channels(1)
 
             # Save processed audio
-            processed_path = os.path.join(OUTPUT_DIR, "processed_user_audio.wav")
+            processed_path = os.path.join(temp_dir, "processed_user_audio.wav")
             audio.export(processed_path, format="wav")
-            logger.debug(f"📁 Processed user audio saved to {processed_path}")
+            logger.debug(f"[{request_id}] 📁 Processed user audio saved to {processed_path}")
 
             # Load the processed audio for ASR
             user_waveform, sr = torchaudio.load(processed_path)
             user_waveform = user_waveform.squeeze().numpy()
-            logger.info(f"✅ User audio processed successfully: {sr}Hz, length: {len(user_waveform)} samples")
+            logger.info(f"[{request_id}] ✅ User audio processed successfully: {sr}Hz, length: {len(user_waveform)} samples")
 
             # Update user_audio_path to processed file
             user_audio_path = processed_path
         except Exception as e:
-            logger.error(f"❌ Audio processing failed: {str(e)}")
-            logger.debug(f"Stack trace: {traceback.format_exc()}")
+            logger.error(f"[{request_id}] ❌ Audio processing failed: {str(e)}")
+            logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
+            # Clean up temp directory
+            try:
+                import shutil
+                shutil.rmtree(temp_dir)
+            except:
+                pass
             return jsonify({"error": f"Audio processing failed: {str(e)}"}), 500
 
         # Transcribe user audio
         try:
-            logger.info(f"🔄 Transcribing user audio")
+            logger.info(f"[{request_id}] 🔄 Transcribing user audio")
             # Process audio for ASR
             inputs = asr_processor(
                 user_waveform,
@@ -648,9 +656,15 @@ def evaluate_pronunciation():
             ids = torch.argmax(logits, dim=-1)[0]
             user_transcription = asr_processor.decode(ids)
 
-            logger.info(f"✅ User transcription: '{user_transcription}'")
+            logger.info(f"[{request_id}] ✅ User transcription: '{user_transcription}'")
         except Exception as e:
-            logger.error(f"❌ ASR inference failed: {str(e)}")
+            logger.error(f"[{request_id}] ❌ ASR inference failed: {str(e)}")
+            # Clean up temp directory
+            try:
+                import shutil
+                shutil.rmtree(temp_dir)
+            except:
+                pass
             return jsonify({"error": f"ASR inference failed: {str(e)}"}), 500
 
         # Compare with reference audios
@@ -659,22 +673,23 @@ def evaluate_pronunciation():
         best_reference = None
         best_transcription = None
 
-        logger.info(f"🔄 Beginning comparison with {len(reference_files)} reference files")
+        logger.info(f"[{request_id}] 🔄 Beginning comparison with {len(reference_files)} reference files")
 
-        for ref_file in reference_files:
+        for ref_idx, ref_file in enumerate(reference_files):
             try:
-                logger.info(f"🔄 Processing reference file: {os.path.basename(ref_file)}")
+                ref_filename = os.path.basename(ref_file)
+                logger.info(f"[{request_id}] 🔄 [{ref_idx+1}/{len(reference_files)}] Processing reference file: {ref_filename}")
 
                 # Load reference audio using torchaudio instead of librosa
                 ref_waveform, ref_sr = torchaudio.load(ref_file)
                 if ref_sr != SAMPLE_RATE:
-                    logger.debug(f"🔄 Resampling reference audio from {ref_sr}Hz to {SAMPLE_RATE}Hz")
+                    logger.debug(f"[{request_id}] 🔄 Resampling reference audio from {ref_sr}Hz to {SAMPLE_RATE}Hz")
                     ref_waveform = torchaudio.transforms.Resample(ref_sr, SAMPLE_RATE)(ref_waveform)
                 ref_waveform = ref_waveform.squeeze().numpy()
-                logger.debug(f"✅ Reference audio loaded: {len(ref_waveform)} samples")
+                logger.debug(f"[{request_id}] ✅ Reference audio loaded: {len(ref_waveform)} samples")
 
                 # Transcribe reference audio
-                logger.debug(f"🔄 Transcribing reference audio")
+                logger.debug(f"[{request_id}] 🔄 Transcribing reference audio: {ref_filename}")
                 inputs = asr_processor(
                     ref_waveform,
                     sampling_rate=SAMPLE_RATE,
@@ -687,40 +702,40 @@ def evaluate_pronunciation():
                     logits = asr_model(**inputs).logits
                 ids = torch.argmax(logits, dim=-1)[0]
                 ref_transcription = asr_processor.decode(ids)
-                logger.info(f"✅ Reference transcription: '{ref_transcription}'")
+                logger.info(f"[{request_id}] ✅ Reference transcription for {ref_filename}: '{ref_transcription}'")
 
                 # Calculate similarity
                 similarity = calculate_similarity(user_transcription, ref_transcription)
-                logger.info(f"📊 Similarity with {os.path.basename(ref_file)}: {similarity:.2f}%")
+                logger.info(f"[{request_id}] 📊 Similarity with {ref_filename}: {similarity:.2f}%")
 
                 results.append({
-                    "reference_file": os.path.basename(ref_file),
+                    "reference_file": ref_filename,
                     "reference_text": ref_transcription,
                     "similarity_score": similarity
                 })
 
                 if similarity > best_score:
                     best_score = similarity
-                    best_reference = os.path.basename(ref_file)
+                    best_reference = ref_filename
                     best_transcription = ref_transcription
-                    logger.info(f"📊 New best match: {best_reference} with score {best_score:.2f}%")
+                    logger.info(f"[{request_id}] 📊 New best match: {best_reference} with score {best_score:.2f}%")
 
                     # Add this early exit condition here
                     if similarity > 80.0:  # If we find a really good match
-                        logger.info(f"🏁 Found excellent match (>80%). Stopping evaluation early.")
+                        logger.info(f"[{request_id}] 🏁 Found excellent match (>80%). Stopping evaluation early.")
                         break  # Exit the loop early
                     
             except Exception as e:
-                logger.error(f"❌ Error processing reference audio {ref_file}: {str(e)}")
-                logger.debug(f"Stack trace: {traceback.format_exc()}")
+                logger.error(f"[{request_id}] ❌ Error processing reference audio {ref_file}: {str(e)}")
+                logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
 
         # Clean up temp files
         try:
-            if os.path.exists(user_audio_path) and user_audio_path != processed_path:
-                os.unlink(user_audio_path)
-                logger.debug(f"🧹 Cleaned up temporary file: {user_audio_path}")
+            import shutil
+            shutil.rmtree(temp_dir)
+            logger.debug(f"[{request_id}] 🧹 Cleaned up temporary directory: {temp_dir}")
         except Exception as e:
-            logger.warning(f"⚠️ Failed to clean up temp files: {str(e)}")
+            logger.warning(f"[{request_id}] ⚠️ Failed to clean up temp files: {str(e)}")
 
         # Enhanced feedback based on score range
         is_correct = best_score >= 70.0
@@ -737,8 +752,9 @@ def evaluate_pronunciation():
         else:
             feedback = "Try again. Listen carefully to the sample pronunciation."
 
-        logger.info(f"📊 Final evaluation results: score={best_score:.2f}%, is_correct={is_correct}")
-        logger.info(f"📝 Feedback: '{feedback}'")
+        logger.info(f"[{request_id}] 📊 Final evaluation results: score={best_score:.2f}%, is_correct={is_correct}")
+        logger.info(f"[{request_id}] 📝 Feedback: '{feedback}'")
+        logger.info(f"[{request_id}] ✅ Evaluation complete")
 
         # Sort results by score descending
         results.sort(key=lambda x: x["similarity_score"], reverse=True)
@@ -754,8 +770,8 @@ def evaluate_pronunciation():
         })
 
     except Exception as e:
-        logger.error(f"❌ Unhandled exception in evaluation endpoint: {str(e)}")
-        logger.debug(f"Stack trace: {traceback.format_exc()}")
+        logger.error(f"[{request_id}] ❌ Unhandled exception in evaluation endpoint: {str(e)}")
+        logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
         return jsonify({"error": f"Internal server error: {str(e)}"}), 500
 
 @app.route("/upload_reference", methods=["POST"])
@@ -773,11 +789,6 @@ def upload_reference_audio():
         # Validate reference word
         reference_patterns = [
             "mayap_a_abak", "mayap_a_ugtu", "mayap_a_gatpanapun", "mayap_a_bengi", "komusta_ka", "malaus_ko_pu","malaus_kayu","agaganaka_da_ka", "pagdulapan_da_ka","kaluguran_da_ka","dakal_a_salamat","panapaya_mu_ku"
-
-
-
-
-
         ]
 
         if reference_word not in reference_patterns: