Update process_interview.py

process_interview.py

@@ -18,9 +18,8 @@ import re
 from typing import Dict, List, Tuple
 import logging
 import tempfile
-# --- Imports for enhanced PDF ---
 from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, Image
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.units import inch
 from reportlab.lib import colors
@@ -29,21 +28,12 @@ import matplotlib
 matplotlib.use('Agg')
 from reportlab.platypus import Image
 import io
-# --- End Imports for enhanced PDF ---
 from transformers import AutoTokenizer, AutoModel
 import spacy
 import google.generativeai as genai
 import joblib
 from concurrent.futures import ThreadPoolExecutor
-# --- Imports to ensure are present at the top of process_interview.py ---
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, Image
-from reportlab.lib.pagesizes import letter
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import inch
-from reportlab.lib import colors
-import time
-import re
-import io
+
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -60,15 +50,11 @@ PINECONE_KEY = os.getenv("PINECONE_KEY")
 ASSEMBLYAI_KEY = os.getenv("ASSEMBLYAI_KEY")
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 
-
-# --- NEW HELPER FUNCTION to download from URL ---
 def download_audio_from_url(url: str) -> str:
     """Downloads an audio file from a URL to a temporary local path."""
     try:
-        # Create a temporary file to store the downloaded audio
         temp_dir = tempfile.gettempdir()
         temp_path = os.path.join(temp_dir, f"{uuid.uuid4()}.tmp_audio")
-
         logger.info(f"Downloading audio from {url} to {temp_path}")
         with requests.get(url, stream=True) as r:
             r.raise_for_status()
@@ -79,10 +65,7 @@ def download_audio_from_url(url: str) -> str:
     except Exception as e:
         logger.error(f"Failed to download audio from URL {url}: {e}")
         raise
-# --- END NEW HELPER FUNCTION ---
-
 
-# Initialize services
 def initialize_services():
     try:
         pc = Pinecone(api_key=PINECONE_KEY)
@@ -104,11 +87,9 @@ def initialize_services():
 
 index, gemini_model = initialize_services()
 
-# Device setup
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 logger.info(f"Using device: {device}")
 
-
 def load_speaker_model():
     try:
         import torch
@@ -123,8 +104,6 @@ def load_speaker_model():
         logger.error(f"Model loading failed: {str(e)}")
         raise RuntimeError("Could not load speaker verification model")
 
-
-# Load ML models
 def load_models():
     speaker_model = load_speaker_model()
     nlp = spacy.load("en_core_web_sm")
@@ -133,11 +112,8 @@ def load_models():
     llm_model.eval()
     return speaker_model, nlp, tokenizer, llm_model
 
-
 speaker_model, nlp, tokenizer, llm_model = load_models()
 
-
-# Audio processing functions
 def convert_to_wav(audio_path: str, output_dir: str = OUTPUT_DIR) -> str:
     try:
         audio = AudioSegment.from_file(audio_path)
@@ -151,7 +127,6 @@ def convert_to_wav(audio_path: str, output_dir: str = OUTPUT_DIR) -> str:
         logger.error(f"Audio conversion failed: {str(e)}")
         raise
 
-
 def extract_prosodic_features(audio_path: str, start_ms: int, end_ms: int) -> Dict:
     try:
         audio = AudioSegment.from_file(audio_path)
@@ -182,7 +157,6 @@ def extract_prosodic_features(audio_path: str, start_ms: int, end_ms: int) -> Di
             'intensityMax': 0.0, 'intensitySD': 0.0
         }
 
-
 def transcribe(audio_path: str) -> Dict:
     try:
         with open(audio_path, 'rb') as f:
@@ -216,7 +190,6 @@ def transcribe(audio_path: str) -> Dict:
         logger.error(f"Transcription failed: {str(e)}")
         raise
 
-
 def process_utterance(utterance, full_audio, wav_file):
     try:
         start = utterance['start']
@@ -255,7 +228,6 @@ def process_utterance(utterance, full_audio, wav_file):
             'embedding': None
         }
 
-
 def identify_speakers(transcript: Dict, wav_file: str) -> List[Dict]:
     try:
         full_audio = AudioSegment.from_wav(wav_file)
@@ -271,7 +243,6 @@ def identify_speakers(transcript: Dict, wav_file: str) -> List[Dict]:
         logger.error(f"Speaker identification failed: {str(e)}")
         raise
 
