Update evaluate.py

evaluate.py

@@ -31,62 +31,181 @@ def calculate_similarity(text1, text2):
     matcher = SequenceMatcher(None, clean1, clean2)
     return matcher.ratio() * 100
 
-# In evaluate.py, modify the init_reference_audio function
+def setup_reference_patterns(reference_dir, sample_rate=16000):
+    """Create standard reference pattern directories and dummy files if needed"""
+    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"
+    ]
+    
+    created_dirs = 0
+    created_files = 0
+    
+    for pattern in reference_patterns:
+        pattern_dir = os.path.join(reference_dir, pattern)
+        if not os.path.exists(pattern_dir):
+            try:
+                os.makedirs(pattern_dir, exist_ok=True)
+                logger.info(f"📁 Created reference pattern directory: {pattern_dir}")
+                created_dirs += 1
+            except Exception as e:
+                logger.error(f"❌ Failed to create reference pattern directory {pattern_dir}: {str(e)}")
+                continue
+        
+        # Check if directory has any WAV files, add a dummy if not
+        wav_files = glob.glob(os.path.join(pattern_dir, "*.wav"))
+        if not wav_files:
+            try:
+                dummy_path = os.path.join(pattern_dir, "dummy_reference.wav")
+                # Create a 1-second silent audio file - not completely silent to avoid transcription issues
+                # Adding a small amount of noise helps ASR models detect something
+                silent = AudioSegment.silent(duration=1000, frame_rate=sample_rate)
+                # Add a tiny bit of noise
+                for i in range(50, 950, 300):
+                    silent = silent.overlay(AudioSegment.silent(duration=50, frame_rate=sample_rate) + 3, position=i)
+                silent.export(dummy_path, format="wav")
+                logger.info(f"📄 Created dummy reference file: {dummy_path}")
+                created_files += 1
+            except Exception as e:
+                logger.error(f"❌ Failed to create dummy file in {pattern_dir}: {str(e)}")
+    
+    return created_dirs, created_files
+
+def search_reference_directories():
+    """Search for possible reference directories in various locations"""
+    possible_locations = [
+        "./reference_audios",
+        "../reference_audios",
+        "/app/reference_audios",
+        "/tmp/reference_audios",
+        os.path.join(os.path.dirname(os.path.abspath(__file__)), "reference_audios")
+    ]
+    
+    found_dirs = []
+    for location in possible_locations:
+        if os.path.exists(location) and os.path.isdir(location):
+            access_info = {
+                "readable": os.access(location, os.R_OK),
+                "writable": os.access(location, os.W_OK),
+                "executable": os.access(location, os.X_OK)
+            }
+            
+            # Count pattern directories
+            pattern_dirs = [d for d in os.listdir(location) 
+                          if os.path.isdir(os.path.join(location, d))]
+            
+            # Count total wav files
+            wav_count = 0
+            for pattern in pattern_dirs:
+                pattern_path = os.path.join(location, pattern)
+                wav_count += len(glob.glob(os.path.join(pattern_path, "*.wav")))
+            
+            found_dirs.append({
+                "path": location,
+                "access": access_info,
+                "pattern_dirs": len(pattern_dirs),
+                "wav_files": wav_count
+            })
+    
+    return found_dirs
 
 def init_reference_audio(reference_dir, output_dir):
+    """Initialize reference audio directories and return the working directory path"""
     try:
         # Create the output directory first
         os.makedirs(output_dir, exist_ok=True)
         logger.info(f"📁 Created output directory: {output_dir}")
 
-        # Check if the reference audio directory exists
-        if not os.path.exists(reference_dir) or not os.access(os.path.dirname(reference_dir), os.W_OK):
-            # Use a directory in /tmp instead
-            reference_dir = os.path.join('/tmp', 'reference_audios')
-            logger.warning(f"⚠️ Using alternate reference directory: {reference_dir}")
-            
-        # Make sure the reference directory exists
-        os.makedirs(reference_dir, exist_ok=True)
-        logger.info(f"📁 Created/verified reference audio directory: {reference_dir}")
+        # Search for existing reference directories
+        found_dirs = search_reference_directories()
+        for directory in found_dirs:
+            logger.info(f"🔍 Found reference directory: {directory['path']} "
+                      f"(patterns: {directory['pattern_dirs']}, wav files: {directory['wav_files']})")
+        
+        # First, try to use the provided reference_dir
+        working_dir = reference_dir
         
