Upload 16 files

Dockerfile.dockerfile

@@ -0,0 +1,11 @@
+# Dockerfile.backend
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "backend.api.main:app", "--host", "0.0.0.0", "--port", "8000"]

analytics_service.py

@@ -0,0 +1,66 @@
+# backend/services/analytics_service.py
+from datetime import datetime, timedelta
+from sqlalchemy import func, and_
+from database.models import Attendance, Employee
+import pandas as pd
+
+class AnalyticsService:
+    def __init__(self, db_session):
+        self.db = db_session
+        
+    def get_personnel_present(self, date=None):
+        """Get number of personnel present today"""
+        if date is None:
+            date = datetime.now().date()
+            
+        count = self.db.query(Attendance).filter(
+            Attendance.date == date,
+            Attendance.status.in_(['present', 'early', 'on_time', 'late'])
+        ).count()
+        return count
+        
+    def get_shift_coverage(self):
+        """Calculate shift coverage percentage"""
+        total_employees = self.db.query(Employee).count()
+        present_today = self.get_personnel_present()
+        
+        if total_employees == 0:
+            return 0
+        return (present_today / total_employees) * 100
+        
+    def get_staffing_trends(self, days=30):
+        """Get staffing trends for last N days"""
+        end_date = datetime.now().date()
+        start_date = end_date - timedelta(days=days)
+        
+        results = self.db.query(
+            Attendance.date,
+            func.count(Attendance.id).label('present_count')
+        ).filter(
+            Attendance.date.between(start_date, end_date),
+            Attendance.status.in_(['present', 'early', 'on_time', 'late'])
+        ).group_by(Attendance.date).all()
+        
+        return pd.DataFrame(results, columns=['date', 'present_count'])
+        
+    def get_missing_personnel(self):
+        """Get list of employees who haven't checked in today"""
+        today = datetime.now().date()
+        
+        # Get all employees
+        all_employees = self.db.query(Employee).all()
+        all_ids = [e.id for e in all_employees]
+        
+        # Get present employees today
+        present = self.db.query(Attendance.employee_id).filter(
+            Attendance.date == today,
+            Attendance.status.in_(['present', 'early', 'on_time', 'late'])
+        ).distinct().all()
+        present_ids = [p[0] for p in present]
+        
+        # Find missing
+        missing_ids = set(all_ids) - set(present_ids)
+        
+        return self.db.query(Employee).filter(
+            Employee.id.in_(missing_ids)
+        ).all()

app.py

@@ -0,0 +1,65 @@
+# frontend/app.py (Streamlit version)
+import streamlit as st
+import requests
+import websocket
+import json
+import base64
+from PIL import Image
+import io
+import numpy as np
+import cv2
+
+st.set_page_config(
+    page_title="AI Personnel Dashboard",
+    page_icon="👥",
+    layout="wide"
+)
+
+# Sidebar
+st.sidebar.title("🔍 Navigation")
+page = st.sidebar.selectbox(
+    "Select Page",
+    ["Live Feed", "Dashboard", "Analytics", "Employee Management"]
+)
+
+if page == "Live Feed":
+    st.title("📹 Live Personnel Monitoring")
+    
+    # Video feed placeholder
+    video_placeholder = st.empty()
+    metrics_placeholder = st.empty()
+    
+    # Connect to WebSocket
+    # ... WebSocket implementation for real-time feed
+
+elif page == "Dashboard":
+    st.title("📊 Dashboard")
+    
+    # Fetch analytics
+    response = requests.get("http://localhost:8000/api/analytics/dashboard")
+    data = response.json()
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("👥 Personnel Present", data['personnel_present'])
+    
+    with col2:
+        st.metric("📈 Shift Coverage", f"{data['shift_coverage']:.1f}%")
+    
+    with col3:
+        st.metric("📅 Total Employees", 50)  # Fetch from DB
+    
+    with col4:
+        missing_count = len(data['missing_personnel'])
+        st.metric("⚠️ Missing Personnel", missing_count)
+    
+    # Staffing trends chart
+    st.subheader("Staffing Trends (Last 30 Days)")
+    # ... Plot trends using matplotlib/plotly
+    
+    # Missing personnel alerts
+    if missing_count > 0:
+        st.warning(f"⚠️ {missing_count} employees haven't checked in today!")
+        for employee in data['missing_personnel']:
+            st.write(f"- {employee['name']}")