-
 def train_role_classifier(utterances: List[Dict]):
     try:
         texts = [u['text'] for u in utterances]
@@ -311,7 +282,6 @@ def train_role_classifier(utterances: List[Dict]):
         logger.error(f"Classifier training failed: {str(e)}")
         raise
 
-
 def classify_roles(utterances: List[Dict], clf, vectorizer, scaler):
     try:
         texts = [u['text'] for u in utterances]
@@ -341,7 +311,6 @@ 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, utterances: List[Dict]) -> Dict:
     try:
         y, sr = librosa.load(audio_path, sr=16000)
@@ -382,9 +351,9 @@ def analyze_interviewee_voice(audio_path: str, utterances: List[Dict]) -> Dict:
         anxiety_score = 0.6 * (pitch_std / pitch_mean) + 0.4 * (jitter + shimmer) if pitch_mean > 0 else 0
         confidence_score = 0.7 * (1 / (1 + intensity_std)) + 0.3 * (1 / (1 + filler_ratio))
         hesitation_score = filler_ratio + repetition_score
-        anxiety_level = 'high' if anxiety_score > 0.15 else 'moderate' if anxiety_score > 0.07 else 'low'
-        confidence_level = 'high' if confidence_score > 0.7 else 'moderate' if confidence_score > 0.5 else 'low'
-        fluency_level = 'fluent' if (filler_ratio < 0.05 and repetition_score < 0.1) else 'moderate' if (filler_ratio < 0.1 and repetition_score < 0.2) else 'disfluent'
+        anxiety_level = 'High' if anxiety_score > 0.15 else 'Moderate' if anxiety_score > 0.07 else 'Low'
+        confidence_level = 'High' if confidence_score > 0.7 else 'Moderate' if confidence_score > 0.5 else 'Low'
+        fluency_level = 'Fluent' if (filler_ratio < 0.05 and repetition_score < 0.1) else 'Moderate' if (filler_ratio < 0.1 and repetition_score < 0.2) else 'Disfluent'
         return {
             'speaking_rate': float(round(speaking_rate, 2)),
             'filler_ratio': float(round(filler_ratio, 4)),
@@ -398,58 +367,57 @@ def analyze_interviewee_voice(audio_path: str, utterances: List[Dict]) -> Dict:
         logger.error(f"Voice analysis failed: {str(e)}")
         return {'error': str(e)}
 
-
 def generate_voice_interpretation(analysis: Dict) -> str:
     if 'error' in analysis:
-        return "Voice analysis not available."
+        return "Voice analysis not available due to processing error."
     interpretation_lines = [
-        "Voice Analysis Summary:",
-        f"- Speaking Rate: {analysis['speaking_rate']} words/sec (average)",
-        f"- Filler Words: {analysis['filler_ratio'] * 100:.1f}% of words",
-        f"- Repetition Score: {analysis['repetition_score']:.3f}",
-        f"- Anxiety Level: {analysis['interpretation']['anxiety_level'].upper()} (score: {analysis['composite_scores']['anxiety']:.3f})",
-        f"- Confidence Level: {analysis['interpretation']['confidence_level'].upper()} (score: {analysis['composite_scores']['confidence']:.3f})",
-        f"- Fluency: {analysis['interpretation']['fluency_level'].upper()}",
+        "Voice and Speech Profile:",
+        f"- Speaking Rate: {analysis['speaking_rate']} words/sec - Compared to optimal range (2.0-3.0 words/sec)",
+        f"- Filler Word Usage: {analysis['filler_ratio'] * 100:.1f}% - Frequency of non-content words (e.g., 'um', 'like')",
+        f"- Repetition Tendency: {analysis['repetition_score']:.3f} - Measure of repeated phrases",
+        f"- Anxiety Indicator: {analysis['interpretation']['anxiety_level']} (Score: {analysis['composite_scores']['anxiety']:.3f}) - Based on pitch and voice stability",
+        f"- Confidence Indicator: {analysis['interpretation']['confidence_level']} (Score: {analysis['composite_scores']['confidence']:.3f}) - Derived from vocal consistency",
+        f"- Fluency Assessment: {analysis['interpretation']['fluency_level']} - Reflects speech flow and coherence",
         "",
-        "Detailed Interpretation:",
-        "1. A higher speaking rate indicates faster speech, which can suggest nervousness or enthusiasm.",
-        "2. Filler words and repetitions reduce speech clarity and professionalism.",
-        "3. Anxiety is measured through pitch variability and voice instability.",
-        "4. Confidence is assessed through voice intensity and stability.",
-        "5. Fluency combines filler words and repetition metrics."
+        "HR Insights:",
+        "- Faster speaking rates may indicate confidence but can suggest nervousness if excessive.",
+        "- High filler word usage often reduces perceived professionalism and clarity.",
+        "- Elevated anxiety indicators (pitch variability, jitter) may reflect interview pressure.",
+        "- Strong confidence scores suggest effective vocal presence and control.",
+        "- Fluency impacts listener engagement; disfluency may hinder communication effectiveness."
     ]
     return "\n".join(interpretation_lines)
 
-
 def generate_anxiety_confidence_chart(composite_scores: Dict, chart_path_or_buffer):
     try:
         labels = ['Anxiety', 'Confidence']
         scores = [composite_scores.get('anxiety', 0), composite_scores.get('confidence', 0)]
         fig, ax = plt.subplots(figsize=(4, 2.5))
-        ax.bar(labels, scores, color=['lightcoral', 'lightskyblue'])
-        ax.set_ylabel('Score')
-        ax.set_title('Anxiety vs. Confidence Scores')
-        ax.set_ylim(0, 1.0)
-        for i, v in enumerate(scores):
-            ax.text(i, v + 0.05, f"{v:.2f}", color='black', ha='center', fontweight='bold')
+        bars = ax.bar(labels, scores, color=['#FF6B6B', '#4ECDC4'], edgecolor='black')
+        ax.set_ylabel('Score (Normalized)')
+        ax.set_title('Vocal Dynamics: Anxiety vs. Confidence')
+        ax.set_ylim(0, 1.2)
+        for bar in bars:
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2, height + 0.05, f"{height:.2f}",
+                    ha='center', color='black', fontweight='bold', fontsize=10)
         plt.tight_layout()