-        # Create all the pattern subdirectories
-        setup_reference_patterns(reference_dir)
+        # Check if reference_dir is accessible and writable
+        if not os.path.exists(reference_dir) or not os.access(reference_dir, os.W_OK):
+            logger.warning(f"⚠️ Provided reference directory {reference_dir} is not writable")
             
-        # Try to copy any existing reference files if they exist in the original location
-        original_ref_dir = "./reference_audios"
-        if os.path.exists(original_ref_dir) and reference_dir != original_ref_dir:
-            try:
-                import shutil
-                # Get all pattern directories
-                for item in os.listdir(original_ref_dir):
-                    src_path = os.path.join(original_ref_dir, item)
-                    dst_path = os.path.join(reference_dir, item)
-                    
-                    if os.path.isdir(src_path):
-                        # Copy directory and contents
-                        if not os.path.exists(dst_path):
-                            shutil.copytree(src_path, dst_path)
-                            logger.info(f"📁 Copied reference pattern from {src_path} to {dst_path}")
-            except Exception as e:
-                logger.warning(f"⚠️ Could not copy original reference files: {str(e)}")
+            # Try to use a found directory that has patterns and is writable
+            for directory in found_dirs:
+                if directory['access']['writable'] and directory['pattern_dirs'] > 0:
+                    working_dir = directory['path']
+                    logger.info(f"✅ Using found reference directory: {working_dir}")
+                    break
+            else:
+                # If no suitable directory found, create one in /tmp
+                working_dir = os.path.join('/tmp', 'reference_audios')
+                logger.warning(f"⚠️ Using fallback reference directory in /tmp: {working_dir}")
+        
+        # Ensure the working directory exists
+        os.makedirs(working_dir, exist_ok=True)
+        logger.info(f"📁 Using reference directory: {working_dir}")
+        
+        # Set up reference pattern directories with dummy files if needed
+        dirs_created, files_created = setup_reference_patterns(working_dir)
+        logger.info(f"📊 Created {dirs_created} directories and {files_created} dummy files")
+        
+        # Try to copy reference files from other found directories to working directory if needed
+        if files_created > 0 and len(found_dirs) > 1:
+            # Try to find a directory with existing WAV files
+            for directory in found_dirs:
+                if directory['path'] != working_dir and directory['wav_files'] > 0:
+                    try:
+                        source_dir = directory['path']
+                        logger.info(f"🔄 Copying reference files from {source_dir} to {working_dir}")
+                        
+                        # Copy pattern directories that have WAV files
+                        for item in os.listdir(source_dir):
+                            src_path = os.path.join(source_dir, item)
+                            if os.path.isdir(src_path) and glob.glob(os.path.join(src_path, "*.wav")):
+                                dst_path = os.path.join(working_dir, item)
+                                
+                                # Copy each WAV file individually
+                                for wav_file in glob.glob(os.path.join(src_path, "*.wav")):
+                                    wav_name = os.path.basename(wav_file)
+                                    dst_file = os.path.join(dst_path, wav_name)
+                                    if not os.path.exists(dst_file):
+                                        shutil.copy2(wav_file, dst_file)
+                                        logger.info(f"📄 Copied {wav_name} to {dst_path}")
+                        
+                        break
+                    except Exception as e:
+                        logger.warning(f"⚠️ Failed to copy reference files: {str(e)}")
+        
+        # Log the final contents
+        pattern_dirs = [d for d in os.listdir(working_dir)
+                       if os.path.isdir(os.path.join(working_dir, d))]
+        logger.info(f"📊 Final reference directory has {len(pattern_dirs)} pattern directories")
+        
+        total_wav_files = 0
+        for pattern in pattern_dirs:
+            pattern_path = os.path.join(working_dir, pattern)
+            wav_files = glob.glob(os.path.join(pattern_path, "*.wav"))
+            total_wav_files += len(wav_files)
+            logger.info(f"  - {pattern}: {len(wav_files)} WAV files")
+        
+        logger.info(f"📊 Total reference WAV files: {total_wav_files}")
         
-        # Log the contents to verify
-        if os.path.exists(reference_dir):
-            pattern_dirs = [d for d in os.listdir(reference_dir)
-                           if os.path.isdir(os.path.join(reference_dir, d))]
-            logger.info(f"📁 Found reference patterns: {pattern_dirs}")
-
-            # Check each pattern directory for wav files
-            for pattern_dir_name in pattern_dirs:
-                pattern_path = os.path.join(reference_dir, pattern_dir_name)
-                wav_files = glob.glob(os.path.join(pattern_path, "*.wav"))
-                logger.info(f"📁 Found {len(wav_files)} wav files in {pattern_dir_name}")
-                
-        return reference_dir
+        return working_dir
             
     except Exception as e:
         logger.error(f"❌ Failed to set up reference audio directory: {str(e)}")