attendance_manager.py

@@ -0,0 +1,50 @@
+# backend/core/attendance_manager.py
+from datetime import datetime, timedelta
+from sqlalchemy.orm import Session
+from database.models import Attendance, Employee
+import logging
+
+class AttendanceManager:
+    def __init__(self, db_session: Session):
+        self.db = db_session
+        self.attendance_cache = {}
+        self.grace_period_minutes = 15
+        
+    def mark_attendance(self, employee_id, timestamp=None):
+        """Mark attendance for an employee"""
+        if timestamp is None:
+            timestamp = datetime.now()
+            
+        # Check if already marked today
+        today = timestamp.date()
+        existing = self.db.query(Attendance).filter(
+            Attendance.employee_id == employee_id,
+            Attendance.date == today
+        ).first()
+        
+        if existing:
+            existing.check_out = timestamp
+            existing.status = 'present'
+        else:
+            # Determine if early/late/on-time
+            status = self._determine_status(timestamp)
+            attendance = Attendance(
+                employee_id=employee_id,
+                date=today,
+                check_in=timestamp,
+                status=status
+            )
+            self.db.add(attendance)
+        
+        self.db.commit()
+        return True
+        
+    def _determine_status(self, timestamp):
+        """Determine if employee is on-time, late, or early"""
+        shift_start = timestamp.replace(hour=9, minute=0, second=0)
+        if timestamp < shift_start:
+            return 'early'
+        elif timestamp <= shift_start + timedelta(minutes=self.grace_period_minutes):
+            return 'on_time'
+        else:
+            return 'late'

capture_screenshots.py