-        plt.savefig(chart_path_or_buffer, format='png', bbox_inches='tight')
+        plt.savefig(chart_path_or_buffer, format='png', bbox_inches='tight', dpi=150)
         plt.close(fig)
     except Exception as e:
         logger.error(f"Error generating chart: {str(e)}")
 
-
 def calculate_acceptance_probability(analysis_data: Dict) -> float:
     voice = analysis_data.get('voice_analysis', {})
     if 'error' in voice: return 0.0
     w_confidence, w_anxiety, w_fluency, w_speaking_rate, w_filler_repetition, w_content_strengths = 0.4, -0.3, 0.2, 0.1, -0.1, 0.2
     confidence_score = voice.get('composite_scores', {}).get('confidence', 0.0)
     anxiety_score = voice.get('composite_scores', {}).get('anxiety', 0.0)
-    fluency_level = voice.get('interpretation', {}).get('fluency_level', 'disfluent')
+    fluency_level = voice.get('interpretation', {}).get('fluency_level', 'Disfluent')
     speaking_rate = voice.get('speaking_rate', 0.0)
     filler_ratio = voice.get('filler_ratio', 0.0)
     repetition_score = voice.get('repetition_score', 0.0)
-    fluency_map = {'fluent': 1.0, 'moderate': 0.5, 'disfluent': 0.0}
+    fluency_map = {'Fluent': 1.0, 'Moderate': 0.5, 'Disfluent': 0.0}
     fluency_val = fluency_map.get(fluency_level, 0.0)
     ideal_speaking_rate = 2.5
     speaking_rate_deviation = abs(speaking_rate - ideal_speaking_rate)
@@ -464,7 +432,6 @@ def calculate_acceptance_probability(analysis_data: Dict) -> float:
     acceptance_probability = max(0.0, min(1.0, normalized_score))
     return float(f"{acceptance_probability * 100:.2f}")
 
-
 def generate_report(analysis_data: Dict) -> str:
     try:
         voice = analysis_data.get('voice_analysis', {})
@@ -473,28 +440,34 @@ def generate_report(analysis_data: Dict) -> str:
         acceptance_prob = analysis_data.get('acceptance_probability', None)
         acceptance_line = ""
         if acceptance_prob is not None:
-            acceptance_line = f"\n**Estimated Acceptance Probability: {acceptance_prob:.2f}%**\n"
-            if acceptance_prob >= 80: acceptance_line += "This indicates a very strong candidate. Well done!"
-            elif acceptance_prob >= 50: acceptance_line += "This indicates a solid candidate with potential for improvement."
-            else: acceptance_line += "This candidate may require significant development or may not be a strong fit."
+            acceptance_line = f"\n**Hiring Potential Score: {acceptance_prob:.2f}%**\n"
+            if acceptance_prob >= 80: acceptance_line += "Assessment: Exceptional candidate, strongly recommended for advancement."
+            elif acceptance_prob >= 50: acceptance_line += "Assessment: Promising candidate with moderate strengths; consider for further evaluation."
+            else: acceptance_line += "Assessment: Limited alignment with role expectations; significant development needed."
         prompt = f"""
-        As EvalBot, an AI interview analysis system, generate a highly professional, well-structured, and concise interview analysis report. Use clear headings and subheadings. For bullet points, use '- '.
+        You are an expert HR consultant, EvalBot, tasked with producing a professional, concise, and actionable interview analysis report. Structure the report with clear headings, subheadings, and bullet points (use '- ' for bullets). Adopt a formal, HR-professional tone, focusing on candidate evaluation, fit for role, and development insights.
         {acceptance_line}
         **1. Executive Summary**
-        Provide a brief, high-level overview of the interview.
-        - Overall interview duration: {analysis_data['text_analysis']['total_duration']:.2f} seconds
-        - Number of speaker turns: {analysis_data['text_analysis']['speaker_turns']}
-        - Main participants: {', '.join(analysis_data['speakers'])}
-        **2. Voice Analysis Insights**
-        Analyze key voice metrics and provide a detailed interpretation.
+        - Provide a concise overview of the interview, highlighting key metrics and overall candidate performance.
+        - Interview duration: {analysis_data['text_analysis']['total_duration']:.2f} seconds
+        - Total speaker turns: {analysis_data['text_analysis']['speaker_turns']}
+        - Participants: {', '.join(analysis_data['speakers'])}
+        **2. Communication and Vocal Analysis**
+        - Evaluate the candidate's vocal delivery, including speaking rate, fluency, and confidence indicators.
+        - Provide HR-relevant insights into how these metrics impact perceived professionalism and role suitability.
         {voice_interpretation}
-        **3. Content Analysis & Strengths/Areas for Development**
-        Analyze the key themes and identify both strengths and areas for development in the interviewee's responses.
-        Key responses from interviewee (for context):
+        **3. Content Analysis and Competency Assessment**
+        - Analyze key themes in the candidate's responses to assess alignment with job competencies (e.g., problem-solving, communication, leadership).
+        - Identify strengths and areas for improvement, supported by specific examples.
+        - Sample responses for context:
         {chr(10).join(interviewee_responses)}
-        **4. Actionable Recommendations**
-        Offer specific, actionable suggestions for improvement.
-        Focus on: Communication Skills, Content Delivery, Professional Presentation.
+        **4. Fit and Potential Evaluation**
+        - Assess the candidate's overall fit for a typical professional role based on communication, content, and vocal dynamics.
+        - Consider cultural fit, adaptability, and readiness for the role.
+        **5. Actionable HR Recommendations**
+        - Provide specific, prioritized recommendations for the candidate’s development.
+        - Focus areas: Effective Communication, Content Clarity and Depth, Professional Presence.
+        - Suggest next steps for hiring managers (e.g., advance to next round, additional assessments, training focus).
         """
         response = gemini_model.generate_content(prompt)
         return response.text
@@ -502,158 +475,157 @@ def generate_report(analysis_data: Dict) -> str:
         logger.error(f"Report generation failed: {str(e)}")
         return f"Error generating report: {str(e)}"
 
-
-
-# --- NEW, ENHANCED PDF GENERATION FUNCTION ---
-# --- Make sure these imports are at the top of your process_interview.py file ---
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak, Image
-from reportlab.lib.pagesizes import letter
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import inch
-from reportlab.lib import colors
-import time
-import re
-import io
-
-# --- New, Enhanced PDF Generation Function ---
 def create_pdf_report(analysis_data: Dict, output_path: str, gemini_report_text: str):
     try:
         doc = SimpleDocTemplate(output_path, pagesize=letter,
                                 rightMargin=0.75*inch, leftMargin=0.75*inch,
                                 topMargin=1*inch, bottomMargin=1*inch)