-        return reference_dir
+        logger.debug(f"Stack trace: {traceback.format_exc()}")
+        
+        # As a last resort, try to use /tmp
+        fallback_dir = os.path.join('/tmp', 'reference_audios')
+        try:
+            os.makedirs(fallback_dir, exist_ok=True)
+            setup_reference_patterns(fallback_dir)
+            logger.warning(f"⚠️ Using emergency fallback directory: {fallback_dir}")
+            return fallback_dir
+        except:
+            logger.critical("💥 CRITICAL: Failed to create even a fallback directory")
+            return reference_dir
 
 def handle_upload_reference(request, reference_dir, sample_rate):
     """Handle upload of reference audio files"""
@@ -111,38 +230,54 @@ def handle_upload_reference(request, reference_dir, sample_rate):
             logger.warning(f"⚠️ Invalid reference word: {reference_word}")
             return jsonify({"error": f"Invalid reference word. Available: {reference_patterns}"}), 400
 
+        # Make sure we have a writable reference directory
+        if not os.path.exists(reference_dir):
+            reference_dir = os.path.join('/tmp', 'reference_audios')
+            os.makedirs(reference_dir, exist_ok=True)
+            logger.warning(f"⚠️ Using alternate reference directory for upload: {reference_dir}")
+
         # Create directory for reference pattern if it doesn't exist
         pattern_dir = os.path.join(reference_dir, reference_word)
         os.makedirs(pattern_dir, exist_ok=True)
 
         # Save the reference audio file
         audio_file = request.files["audio"]
-        file_path = os.path.join(pattern_dir, secure_filename(audio_file.filename))
-        audio_file.save(file_path)
-
-        # Convert to WAV if not already in that format
-        if not file_path.lower().endswith('.wav'):
-            base_path = os.path.splitext(file_path)[0]
-            wav_path = f"{base_path}.wav"
+        filename = secure_filename(audio_file.filename)
+        
+        # Ensure filename has .wav extension
+        if not filename.lower().endswith('.wav'):
+            base_name = os.path.splitext(filename)[0]
+            filename = f"{base_name}.wav"
+            
+        file_path = os.path.join(pattern_dir, filename)
+        
+        # Create a temporary file first, then convert to WAV
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            audio_file.save(temp_file.name)
+            temp_path = temp_file.name
+        
+        try:
+            # Process the audio file
+            audio = AudioSegment.from_file(temp_path)
+            audio = audio.set_frame_rate(sample_rate).set_channels(1)
+            audio.export(file_path, format="wav")
+            logger.info(f"✅ Reference audio saved successfully for {reference_word}: {file_path}")
+            
+            # Clean up temp file
             try:
-                audio = AudioSegment.from_file(file_path)
-                audio = audio.set_frame_rate(sample_rate).set_channels(1)
-                audio.export(wav_path, format="wav")
-                # Remove original file if conversion successful
-                os.unlink(file_path)
-                file_path = wav_path
-            except Exception as e:
-                logger.error(f"❌ Reference audio conversion failed: {str(e)}")
-                return jsonify({"error": f"Audio conversion failed: {str(e)}"}), 500
-
-        logger.info(f"✅ Reference audio saved successfully for {reference_word}: {file_path}")
+                os.unlink(temp_path)
+            except:
+                pass
+        except Exception as e:
+            logger.error(f"❌ Reference audio processing failed: {str(e)}")
+            return jsonify({"error": f"Audio processing failed: {str(e)}"}), 500
 
         # Count how many references we have now
         references = glob.glob(os.path.join(pattern_dir, "*.wav"))
         return jsonify({
             "message": "Reference audio uploaded successfully",
             "reference_word": reference_word,
-            "file": os.path.basename(file_path),
+            "file": filename,
             "total_references": len(references)
         })
 
@@ -151,8 +286,8 @@ def handle_upload_reference(request, reference_dir, sample_rate):
         logger.debug(f"Stack trace: {traceback.format_exc()}")
         return jsonify({"error": f"Internal server error: {str(e)}"}), 500
 
-
 def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
+    """Handle pronunciation evaluation requests"""
     request_id = f"req-{id(request)}"  # Create unique ID for this request
     logger.info(f"[{request_id}] 🆕 Starting new pronunciation evaluation request")
     