@@ -0,0 +1,19 @@
+# capture_screenshots.py
+import cv2
+import numpy as np
+
+def create_demo_screenshot():
+    """Generate visual screenshots for portfolio"""
+    
+    # Create simulated dashboard images
+    dashboard = np.zeros((800, 1200, 3), dtype=np.uint8)
+    
+    # Add simulated metrics
+    cv2.rectangle(dashboard, (50, 50), (250, 150), (30, 30, 30), -1)
+    cv2.putText(dashboard, "👥 8 Personnel Present", (70, 110),
+               cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+    
+    # Save
+    cv2.imwrite('dashboard_screenshot.jpg', dashboard)
+
+create_demo_screenshot()

create_demo.py

@@ -0,0 +1,26 @@
+# create_demo_gif.py
+import imageio
+import cv2
+import os
+
+def create_demo_gif(video_path, output_path='demo.gif', duration=0.5):
+    """Create GIF from video for portfolio"""
+    reader = imageio.get_reader(video_path)
+    fps = reader.get_meta_data()['fps']
+    
+    # Extract frames (every 3rd frame)
+    frames = []
+    for i, frame in enumerate(reader):
+        if i % 3 == 0:
+            # Convert to RGB
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frames.append(frame_rgb)
+        if len(frames) >= 20:  # Limit GIF length
+            break
+    
+    # Save as GIF
+    imageio.mimsave(output_path, frames, duration=duration)
+    print(f"✅ GIF saved to {output_path}")
+
+# Usage
+create_demo_gif('demo_video.mp4')

demo_live.py

@@ -0,0 +1,56 @@
+# demo_live.py - Simple script to run a live demo
+import cv2
+from core.face_detection import FaceDetector
+from core.face_recognition import FaceRecognizer
+from core.attendance_manager import AttendanceManager
+import time
+
+def run_live_demo():
+    """Run live demo with webcam"""
+    # Initialize components
+    detector = FaceDetector()
+    recognizer = FaceRecognizer()
+    
+    # Open webcam
+    cap = cv2.VideoCapture(0)
+    
+    print("🎥 Live Demo Started - Press 'q' to quit")
+    print("👤 Show your face to the camera")
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        # Detect and recognize
+        faces = detector.detect_faces(frame)
+        for face_data in faces:
+            name = recognizer.recognize_face(face_data['face_img'])
+            
+            # Draw results
+            x1, y1, x2, y2 = face_data['bbox']
+            color = (0, 255, 0) if name else (0, 0, 255)
+            label = name if name else "Unknown"
+            
+            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+            cv2.putText(frame, label, (x1, y1-10), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
+            
+            # Show confidence
+            cv2.putText(frame, f"Conf: {face_data['confidence']:.2f}", 
+                       (x1, y2+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+        
+        # Display stats
+        cv2.putText(frame, f"Faces Detected: {len(faces)}", (10, 30),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        cv2.imshow('AI Attendance Demo', frame)
+        
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    cap.release()
+    cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+    run_live_demo()

demo_simulated.py

@@ -0,0 +1,90 @@
+# demo_simulated.py - Generate realistic demo data
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import random
+
+class SimulatedDemo:
+    """Generate simulated attendance data for dashboard demo"""
+    
+    def __init__(self):
+        self.employees = self._create_employees()
+        self.attendance_log = []
+        
+    def _create_employees(self):
+        """Create employee database"""
+        names = [
+            "Alice Johnson", "Bob Smith", "Carol White", 
+            "David Brown", "Eve Davis", "Frank Wilson",
+            "Grace Lee", "Henry Kim", "Ivy Chen", "Jack Taylor"
+        ]
+        
+        employees = []
+        for i, name in enumerate(names, 1):
+            employees.append({
+                'id': i,
+                'name': name,
+                'department': random.choice(['Engineering', 'Sales', 'HR', 'Marketing']),
+                'shift_start': '09:00',
+                'shift_end': '18:00'
+            })
+        return employees
+    
+    def generate_attendance(self, days=30):
+        """Generate simulated attendance data"""
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days)
+        
+        attendance = []
+        
+        for day in range(days):
+            current_date = start_date + timedelta(days=day)
+            # Skip weekends
+            if current_date.weekday() >= 5:
+                continue
+                
+            for employee in self.employees:
+                # 90% attendance rate
+                if random.random() < 0.9:
+                    check_in = self._random_time(current_date, 8, 10)
+                    check_out = self._random_time(current_date, 17, 19)
+                    
+                    status = self._determine_status(check_in, '09:00')
+                    
+                    attendance.append({
+                        'employee_name': employee['name'],
+                        'date': current_date.strftime('%Y-%m-%d'),
+                        'check_in': check_in.strftime('%H:%M'),
+                        'check_out': check_out.strftime('%H:%M'),
+                        'status': status,
+                        'department': employee['department']
+                    })
+        
+        self.attendance_log = pd.DataFrame(attendance)
+        return self.attendance_log
+    
+    def _random_time(self, date, hour_start, hour_end):
+        """Generate random time within range"""
+        hour = random.randint(hour_start, hour_end)
+        minute = random.randint(0, 59)
+        return date.replace(hour=hour, minute=minute)
+    
+    def _determine_status(self, check_in, shift_start):
+        """Determine attendance status"""
+        shift_hour, shift_min = map(int, shift_start.split(':'))
+        shift_start_time = check_in.replace(hour=shift_hour, minute=shift_min)
+        
+        if check_in < shift_start_time:
+            return 'early'
+        elif check_in <= shift_start_time + timedelta(minutes=15):
+            return 'on_time'
+        else:
+            return 'late'
+
+# Generate and save demo data
+demo = SimulatedDemo()
+attendance_data = demo.generate_attendance()
+
+# Save as CSV for dashboard
+attendance_data.to_csv('demo_attendance_data.csv', index=False)
+print("✅ Demo data generated and saved to 'demo_attendance_data.csv'")

demo_video.py

@@ -0,0 +1,80 @@
+# demo_video.py - Process a video file
+def process_video_demo(video_path='sample_video.mp4'):
+    """Process a pre-recorded video for demo"""
+    cap = cv2.VideoCapture(video_path)
+    
+    # Setup video writer for output
+    output_path = 'demo_output.mp4'
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, 30.0, 
+                         (int(cap.get(3)), int(cap.get(4))))
+    
+    detector = FaceDetector()
+    recognizer = FaceRecognizer()
+    
+    frame_count = 0
+    recognition_results = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        frame_count += 1
+        
+        # Process every 3rd frame for speed
+        if frame_count % 3 == 0:
+            faces = detector.detect_faces(frame)
+            
+            for face_data in faces:
+                name = recognizer.recognize_face(face_data['face_img'])
+                recognition_results.append({
+                    'frame': frame_count,
+                    'name': name,
+                    'confidence': float(face_data['confidence'])
+                })
+                
+                # Draw on frame
+                x1, y1, x2, y2 = face_data['bbox']
+                if name:
+                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 3)
+                    cv2.putText(frame, f"✅ {name}", (x1, y1-10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+                else:
+                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 0, 255), 2)
+                    cv2.putText(frame, "❌ Unknown", (x1, y1-10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+        
+        out.write(frame)
+    
+    cap.release()
+    out.release()
+    
+    # Generate demo report
+    generate_demo_report(recognition_results)
+    print(f"✅ Demo video saved to {output_path}")
+
+def generate_demo_report(results):
+    """Create a report showing recognition accuracy"""
+    recognized = [r for r in results if r['name']]
+    unknown = [r for r in results if not r['name']]
+    
+    report = f"""
+    📊 Demo Results Report
+    {'='*40}
+    Total Faces Processed: {len(results)}
+    Successfully Recognized: {len(recognized)} ({len(recognized)/len(results)*100:.1f}%)
+    Unknown Faces: {len(unknown)}
+    Average Confidence: {sum(r['confidence'] for r in recognized)/len(recognized):.2f}
+    
+    Recognized Personnel:
+    """
+    # Group by name
+    from collections import Counter
+    name_counts = Counter(r['name'] for r in recognized)
+    for name, count in name_counts.items():
+        report += f"  - {name}: {count} detections\n"
+    
+    with open('demo_report.txt', 'w') as f:
+        f.write(report)
+    print(report)

face_detection.py

@@ -0,0 +1,27 @@
+# backend/core/face_detection.py
+import cv2
+from ultralytics import YOLO
+import numpy as np
+
+class FaceDetector:
+    def __init__(self, model_path='yolov8n-face.pt'):
+        self.model = YOLO(model_path)
+        self.confidence_threshold = 0.5
+        
+    def detect_faces(self, frame):
+        """Detect faces in a frame using YOLO"""
+        results = self.model(frame)
+        faces = []
+        
+        for result in results:
+            boxes = result.boxes
+            for box in boxes:
+                if box.conf > self.confidence_threshold:
+                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
+                    face = frame[y1:y2, x1:x2]
+                    faces.append({
+                        'bbox': (x1, y1, x2, y2),
+                        'face_img': face,
+                        'confidence': box.conf
+                    })
+        return faces

face_recognition.py

@@ -0,0 +1,42 @@
+# backend/core/face_recognition.py
+import face_recognition
+import numpy as np
+import pickle
+import os
+
+class FaceRecognizer:
+    def __init__(self, encodings_path='models/face_encodings.pkl'):
+        self.known_face_encodings = []
+        self.known_face_names = []
+        self.load_encodings(encodings_path)
+        
+    def load_encodings(self, path):
+        """Load pre-computed face encodings"""
+        if os.path.exists(path):
+            with open(path, 'rb') as f:
+                data = pickle.load(f)
+                self.known_face_encodings = data['encodings']
+                self.known_face_names = data['names']
+                
+    def recognize_face(self, face_img):
+        """Recognize a single face"""
+        if face_img is None or face_img.size == 0:
+            return None
+            
+        # Get face encoding
+        face_locations = face_recognition.face_locations(face_img)
+        if not face_locations:
+            return None
+            
+        face_encoding = face_recognition.face_encodings(face_img, face_locations)[0]
+        
+        # Compare with known faces
+        matches = face_recognition.compare_faces(
+            self.known_face_encodings, 
+            face_encoding
+        )
+        
+        if True in matches:
+            matched_index = matches.index(True)
+            return self.known_face_names[matched_index]
+        return None

interview_demo.py

@@ -0,0 +1,95 @@
+# interview_demo.py - Streamlit app for interviews
+import streamlit as st
+import cv2
+import tempfile
+import numpy as np
+from PIL import Image
+
+def interview_demo_app():
+    st.set_page_config(page_title="Live Demo", layout="wide")
+    
+    st.title("🎯 Live Demo - AI Attendance System")
+    
+    st.info("""
+    **How to demonstrate:**
+    1. Click 'Start Camera' below
+    2. Show your face to the camera
+    3. See real-time detection and recognition
+    4. Watch attendance log update automatically
+    """)
+    
+    # Sidebar with status
+    with st.sidebar:
+        st.header("🔴 System Status")
+        st.success("✅ Camera Ready")
+        st.success("✅ Model Loaded")
+        st.success("✅ Database Connected")
+        
+        st.header("📊 Session Stats")
+        if 'detections' not in st.session_state:
+            st.session_state.detections = []
+        
+        st.metric("Faces Detected", len(st.session_state.detections))
+    
+    # Camera feed
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.subheader("📹 Live Feed")
+        camera_placeholder = st.empty()
+        
+        # Start camera button
+        if st.button("🚀 Start Camera", use_container_width=True):
+            cap = cv2.VideoCapture(0)
+            
+            if not cap.isOpened():
+                st.error("⚠️ Could not access camera")
+            else:
+                # Process frames
+                frame_count = 0
+                while True:
+                    ret, frame = cap.read()
+                    if not ret:
+                        break
+                    
+                    # Your detection code here
+                    # For demo, just show frame with overlay
+                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    frame = cv2.putText(frame, "🟢 Live Demo", (10, 30),
+                                      cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+                    
+                    camera_placeholder.image(frame, use_container_width=True)
+                    
+                    # Simulate detections
+                    if frame_count % 30 == 0:
+                        st.session_state.detections.append({
+                            'time': datetime.now(),
+                            'name': 'Demo User'
+                        })
+                    
+                    frame_count += 1
+    
+    with col2:
+        st.subheader("📋 Live Attendance")
+        attendance_table = st.empty()
+        
+        # Show attendance log
+        if st.session_state.detections:
+            df = pd.DataFrame(st.session_state.detections)
+            attendance_table.dataframe(df.tail(10))
+        else:
+            st.info("Waiting for detections...")
+    
+    # Demo controls
+    col3, col4 = st.columns(2)
+    with col3:
+        if st.button("🧹 Clear Log", use_container_width=True):
+            st.session_state.detections = []
+            st.rerun()
+    with col4:
+        if st.button("📥 Export Demo Data", use_container_width=True):
+            # Export functionality
+            st.success("✅ Demo data exported!")
+
+if __name__ == "__main__":
+    interview_demo_app()

mock_dashboard.py

@@ -0,0 +1,66 @@
+# mock_dashboard.py - Show dashboard working without webcam
+import streamlit as st
+import pandas as pd
+from datetime import datetime
+import plotly.express as px
+
+# Load demo data
+df = pd.read_csv('demo_attendance_data.csv')
+
+def show_mock_dashboard():
+    """Display dashboard with mock data"""
+    st.title("👥 AI Personnel Dashboard - Demo")
+    
+    # Add watermark
+    st.markdown("""
+    <div style='position: fixed; bottom: 0; right: 0; 
+                background: rgba(255,255,255,0.8); padding: 10px;'>
+        🎯 Demo Data - Not Live
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    today = datetime.now().strftime('%Y-%m-%d')
+    today_data = df[df['date'] == today]
+    
+    with col1:
+        st.metric("👥 Present Today", len(today_data))
+    
+    with col2:
+        total_employees = 50
+        coverage = (len(today_data) / total_employees) * 100
+        st.metric("📈 Coverage", f"{coverage:.1f}%")
+    
+    with col3:
+        late = len(today_data[today_data['status'] == 'late'])
+        st.metric("⏰ Late Arrivals", late)
+    
+    with col4:
+        missing = total_employees - len(today_data)
+        st.metric("⚠️ Missing", missing)
+    
+    # Charts
+    st.subheader("📊 Attendance Trends")
+    
+    daily_attendance = df.groupby('date').size().reset_index(name='count')
+    fig = px.line(daily_attendance, x='date', y='count', 
+                  title='Daily Attendance Trend')
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Department breakdown
+    st.subheader("🏢 Department-wise Attendance")
+    dept_data = today_data.groupby('department').size().reset_index(name='count')
+    fig = px.bar(dept_data, x='department', y='count', 
+                 title='Today\'s Attendance by Department')
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Missing personnel
+    st.subheader("⚠️ Missing Personnel Alert")
+    missing_emps = ['Alice Johnson', 'Bob Smith', 'Carol White']
+    for emp in missing_emps:
+        st.warning(f"🔴 {emp} has not checked in today")
+
+if __name__ == "__main__":
+    show_mock_dashboard()

sql.sql

@@ -0,0 +1,35 @@
+-- PostgreSQL Schema
+CREATE TABLE employees (
+    id SERIAL PRIMARY KEY,
+    employee_id VARCHAR(50) UNIQUE NOT NULL,
+    name VARCHAR(100) NOT NULL,
+    department VARCHAR(100),
+    position VARCHAR(100),
+    shift_start TIME,
+    shift_end TIME,
+    email VARCHAR(100),
+    face_encoding BYTEA,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE attendance (
+    id SERIAL PRIMARY KEY,
+    employee_id INTEGER REFERENCES employees(id),
+    date DATE NOT NULL,
+    check_in TIMESTAMP,
+    check_out TIMESTAMP,
+    status VARCHAR(20),
+    location VARCHAR(100),
+    device_id VARCHAR(50),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE alerts (
+    id SERIAL PRIMARY KEY,
+    type VARCHAR(50),
+    employee_id INTEGER REFERENCES employees(id),
+    message TEXT,
+    severity VARCHAR(20),
+    read BOOLEAN DEFAULT FALSE,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);

video_processor.py

@@ -0,0 +1,55 @@
+# backend/core/video_processor.py
+import cv2
+import asyncio
+from datetime import datetime
+from core.face_detection import FaceDetector
+from core.face_recognition import FaceRecognizer
+from core.attendance_manager import AttendanceManager
+
+class VideoProcessor:
+    def __init__(self, detector, recognizer, attendance_manager):
+        self.detector = detector
+        self.recognizer = recognizer
+        self.attendance_manager = attendance_manager
+        self.frame_buffer = []
+        self.processing_interval = 0.5  # Process every 0.5 seconds
+        
+    async def process_video(self, video_source=0):
+        """Process video stream from camera or file"""
+        cap = cv2.VideoCapture(video_source)
+        
+        if not cap.isOpened():
+            raise ValueError("Could not open video source")
+            
+        last_process_time = datetime.now()
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            # Process at intervals for efficiency
+            current_time = datetime.now()
+            if (current_time - last_process_time).total_seconds() >= self.processing_interval:
+                # Detect faces
+                faces = self.detector.detect_faces(frame)
+                
+                for face_data in faces:
+                    # Recognize face
+                    name = self.recognizer.recognize_face(face_data['face_img'])
+                    if name:
+                        # Mark attendance
+                        employee_id = self._get_employee_id(name)
+                        if employee_id:
+                            self.attendance_manager.mark_attendance(employee_id)
+                            # Draw bounding box with name
+                            x1, y1, x2, y2 = face_data['bbox']
+                            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                            cv2.putText(frame, name, (x1, y1-10), 
+                                      cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0,255,0), 2)
+                
+                last_process_time = current_time
+                
+            yield frame
+            
+        cap.release()

web_socket.py

@@ -0,0 +1,58 @@
+# backend/api/websocket.py
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+import asyncio
+import json
+import cv2
+import base64
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.websocket("/ws/video")
+async def video_websocket(websocket: WebSocket):
+    await websocket.accept()
+    
+    # Initialize components
+    detector = FaceDetector()
+    recognizer = FaceRecognizer()
+    attendance_manager = AttendanceManager(db_session)
+    processor = VideoProcessor(detector, recognizer, attendance_manager)
+    
+    try:
+        async for frame in processor.process_video():
+            # Encode frame to JPEG
+            _, buffer = cv2.imencode('.jpg', frame)
+            frame_b64 = base64.b64encode(buffer).decode('utf-8')
+            
+            # Send to client
+            await websocket.send_json({
+                'frame': frame_b64,
+                'timestamp': datetime.now().isoformat()
+            })
+            
+    except WebSocketDisconnect:
+        print("Client disconnected")
+
+@app.get("/api/analytics/dashboard")
+async def get_dashboard_data():
+    """Get all dashboard metrics"""
+    analytics = AnalyticsService(db_session)
+    
+    return {
+        'personnel_present': analytics.get_personnel_present(),
+        'shift_coverage': analytics.get_shift_coverage(),
+        'staffing_trends': analytics.get_staffing_trends().to_dict(),
+        'missing_personnel': [
+            {'id': e.id, 'name': e.name} 
+            for e in analytics.get_missing_personnel()
+        ],
+        'timestamp': datetime.now().isoformat()
+    }