-
         styles = getSampleStyleSheet()
-        h1 = ParagraphStyle(name='Heading1', fontSize=20, leading=24, spaceAfter=18, alignment=1, textColor=colors.HexColor('#00205B'))
-        h2 = ParagraphStyle(name='Heading2', fontSize=14, leading=18, spaceBefore=12, spaceAfter=6, textColor=colors.HexColor('#003366'))
-        body_text = ParagraphStyle(name='BodyText', parent=styles['Normal'], fontSize=10, leading=14, spaceAfter=6)
-        bullet_style = ParagraphStyle(name='Bullet', parent=body_text, leftIndent=18, bulletIndent=9)
+        h1 = ParagraphStyle(name='Heading1', fontSize=22, leading=26, spaceAfter=20, alignment=1, textColor=colors.HexColor('#1A3C5E'))
+        h2 = ParagraphStyle(name='Heading2', fontSize=14, leading=18, spaceBefore=14, spaceAfter=8, textColor=colors.HexColor('#2E5A87'))
+        body_text = ParagraphStyle(name='BodyText', parent=styles['Normal'], fontSize=10, leading=14, spaceAfter=8, fontName='Helvetica')
+        bullet_style = ParagraphStyle(name='Bullet', parent=body_text, leftIndent=20, bulletIndent=10, fontName='Helvetica')
         
         story = []
 
-        # --- Header and Footer Logic ---
         def header_footer(canvas, doc):
             canvas.saveState()
-            # Footer
             canvas.setFont('Helvetica', 9)
             canvas.setFillColor(colors.grey)
-            canvas.drawString(doc.leftMargin, 0.5 * inch, f"Page {doc.page} | EvalBot Confidential Report")
-            # Header line
-            canvas.setStrokeColor(colors.HexColor('#003366'))
+            canvas.drawString(doc.leftMargin, 0.5 * inch, f"Page {doc.page} | EvalBot HR Interview Report | Confidential")
+            canvas.setStrokeColor(colors.HexColor('#2E5A87'))
             canvas.setLineWidth(1)
-            canvas.line(doc.leftMargin, doc.height + 0.75*inch, doc.width + doc.leftMargin, doc.height + 0.75*inch)
+            canvas.line(doc.leftMargin, doc.height + 0.85*inch, doc.width + doc.leftMargin, doc.height + 0.85*inch)
+            canvas.setFont('Helvetica-Bold', 10)
+            canvas.drawString(doc.leftMargin, doc.height + 0.9*inch, "Candidate Interview Analysis Report")
             canvas.restoreState()
 
-        # --- First Page: Title and Summary ---
-        story.append(Paragraph("Interview Performance Analysis", h1))
-        story.append(Paragraph(f"Analysis Date: {time.strftime('%Y-%m-%d')}", ParagraphStyle(name='Date', alignment=1, fontSize=9, textColor=colors.grey)))
-        story.append(Spacer(1, 0.4 * inch))
-
+        # Title Page
+        story.append(Paragraph("Candidate Interview Analysis Report", h1))
+        story.append(Paragraph(f"Generated on: {time.strftime('%B %d, %Y')}", ParagraphStyle(name='Date', alignment=1, fontSize=10, textColor=colors.grey)))
+        story.append(Spacer(1, 0.5 * inch))
         acceptance_prob = analysis_data.get('acceptance_probability')
         if acceptance_prob is not None:
-            story.append(Paragraph("Candidate Evaluation Summary", h2))
-            prob_color = colors.green if acceptance_prob >= 70 else (colors.darkorange if acceptance_prob >= 40 else colors.red)
-            story.append(Paragraph(f"Estimated Acceptance Probability: <font size=14 color='{prob_color.hexval()}'><b>{acceptance_prob:.2f}%</b></font>",
-                                 ParagraphStyle(name='Prob', fontSize=12, spaceAfter=10)))
+            story.append(Paragraph("Hiring Potential Snapshot", h2))
+            prob_color = colors.HexColor('#2E7D32') if acceptance_prob >= 70 else (colors.HexColor('#F57C00') if acceptance_prob >= 40 else colors.HexColor('#D32F2F'))
+            story.append(Paragraph(f"Hiring Potential Score: <font size=16 color='{prob_color.hexval()}'><b>{acceptance_prob:.2f}%</b></font>",
+                                 ParagraphStyle(name='Prob', fontSize=12, spaceAfter=12, alignment=1)))
             if acceptance_prob >= 80:
