Update process_interview.py

process_interview.py

@@ -442,45 +442,74 @@ def create_pdf_report(analysis_data: Dict, output_path: str):
 # 7. MAIN PROCESSING PIPELINE
 # ==============================================================================
 def process_interview(audio_path: str, user_id: str = "candidate-123") -> Dict:
-    """The main orchestrator function to process an interview from start to finish."""
-    wav_file = None
     try:
-        logger.info(f"===== STARTING FULL ANALYSIS FOR USER: {user_id} | FILE: {audio_path} =====")
+        logger.info(f"Starting processing for {audio_path} (User ID: {user_id})")
         wav_file = convert_to_wav(audio_path)
+        logger.debug(f"Created WAV file: {wav_file}")
+        logger.info("Starting transcription")
         transcript = transcribe(wav_file)
-        if not transcript or 'utterances' not in transcript: raise ValueError("Transcription failed.")
-
+        logger.info("Transcript result: %s", transcript)
+        if not transcript or 'utterances' not in transcript or not transcript['utterances']:
+            logger.error("Transcription failed or returned empty utterances")
+            raise ValueError("Transcription failed or returned empty utterances")
+        logger.info("Extracting prosodic features")
+        for utterance in transcript['utterances']:
+            utterance['prosodic_features'] = extract_prosodic_features(
+                wav_file,
+                utterance['start'],
+                utterance['end']
+            )
+        logger.info("Identifying speakers")
         utterances_with_speakers = identify_speakers(transcript, wav_file)
-        classified_utterances = classify_roles_ultimate(utterances_with_speakers, wav_file)
-        utterances_with_features = extract_duration_feature(classified_utterances)
-        voice_analysis = analyze_interviewee_voice(wav_file, utterances_with_features)
-
-        analysis_data = {'user_id': user_id, 'source_file': audio_path,
-                         'transcript_with_roles': utterances_with_features, 'voice_analysis_metrics': voice_analysis}
-
-        analysis_data['acceptance_probability'] = calculate_acceptance_probability(analysis_data)
-        analysis_data['voice_interpretation_text'] = generate_voice_interpretation(voice_analysis)
-        analysis_data['gemini_report_text'] = generate_gemini_report_text(analysis_data)
-
-        with io.BytesIO() as chart_buffer:
-            generate_anxiety_confidence_chart(voice_analysis.get('composite_scores', {}), chart_buffer)
-            analysis_data['chart_image_bytes'] = chart_buffer.getvalue()
-
-        pdf_path = os.path.join(OUTPUT_DIR, f"{user_id}_{time.strftime('%Y%m%d')}_report.pdf")
-        create_pdf_report(analysis_data, pdf_path)
-
-        json_path = os.path.join(OUTPUT_DIR, f"{user_id}_{time.strftime('%Y%m%d')}_analysis.json")
-        with open(json_path, 'w') as f:
-            json_friendly_data = {k: v for k, v in analysis_data.items() if k != 'chart_image_bytes'}
-            json.dump(convert_to_serializable(json_friendly_data), f, indent=4)
-
-        logger.info(f"===== ANALYSIS COMPLETED. PDF: {pdf_path}, JSON: {json_path} =====")
-        return {'status': 'Success', 'pdf_path': pdf_path, 'json_path': json_path}
-
+        logger.info("Classifying roles")
+        if os.path.exists(os.path.join(OUTPUT_DIR, 'role_classifier.pkl')):
+            clf = joblib.load(os.path.join(OUTPUT_DIR, 'role_classifier.pkl'))
+            vectorizer = joblib.load(os.path.join(OUTPUT_DIR, 'text_vectorizer.pkl'))
+            scaler = joblib.load(os.path.join(OUTPUT_DIR, 'feature_scaler.pkl'))
+        else:
+            clf, vectorizer, scaler = train_role_classifier(utterances_with_speakers)
+        classified_utterances = classify_roles(utterances_with_speakers, clf, vectorizer, scaler)
+        logger.info("Analyzing interviewee voice")
+        voice_analysis = analyze_interviewee_voice(wav_file, classified_utterances)
+        analysis_data = {
+            'user_id': user_id,
+            'transcript': classified_utterances,
+            'speakers': list(set(u['speaker'] for u in classified_utterances)),
+            'voice_analysis': voice_analysis,
+            'text_analysis': {
+                'total_duration': sum(u['prosodic_features']['duration'] for u in classified_utterances),
+                'speaker_turns': len(classified_utterances)
+            }
+        }
+        acceptance_probability = calculate_acceptance_probability(analysis_data)
+        analysis_data['acceptance_probability'] = acceptance_probability
+        logger.info("Generating report text using Gemini")
+        gemini_report_text = generate_report(analysis_data)
+        base_name = f"{user_id}_{os.path.splitext(os.path.basename(audio_path))[0].split('_', 1)[1]}"
+        pdf_path = os.path.join(OUTPUT_DIR, f"{base_name}_report.pdf")
+        if not create_pdf_report(analysis_data, pdf_path, gemini_report_text=gemini_report_text):
+            logger.error(f"Failed to create PDF report: {pdf_path}")
+            raise RuntimeError("PDF report generation failed")
+        try:
+            json_path = os.path.join(OUTPUT_DIR, f"{base_name}_analysis.json")
+            with open(json_path, 'w') as f:
+                logger.debug(f"Serializing analysis_data with keys: {list(analysis_data.keys())}")
+                serializable_data = convert_to_serializable(analysis_data)
+                json.dump(serializable_data, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to serialize analysis_data to JSON: {str(e)}", exc_info=True)
+            raise
+        os.remove(wav_file)
+        logger.info(f"Processing completed for {audio_path} (User ID: {user_id})")
+        return {
+            'summary': f"User ID: {user_id}\nspeakers: {', '.join(analysis_data['speakers'])}",
+            'json_path': json_path,
+            'pdf_path': pdf_path
+        }
     except Exception as e:
-        logger.critical(f"!!!!!! A CRITICAL ERROR OCCURRED IN THE PIPELINE for {user_id}: {e}", exc_info=True)
-        return {'status': 'Error', 'message': str(e)}
-    finally:
-        if wav_file and os.path.exists(wav_file): os.remove(wav_file)
+        logger.error(f"Processing failed: {str(e)}", exc_info=True)
+        if 'wav_file' in locals() and os.path.exists(wav_file):
+            os.remove(wav_file)
+        raise