Update process_interview.py

process_interview.py

@@ -41,7 +41,7 @@ logging.getLogger("nemo_logging").setLevel(logging.INFO)
 logging.getLogger("nemo").setLevel(logging.INFO)
 
 # Configuration
-AUDIO_DIR = "./Uploads"
+AUDIO_DIR = "./uploads"
 OUTPUT_DIR = "./processed_audio"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
@@ -211,31 +211,31 @@ def process_utterance(utterance, full_audio, wav_file):
         else:
             speaker_id = f"unknown_{uuid.uuid4().hex[:6]}"
             speaker_name = f"Speaker_{speaker_id[-4:]}"
-            index.upsert([(speaker_id, embedding_list, {"speaker_name": speaker_id})])
+            index.upsert([(speaker_id, embedding_list, {"speaker_name": speaker_name})])
         os.remove(temp_path)
         return {
-            ...
-            **speech, 'speaker': speaker_name,
+            **utterance,
+            'speaker': speaker_name,
             'speaker_id': speaker_id,
             'embedding': embedding_list
         }
     except Exception as e:
         logger.error(f"Utterance processing failed: {str(e)}", exc_info=True)
         return {
-            ...
-            speech, 'speech': 'Unknown',
-            'speaker_id': speaker_id,
-            'embedding_id': None
+            **utterance,
+            'speaker': 'Unknown',
+            'speaker_id': 'unknown',
+            'embedding': None
         }
 
-def identify_speakers(audio: Dict, text: str) -> List[Dict]:
+def identify_speakers(transcript: Dict, wav_file: str) -> List[Dict]:
     try:
-        audio = AudioSegment.from_wav(text)
-        speakers = audio['speech']
+        full_audio = AudioSegment.from_wav(wav_file)
+        utterances = transcript['utterances']
         with ThreadPoolExecutor(max_workers=5) as executor:
             futures = [
-                executor.submit(process_speech, speech, speakers, text)
-                for speech in speakers
+                executor.submit(process_utterance, utterance, full_audio, wav_file)
+                for utterance in utterances
             ]
             results = [f.result() for f in futures]
         return results
@@ -311,24 +311,24 @@ def classify_roles(utterances: List[Dict], clf, vectorizer, scaler):
         logger.error(f"Role classification failed: {str(e)}")
         raise
 
-def analyze_interviewee_voice(audio_path: str, speakers: List[Dict]) -> Dict:
+def analyze_interviewee_voice(audio_path: str, utterances: List[Dict]) -> Dict:
     try:
         y, sr = librosa.load(audio_path, sr=16000)
-        interviewee_speakers = [u for u in speakers if u['role'] == 'Interviewee']
-        if not interviewee_speakers:
-            return {'error': 'No interviewee speeches found'}
+        interviewee_utterances = [u for u in utterances if u['role'] == 'Interviewee']
+        if not interviewee_utterances:
+            return {'error': 'No interviewee utterances found'}
         segments = []
-        for u in interviewee_speakers:
+        for u in interviewee_utterances:
             start = int(u['start'] * sr / 1000)
             end = int(u['end'] * sr / 1000)
             segments.append(y[start:end])
-        total_duration = sum(u['speech_features']['duration'] for u in interviewee_speakers)
-        total_words = sum(len(u['speech'].split()) for u in interviewee_speakers)
+        total_duration = sum(u['prosodic_features']['duration'] for u in interviewee_utterances)
+        total_words = sum(len(u['text'].split()) for u in interviewee_utterances)
         speaking_rate = total_words / total_duration if total_duration > 0 else 0
         filler_words = ['um', 'uh', 'like', 'you know', 'so', 'i mean']
-        filler_count = sum(sum(u['speech'].lower().count(fw) for fw in filler_words) for u in interviewee_speakers)
+        filler_count = sum(sum(u['text'].lower().count(fw) for fw in filler_words) for u in interviewee_utterances)
         filler_ratio = filler_count / total_words if total_words > 0 else 0
-        all_words = ' '.join(u['speech'].lower() for u in interviewee_speakers).split()
+        all_words = ' '.join(u['text'].lower() for u in interviewee_utterances).split()
         word_counts = {}
         for i in range(len(all_words) - 1):
             bigram = (all_words[i], all_words[i + 1])