@@ -184,24 +319,33 @@ def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
         reference_dir_path = os.path.join(reference_dir, reference_locator)
         logger.info(f"[{request_id}] 📁 Reference directory path: {reference_dir_path}")
 
-        if not os.path.exists(reference_dir_path):
-            logger.warning(f"[{request_id}] ⚠️ Reference directory not found: {reference_dir_path}")
-            return jsonify({"error": f"Reference audio directory not found: {reference_locator}"}), 404
-
+        # Make sure the reference directory exists
+            if not os.path.exists(reference_dir_path):
+                try:
+                    os.makedirs(reference_dir_path, exist_ok=True)
+                    logger.warning(f"[{request_id}] ⚠️ Created missing reference directory: {reference_dir_path}")
+                except Exception as e:
+                    logger.error(f"[{request_id}] ❌ Failed to create reference directory: {str(e)}")
+                    return jsonify({"error": f"Reference audio directory not found: {reference_locator}"}), 404
+
+        # Check for reference files
         reference_files = glob.glob(os.path.join(reference_dir_path, "*.wav"))
         logger.info(f"[{request_id}] 📁 Found {len(reference_files)} reference files")
 
-        # Inside handle_evaluation_request, after checking for reference files:
+        # If no reference files exist, create a dummy reference file
         if not reference_files:
             logger.warning(f"[{request_id}] ⚠️ No reference audio files found in {reference_dir_path}")
     
-            # Create a dummy reference file for testing
+            # Create a dummy reference file
             try:
                 dummy_file_path = os.path.join(reference_dir_path, "dummy_reference.wav")
                 logger.info(f"[{request_id}] 🔄 Creating dummy reference file: {dummy_file_path}")
         
-                # Create a 1-second silent WAV file
+                # Create a 1-second audio file with a slight sound
                 silent_audio = AudioSegment.silent(duration=1000, frame_rate=sample_rate)
+                # Add a tiny bit of noise to help ASR
+                for i in range(50, 950, 300):
+                    silent_audio = silent_audio.overlay(AudioSegment.silent(duration=50, frame_rate=sample_rate) + 3, position=i)
                 silent_audio.export(dummy_file_path, format="wav")
         
                 # Add it to the list of reference files
@@ -212,8 +356,7 @@ def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
                 return jsonify({"error": f"No reference audio found for {reference_locator}"}), 404
 
         lang_code = LANGUAGE_CODES.get(language, language)
-        logger.info(
-            f"[{request_id}] 🔄 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}")
@@ -244,11 +387,11 @@ def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
         # Transcribe user audio
         try:
             logger.info(f"[{request_id}] 🔄 Transcribing user audio")
+            # Remove language parameter if causing warnings
             inputs = asr_processor(
                 user_waveform,
                 sampling_rate=sample_rate,
-                return_tensors="pt",
-                language=lang_code
+                return_tensors="pt"
             )
             inputs = {k: v.to(asr_model.device) for k, v in inputs.items()}
 
@@ -286,15 +429,14 @@ def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
                 ref_waveform = ref_waveform.squeeze().numpy()
         
                 # Transcribe reference audio - use the local asr_model and asr_processor
+                # Remove language parameter if causing warnings
                 inputs = asr_processor(
                     ref_waveform,
                     sampling_rate=sample_rate,
-                    return_tensors="pt",
-                    language=lang_code
+                    return_tensors="pt"
                 )
                 inputs = {k: v.to(asr_model.device) for k, v in inputs.items()}
 
-
                 with torch.no_grad():
                     logits = asr_model(**inputs).logits
                 ids = torch.argmax(logits, dim=-1)[0]
@@ -387,21 +529,4 @@ def handle_evaluation_request(request, reference_dir, output_dir, sample_rate):
         except:
             pass
 
-        return jsonify({"error": f"Internal server error: {str(e)}"}), 500
-
-def setup_reference_patterns(reference_dir):
-    """Create standard reference pattern directories if they don't exist"""
-    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"
-    ]
-    
-    for pattern in reference_patterns:
-        pattern_dir = os.path.join(reference_dir, pattern)
-        if not os.path.exists(pattern_dir):
-            try:
-                os.makedirs(pattern_dir, exist_ok=True)
-                logger.info(f"📁 Created reference pattern directory: {pattern_dir}")
-            except Exception as e:
-                logger.error(f"❌ Failed to create reference pattern directory {pattern_dir}: {str(e)}")
+        return jsonify({"error": f"Internal server error: {str(e)}"}), 500