-                story.append(Paragraph("<b>Overall Assessment:</b> This indicates a very strong candidate with high potential. Recommended for the next round.", body_text))
+                story.append(Paragraph("<b>HR Assessment:</b> Exceptional candidate, strongly recommended for advancement to the next stage.", body_text))
             elif acceptance_prob >= 50:
-                story.append(Paragraph("<b>Overall Assessment:</b> This candidate shows solid potential but has key areas for improvement.", body_text))
+                story.append(Paragraph("<b>HR Assessment:</b> Promising candidate with moderate strengths; consider for further evaluation.", body_text))
             else:
-                story.append(Paragraph("<b>Overall Assessment:</b> This candidate may require significant development or may not be the ideal fit at this time.", body_text))
-        
+                story.append(Paragraph("<b>HR Assessment:</b> Limited alignment with role expectations; significant development needed.", body_text))
+        story.append(Spacer(1, 0.3 * inch))
+        story.append(Paragraph("Prepared by: EvalBot - AI-Powered HR Interview Analysis System", body_text))
         story.append(PageBreak())
 
-        # --- Second Page: Detailed Analysis ---
-        story.append(Paragraph("Detailed Analysis", h1))
+        # Detailed Analysis
+        story.append(Paragraph("Detailed Candidate Evaluation", h1))
         
-        story.append(Paragraph("1. Voice & Speech Metrics", h2))
+        story.append(Paragraph("1. Communication and Vocal Profile", h2))
         voice_analysis = analysis_data.get('voice_analysis', {})
         if voice_analysis and 'error' not in voice_analysis:
-            # --- This is the corrected table ---
             table_data = [
-                ['Metric', 'Value', 'Interpretation'],
-                ['Speaking Rate', f"{voice_analysis.get('speaking_rate', 0):.2f} words/sec", 'Indicator of pace and confidence.'],
-                ['Filler Words Ratio', f"{voice_analysis.get('filler_ratio', 0) * 100:.1f}%", 'Measures use of "um", "uh", etc.'],
-                ['Anxiety Level', voice_analysis.get('interpretation', {}).get('anxiety_level', 'N/A').upper(), f"Score: {voice_analysis.get('composite_scores', {}).get('anxiety', 0):.3f}"],
-                ['Confidence Level', voice_analysis.get('interpretation', {}).get('confidence_level', 'N/A').upper(), f"Score: {voice_analysis.get('composite_scores', {}).get('confidence', 0):.3f}"],
-                ['Fluency Level', voice_analysis.get('interpretation', {}).get('fluency_level', 'N/A').upper(), 'Overall speech flow and coherence.']
+                ['Metric', 'Value', 'HR Insight'],
+                ['Speaking Rate', f"{voice_analysis.get('speaking_rate', 0):.2f} words/sec", 'Optimal: 2.0-3.0 wps; impacts clarity and confidence'],
+                ['Filler Word Usage', f"{voice_analysis.get('filler_ratio', 0) * 100:.1f}%", 'High usage may reduce perceived professionalism'],
+                ['Anxiety Indicator', voice_analysis.get('interpretation', {}).get('anxiety_level', 'N/A'), f"Score: {voice_analysis.get('composite_scores', {}).get('anxiety', 0):.3f}; reflects pressure response"],
+                ['Confidence Indicator', voice_analysis.get('interpretation', {}).get('confidence_level', 'N/A'), f"Score: {voice_analysis.get('composite_scores', {}).get('confidence', 0):.3f}; indicates vocal authority"],
+                ['Fluency Assessment', voice_analysis.get('interpretation', {}).get('fluency_level', 'N/A'), 'Affects engagement and message delivery']
             ]
