Upload 5 files

app.py

@@ -0,0 +1,1016 @@
+import os
+import json
+import logging
+import tempfile
+import re
+from typing import Dict, Any, Optional, List, Tuple
+from pathlib import Path
+from dotenv import load_dotenv
+from flask import Flask, request, jsonify, render_template, send_file
+from flask_cors import CORS
+import google.generativeai as genai
+from groq import Groq
+import pandas as pd
+from datetime import datetime
+import io
+import cv2
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.utils import img_to_array
+from moviepy.editor import VideoFileClip
+import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import numpy as np
+
+# Configure logger first before using it elsewhere
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('app.log')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Suppress TensorFlow warnings
+tf.get_logger().setLevel('ERROR')
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
+# Load environment variables
+load_dotenv()
+
+# Configure Flask app
+app = Flask(__name__)
+app.config['TEMPLATES_AUTO_RELOAD'] = False
+app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500MB max file size
+
+# Configure API keys with validation
+GROQ_API_KEY = os.getenv('GROQ_API_KEY')
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY')
+
+if not GROQ_API_KEY:
+    logger.error("GROQ_API_KEY environment variable not set")
+    raise ValueError("GROQ_API_KEY environment variable must be set")
+
+if not GEMINI_API_KEY:
+    logger.error("GEMINI_API_KEY environment variable not set")
+    raise ValueError("GEMINI_API_KEY environment variable must be set")
+
+# Initialize clients with proper configuration and error handling
+try:
+    # Initialize Groq client with basic configuration
+    from groq._base_client import SyncHttpxClientWrapper
+    import httpx
+
+    # Create a simple httpx client
+    http_client = SyncHttpxClientWrapper(
+        base_url="https://api.groq.com/v1",
+        timeout=httpx.Timeout(60.0)
+    )
+
+    # Initialize Groq client
+    groq_client = Groq(
+        api_key=GROQ_API_KEY,
+        http_client=http_client
+    )
+
+    # Initialize Gemini client
+    genai.configure(api_key=GEMINI_API_KEY)
+    MODEL_NAME = "gemini-1.5-flash"
+    logger.info("API clients initialized successfully")
+except Exception as e:
+    logger.error(f"Error initializing API clients: {str(e)}")
+    raise
+
+# Emotion Detection Setup
+MODEL_PATH = os.path.join(os.path.dirname(__file__), 'model.h5')
+HAARCASCADE_PATH = os.path.join(os.path.dirname(__file__), 'haarcascade_frontalface_default.xml')
+
+# Load models with optimized settings
+try:
+    # Configure TensorFlow for optimal CPU performance
+    physical_devices = tf.config.list_physical_devices('CPU')
+    if physical_devices:
+        try:
+            # Limit memory growth to prevent OOM errors
+            tf.config.experimental.set_memory_growth(physical_devices[0], True)
+        except:
+            # Not all devices support memory growth
+            pass
+            
+    tf.config.threading.set_inter_op_parallelism_threads(4)
+    tf.config.threading.set_intra_op_parallelism_threads(4)
+    
+    # Load emotion model with optimized settings
+    model = load_model(MODEL_PATH, compile=False)
+    model.compile(
+        optimizer='adam',
+        loss='categorical_crossentropy',
+        metrics=['accuracy'],
+        run_eagerly=False
+    )
+    
+    # Load face cascade
+    face_cascade = cv2.CascadeClassifier(HAARCASCADE_PATH)
+    if face_cascade.empty():
+        raise Exception("Error: Haar Cascade file could not be loaded")
+    
+    logger.info("Successfully loaded model and face cascade")
+except Exception as e:
+    logger.error(f"Error loading model or face cascade: {str(e)}")
+    model = None
+    face_cascade = None
+
+EMOTIONS = ['Angry', 'Disgust', 'Fear', 'Happy', 'Neutral', 'Sad', 'Surprise']
+
+# Video processing configuration
+VIDEO_CHUNK_SIZE = 1024 * 1024  # 1MB chunks for video processing
+MAX_VIDEO_DURATION = 120  # Maximum video duration in minutes
+FRAME_SAMPLE_RATE = 5  # Process every 5th frame for long videos
+
+
+def extract_json(text: str) -> Optional[str]:
+    """Extract JSON from response text."""
+    try:
+        json_match = re.search(r'\{.*\}', text, re.DOTALL)
+        if json_match:
+            return json_match.group(0)
+        return None
+    except Exception as e:
+        logger.error(f"Error extracting JSON: {str(e)}")
+        return None
+
+
+def extract_audio_from_video(video_path: str) -> Optional[str]:
+    """Extract audio from video file with optimized processing."""
+    try:
+        temp_audio_path = video_path.replace('.mp4', '.mp3')
+        
+        # Load video clip with optimized settings
+        video_clip = VideoFileClip(
+            video_path,
+            audio_buffersize=200000,
+            verbose=False,
+            audio_fps=44100
+        )
+        
+        if video_clip.audio is None:
+            logger.warning("Video has no audio track")
+            return None
+        
+        # Extract audio with optimized settings
+        video_clip.audio.write_audiofile(
+            temp_audio_path,
+            buffersize=2000,
+            verbose=False,
+            logger=None
+        )
+        video_clip.close()
+
+        logger.info(f"Successfully extracted audio to {temp_audio_path}")
+        return temp_audio_path
+    except Exception as e:
+        logger.error(f"Error extracting audio: {str(e)}")
+        return None
+    finally:
+        # Ensure video clip is closed even if an exception occurs
+        if 'video_clip' in locals() and video_clip is not None:
+            try:
+                video_clip.close()
+            except:
+                pass
+
+
+def transcribe_audio(audio_path: str) -> Optional[str]:
+    """Transcribe audio using Groq."""
+    if not audio_path or not os.path.exists(audio_path):
+        logger.error(f"Audio file not found at {audio_path}")
+        return None
+        
+    try:
+        # Transcribe audio
+        with open(audio_path, "rb") as file:
+            transcription = groq_client.audio.transcriptions.create(
+                file=(audio_path, file.read()),
+                model="whisper-large-v3-turbo",
+                response_format="json",
+                language="en",
+                temperature=0.0
+            )
+
+        logger.info(f"Transcription successful: {transcription.text[:100]}...")
+        return transcription.text
+
+    except Exception as e:
+        logger.error(f"Transcription error: {str(e)}")
+        return None
+
+
+def process_video_chunk(frame_chunk: List[np.ndarray], start_frame: int) -> Dict[str, Any]:
+    """Process a chunk of video frames efficiently."""
+    results = {
+        'emotion_counts': {emotion: 0 for emotion in EMOTIONS},
+        'faces_detected': 0,
+        'frames_with_faces': 0,
+        'frames_processed': 0
+    }
+    
+    for frame_idx, frame in enumerate(frame_chunk):
+        try:
+            # Skip empty frames
+            if frame is None or frame.size == 0:
+                continue
+                
+            # Resize frame for faster processing if too large
+            height, width = frame.shape[:2]
+            if width > 1280:
+                scale = 1280 / width
+                frame = cv2.resize(frame, None, fx=scale, fy=scale)
+
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            faces = face_cascade.detectMultiScale(
+                gray,
+                scaleFactor=1.1,
+                minNeighbors=5,
+                minSize=(30, 30),
+                flags=cv2.CASCADE_SCALE_IMAGE
+            )
+
+            results['frames_processed'] += 1
+            if len(faces) > 0:
+                results['frames_with_faces'] += 1
+                results['faces_detected'] += len(faces)
+
+                for (x, y, w, h) in faces:
+                    # Add boundary checks
+                    if y >= gray.shape[0] or x >= gray.shape[1] or y+h > gray.shape[0] or x+w > gray.shape[1]:
+                        continue
+                    
+                    roi = gray[y:y + h, x:x + w]
+                    roi = cv2.resize(roi, (48, 48), interpolation=cv2.INTER_AREA)
+                    
+                    if np.sum(roi) == 0:
+                        continue
+
+                    roi = roi.astype("float32") / 255.0
+                    roi = img_to_array(roi)
+                    roi = np.expand_dims(roi, axis=0)
+
+                    with tf.device('/CPU:0'):
+                        preds = model.predict(roi, verbose=0)[0]
+                    label = EMOTIONS[np.argmax(preds)]
+                    results['emotion_counts'][label] += 1
+
+        except Exception as e:
+            logger.error(f"Error processing frame {start_frame + frame_idx}: {str(e)}")
+            continue
+
+    return results
+
+
+def analyze_video_emotions(video_path: str) -> Dict[str, Any]:
+    """Analyze emotions in a video with optimized processing for large files."""
+    if model is None or face_cascade is None:
+        logger.error("Model or face detector not properly loaded")
+        return {
+            'emotion_counts': {},
+            'emotion_percentages': {},
+            'total_faces': 0,
+            'frames_processed': 0,
+            'frames_with_faces': 0,
+            'error': 'Models not properly loaded'
+        }
+
+    cap = None
+    try:
+        # Open video and get properties
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise Exception("Failed to open video file")
+
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = int(cap.get(cv2.CAP_PROP_FPS)) or 30  # Default to 30 if fps is 0
+        duration = total_frames / max(fps, 1) / 60  # Duration in minutes, prevent division by zero
+
+        # Check video duration
+        if duration > MAX_VIDEO_DURATION:
+            raise Exception(f"Video duration exceeds maximum limit of {MAX_VIDEO_DURATION} minutes")
+
+        # Initialize results
+        combined_results = {
+            'emotion_counts': {emotion: 0 for emotion in EMOTIONS},
+            'total_faces': 0,
+            'frames_processed': 0,
+            'frames_with_faces': 0,
+            'processing_stats': {
+                'total_video_frames': total_frames,
+                'video_fps': fps,
+                'video_duration_minutes': round(duration, 2)
+            }
+        }
+
+        # Process video in chunks using ThreadPoolExecutor
+        frame_buffer = []
+        frame_count = 0
+        chunk_size = 30  # Process 30 frames per chunk
+
+        with ThreadPoolExecutor(max_workers=min(4, os.cpu_count() or 4)) as executor:
+            future_to_chunk = {}
+
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+
+                frame_count += 1
+                if frame_count % FRAME_SAMPLE_RATE != 0:
+                    continue
+
+                frame_buffer.append(frame)
+
+                if len(frame_buffer) >= chunk_size:
+                    # Submit chunk for processing
+                    future = executor.submit(
+                        process_video_chunk,
+                        frame_buffer.copy(),
+                        frame_count - len(frame_buffer)
+                    )
+                    future_to_chunk[future] = len(frame_buffer)
+                    frame_buffer = []
+
+            # Process remaining frames
+            if frame_buffer:
+                future = executor.submit(
+                    process_video_chunk,
+                    frame_buffer,
+                    frame_count - len(frame_buffer)
+                )
+                future_to_chunk[future] = len(frame_buffer)
+
+            # Collect results
+            for future in as_completed(future_to_chunk):
+                try:
+                    chunk_results = future.result()
+                    # Combine results
+                    for emotion, count in chunk_results['emotion_counts'].items():
+                        combined_results['emotion_counts'][emotion] += count
+                    combined_results['total_faces'] += chunk_results['faces_detected']
+                    combined_results['frames_processed'] += chunk_results['frames_processed']
+                    combined_results['frames_with_faces'] += chunk_results['frames_with_faces']
+                except Exception as e:
+                    logger.error(f"Error processing chunk: {str(e)}")
+
+        # Calculate percentages
+        total_emotions = sum(combined_results['emotion_counts'].values())
+        combined_results['emotion_percentages'] = {
+            emotion: round((count / max(total_emotions, 1) * 100), 2)
+            for emotion, count in combined_results['emotion_counts'].items()
+        }
+
+        # Add processing statistics
+        combined_results['processing_stats'].update({
+            'frames_sampled': combined_results['frames_processed'],
+            'sampling_rate': f'1/{FRAME_SAMPLE_RATE}',
+            'processing_complete': True
+        })
+
+        return combined_results
+
+    except Exception as e:
+        logger.error(f"Error in emotion analysis: {str(e)}")
+        return {
+            'error': str(e),
+            'emotion_counts': {emotion: 0 for emotion in EMOTIONS},
+            'emotion_percentages': {emotion: 0 for emotion in EMOTIONS},
+            'total_faces': 0,
+            'frames_processed': 0,
+            'frames_with_faces': 0,
+            'processing_stats': {
+                'error_occurred': True,
+                'error_message': str(e)
+            }
+        }
+    finally:
+        if cap is not None:
+            cap.release()
+
+
+def analyze_interview(conversation_text: str, role_applied: Optional[str] = None, tech_skills: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Analyze technical interview transcript."""
+    if not conversation_text or len(conversation_text.strip()) < 50:
+        logger.warning("Transcript too short for meaningful analysis")
+        return create_default_assessment()
+        
+    try:
+        model = genai.GenerativeModel(MODEL_NAME)
+
+        skills_context = ""
+        if tech_skills and len(tech_skills) > 0:
+            skills_context = f"Focus on evaluating these specific technical skills: {', '.join(tech_skills)}."
+
+        role_context = ""
+        if role_applied:
+            role_context = f"The candidate is being interviewed for the role of {role_applied}."
+
+        prompt = f"""
+            Based on the following technical interview transcript, analyze the candidate's responses and provide a structured assessment in *valid JSON format*.
+
+            {role_context}
+            {skills_context}
+
+            *JSON Format:*
+            {{
+                "candidate_assessment": {{
+                    "technical_knowledge": {{
+                        "score": 0,  // Score from 1-10
+                        "strengths": [],
+                        "areas_for_improvement": []
+                    }},
+                    "problem_solving": {{
+                        "score": 0,  // Score from 1-10
+                        "strengths": [],
+                        "areas_for_improvement": []
+                    }},
+                    "communication": {{
+                        "score": 0,  // Score from 1-10
+                        "strengths": [],
+                        "areas_for_improvement": []
+                    }}
+                }},
+                "question_analysis": [
+                    {{
+                        "question": "",
+                        "answer_quality": "",  // Excellent, Good, Average, Poor
+                        "feedback": ""
+                    }}
+                ],
+                "overall_recommendation": "",  // Hire, Strong Consider, Consider, Do Not Recommend
+                "overall_feedback": ""
+            }}
+
+            *Interview Transcript:*
+            {conversation_text}
+
+            *Output Strictly JSON. Do NOT add explanations or extra text.*
+        """
+
+        # Set timeout and retry parameters
+        safety_settings = [
+            {
+                "category": "HARM_CATEGORY_HARASSMENT",
+                "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+            },
+            {
+                "category": "HARM_CATEGORY_HATE_SPEECH",
+                "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+            },
+            {
+                "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+            },
+            {
+                "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+            },
+        ]
+
+        generation_config = {
+            "temperature": 0.2,
+            "top_p": 0.95,
+            "top_k": 40,
+            "max_output_tokens": 8192,
+        }
+
+        # Try to generate response with retry mechanism
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = model.generate_content(
+                    prompt,
+                    safety_settings=safety_settings,
+                    generation_config=generation_config
+                )
+                raw_response = response.text
+                logger.info(f"Raw Gemini Response: {raw_response[:100]}...")
+                break
+            except Exception as e:
+                logger.warning(f"Attempt {attempt+1} failed: {str(e)}")
+                if attempt == max_retries - 1:  # Last attempt
+                    logger.error(f"All {max_retries} attempts failed")
+                    return create_default_assessment()
+
+        json_text = extract_json(raw_response)
+        if json_text:
+            try:
+                assessment = json.loads(json_text)
+                # Ensure the response has all required fields
+                required_fields = {
+                    'candidate_assessment': {
+                        'technical_knowledge': ['score', 'strengths', 'areas_for_improvement'],
+                        'problem_solving': ['score', 'strengths', 'areas_for_improvement'],
+                        'communication': ['score', 'strengths', 'areas_for_improvement']
+                    },
+                    'question_analysis': ['question', 'answer_quality', 'feedback'],
+                    'overall_recommendation': None,
+                    'overall_feedback': None
+                }
+
+                # Validate and set defaults if needed
+                if 'candidate_assessment' not in assessment:
+                    assessment['candidate_assessment'] = {}
+                
+                for category in ['technical_knowledge', 'problem_solving', 'communication']:
+                    if category not in assessment['candidate_assessment']:
+                        assessment['candidate_assessment'][category] = {
+                            'score': 5,
+                            'strengths': ['Not enough information to assess.'],
+                            'areas_for_improvement': ['Not enough information to assess.']
+                        }
+                    else:
+                        cat_data = assessment['candidate_assessment'][category]
+                        for field in required_fields['candidate_assessment'][category]:
+                            if field not in cat_data:
+                                if field == 'score':
+                                    cat_data[field] = 5
+                                else:
+                                    cat_data[field] = ['Not enough information to assess.']
+
+                if 'question_analysis' not in assessment or not assessment['question_analysis']:
+                    assessment['question_analysis'] = [{
+                        'question': 'General Interview',
+                        'answer_quality': 'Average',
+                        'feedback': 'Not enough specific questions to analyze.'
+                    }]
+                else:
+                    for qa in assessment['question_analysis']:
+                        for field in required_fields['question_analysis']:
+                            if field not in qa:
+                                qa[field] = 'Not available'
+
+                if 'overall_recommendation' not in assessment or not assessment['overall_recommendation']:
+                    assessment['overall_recommendation'] = 'Consider'
+
+                if 'overall_feedback' not in assessment or not assessment['overall_feedback']:
+                    assessment['overall_feedback'] = 'Not enough information to provide detailed feedback.'
+
+                return assessment
+            except json.JSONDecodeError as e:
+                logger.error(f"Error parsing JSON response: {str(e)}")
+                return create_default_assessment()
+        else:
+            logger.error("No valid JSON found in response")
+            return create_default_assessment()
+
+    except Exception as e:
+        logger.error(f"Interview analysis error: {str(e)}")
+        return create_default_assessment()
+
+
+def create_default_assessment() -> Dict[str, Any]:
+    """Create a default assessment when analysis fails."""
+    return {
+        "candidate_assessment": {
+            "technical_knowledge": {
+                "score": 5,
+                "strengths": ["Unable to assess strengths from the provided transcript."],
+                "areas_for_improvement": ["Unable to assess areas for improvement from the provided transcript."]
+            },
+            "problem_solving": {
+                "score": 5,
+                "strengths": ["Unable to assess strengths from the provided transcript."],
+                "areas_for_improvement": ["Unable to assess areas for improvement from the provided transcript."]
+            },
+            "communication": {
+                "score": 5,
+                "strengths": ["Unable to assess strengths from the provided transcript."],
+                "areas_for_improvement": ["Unable to assess areas for improvement from the provided transcript."]
+            }
+        },
+        "question_analysis": [{
+            "question": "General Interview",
+            "answer_quality": "Average",
+            "feedback": "Unable to assess specific questions from the transcript."
+        }],
+        "overall_recommendation": "Consider",
+        "overall_feedback": "Unable to provide a detailed assessment based on the provided transcript."
+    }
+
+
+def process_video_and_audio_parallel(video_path: str, role_applied: str = None, tech_skills: list = None) -> Tuple[Dict[str, Any], str, Dict[str, Any]]:
+    """Process video and audio in parallel with optimized handling."""
+    audio_path = None
+    emotion_results = None
+    transcript = None
+    interview_assessment = None
+    
+    try:
+        with ThreadPoolExecutor(max_workers=min(3, os.cpu_count() or 2)) as executor:
+            # Submit emotions analysis task
+            emotion_future = executor.submit(analyze_video_emotions, video_path)
+            
+            # Submit audio extraction task
+            audio_future = executor.submit(extract_audio_from_video, video_path)
+            
+            # Wait for audio extraction to complete with timeout
+            try:
+                audio_path = audio_future.result(timeout=120)  # 2 minutes timeout
+            except concurrent.futures.TimeoutError:
+                logger.error("Audio extraction timeout exceeded")
+                audio_path = None
+            
+            # Continue with transcription if audio was extracted
+            transcript_future = None
+            if audio_path:
+                transcript_future = executor.submit(transcribe_audio, audio_path)
+            
+            # Wait for emotion analysis with timeout
+            try:
+                emotion_results = emotion_future.result(timeout=300)  # 5 minutes timeout
+            except concurrent.futures.TimeoutError:
+                logger.error("Emotion analysis timeout exceeded")
+                emotion_results = {
+                    'error': 'Processing timeout exceeded',
+                    'emotion_counts': {emotion: 0 for emotion in EMOTIONS},
+                    'emotion_percentages': {emotion: 0 for emotion in EMOTIONS},
+                    'total_faces': 0,
+                    'frames_processed': 0,
+                    'frames_with_faces': 0
+                }
+            
+            # Wait for transcription with timeout
+            if transcript_future:
+                try:
+                    transcript = transcript_future.result(timeout=300)  # 5 minutes timeout
+                except concurrent.futures.TimeoutError:
+                    logger.error("Transcription timeout exceeded")
+                    transcript = "Transcription failed due to timeout."
+            else:
+                transcript = "Audio extraction failed, no transcription available."
+            
+            # Analyze interview content if transcript is available
+            if transcript and len(transcript) > 50:
+                interview_assessment = analyze_interview(transcript, role_applied, tech_skills)
+            else:
+                interview_assessment = create_default_assessment()
+            
+            # Clean up audio file
+            if audio_path and os.path.exists(audio_path):
+                try:
+                    os.unlink(audio_path)
+                except Exception as e:
+                    logger.warning(f"Error cleaning up audio file: {str(e)}")
+            
+            return emotion_results, transcript, interview_assessment
+            
+    except Exception as e:
+        logger.error(f"Error in parallel processing: {str(e)}")
+        
+        # Create default results if any component failed
+        if not emotion_results:
+            emotion_results = {
+                'error': str(e),
+                'emotion_counts': {emotion: 0 for emotion in EMOTIONS},
+                'emotion_percentages': {emotion: 0 for emotion in EMOTIONS},
+                'total_faces': 0,
+                'frames_processed': 0,
+                'frames_with_faces': 0
+            }
+        
+        if not transcript:
+            transcript = f"Error processing audio: {str(e)}"
+            
+        if not interview_assessment:
+            interview_assessment = create_default_assessment()
+            
+        # Clean up audio file if it exists
+        if audio_path and os.path.exists(audio_path):
+            try:
+                os.unlink(audio_path)
+            except:
+                pass
+                
+        return emotion_results, transcript, interview_assessment
+
+
+@app.route('/')
+def index():
+    """Render the main page."""
+    return render_template('index.html')
+
+
+@app.route('/test', methods=['GET'])
+def test_endpoint():
+    """Test endpoint to verify server is running."""
+    return jsonify({"status": "ok", "message": "Server is running"}), 200
+
+
+@app.route("/analyze_interview", methods=["POST", "OPTIONS"])
+def analyze_interview_route():
+    """Main route for comprehensive interview analysis."""
+    # Add CORS headers for preflight requests
+    if request.method == 'OPTIONS':
+        headers = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+            'Access-Control-Max-Age': '86400'  # 24 hours
+        }
+        return ('', 204, headers)
+        
+    try:
+        logger.info("Received analyze_interview request")
+        
+        # Check for required file
+        if 'video' not in request.files:
+            logger.error("No video file in request")
+            return jsonify({"error": "Video file is required"}), 400
+
+        video_file = request.files['video']
+        if not video_file:
+            logger.error("Empty video file")
+            return jsonify({"error": "Empty video file"}), 400
+
+        # Get additional form data
+        role_applied = request.form.get('role_applied', '')
+        tech_skills = request.form.get('tech_skills', '')
+        candidate_name = request.form.get('candidate_name', 'Candidate')
+        tech_skills_list = [skill.strip() for skill in tech_skills.split(',')] if tech_skills else []
+
+        # Create temporary video file
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as video_temp:
+                video_file.save(video_temp.name)
+                video_temp_path = video_temp.name
+                logger.info(f"Video saved to temporary file: {video_temp_path}")
+        except Exception as e:
+            logger.error(f"Error saving video file: {str(e)}")
+            return jsonify({"error": f"Failed to save video file: {str(e)}"}), 500
+
+        # Process video and audio in parallel
+        try:
+            emotion_analysis, transcript, interview_assessment = process_video_and_audio_parallel(
+                video_temp_path, role_applied, tech_skills_list
+            )
+        except Exception as e:
+            logger.error(f"Error during parallel processing: {str(e)}")
+            return jsonify({"error": str(e)}), 500
+
+        # Combine results
+        combined_results = {
+            "candidate_assessment": interview_assessment["candidate_assessment"],
+            "question_analysis": interview_assessment["question_analysis"],
+            "overall_recommendation": interview_assessment["overall_recommendation"],
+            "overall_feedback": interview_assessment["overall_feedback"],
+            "transcription": transcript,
+            "candidate_name": candidate_name,
+            "role_applied": role_applied,
+            "interview_date": datetime.now().strftime('%Y-%m-%d'),
+            "emotion_analysis": emotion_analysis
+        }
+
+        logger.info("Combined results created successfully")
+        logger.debug(f"Response data: {json.dumps(combined_results, indent=2)}")
+
+        # Clean up temporary video file
+        try:
+            os.unlink(video_temp_path)
+            logger.info("Temporary files cleaned up")
+        except Exception as e:
+            logger.warning(f"Error cleaning up temporary files: {str(e)}")
+
+        # Add CORS headers to response
+        response = jsonify(combined_results)
+        response.headers.add('Access-Control-Allow-Origin', '*')
+        return response
+
+    except Exception as e:
+        logger.error(f"Error in analyze_interview_route: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/download_assessment', methods=['POST', 'OPTIONS'])
+def download_assessment():
+    """Download comprehensive assessment report."""
+    # Add CORS headers for preflight requests
+    if request.method == 'OPTIONS':
+        headers = {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type',
+            'Access-Control-Max-Age': '86400'  # 24 hours
+        }
+        return ('', 204, headers)
+        
+    try:
+        data = request.json
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        # Create Excel writer object
+        output = io.BytesIO()
+        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+            workbook = writer.book
+            
+            # Define formats
+            header_format = workbook.add_format({
+                'bold': True,
+                'bg_color': '#CCCCCC',
+                'border': 1
+            })
+            
+            cell_format = workbook.add_format({
+                'border': 1
+            })
+            
+            # Summary Sheet
+            summary_data = {
+                'Metric': [
+                    'Technical Knowledge',
+                    'Problem Solving',
+                    'Communication',
+                    'Overall Recommendation',
+                    'Total Faces Detected'
+                ],
+                'Score/Rating': [
+                    f"{data['candidate_assessment']['technical_knowledge']['score']}/10",
+                    f"{data['candidate_assessment']['problem_solving']['score']}/10",
+                    f"{data['candidate_assessment']['communication']['score']}/10",
+                    data['overall_recommendation'],
+                    data['emotion_analysis'].get('total_faces', 0)
+                ]
+            }
+            
+            summary_df = pd.DataFrame(summary_data)
+            summary_df.to_excel(writer, sheet_name='Summary', index=False)
+            
+            # Format Summary sheet
+            summary_sheet = writer.sheets['Summary']
+            summary_sheet.set_column('A:A', 25)
+            summary_sheet.set_column('B:B', 20)
+            
+            # Apply formats to Summary sheet
+            for col_num, value in enumerate(summary_df.columns.values):
+                summary_sheet.write(0, col_num, value, header_format)
+            
+            for row_num in range(len(summary_df)):
+                for col_num in range(len(summary_df.columns)):
+                    summary_sheet.write(row_num + 1, col_num, summary_df.iloc[row_num, col_num], cell_format)
+            
+            # Technical Assessment Sheet
+            tech_data = []
+            
+            # Add technical knowledge
+            tech_data.append(['Technical Knowledge', f"{data['candidate_assessment']['technical_knowledge']['score']}/10", ''])
+            tech_data.append(['Strengths', '', ''])
+            for strength in data['candidate_assessment']['technical_knowledge']['strengths']:
+                tech_data.append(['', '', strength])
+            
+            tech_data.append(['Areas for Improvement', '', ''])
+            for area in data['candidate_assessment']['technical_knowledge']['areas_for_improvement']:
+                tech_data.append(['', '', area])
+            
+            # Add problem solving
+            tech_data.append(['Problem Solving', f"{data['candidate_assessment']['problem_solving']['score']}/10", ''])
+            tech_data.append(['Strengths', '', ''])
+            for strength in data['candidate_assessment']['problem_solving']['strengths']:
+                tech_data.append(['', '', strength])
+            
+            tech_data.append(['Areas for Improvement', '', ''])
+            for area in data['candidate_assessment']['problem_solving']['areas_for_improvement']:
+                tech_data.append(['', '', area])
+            
+            # Add communication
+            tech_data.append(['Communication', f"{data['candidate_assessment']['communication']['score']}/10", ''])
+            tech_data.append(['Strengths', '', ''])
+            for strength in data['candidate_assessment']['communication']['strengths']:
+                tech_data.append(['', '', strength])
+            
+            tech_data.append(['Areas for Improvement', '', ''])
+            for area in data['candidate_assessment']['communication']['areas_for_improvement']:
+                tech_data.append(['', '', area])
+            
+            # Create Technical Assessment dataframe
+            tech_df = pd.DataFrame(tech_data, columns=['Category', 'Score', 'Details'])
+            tech_df.to_excel(writer, sheet_name='Technical Assessment', index=False)
+            
+            # Format Technical Assessment sheet
+            tech_sheet = writer.sheets['Technical Assessment']
+            tech_sheet.set_column('A:A', 25)
+            tech_sheet.set_column('B:B', 15)
+            tech_sheet.set_column('C:C', 60)
+            
+            # Apply formats to Technical Assessment sheet
+            for col_num, value in enumerate(tech_df.columns.values):
+                tech_sheet.write(0, col_num, value, header_format)
+            
+            # Question Analysis Sheet
+            question_data = []
+            for qa in data['question_analysis']:
+                question_data.append([
+                    qa['question'],
+                    qa['answer_quality'],
+                    qa['feedback']
+                ])
+            
+            question_df = pd.DataFrame(question_data, columns=['Question', 'Answer Quality', 'Feedback'])
+            question_df.to_excel(writer, sheet_name='Question Analysis', index=False)
+            
+            # Format Question Analysis sheet
+            qa_sheet = writer.sheets['Question Analysis']
+            qa_sheet.set_column('A:A', 40)
+            qa_sheet.set_column('B:B', 15)
+            qa_sheet.set_column('C:C', 60)
+            
+            # Apply formats to Question Analysis sheet
+            for col_num, value in enumerate(question_df.columns.values):
+                qa_sheet.write(0, col_num, value, header_format)
+            
+            # Emotion Analysis Sheet
+            if 'emotion_analysis' in data and 'emotion_percentages' in data['emotion_analysis']:
+                emotion_data = {
+                    'Emotion': list(data['emotion_analysis']['emotion_percentages'].keys()),
+                    'Percentage': list(data['emotion_analysis']['emotion_percentages'].values()),
+                    'Count': [data['emotion_analysis']['emotion_counts'].get(emotion, 0) 
+                             for emotion in data['emotion_analysis']['emotion_percentages'].keys()]
+                }
+                
+                emotion_df = pd.DataFrame(emotion_data)
+                emotion_df.to_excel(writer, sheet_name='Emotion Analysis', index=False)
+                
+                # Format Emotion Analysis sheet
+                emotion_sheet = writer.sheets['Emotion Analysis']
+                emotion_sheet.set_column('A:A', 15)
+                emotion_sheet.set_column('B:B', 15)
+                emotion_sheet.set_column('C:C', 15)
+                
+                # Apply formats to Emotion Analysis sheet
+                for col_num, value in enumerate(emotion_df.columns.values):
+                    emotion_sheet.write(0, col_num, value, header_format)
+                
+                # Add a chart
+                chart = workbook.add_chart({'type': 'pie'})
+                chart.add_series({
+                    'name': 'Emotions',
+                    'categories': ['Emotion Analysis', 1, 0, len(emotion_df), 0],
+                    'values': ['Emotion Analysis', 1, 1, len(emotion_df), 1],
+                    'data_labels': {'percentage': True}
+                })
+                
+                chart.set_title({'name': 'Emotion Distribution'})
+                chart.set_style(10)
+                emotion_sheet.insert_chart('E2', chart, {'x_scale': 1.5, 'y_scale': 1.5})
+            
+            # Transcript Sheet
+            if 'transcription' in data:
+                transcript_data = {'Transcript': [data['transcription']]}
+                transcript_df = pd.DataFrame(transcript_data)
+                transcript_df.to_excel(writer, sheet_name='Transcript', index=False)
+                
+                # Format Transcript sheet
+                transcript_sheet = writer.sheets['Transcript']
+                transcript_sheet.set_column('A:A', 100)
+                
+                # Apply formats to Transcript sheet
+                transcript_sheet.write(0, 0, 'Transcript', header_format)
+            
+            # Overall Feedback Sheet
+            overall_data = {'Overall Feedback': [data['overall_feedback']]}
+            overall_df = pd.DataFrame(overall_data)
+            overall_df.to_excel(writer, sheet_name='Overall Feedback', index=False)
+            
+            # Format Overall Feedback sheet
+            overall_sheet = writer.sheets['Overall Feedback']
+            overall_sheet.set_column('A:A', 100)
+            
+            # Apply formats to Overall Feedback sheet
+            overall_sheet.write(0, 0, 'Overall Feedback', header_format)
+
+        # Prepare the output file for download
+        output.seek(0)
+        candidate_name = data.get('candidate_name', 'Candidate').replace(' ', '_')
+        role_applied = data.get('role_applied', 'Role').replace(' ', '_')
+        filename = f"{candidate_name}_{role_applied}_Assessment.xlsx"
+        
+        # Create response with appropriate headers
+        response = send_file(
+            output,
+            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            as_attachment=True,
+            download_name=filename
+        )
+        
+        # Add CORS headers
+        response.headers.add('Access-Control-Allow-Origin', '*')
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error generating assessment report: {str(e)}")
+        return jsonify({"error": f"Failed to generate assessment report: {str(e)}"}), 500
+
+
+if __name__ == "__main__":
+    # Setup Flask app with proper settings for production
+    PORT = int(os.environ.get("PORT", 5000))
+    app.run(host="0.0.0.0", port=PORT, debug=False, threaded=True)

index.html

@@ -0,0 +1,1201 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Technical Interview Analyzer</title>
+  <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.4/css/all.min.css">
+  <style>
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 20px;
+      background-color: #f5f5f5;
+    }
+    .container {
+      background-color: white;
+      padding: 30px;
+      border-radius: 12px;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+      margin-bottom: 30px;
+    }
+    h1, h2, h3 {
+      color: #2c3e50;
+    }
+    h1 {
+      text-align: center;
+      margin-bottom: 30px;
+    }
+    .section {
+      margin-bottom: 40px;
+    }
+    .upload-section {
+      text-align: center;
+      margin: 30px 0;
+      padding: 20px;
+      background-color: #f8f9fa;
+      border-radius: 8px;
+    }
+    #uploadForm {
+      margin: 20px 0;
+    }
+    .results-container {
+      margin-top: 30px;
+    }
+    .progress-bar {
+      background-color: #3498db;
+    }
+    button {
+      background-color: #3498db;
+      color: white;
+      padding: 12px 24px;
+      border: none;
+      border-radius: 6px;
+      cursor: pointer;
+      font-size: 16px;
+      transition: background-color 0.3s;
+    }
+    button:hover {
+      background-color: #2980b9;
+    }
+    .loading {
+      text-align: center;
+      margin: 20px 0;
+      display: none;
+    }
+    .error {
+      color: #e74c3c;
+      padding: 10px;
+      background-color: #fde8e8;
+      border-radius: 4px;
+      margin: 10px 0;
+    }
+    /* Print styles */
+    @media print {
+      body {
+        padding: 0;
+        margin: 0;
+      }
+      .container {
+        box-shadow: none;
+        padding: 20px;
+      }
+      .upload-section,
+      #uploadForm,
+      #loading,
+      #downloadExcelBtn,
+      .btn {
+        display: none !important;
+      }
+      .assessment-card {
+        break-inside: avoid;
+      }
+    }
+    .loading-overlay {
+        display: none;
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 1000;
+    }
+
+    .loading-content {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        background: white;
+        padding: 30px;
+        border-radius: 10px;
+        text-align: center;
+    }
+
+    .spinner {
+        width: 50px;
+        height: 50px;
+        border: 5px solid #f3f3f3;
+        border-top: 5px solid #3498db;
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+        margin: 0 auto 20px;
+    }
+
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+
+    .loading-text {
+        color: #2c3e50;
+        font-size: 18px;
+        margin-top: 15px;
+    }
+
+    .progress-steps {
+        margin-top: 15px;
+        text-align: left;
+    }
+
+    .step {
+        margin: 8px 0;
+        color: #666;
+    }
+
+    .step.active {
+        color: #3498db;
+        font-weight: bold;
+    }
+
+    .step.completed {
+        color: #2ecc71;
+    }
+
+    .score-display {
+        display: flex;
+        align-items: center;
+        margin-bottom: 15px;
+    }
+
+    .score-number {
+        font-size: 2rem;
+        font-weight: bold;
+        margin-right: 15px;
+        color: #2c3e50;
+        min-width: 50px;
+        text-align: center;
+    }
+
+    .progress {
+        flex-grow: 1;
+        height: 15px;
+    }
+
+    .list-group-item {
+        border-left: none;
+        border-right: none;
+    }
+
+    .assessment-card {
+        margin-bottom: 25px;
+        border-radius: 10px;
+        overflow: hidden;
+    }
+
+    .assessment-card .card-header {
+        font-weight: bold;
+        padding: 15px;
+    }
+
+    .card-header-technical {
+        background-color: #4a90e2;
+        color: white;
+    }
+
+    .card-header-problem {
+        background-color: #50c878;
+        color: white;
+    }
+
+    .card-header-communication {
+        background-color: #6a5acd;
+        color: white;
+    }
+
+    .card-header-questions {
+        background-color: #ff7f50;
+        color: white;
+    }
+
+    .card-header-recommendation {
+        background-color: #2c3e50;
+        color: white;
+    }
+
+    .card-header-emotions {
+        background-color: #9b59b6;
+        color: white;
+    }
+
+    .badge-excellent {
+        background-color: #28a745;
+    }
+
+    .badge-good {
+        background-color: #4a90e2;
+    }
+
+    .badge-average {
+        background-color: #ffc107;
+        color: #212529;
+    }
+
+    .badge-poor {
+        background-color: #dc3545;
+    }
+
+    .recommendation-display {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        margin: 20px 0;
+    }
+
+    .recommendation-badge {
+        padding: 10px 20px;
+        font-size: 1.2rem;
+        margin-bottom: 15px;
+        border-radius: 30px;
+    }
+
+    .recommendation-hire {
+        background-color: #28a745;
+        color: white;
+    }
+
+    .recommendation-strong {
+        background-color: #4a90e2;
+        color: white;
+    }
+
+    .recommendation-consider {
+        background-color: #ffc107;
+        color: #212529;
+    }
+
+    .recommendation-reject {
+        background-color: #dc3545;
+        color: white;
+    }
+
+    .transcript-container {
+        max-height: 300px;
+        overflow-y: auto;
+        background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 5px;
+        margin-top: 15px;
+        border: 1px solid #dee2e6;
+    }
+
+    #accordionTranscript .accordion-button:not(.collapsed) {
+        background-color: #e7f5ff;
+        color: #0c63e4;
+    }
+
+    .question-card {
+        margin-bottom: 15px;
+        border-left: 4px solid #4a90e2;
+    }
+
+    .question-text {
+        font-weight: bold;
+    }
+
+    .answer-quality {
+        display: inline-block;
+        padding: 3px 10px;
+        border-radius: 15px;
+        font-size: 0.85rem;
+        margin: 5px 0;
+    }
+
+    .emotion-bar {
+        height: 30px;
+        margin-bottom: 10px;
+        border-radius: 5px;
+        position: relative;
+    }
+
+    .emotion-label {
+        position: absolute;
+        left: 10px;
+        top: 5px;
+        color: white;
+        font-weight: bold;
+        text-shadow: 1px 1px 1px rgba(0,0,0,0.5);
+    }
+
+    .emotion-percentage {
+        position: absolute;
+        right: 10px;
+        top: 5px;
+        color: white;
+        font-weight: bold;
+        text-shadow: 1px 1px 1px rgba(0,0,0,0.5);
+    }
+
+    .emotion-angry {
+        background-color: #e74c3c;
+    }
+
+    .emotion-disgust {
+        background-color: #8e44ad;
+    }
+
+    .emotion-fear {
+        background-color: #34495e;
+    }
+
+    .emotion-happy {
+        background-color: #27ae60;
+    }
+
+    .emotion-neutral {
+        background-color: #7f8c8d;
+    }
+
+    .emotion-sad {
+        background-color: #3498db;
+    }
+
+    .emotion-surprise {
+        background-color: #f39c12;
+    }
+
+    /* Add new styles for video preview */
+    .video-preview-container {
+      margin-top: 15px;
+      max-width: 100%;
+      display: none;
+    }
+
+    .video-preview {
+      width: 100%;
+      max-width: 640px;
+      margin: 0 auto;
+      display: block;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    /* Add processing status styles */
+    .processing-status {
+      margin-top: 10px;
+      padding: 10px;
+      border-radius: 5px;
+      background-color: #f8f9fa;
+      display: none;
+    }
+
+    .processing-status.success {
+      background-color: #d4edda;
+      color: #155724;
+    }
+
+    .processing-status.error {
+      background-color: #f8d7da;
+      color: #721c24;
+    }
+
+    /* Improve loading overlay */
+    .loading-overlay .progress {
+      width: 100%;
+      margin-top: 15px;
+      height: 10px;
+    }
+
+    .step-status {
+      display: inline-block;
+      margin-left: 10px;
+      font-size: 14px;
+    }
+
+    .step-time {
+      float: right;
+      color: #666;
+    }
+  </style>
+</head>
+<body>
+  <div class="loading-overlay" id="loadingOverlay">
+    <div class="loading-content">
+        <div class="spinner"></div>
+        <div class="loading-text">Processing your interview recording...</div>
+        <div class="progress-steps">
+            <div class="step" id="step1">1. Uploading video file...</div>
+            <div class="step" id="step2">2. Extracting audio and analyzing emotions...</div>
+            <div class="step" id="step3">3. Transcribing audio...</div>
+            <div class="step" id="step4">4. Analyzing technical interview...</div>
+        </div>
+    </div>
+  </div>
+  <div class="container section">
+    <h1>An AI Based Analyzer for Personal Attributes</h1>
+    <p class="text-center text-muted">Upload a recording of a technical interview to get AI-powered analysis and feedback</p>
+
+    <form id="uploadForm" class="mb-4">
+      <div class="row mb-3">
+        <div class="col-md-6">
+          <label for="candidateName" class="form-label">Candidate Name</label>
+          <input type="text" id="candidateName" name="candidate_name" class="form-control" placeholder="Enter candidate name" required>
+        </div>
+        <div class="col-md-6">
+          <label for="roleApplied" class="form-label">Role Applied For</label>
+          <input type="text" id="roleApplied" name="role_applied" class="form-control" placeholder="e.g. Senior Full Stack Developer" required>
+        </div>
+      </div>
+      <div class="mb-3">
+        <label for="techSkills" class="form-label">Technical Skills to Evaluate (comma-separated)</label>
+        <input type="text" id="techSkills" name="tech_skills" class="form-control" placeholder="e.g. JavaScript, React, Node.js, System Design">
+      </div>
+      <div class="mb-3">
+        <label for="videoFile" class="form-label">Upload Interview Recording</label>
+        <input type="file" id="videoFile" name="video" accept="video/*" class="form-control" required>
+        <div class="form-text">Upload a video recording of the technical interview (.mp4, .mov, .avi)</div>
+        <div class="video-preview-container">
+          <video id="videoPreview" class="video-preview" controls>
+            Your browser does not support the video tag.
+          </video>
+        </div>
+        <div id="processingStatus" class="processing-status"></div>
+      </div>
+      <div class="d-grid">
+        <button type="submit" class="btn btn-primary">
+          <i class="fas fa-analytics"></i> Analyze Interview
+        </button>
+      </div>
+    </form>
+  </div>
+
+  <!-- Assessment Results Section -->
+  <div class="container section" id="assessmentResultContainer" style="display:none;">
+    <h2 class="text-center mb-4">Interview Assessment Results</h2>
+    <div id="candidateInfo" class="text-center mb-4"></div>
+
+    <div class="row">
+      <!-- Technical Knowledge Section -->
+      <div class="col-md-4">
+        <div class="card assessment-card">
+          <div class="card-header card-header-technical">
+            <i class="fas fa-code"></i> Technical Knowledge
+          </div>
+          <div class="card-body">
+            <div id="technicalScore" class="score-display">
+              <div class="score-number">-</div>
+              <div class="progress">
+                <div class="progress-bar" role="progressbar" style="width: 0%" aria-valuenow="0" aria-valuemin="0" aria-valuemax="10"></div>
+              </div>
+            </div>
+            <h5>Strengths</h5>
+            <ul id="technicalStrengths" class="list-group list-group-flush mb-3"></ul>
+            <h5>Areas for Improvement</h5>
+            <ul id="technicalImprovements" class="list-group list-group-flush"></ul>
+          </div>
+        </div>
+      </div>
+
+      <!-- Problem Solving Section -->
+      <div class="col-md-4">
+        <div class="card assessment-card">
+          <div class="card-header card-header-problem">
+            <i class="fas fa-puzzle-piece"></i> Problem Solving
+          </div>
+          <div class="card-body">
+            <div id="problemSolvingScore" class="score-display">
+              <div class="score-number">-</div>
+              <div class="progress">
+                <div class="progress-bar" role="progressbar" style="width: 0%" aria-valuenow="0" aria-valuemin="0" aria-valuemax="10"></div>
+              </div>
+            </div>
+            <h5>Strengths</h5>
+            <ul id="problemSolvingStrengths" class="list-group list-group-flush mb-3"></ul>
+            <h5>Areas for Improvement</h5>
+            <ul id="problemSolvingImprovements" class="list-group list-group-flush"></ul>
+          </div>
+        </div>
+      </div>
+
+      <!-- Communication Section -->
+      <div class="col-md-4">
+        <div class="card assessment-card">
+          <div class="card-header card-header-communication">
+            <i class="fas fa-comments"></i> Communication
+          </div>
+          <div class="card-body">
+            <div id="communicationScore" class="score-display">
+              <div class="score-number">-</div>
+              <div class="progress">
+                <div class="progress-bar" role="progressbar" style="width: 0%" aria-valuenow="0" aria-valuemin="0" aria-valuemax="10"></div>
+              </div>
+            </div>
+            <h5>Strengths</h5>
+            <ul id="communicationStrengths" class="list-group list-group-flush mb-3"></ul>
+            <h5>Areas for Improvement</h5>
+            <ul id="communicationImprovements" class="list-group list-group-flush"></ul>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Emotion Analysis Section -->
+    <div class="card assessment-card">
+      <div class="card-header card-header-emotions">
+        <i class="fas fa-smile"></i> Emotion Analysis
+      </div>
+      <div class="card-body">
+        <p>Facial emotions detected throughout the interview:</p>
+        <div id="emotionAnalysis" class="mb-4"></div>
+        <div class="row">
+          <div class="col-md-6">
+            <p><strong>Total Faces Detected:</strong> <span id="totalFaces">-</span></p>
+            <p><strong>Frames Processed:</strong> <span id="framesProcessed">-</span></p>
+          </div>
+          <div class="col-md-6">
+            <p><strong>Frames with Faces:</strong> <span id="framesWithFaces">-</span></p>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Overall Recommendation -->
+    <div class="card assessment-card">
+      <div class="card-header card-header-recommendation">
+        <i class="fas fa-thumbs-up"></i> Overall Recommendation
+      </div>
+      <div class="card-body text-center">
+        <div id="overallRecommendation" class="recommendation-display">
+          <div class="recommendation-badge">-</div>
+        </div>
+        <div id="overallFeedback" class="mt-3"></div>
+      </div>
+    </div>
+
+    <!-- Questions Analysis Section -->
+    <div class="card assessment-card">
+      <div class="card-header card-header-questions">
+        <i class="fas fa-question-circle"></i> Question Analysis
+      </div>
+      <div class="card-body">
+        <div id="questionAnalysis"></div>
+      </div>
+    </div>
+
+    <!-- Interview Transcript -->
+    <div class="card">
+      <div class="card-header">
+        Interview Transcript
+      </div>
+      <div class="card-body">
+        <div class="accordion" id="accordionTranscript">
+          <div class="accordion-item">
+            <h2 class="accordion-header" id="headingTranscript">
+              <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#collapseTranscript" aria-expanded="false" aria-controls="collapseTranscript">
+                Show Full Transcript
+              </button>
+            </h2>
+            <div id="collapseTranscript" class="accordion-collapse collapse" aria-labelledby="headingTranscript" data-bs-parent="#accordionTranscript">
+              <div class="accordion-body">
+                <div id="transcriptText" class="transcript-container"></div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Action Buttons -->
+    <div class="d-flex justify-content-center gap-3 mt-4">
+      <button id="downloadExcelBtn" class="btn btn-success">
+        <i class="fas fa-file-excel"></i> Download Assessment Report
+      </button>
+      <button id="printAssessmentBtn" class="btn btn-secondary">
+        <i class="fas fa-print"></i> Print Assessment
+      </button>
+      <button id="newAnalysisBtn" class="btn btn-primary">
+        <i class="fas fa-plus"></i> New Analysis
+      </button>
+    </div>
+  </div>
+
+  <!-- Error Modal -->
+  <div class="modal fade" id="errorModal" tabindex="-1" aria-labelledby="errorModalLabel" aria-hidden="true">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header bg-danger text-white">
+          <h5 class="modal-title" id="errorModalLabel">Error</h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+        </div>
+        <div class="modal-body" id="errorModalBody">
+          An error occurred while processing your request.
+        </div>
+        <div class="modal-footer">
+          <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Bootstrap JS -->
+  <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
+
+  <!-- SheetJS (for Excel export) -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js"></script>
+
+  <!-- FileSaver.js (for Excel download) -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script>
+
+  <script>
+document.addEventListener('DOMContentLoaded', function() {
+  // Get DOM elements
+  const uploadForm = document.getElementById('uploadForm');
+  const loadingOverlay = document.getElementById('loadingOverlay');
+  const step1 = document.getElementById('step1');
+  const step2 = document.getElementById('step2');
+  const step3 = document.getElementById('step3');
+  const step4 = document.getElementById('step4');
+  const assessmentResultContainer = document.getElementById('assessmentResultContainer');
+  const downloadExcelBtn = document.getElementById('downloadExcelBtn');
+  const printAssessmentBtn = document.getElementById('printAssessmentBtn');
+  const newAnalysisBtn = document.getElementById('newAnalysisBtn');
+  const errorModal = new bootstrap.Modal(document.getElementById('errorModal'));
+  const errorModalBody = document.getElementById('errorModalBody');
+
+  // Store the current analysis results
+  let currentAnalysisResults = null;
+
+  // Test server connection on page load
+  async function testServerConnection() {
+    try {
+      const response = await fetch('/test');
+      if (!response.ok) {
+        throw new Error(`Server responded with status: ${response.status}`);
+      }
+      const data = await response.json();
+      console.log('Server connection test:', data);
+      return true;
+    } catch (error) {
+      console.error('Server connection test failed:', error);
+      showError('Server connection failed. Please check if the server is running.');
+      return false;
+    }
+  }
+
+  // Test connection on page load
+  testServerConnection();
+
+  // Form submission handler
+  uploadForm.addEventListener('submit', async function(e) {
+    e.preventDefault();
+    console.log('Form submission started');
+
+    // Test server connection before proceeding
+    const isServerConnected = await testServerConnection();
+    if (!isServerConnected) {
+      return;
+    }
+
+    // Get form data
+    const formData = new FormData(uploadForm);
+    const candidateName = formData.get('candidate_name');
+    const roleApplied = formData.get('role_applied');
+    const techSkills = formData.get('tech_skills');
+    const videoFile = formData.get('video');
+
+    // Validate video file
+    if (videoFile.size === 0) {
+      showError('Please select a valid video file.');
+      return;
+    }
+
+    // Check file size (max 100MB)
+    const maxSize = 100 * 1024 * 1024; // 100MB in bytes
+    if (videoFile.size > maxSize) {
+      showError('Video file is too large. Please select a file smaller than 100MB.');
+      return;
+    }
+
+    // Check file type
+    const allowedTypes = ['video/mp4', 'video/quicktime', 'video/x-msvideo'];
+    if (!allowedTypes.includes(videoFile.type)) {
+      showError('Please select a valid video file (MP4, MOV, or AVI).');
+      return;
+    }
+
+    console.log('Form data:', {
+      candidateName,
+      roleApplied,
+      techSkills,
+      videoFileName: videoFile.name,
+      videoFileSize: videoFile.size,
+      videoFileType: videoFile.type
+    });
+
+    // Validate form inputs
+    if (!candidateName || !roleApplied || !videoFile) {
+      showError('Please fill in all required fields.');
+      return;
+    }
+
+    try {
+      loadingOverlay.style.display = 'block';
+      const startTime = Date.now();
+
+      // Update processing status
+      processingStatus.innerHTML = `
+        <div class="d-flex align-items-center">
+          <i class="fas fa-spinner fa-spin me-2"></i>
+          <div>Processing video... Please wait</div>
+        </div>
+        <div class="progress mt-2">
+          <div class="progress-bar progress-bar-striped progress-bar-animated" style="width: 0%"></div>
+        </div>
+      `;
+      processingStatus.style.display = 'block';
+      processingStatus.className = 'processing-status';
+
+      // Send video to server for analysis
+      const response = await fetch('/analyze_interview', {
+        method: 'POST',
+        body: formData
+      });
+
+      console.log('Server response status:', response.status);
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error('Server error response:', errorText);
+        throw new Error(`Server responded with ${response.status}: ${errorText}`);
+      }
+
+      const results = await response.json();
+      console.log('Received results:', results);
+
+      if (!results || typeof results !== 'object') {
+        throw new Error('Invalid response format from server');
+      }
+
+      if (results.error) {
+        throw new Error(results.error);
+      }
+
+      // Store current results
+      currentAnalysisResults = results;
+      console.log('Results stored in currentAnalysisResults');
+
+      // Hide loading overlay
+      loadingOverlay.style.display = 'none';
+
+      // Make sure the results container is visible
+      assessmentResultContainer.style.display = 'block';
+      console.log('Results container displayed');
+
+      // Display results
+      await displayAnalysisResults(results);
+      console.log('Results displayed');
+
+      // Update processing status
+      const endTime = Date.now();
+      const duration = ((endTime - startTime) / 1000).toFixed(2);
+      processingStatus.innerHTML = `
+        <div class="d-flex align-items-center">
+          <i class="fas fa-check-circle text-success me-2"></i>
+          <div>Analysis completed in ${duration} seconds</div>
+        </div>
+      `;
+      processingStatus.style.display = 'block';
+      processingStatus.className = 'processing-status success';
+
+      // Scroll to results
+      assessmentResultContainer.scrollIntoView({ behavior: 'smooth' });
+      console.log('Scrolled to results');
+
+    } catch (error) {
+      console.error('Error in form submission:', error);
+      loadingOverlay.style.display = 'none';
+      showError('Failed to analyze the interview: ' + error.message);
+    }
+  });
+
+  // Download Excel report handler
+  downloadExcelBtn.addEventListener('click', async function() {
+    if (!currentAnalysisResults) {
+      showError('No analysis results available');
+      return;
+    }
+
+    try {
+      const response = await fetch('/download_assessment', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(currentAnalysisResults)
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to generate Excel report');
+      }
+
+      // Create a blob from the response
+      const blob = await response.blob();
+
+      // Create a download link
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.style.display = 'none';
+      a.href = url;
+      a.download = `${currentAnalysisResults.candidate_name.replace(/\s+/g, '_')}_interview_assessment.xlsx`;
+
+      // Append to the document and trigger click
+      document.body.appendChild(a);
+      a.click();
+
+      // Clean up
+      window.URL.revokeObjectURL(url);
+      document.body.removeChild(a);
+    } catch (error) {
+      console.error('Error downloading Excel:', error);
+      showError('Failed to download Excel report: ' + error.message);
+    }
+  });
+
+  // Print assessment handler
+  printAssessmentBtn.addEventListener('click', function() {
+    window.print();
+  });
+
+  // New analysis handler
+  newAnalysisBtn.addEventListener('click', function() {
+    // Hide results container
+    assessmentResultContainer.style.display = 'none';
+
+    // Reset form
+    uploadForm.reset();
+
+    // Scroll to top
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+  });
+
+  // Function to show error message
+  function showError(message) {
+    console.error('Error:', message);
+    errorModalBody.textContent = message;
+    errorModal.show();
+  }
+
+  // Function to update progress steps
+  function updateProgressStep(step) {
+    console.log('Updating to step:', step);
+    const steps = [step1, step2, step3, step4];
+    const startTime = new Date();
+
+    // Reset all steps
+    steps.forEach((el, index) => {
+      el.classList.remove('active', 'completed');
+      
+      // Add timing element if not exists
+      if (!el.querySelector('.step-time')) {
+        const timeSpan = document.createElement('span');
+        timeSpan.className = 'step-time';
+        el.appendChild(timeSpan);
+      }
+
+      // Add status indicator if not exists
+      if (!el.querySelector('.step-status')) {
+        const statusSpan = document.createElement('span');
+        statusSpan.className = 'step-status';
+        el.appendChild(statusSpan);
+      }
+    });
+
+    // Update steps based on progress
+    steps.forEach((el, index) => {
+      const stepNum = index + 1;
+      const statusSpan = el.querySelector('.step-status');
+      const timeSpan = el.querySelector('.step-time');
+
+      if (stepNum < step) {
+        el.classList.add('completed');
+        statusSpan.innerHTML = '<i class="fas fa-check text-success"></i>';
+        timeSpan.textContent = '✓';
+      } else if (stepNum === step) {
+        el.classList.add('active');
+        statusSpan.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+        timeSpan.textContent = 'Processing...';
+      } else {
+        statusSpan.innerHTML = '';
+        timeSpan.textContent = 'Waiting...';
+      }
+    });
+  }
+
+  // Function to display analysis results
+  async function displayAnalysisResults(results) {
+    console.log('Starting to display results');
+    try {
+      if (!results.candidate_assessment) {
+        throw new Error('Missing candidate assessment data');
+      }
+
+      // Update candidate info
+      const candidateInfo = document.getElementById('candidateInfo');
+      if (!candidateInfo) {
+        throw new Error('Cannot find candidateInfo element');
+      }
+
+      candidateInfo.innerHTML = `
+        <h3>${results.candidate_name || 'Candidate'}</h3>
+        <p class="text-muted">${results.role_applied || 'Role not specified'}</p>
+        <p>Interview Date: ${results.interview_date || new Date().toLocaleDateString()}</p>
+      `;
+      console.log('Updated candidate info');
+
+      // Update scores and assessments
+      await updateAssessmentSection('technical', results.candidate_assessment.technical_knowledge);
+      await updateAssessmentSection('problemSolving', results.candidate_assessment.problem_solving);
+      await updateAssessmentSection('communication', results.candidate_assessment.communication);
+      console.log('Updated assessment sections');
+
+      // Update emotion analysis
+      await updateEmotionAnalysis(results.emotion_analysis);
+      console.log('Updated emotion analysis');
+
+      // Update recommendation
+      await updateRecommendation(results);
+      console.log('Updated recommendation');
+
+      // Update question analysis
+      await updateQuestionAnalysis(results.question_analysis);
+      console.log('Updated question analysis');
+
+      // Update transcript
+      const transcriptText = document.getElementById('transcriptText');
+      if (transcriptText) {
+        transcriptText.textContent = results.transcription || 'No transcript available';
+        console.log('Updated transcript');
+      }
+
+    } catch (error) {
+      console.error('Error in displayAnalysisResults:', error);
+      showError('Error displaying results: ' + error.message);
+    }
+  }
+
+  // Helper function to update assessment sections
+  async function updateAssessmentSection(type, data) {
+    if (!data) {
+      console.warn(`No data provided for ${type} assessment`);
+      return;
+    }
+
+    try {
+      // Update score
+      const scoreElement = document.querySelector(`#${type}Score .score-number`);
+      const progressBar = document.querySelector(`#${type}Score .progress-bar`);
+      
+      if (scoreElement && progressBar) {
+        scoreElement.textContent = data.score || 0;
+        const width = ((data.score || 0) * 10) + '%';
+        progressBar.style.width = width;
+        progressBar.setAttribute('aria-valuenow', data.score || 0);
+      }
+
+      // Update strengths
+      const strengthsList = document.getElementById(`${type}Strengths`);
+      if (strengthsList) {
+        strengthsList.innerHTML = '';
+        (data.strengths || []).forEach(strength => {
+          const li = document.createElement('li');
+          li.className = 'list-group-item';
+          li.innerHTML = `<i class="fas fa-check-circle text-success me-2"></i>${strength}`;
+          strengthsList.appendChild(li);
+        });
+      }
+
+      // Update improvements
+      const improvementsList = document.getElementById(`${type}Improvements`);
+      if (improvementsList) {
+        improvementsList.innerHTML = '';
+        (data.areas_for_improvement || []).forEach(improvement => {
+          const li = document.createElement('li');
+          li.className = 'list-group-item';
+          li.innerHTML = `<i class="fas fa-arrow-circle-up text-primary me-2"></i>${improvement}`;
+          improvementsList.appendChild(li);
+        });
+      }
+    } catch (error) {
+      console.error(`Error updating ${type} assessment:`, error);
+    }
+  }
+
+  // Helper function to update emotion analysis
+  async function updateEmotionAnalysis(emotionData) {
+    if (!emotionData) {
+      console.warn('No emotion data provided');
+      return;
+    }
+
+    try {
+      const emotionAnalysis = document.getElementById('emotionAnalysis');
+      if (!emotionAnalysis) return;
+
+      emotionAnalysis.innerHTML = '';
+      
+      if (emotionData.emotion_percentages) {
+        const emotions = emotionData.emotion_percentages;
+        const sortedEmotions = Object.entries(emotions)
+          .sort((a, b) => b[1] - a[1])
+          .filter(([_, value]) => value > 0);
+
+        sortedEmotions.forEach(([emotion, percentage]) => {
+          const emotionBar = document.createElement('div');
+          emotionBar.className = `emotion-bar emotion-${emotion.toLowerCase()}`;
+          emotionBar.style.width = `${percentage}%`;
+          emotionBar.style.minWidth = '150px';
+
+          const emotionLabel = document.createElement('span');
+          emotionLabel.className = 'emotion-label';
+          emotionLabel.textContent = emotion.charAt(0).toUpperCase() + emotion.slice(1);
+
+          const emotionPercentage = document.createElement('span');
+          emotionPercentage.className = 'emotion-percentage';
+          emotionPercentage.textContent = `${percentage.toFixed(1)}%`;
+
+          emotionBar.appendChild(emotionLabel);
+          emotionBar.appendChild(emotionPercentage);
+          emotionAnalysis.appendChild(emotionBar);
+        });
+      }
+
+      // Update metrics
+      document.getElementById('totalFaces').textContent = emotionData.total_faces || 0;
+      document.getElementById('framesProcessed').textContent = emotionData.frames_processed || 0;
+      document.getElementById('framesWithFaces').textContent = emotionData.frames_with_faces || 0;
+    } catch (error) {
+      console.error('Error updating emotion analysis:', error);
+    }
+  }
+
+  // Helper function to update recommendation
+  async function updateRecommendation(results) {
+    try {
+      const recommendationBadge = document.querySelector('#overallRecommendation .recommendation-badge');
+      if (!recommendationBadge) return;
+
+      const recommendation = results.overall_recommendation || 'Consider';
+      recommendationBadge.textContent = recommendation;
+      recommendationBadge.className = 'recommendation-badge';
+
+      const recommendationLower = recommendation.toLowerCase();
+      if (recommendationLower.includes('hire')) {
+        recommendationBadge.classList.add('recommendation-hire');
+      } else if (recommendationLower.includes('strong')) {
+        recommendationBadge.classList.add('recommendation-strong');
+      } else if (recommendationLower.includes('consider')) {
+        recommendationBadge.classList.add('recommendation-consider');
+      } else {
+        recommendationBadge.classList.add('recommendation-reject');
+      }
+
+      const feedbackElement = document.getElementById('overallFeedback');
+      if (feedbackElement) {
+        feedbackElement.innerHTML = results.overall_feedback || 'No feedback available';
+      }
+    } catch (error) {
+      console.error('Error updating recommendation:', error);
+    }
+  }
+
+  // Helper function to update question analysis
+  async function updateQuestionAnalysis(questionData) {
+    try {
+      const questionAnalysis = document.getElementById('questionAnalysis');
+      if (!questionAnalysis) return;
+
+      questionAnalysis.innerHTML = '';
+      
+      if (Array.isArray(questionData)) {
+        questionData.forEach(qa => {
+          const questionCard = document.createElement('div');
+          questionCard.className = 'card question-card mb-3';
+          
+          questionCard.innerHTML = `
+            <div class="card-body">
+              <p class="question-text"><i class="fas fa-question-circle me-2"></i>${qa.question || 'Question not available'}</p>
+              <span class="answer-quality ${getQualityClass(qa.answer_quality)}">${qa.answer_quality || 'Not rated'}</span>
+              <p class="mt-2">${qa.feedback || 'No feedback available'}</p>
+            </div>
+          `;
+          
+          questionAnalysis.appendChild(questionCard);
+        });
+      }
+    } catch (error) {
+      console.error('Error updating question analysis:', error);
+    }
+  }
+
+  // Helper function to get the appropriate class for answer quality
+  function getQualityClass(quality) {
+    quality = quality.toLowerCase();
+    if (quality.includes('excellent')) return 'bg-success text-white';
+    if (quality.includes('good')) return 'bg-primary text-white';
+    if (quality.includes('average') || quality.includes('satisfactory')) return 'bg-warning';
+    return 'bg-danger text-white';
+  }
+
+  // Simulated progression for the demo
+  function simulateProgressSteps() {
+    setTimeout(() => updateProgressStep(1), 1000);
+    setTimeout(() => updateProgressStep(2), 3000);
+    setTimeout(() => updateProgressStep(3), 6000);
+    setTimeout(() => updateProgressStep(4), 9000);
+  }
+
+  // For the demo version, show all sections
+  function setupDemoMode() {
+    // Add event listener to show a loading demo
+    document.getElementById('uploadForm').addEventListener('submit', function(e) {
+      e.preventDefault();
+      loadingOverlay.style.display = 'block';
+      simulateProgressSteps();
+
+      // After "processing" display demo results
+      setTimeout(() => {
+        loadingOverlay.style.display = 'none';
+        displayDemoResults();
+      }, 12000);
+    });
+  }
+
+  // If in demo mode, set up the demo interface
+  if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
+    setupDemoMode();
+  }
+
+  // Add this to your existing JavaScript after DOMContentLoaded
+  const videoFile = document.getElementById('videoFile');
+  const videoPreview = document.getElementById('videoPreview');
+  const videoPreviewContainer = document.querySelector('.video-preview-container');
+  const processingStatus = document.getElementById('processingStatus');
+
+  // Video file preview handler
+  videoFile.addEventListener('change', function(e) {
+    const file = e.target.files[0];
+    if (file) {
+      const videoUrl = URL.createObjectURL(file);
+      videoPreview.src = videoUrl;
+      videoPreviewContainer.style.display = 'block';
+      
+      // Show file details
+      processingStatus.innerHTML = `
+        <div class="d-flex align-items-center">
+          <i class="fas fa-check-circle text-success me-2"></i>
+          <div>
+            <strong>File selected:</strong> ${file.name}<br>
+            <small class="text-muted">Size: ${(file.size / (1024 * 1024)).toFixed(2)} MB</small>
+          </div>
+        </div>
+      `;
+      processingStatus.style.display = 'block';
+      processingStatus.className = 'processing-status success';
+    }
+  });
+});
+  </script>
+</body>
+</html>

model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e15a75d012fa202b4c02220169059d2463a71228d6360e300221167550717550
+size 16139272

requirements.txt

@@ -0,0 +1,14 @@
+flask==3.0.2
+flask-cors==4.0.0
+python-dotenv==1.0.1
+groq==0.3.4
+google-generativeai==0.3.2
+pandas==2.2.1
+opencv-python==4.9.0.80
+numpy==1.26.4
+matplotlib==3.8.3
+tensorflow==2.15.0
+moviepy==1.0.3
+Werkzeug==3.0.1
+openpyxl==3.1.2
+xlsxwriter==3.1.9