Fix: removing the unused legacy methods generate_target_transcript

app.py

@@ -155,7 +155,7 @@ async def analyze_audio(
             except Exception as e:
                 logger.warning(f"Could not clean up {temp_file}: {e}")
 
-@app.get("/")
+@app.get("/api")
 async def root():
     """API documentation"""
     return {

diagnosis/ai_engine/detect_stuttering.py

@@ -670,155 +670,6 @@ class AdvancedStutterDetector:
         }
     
     
-    # Legacy methods - kept for backward compatibility but may not work without additional model initialization
-    # These methods reference models (xlsr, base, large) that are not initialized in __init__
-    # The main analyze_audio() method uses the IndicWav2Vec Hindi model instead
-    
-    def generate_target_transcript(self, audio_file: str) -> str:
-        """Generate expected transcript - Legacy method (uses IndicWav2Vec Hindi model)"""
-        try:
-            audio, sr = librosa.load(audio_file, sr=16000)
-            transcript, _, _ = self._transcribe_with_timestamps(audio)
-            return transcript
-        except Exception as e:
-            logger.error(f"Target transcript generation failed: {e}")
-            return ""
-    
-    def transcribe_and_detect(self, audio_file: str, proper_transcript: str) -> Dict:
-        """Transcribe audio and detect stuttering patterns - Legacy method"""
-        try:
-            audio, _ = librosa.load(audio_file, sr=16000)
-            transcript, _, _ = self._transcribe_with_timestamps(audio)
-            
-            # Find stuttered sequences
-            stuttered_chars = self.find_sequences_not_in_common(transcript, proper_transcript)
-            
-            # Calculate mismatch percentage
-            total_mismatched = sum(len(segment) for segment in stuttered_chars)
-            mismatch_percentage = (total_mismatched / len(proper_transcript)) * 100 if len(proper_transcript) > 0 else 0
-            mismatch_percentage = min(round(mismatch_percentage), 100)
-            
-            return {
-                'transcription': transcript,
-                'stuttered_chars': stuttered_chars,
-                'mismatch_percentage': mismatch_percentage
-            }
-        except Exception as e:
-            logger.error(f"Transcription failed: {e}")
-            return {
-                'transcription': '',
-                'stuttered_chars': [],
-                'mismatch_percentage': 0
-            }
-    
-    def calculate_stutter_timestamps(self, audio_file: str, proper_transcript: str) -> Tuple[float, List[Tuple[float, float]]]:
-        """Calculate stutter timestamps - Legacy method (uses analyze_audio instead)"""
-        try:
-            # Use main analyze_audio method
-            result = self.analyze_audio(audio_file, proper_transcript)
-            
-            # Extract timestamps from result
-            timestamps = []
-            for event in result.get('stutter_timestamps', []):
-                timestamps.append((event['start'], event['end']))
-            
-            ctc_score = result.get('ctc_loss_score', 0.0)
-            return float(ctc_score), timestamps
-        except Exception as e:
-            logger.error(f"Timestamp calculation failed: {e}")
-            return 0.0, []
-    
-    
-    def find_max_common_characters(self, transcription1: str, transcript2: str) -> str:
-        """Longest Common Subsequence algorithm"""
-        m, n = len(transcription1), len(transcript2)
-        lcs_matrix = [[0] * (n + 1) for _ in range(m + 1)]
-        
-        for i in range(1, m + 1):
-            for j in range(1, n + 1):
-                if transcription1[i - 1] == transcript2[j - 1]:
-                    lcs_matrix[i][j] = lcs_matrix[i - 1][j - 1] + 1
-                else:
-                    lcs_matrix[i][j] = max(lcs_matrix[i - 1][j], lcs_matrix[i][j - 1])
-        
-        # Backtrack to find LCS
-        lcs_characters = []
-        i, j = m, n
-        while i > 0 and j > 0:
-            if transcription1[i - 1] == transcript2[j - 1]:
-                lcs_characters.append(transcription1[i - 1])
-                i -= 1
-                j -= 1
-            elif lcs_matrix[i - 1][j] > lcs_matrix[i][j - 1]:
-                i -= 1
-            else:
-                j -= 1
-        
-        lcs_characters.reverse()
-        return ''.join(lcs_characters)
-    
-    
-    def find_sequences_not_in_common(self, transcription1: str, proper_transcript: str) -> List[str]:
-        """Find stuttered character sequences"""
-        common_characters = self.find_max_common_characters(transcription1, proper_transcript)
-        sequences = []
-        sequence = ""
-        i, j = 0, 0
-        
-        while i < len(transcription1) and j < len(common_characters):
-            if transcription1[i] == common_characters[j]:
-                if sequence:
-                    sequences.append(sequence)
-                    sequence = ""
-                i += 1
-                j += 1
-            else:
-                sequence += transcription1[i]
-                i += 1
-        
-        if sequence:
-            sequences.append(sequence)
-        
-        return sequences
-    
-    
-    def _calculate_total_duration(self, timestamps: List[Tuple[float, float]]) -> float:
-        """Calculate total stuttering duration"""
-        return sum(end - start for start, end in timestamps)
-    
-    
-    def _calculate_frequency(self, timestamps: List[Tuple[float, float]], audio_file: str) -> float:
-        """Calculate stutters per minute"""
-        try:
-            audio_duration = librosa.get_duration(path=audio_file)
-            if audio_duration > 0:
-                return (len(timestamps) / audio_duration) * 60
-            return 0.0
-        except:
-            return 0.0
-    
-    
-    def _determine_severity(self, mismatch_percentage: float) -> str:
-        """Determine severity level"""
-        if mismatch_percentage < 10:
-            return 'none'
-        elif mismatch_percentage < 25:
-            return 'mild'
-        elif mismatch_percentage < 50:
-            return 'moderate'
-        else:
-            return 'severe'
-    
-    
-    def _calculate_confidence(self, transcription_result: Dict, ctc_loss: float) -> float:
-        """Calculate confidence score for the analysis"""
-        # Lower mismatch and lower CTC loss = higher confidence
-        mismatch_factor = 1 - (transcription_result['mismatch_percentage'] / 100)
-        loss_factor = max(0, 1 - (ctc_loss / 10))  # Normalize loss
-        confidence = (mismatch_factor + loss_factor) / 2
-        return round(min(max(confidence, 0.0), 1.0), 2)
-
-
-# Model loader is now in a separate module: model_loader.py
-# This follows clean architecture principles - separation of concerns
-# Import using: from diagnosis.ai_engine.model_loader import get_stutter_detector
+    # Model loader is now in a separate module: model_loader.py
+    # This follows clean architecture principles - separation of concerns
+    # Import using: from diagnosis.ai_engine.model_loader import get_stutter_detector