-            table = Table(table_data, colWidths=[1.6*inch, 1.2*inch, 3.7*inch])
+            table = Table(table_data, colWidths=[1.8*inch, 1.2*inch, 3.5*inch])
             table.setStyle(TableStyle([
-                ('BACKGROUND', (0,0), (-1,0), colors.HexColor('#003366')),
-                ('TEXTCOLOR',(0,0),(-1,0),colors.whitesmoke),
+                ('BACKGROUND', (0,0), (-1,0), colors.HexColor('#2E5A87')),
+                ('TEXTCOLOR', (0,0), (-1,0), colors.whitesmoke),
                 ('ALIGN', (0,0), (-1,-1), 'LEFT'),
                 ('VALIGN', (0,0), (-1,-1), 'MIDDLE'),
                 ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
                 ('FONTSIZE', (0, 0), (-1, -1), 9),
-                ('BOTTOMPADDING', (0, 0), (-1, 0), 10),
-                ('TOPPADDING', (0, 0), (-1, 0), 10),
-                ('BACKGROUND', (0, 1), (-1, -1), colors.HexColor('#F0F8FF')),
-                ('GRID', (0,0), (-1,-1), 1, colors.lightgrey)
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('TOPPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.HexColor('#F5F7FA')),
+                ('GRID', (0,0), (-1,-1), 1, colors.HexColor('#DDE4EB'))
             ]))
             story.append(table)
-            story.append(Spacer(1, 0.2 * inch))
-
+            story.append(Spacer(1, 0.25 * inch))
             chart_buffer = io.BytesIO()
             generate_anxiety_confidence_chart(voice_analysis.get('composite_scores', {}), chart_buffer)
             chart_buffer.seek(0)
-            img = Image(chart_buffer, width=4*inch, height=2.5*inch)
+            img = Image(chart_buffer, width=4.5*inch, height=2.8*inch)
             img.hAlign = 'CENTER'
             story.append(img)
         else:
-            story.append(Paragraph("Voice analysis data not available.", body_text))
+            story.append(Paragraph("Voice analysis unavailable due to processing limitations.", body_text))
+        story.append(Spacer(1, 0.3 * inch))
 
-        story.append(PageBreak())
-        
-        # --- Gemini Report Parsing and Display ---
+        # Parse Gemini Report
         sections = {}
-        # Pre-populate to maintain order
-        section_titles = ["Executive Summary", "Voice Analysis Insights", "Content Analysis & Strengths/Areas for Development", "Actionable Recommendations"]
+        section_titles = ["Executive Summary", "Communication and Vocal Analysis", 
+                         "Content Analysis and Competency Assessment", 
+                         "Fit and Potential Evaluation", "Actionable HR Recommendations"]
         for title in section_titles:
             sections[title] = []
-
-        # Use a more robust way to capture content under each heading
-        # This regex captures the heading line itself to exclude it from the content
         report_parts = re.split(r'(\s*\*\*\s*\d\.\s*.*?\s*\*\*)', gemini_report_text)
-        
         current_section = None
         for part in report_parts:
             if not part.strip(): continue
-            
             is_heading = False
             for title in section_titles:
-                # Check if the part is a heading
                 if title.lower() in part.lower():
                     current_section = title
                     is_heading = True
                     break
-            
             if not is_heading and current_section:
                 sections[current_section].append(part.strip())
 
-        # Display Content and Recommendations
-        story.append(Paragraph("2. Content Analysis (from Gemini)", h2))
-        if sections['Content Analysis & Strengths/Areas for Development']:
-            for line in sections['Content Analysis & Strengths/Areas for Development']:
+        # Executive Summary
+        story.append(Paragraph("2. Executive Summary", h2))
+        if sections['Executive Summary']:
+            for line in sections['Executive Summary']:
                 if line.startswith(('-', '•', '*')):
                     story.append(Paragraph(line.lstrip('-•* ').strip(), bullet_style))
                 else:
                     story.append(Paragraph(line, body_text))
         else:
-            story.append(Paragraph("Content analysis not provided.", body_text))
+            story.append(Paragraph("Summary not available from analysis.", body_text))
+        story.append(Spacer(1, 0.3 * inch))
 
-        story.append(Spacer(1, 0.3*inch))
-        
-        story.append(Paragraph("3. Actionable Recommendations (from Gemini)", h2))
-        if sections['Actionable Recommendations']:
-            for line in sections['Actionable Recommendations']:
+        # Content and Competency
+        story.append(Paragraph("3. Content and Competency Assessment", h2))
+        if sections['Content Analysis and Competency Assessment']:
+            for line in sections['Content Analysis and Competency Assessment']:
                 if line.startswith(('-', '•', '*')):
                     story.append(Paragraph(line.lstrip('-•* ').strip(), bullet_style))
                 else:
                     story.append(Paragraph(line, body_text))
         else:
-            story.append(Paragraph("Recommendations not provided.", body_text))
-        
+            story.append(Paragraph("Content and competency analysis not provided.", body_text))
+        story.append(PageBreak())
+
+        # Fit and Potential
+        story.append(Paragraph("4. Fit and Potential Evaluation", h2))
+        if sections['Fit and Potential Evaluation']:
+            for line in sections['Fit and Potential Evaluation']:
+                if line.startswith(('-', '•', '*')):
+                    story.append(Paragraph(line.lstrip('-•* ').strip(), bullet_style))
+                else:
+                    story.append(Paragraph(line, body_text))
+        else:
+            story.append(Paragraph("Fit and potential evaluation not available.", body_text))
+        story.append(Spacer(1, 0.3 * inch))
+
+        # HR Recommendations
+        story.append(Paragraph("5. Actionable HR Recommendations", h2))
+        if sections['Actionable HR Recommendations']:
+            for line in sections['Actionable HR Recommendations']:
+                if line.startswith(('-', '•', '*')):
+                    story.append(Paragraph(line.lstrip('-•* ').strip(), bullet_style))
+                else:
+                    story.append(Paragraph(line, body_text))
+        else:
+            story.append(Paragraph("HR recommendations not provided.", body_text))
+
         doc.build(story, onFirstPage=header_footer, onLaterPages=header_footer)
         return True
     except Exception as e:
@@ -667,28 +639,22 @@ def convert_to_serializable(obj):
     if isinstance(obj, np.ndarray): return obj.tolist()
     return obj
 
-# --- MODIFIED MAIN FUNCTION ---
 def process_interview(audio_path_or_url: str):
     local_audio_path = None
     wav_file = None
     is_downloaded = False
     try:
         logger.info(f"Starting processing for {audio_path_or_url}")
-        
         if audio_path_or_url.startswith(('http://', 'https://')):
             local_audio_path = download_audio_from_url(audio_path_or_url)
             is_downloaded = True
         else:
             local_audio_path = audio_path_or_url
-        
         wav_file = convert_to_wav(local_audio_path)
         transcript = transcribe(wav_file)
-        
         for utterance in transcript['utterances']:
             utterance['prosodic_features'] = extract_prosodic_features(wav_file, utterance['start'], utterance['end'])
-            
         utterances_with_speakers = identify_speakers(transcript, wav_file)
-        
         clf, vectorizer, scaler = None, None, None
         if os.path.exists(os.path.join(OUTPUT_DIR, 'role_classifier.pkl')):
             clf = joblib.load(os.path.join(OUTPUT_DIR, 'role_classifier.pkl'))
@@ -696,10 +662,8 @@ def process_interview(audio_path_or_url: str):
             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)
         voice_analysis = analyze_interviewee_voice(wav_file, classified_utterances)
-        
         analysis_data = {
             'transcript': classified_utterances,
             'speakers': list(set(u['speaker'] for u in classified_utterances)),
@@ -709,32 +673,23 @@ def process_interview(audio_path_or_url: str):
                 'speaker_turns': len(classified_utterances)
             }
         }
-        
         analysis_data['acceptance_probability'] = calculate_acceptance_probability(analysis_data)
         gemini_report_text = generate_report(analysis_data)
-        
         base_name = str(uuid.uuid4())
         pdf_path = os.path.join(OUTPUT_DIR, f"{base_name}_report.pdf")
         json_path = os.path.join(OUTPUT_DIR, f"{base_name}_analysis.json")
-
         create_pdf_report(analysis_data, pdf_path, gemini_report_text=gemini_report_text)
-        
         with open(json_path, 'w') as f:
             serializable_data = convert_to_serializable(analysis_data)
             json.dump(serializable_data, f, indent=2)
-            
         logger.info(f"Processing completed for {audio_path_or_url}")
-        
         return {'pdf_path': pdf_path, 'json_path': json_path}
-
     except Exception as e:
         logger.error(f"Processing failed for {audio_path_or_url}: {str(e)}", exc_info=True)
         raise
-
     finally:
         if wav_file and os.path.exists(wav_file):
             os.remove(wav_file)
         if is_downloaded and local_audio_path and os.path.exists(local_audio_path):
             os.remove(local_audio_path)
-            logger.info(f"Cleaned up temporary downloaded file: {local_audio_path}")
-# --- END MODIFIED MAIN FUNCTION ---
+            logger.info(f"Cleaned up temporary downloaded file: {local_audio_path}")