Update app.py

app.py

@@ -3,456 +3,456 @@ import cv2
 import numpy as np
 import pandas as pd
 from datetime import datetime, date
-import os
-import sqlite3
 import face_recognition
-import io
+import pickle
+import os
+from io import BytesIO
+import base64
 from PIL import Image
 import json
 
-# Initialize database
-def init_database():
-    conn = sqlite3.connect('attendance.db')
-    cursor = conn.cursor()
-    
-    # Create users table
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            employee_id TEXT UNIQUE NOT NULL,
-            face_encoding TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    ''')
-    
-    # Create attendance table
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS attendance (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            employee_id TEXT NOT NULL,
-            name TEXT NOT NULL,
-            date DATE NOT NULL,
-            time_in TIME,
-            time_out TIME,
-            status TEXT DEFAULT 'Present',
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            FOREIGN KEY (employee_id) REFERENCES users (employee_id)
-        )
-    ''')
-    
-    conn.commit()
-    conn.close()
-
-# Load known faces from database
-def load_known_faces():
-    conn = sqlite3.connect('attendance.db')
-    cursor = conn.cursor()
-    cursor.execute("SELECT name, employee_id, face_encoding FROM users")
-    users = cursor.fetchall()
-    conn.close()
-    
-    known_faces = []
-    known_names = []
-    known_ids = []
-    
-    for user in users:
-        name, emp_id, encoding_str = user
-        encoding = json.loads(encoding_str)
-        known_faces.append(np.array(encoding))
-        known_names.append(name)
-        known_ids.append(emp_id)
+class AttendanceAnalyzer:
+    def __init__(self):
+        self.known_face_encodings = []
+        self.known_face_names = []
+        self.attendance_records = []
+        self.load_known_faces()
+        
+    def load_known_faces(self):
+        """Load known faces from storage"""
+        if os.path.exists("known_faces.pkl"):
+            try:
+                with open("known_faces.pkl", "rb") as f:
+                    data = pickle.load(f)
+                    self.known_face_encodings = data.get("encodings", [])
+                    self.known_face_names = data.get("names", [])
+            except:
+                self.known_face_encodings = []
+                self.known_face_names = []
+                
+        if os.path.exists("attendance_records.json"):
+            try:
+                with open("attendance_records.json", "r") as f:
+                    self.attendance_records = json.load(f)
+            except:
+                self.attendance_records = []
     
-    return known_faces, known_names, known_ids
-
-# Register new face
-def register_face(image, name, employee_id):
-    if image is None:
-        return "Please upload an image", None
+    def save_known_faces(self):
+        """Save known faces to storage"""
+        data = {
+            "encodings": self.known_face_encodings,
+            "names": self.known_face_names
+        }
+        with open("known_faces.pkl", "wb") as f:
+            pickle.dump(data, f)
     
-    if not name or not employee_id:
-        return "Please provide both name and employee ID", None
+    def save_attendance_records(self):
+        """Save attendance records to storage"""
+        with open("attendance_records.json", "w") as f:
+            json.dump(self.attendance_records, f, indent=2)
     
-    try:
+    def register_face(self, image, name):
+        """Register a new face for attendance tracking"""
+        if image is None or not name.strip():
+            return "❌ Please provide both image and name!", self.get_registered_faces_info()
+        
         # Convert PIL image to RGB array
-        img_array = np.array(image)
+        if isinstance(image, Image.Image):
+            image = np.array(image)
         
         # Find face encodings
-        face_locations = face_recognition.face_locations(img_array)
+        face_locations = face_recognition.face_locations(image)
+        face_encodings = face_recognition.face_encodings(image, face_locations)
         
-        if len(face_locations) == 0:
-            return "No face detected in the image. Please upload a clear image with a visible face.", None
-        
-        if len(face_locations) > 1:
-            return "Multiple faces detected. Please upload an image with only one face.", None
-        
-        face_encodings = face_recognition.face_encodings(img_array, face_locations)
-        face_encoding = face_encodings[0]
+        if len(face_encodings) == 0:
+            return "❌ No face detected in the image! Please try again with a clear face image.", self.get_registered_faces_info()
         
-        # Check if employee ID already exists
-        conn = sqlite3.connect('attendance.db')
-        cursor = conn.cursor()
-        cursor.execute("SELECT * FROM users WHERE employee_id = ?", (employee_id,))
-        existing_user = cursor.fetchone()
+        if len(face_encodings) > 1:
+            return "❌ Multiple faces detected! Please upload an image with only one face.", self.get_registered_faces_info()
         
-        if existing_user:
-            conn.close()
-            return f"Employee ID {employee_id} already exists!", None
+        # Check if person already exists
+        name = name.strip().title()
+        if name in self.known_face_names:
+            return f"❌ {name} is already registered!", self.get_registered_faces_info()
         
-        # Save to database
-        encoding_str = json.dumps(face_encoding.tolist())
-        cursor.execute(
-            "INSERT INTO users (name, employee_id, face_encoding) VALUES (?, ?, ?)",
-            (name, employee_id, encoding_str)
-        )
-        conn.commit()
-        conn.close()
+        # Add the face encoding and name
+        self.known_face_encodings.append(face_encodings[0])
+        self.known_face_names.append(name)
+        self.save_known_faces()
         
-        return f"Successfully registered {name} with Employee ID: {employee_id}", get_registered_users()
-        
-    except Exception as e:
-        return f"Error during registration: {str(e)}", None
-
-# Mark attendance
-def mark_attendance(image):
-    if image is None:
-        return "Please upload an image", None, None
+        return f"✅ {name} has been successfully registered!", self.get_registered_faces_info()
     
-    try:
-        # Convert PIL image to RGB array
-        img_array = np.array(image)
+    def mark_attendance(self, image):
+        """Mark attendance for detected faces"""
+        if image is None:
+            return "❌ Please provide an image!", self.get_today_attendance()
         
-        # Load known faces
-        known_faces, known_names, known_ids = load_known_faces()
+        if len(self.known_face_encodings) == 0:
+            return "❌ No registered faces found! Please register faces first.", self.get_today_attendance()
         
-        if len(known_faces) == 0:
-            return "No registered users found. Please register users first.", None, None
+        # Convert PIL image to RGB array
+        if isinstance(image, Image.Image):
+            image = np.array(image)
         
-        # Find faces in the uploaded image
-        face_locations = face_recognition.face_locations(img_array)
-        face_encodings = face_recognition.face_encodings(img_array, face_locations)
+        # Find faces in the image
+        face_locations = face_recognition.face_locations(image)
+        face_encodings = face_recognition.face_encodings(image, face_locations)
         
         if len(face_encodings) == 0:
-            return "No face detected in the image.", None, None
+            return "❌ No faces detected in the image!", self.get_today_attendance()
         
-        results = []
-        annotated_image = img_array.copy()
+        # Process each face
+        recognized_faces = []
+        unknown_faces = 0
         
-        for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
+        for face_encoding in face_encodings:
             # Compare with known faces
-            matches = face_recognition.compare_faces(known_faces, face_encoding, tolerance=0.6)
-            face_distances = face_recognition.face_distance(known_faces, face_encoding)
+            matches = face_recognition.compare_faces(self.known_face_encodings, face_encoding, tolerance=0.6)
+            face_distances = face_recognition.face_distance(self.known_face_encodings, face_encoding)
             
             if len(face_distances) > 0:
                 best_match_index = np.argmin(face_distances)
                 
-                if matches[best_match_index]:
-                    name = known_names[best_match_index]
-                    emp_id = known_ids[best_match_index]
-                    confidence = 1 - face_distances[best_match_index]
-                    
-                    # Mark attendance in database
-                    conn = sqlite3.connect('attendance.db')
-                    cursor = conn.cursor()
-                    
-                    today = date.today()
-                    current_time = datetime.now().strftime("%H:%M:%S")
+                if matches[best_match_index] and face_distances[best_match_index] < 0.6:
+                    name = self.known_face_names[best_match_index]
                     
-                    # Check if already marked for today
-                    cursor.execute(
-                        "SELECT * FROM attendance WHERE employee_id = ? AND date = ?",
-                        (emp_id, today)
+                    # Check if already marked today
+                    today = date.today().isoformat()
+                    already_marked = any(
+                        record["name"] == name and record["date"] == today 
+                        for record in self.attendance_records
                     )
-                    existing_record = cursor.fetchone()
                     
-                    if existing_record:
-                        # Update time_out if time_in exists
-                        if existing_record[4]:  # time_in exists
-                            cursor.execute(
-                                "UPDATE attendance SET time_out = ? WHERE employee_id = ? AND date = ?",
-                                (current_time, emp_id, today)
-                            )
-                            status = "Time Out Updated"
-                        else:
-                            status = "Already marked for today"
+                    if not already_marked:
+                        # Mark attendance
+                        self.attendance_records.append({
+                            "name": name,
+                            "date": today,
+                            "time": datetime.now().strftime("%H:%M:%S"),
+                            "status": "Present"
+                        })
+                        recognized_faces.append(name)
                     else:
-                        # Create new attendance record
-                        cursor.execute(
-                            "INSERT INTO attendance (employee_id, name, date, time_in) VALUES (?, ?, ?, ?)",
-                            (emp_id, name, today, current_time)
-                        )
-                        status = "Attendance Marked"
-                    
-                    conn.commit()
-                    conn.close()
-                    
-                    results.append(f"{name} ({emp_id}) - {status} - Confidence: {confidence:.2f}")
-                    
-                    # Draw rectangle and label on image
-                    cv2.rectangle(annotated_image, (left, top), (right, bottom), (0, 255, 0), 2)
-                    cv2.putText(annotated_image, f"{name} ({confidence:.2f})", 
-                              (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                        recognized_faces.append(f"{name} (Already marked)")
                 else:
-                    results.append("Unknown person detected")
-                    cv2.rectangle(annotated_image, (left, top), (right, bottom), (0, 0, 255), 2)
-                    cv2.putText(annotated_image, "Unknown", 
-                              (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+                    unknown_faces += 1
             else:
-                results.append("Unknown person detected")
+                unknown_faces += 1
         
-        result_text = "\n".join(results)
-        return result_text, Image.fromarray(annotated_image), get_attendance_records()
+        # Save attendance records
+        self.save_attendance_records()
         
-    except Exception as e:
-        return f"Error during attendance marking: {str(e)}", None, None
-
-# Get registered users
-def get_registered_users():
-    try:
-        conn = sqlite3.connect('attendance.db')
-        df = pd.read_sql_query("SELECT name, employee_id, created_at FROM users ORDER BY created_at DESC", conn)
-        conn.close()
-        return df
-    except:
-        return pd.DataFrame(columns=['name', 'employee_id', 'created_at'])
-
-# Get attendance records
-def get_attendance_records():
-    try:
-        conn = sqlite3.connect('attendance.db')
-        df = pd.read_sql_query("""
-            SELECT name, employee_id, date, time_in, time_out, status 
-            FROM attendance 
-            ORDER BY date DESC, time_in DESC
-        """, conn)
-        conn.close()
-        return df
-    except:
-        return pd.DataFrame(columns=['name', 'employee_id', 'date', 'time_in', 'time_out', 'status'])
-
-# Get today's attendance
-def get_todays_attendance():
-    try:
-        conn = sqlite3.connect('attendance.db')
-        today = date.today()
-        df = pd.read_sql_query("""
-            SELECT name, employee_id, time_in, time_out, status 
-            FROM attendance 
-            WHERE date = ? 
-            ORDER BY time_in DESC
-        """, conn, params=(today,))
-        conn.close()
-        return df
-    except:
-        return pd.DataFrame(columns=['name', 'employee_id', 'time_in', 'time_out', 'status'])
-
-# Delete user
-def delete_user(employee_id):
-    if not employee_id:
-        return "Please enter an employee ID", get_registered_users()
+        # Prepare result message
+        result_parts = []
+        if recognized_faces:
+            result_parts.append(f"✅ Attendance marked for: {', '.join(recognized_faces)}")
+        if unknown_faces > 0:
+            result_parts.append(f"❓ {unknown_faces} unknown face(s) detected")
+        
+        result = "\n".join(result_parts) if result_parts else "❌ No faces could be processed!"
+        
+        return result, self.get_today_attendance()
     
-    try:
-        conn = sqlite3.connect('attendance.db')
-        cursor = conn.cursor()
+    def get_registered_faces_info(self):
+        """Get information about registered faces"""
+        if not self.known_face_names:
+            return "No faces registered yet."
         
-        # Check if user exists
-        cursor.execute("SELECT name FROM users WHERE employee_id = ?", (employee_id,))
-        user = cursor.fetchone()
+        info = f"**Registered Faces ({len(self.known_face_names)}):**\n"
+        for i, name in enumerate(self.known_face_names, 1):
+            info += f"{i}. {name}\n"
+        return info
+    
+    def get_today_attendance(self):
+        """Get today's attendance records"""
+        today = date.today().isoformat()
+        today_records = [r for r in self.attendance_records if r["date"] == today]
         
-        if not user:
-            conn.close()
-            return f"Employee ID {employee_id} not found", get_registered_users()
+        if not today_records:
+            return f"**Today's Attendance ({today}):**\nNo attendance marked yet."
         
-        # Delete user and their attendance records
-        cursor.execute("DELETE FROM attendance WHERE employee_id = ?", (employee_id,))
-        cursor.execute("DELETE FROM users WHERE employee_id = ?", (employee_id,))
+        info = f"**Today's Attendance ({today}):**\n"
+        for record in today_records:
+            info += f"• {record['name']} - {record['time']} ({record['status']})\n"
         
-        conn.commit()
-        conn.close()
+        return info
+    
+    def get_attendance_report(self, start_date, end_date):
+        """Generate attendance report for date range"""
+        if not start_date or not end_date:
+            return "Please select both start and end dates."
         
-        return f"Successfully deleted user {user[0]} ({employee_id})", get_registered_users()
+        # Filter records by date range
+        filtered_records = [
+            r for r in self.attendance_records 
+            if start_date <= r["date"] <= end_date
+        ]
         
-    except Exception as e:
-        return f"Error deleting user: {str(e)}", get_registered_users()
-
-# Initialize database on startup
-init_database()
+        if not filtered_records:
+            return f"No attendance records found between {start_date} and {end_date}."
+        
+        # Create DataFrame for better presentation
+        df = pd.DataFrame(filtered_records)
+        
+        # Summary statistics
+        total_days = (pd.to_datetime(end_date) - pd.to_datetime(start_date)).days + 1
+        unique_people = df['name'].nunique()
+        total_attendances = len(df)
+        
+        report = f"**Attendance Report ({start_date} to {end_date})**\n\n"
+        report += f"📊 **Summary:**\n"
+        report += f"• Total Days: {total_days}\n"
+        report += f"• Unique People: {unique_people}\n"
+        report += f"• Total Attendances: {total_attendances}\n\n"
+        
+        # Individual attendance counts
+        if not df.empty:
+            attendance_counts = df['name'].value_counts()
+            report += f"👥 **Individual Attendance:**\n"
+            for name, count in attendance_counts.items():
+                percentage = (count / total_days) * 100
+                report += f"• {name}: {count} days ({percentage:.1f}%)\n"
+        
+        return report
+    
+    def export_attendance_csv(self):
+        """Export attendance records to CSV"""
+        if not self.attendance_records:
+            return None, "No attendance records to export."
+        
+        df = pd.DataFrame(self.attendance_records)
+        csv_file = f"attendance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        df.to_csv(csv_file, index=False)
+        
+        return csv_file, f"✅ Attendance exported to {csv_file}"
 
-# Custom CSS
-css = """
-.gradio-container {
-    max-width: 1200px !important;
-}
-.tab-nav {
-    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%) !important;
-}
-.tab-nav button {
-    color: white !important;
-    font-weight: bold !important;
-}
-.tab-nav button.selected {
-    background: rgba(255,255,255,0.2) !important;
-}
-"""
+# Initialize the attendance analyzer
+analyzer = AttendanceAnalyzer()
 
 # Create Gradio interface
-with gr.Blocks(css=css, title="Attendance Analyzer - Face Detection", theme=gr.themes.Soft()) as app:
-    gr.Markdown(
+def create_interface():
+    with gr.Blocks(
+        title="Attendance Analyzer Using Face Detection",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        .tab-nav {
+            font-weight: bold;
+        }
         """
-        # 🎯 Attendance Analyzer Using Face Detection
-        
-        **Advanced AI-powered attendance management system with real-time face recognition**
+    ) as demo:
         
-        ---
-        """,
-        elem_classes="header"
-    )
-    
-    with gr.Tabs():
-        # Tab 1: Mark Attendance
-        with gr.Tab("📸 Mark Attendance"):
-            gr.Markdown("### Mark attendance by uploading an image or using webcam")
+        gr.Markdown(
+            """
+            # 👤 Attendance Analyzer Using Face Detection
             
-            with gr.Row():
-                with gr.Column(scale=1):
-                    attendance_image = gr.Image(
-                        type="pil", 
-                        label="Upload Image for Attendance",
-                        height=400
-                    )
-                    mark_btn = gr.Button("Mark Attendance", variant="primary", size="lg")
-                
-                with gr.Column(scale=1):
-                    attendance_result = gr.Textbox(
-                        label="Attendance Result",
-                        lines=5,
-                        placeholder="Results will appear here..."
-                    )
-                    annotated_output = gr.Image(
-                        label="Detected Faces",
-                        height=400
-                    )
+            **A comprehensive face recognition system for attendance management**
             
-            with gr.Row():
-                attendance_df = gr.Dataframe(
-                    label="📊 Today's Attendance Records",
-                    headers=["Name", "Employee ID", "Time In", "Time Out", "Status"],
-                    datatype=["str", "str", "str", "str", "str"],
-                    value=get_todays_attendance()
-                )
+            📋 **Features:**
+            - Register new faces for attendance tracking
+            - Automatic attendance marking via face detection
+            - Real-time attendance reports and analytics
+            - Export attendance data to CSV
+            """
+        )
         
-        # Tab 2: Register New User
-        with gr.Tab("👤 Register User"):
-            gr.Markdown("### Register a new user for face recognition")
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    register_image = gr.Image(
-                        type="pil",
-                        label="Upload User Photo",
-                        height=400
-                    )
-                    
-                with gr.Column(scale=1):
-                    user_name = gr.Textbox(
-                        label="Full Name",
-                        placeholder="Enter full name..."
-                    )
-                    emp_id = gr.Textbox(
-                        label="Employee ID",
-                        placeholder="Enter unique employee ID..."
-                    )
-                    register_btn = gr.Button("Register User", variant="primary", size="lg")
+        with gr.Tabs():
+            # Face Registration Tab
+            with gr.Tab("👥 Register Face", elem_classes="tab-nav"):
+                gr.Markdown("### Register New Person for Attendance Tracking")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        register_image = gr.Image(
+                            label="Upload Person's Photo",
+                            type="pil",
+                            height=300
+                        )
+                        register_name = gr.Textbox(
+                            label="Person's Name",
+                            placeholder="Enter full name...",
+                            lines=1
+                        )
+                        register_btn = gr.Button(
+                            "🔐 Register Face",
+                            variant="primary",
+                            size="lg"
+                        )
                     
-                    register_result = gr.Textbox(
-                        label="Registration Result",
-                        lines=3,
-                        placeholder="Registration status will appear here..."
-                    )
-            
-            with gr.Row():
-                users_df = gr.Dataframe(
-                    label="👥 Registered Users",
-                    headers=["Name", "Employee ID", "Registration Date"],
-                    datatype=["str", "str", "str"],
-                    value=get_registered_users()
+                    with gr.Column(scale=1):
+                        register_output = gr.Textbox(
+                            label="Registration Status",
+                            lines=3,
+                            interactive=False
+                        )
+                        registered_faces_info = gr.Markdown(
+                            value=analyzer.get_registered_faces_info(),
+                            label="Registered Faces"
+                        )
+                
+                register_btn.click(
+                    fn=analyzer.register_face,
+                    inputs=[register_image, register_name],
+                    outputs=[register_output, registered_faces_info]
                 )
-        
-        # Tab 3: Manage Users
-        with gr.Tab("⚙️ Manage Users"):
-            gr.Markdown("### Manage registered users")
             
-            with gr.Row():
-                with gr.Column(scale=1):
-                    delete_emp_id = gr.Textbox(
-                        label="Employee ID to Delete",
-                        placeholder="Enter employee ID to delete..."
-                    )
-                    delete_btn = gr.Button("Delete User", variant="stop", size="lg")
-                    delete_result = gr.Textbox(
-                        label="Delete Result",
-                        lines=2,
-                        placeholder="Delete status will appear here..."
-                    )
+            # Attendance Marking Tab
+            with gr.Tab("✅ Mark Attendance", elem_classes="tab-nav"):
+                gr.Markdown("### Mark Attendance via Face Recognition")
                 
-                with gr.Column(scale=2):
-                    manage_users_df = gr.Dataframe(
-                        label="👥 All Registered Users",
-                        headers=["Name", "Employee ID", "Registration Date"],
-                        datatype=["str", "str", "str"],
-                        value=get_registered_users()
-                    )
-        
-        # Tab 4: Attendance Reports
-        with gr.Tab("📈 Reports"):
-            gr.Markdown("### View attendance reports and analytics")
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        attendance_image = gr.Image(
+                            label="Upload Photo for Attendance",
+                            type="pil",
+                            height=300
+                        )
+                        mark_attendance_btn = gr.Button(
+                            "📋 Mark Attendance",
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        attendance_output = gr.Textbox(
+                            label="Attendance Status",
+                            lines=4,
+                            interactive=False
+                        )
+                        today_attendance = gr.Markdown(
+                            value=analyzer.get_today_attendance(),
+                            label="Today's Attendance"
+                        )
+                
+                mark_attendance_btn.click(
+                    fn=analyzer.mark_attendance,
+                    inputs=[attendance_image],
+                    outputs=[attendance_output, today_attendance]
+                )
             
-            with gr.Row():
-                refresh_btn = gr.Button("Refresh Reports", variant="secondary")
+            # Reports Tab
+            with gr.Tab("📊 Reports & Analytics", elem_classes="tab-nav"):
+                gr.Markdown("### Attendance Reports and Data Export")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### 📅 Generate Report")
+                        start_date = gr.Date(
+                            label="Start Date",
+                            value=date.today().replace(day=1).isoformat()
+                        )
+                        end_date = gr.Date(
+                            label="End Date",
+                            value=date.today().isoformat()
+                        )
+                        generate_report_btn = gr.Button(
+                            "📊 Generate Report",
+                            variant="primary"
+                        )
+                        
+                        gr.Markdown("#### 💾 Export Data")
+                        export_btn = gr.Button(
+                            "📥 Export to CSV",
+                            variant="secondary"
+                        )
+                        export_status = gr.Textbox(
+                            label="Export Status",
+                            lines=2,
+                            interactive=False
+                        )
+                        export_file = gr.File(
+                            label="Download File",
+                            visible=False
+                        )
+                    
+                    with gr.Column():
+                        report_output = gr.Markdown(
+                            value="Select date range and click 'Generate Report' to view attendance analytics.",
+                            label="Attendance Report"
+                        )
+                
+                generate_report_btn.click(
+                    fn=analyzer.get_attendance_report,
+                    inputs=[start_date, end_date],
+                    outputs=[report_output]
+                )
+                
+                def export_and_show(analyzer=analyzer):
+                    file_path, status = analyzer.export_attendance_csv()
+                    if file_path:
+                        return status, gr.update(visible=True, value=file_path)
+                    else:
+                        return status, gr.update(visible=False)
+                
+                export_btn.click(
+                    fn=export_and_show,
+                    outputs=[export_status, export_file]
+                )
             
-            with gr.Row():
-                all_attendance_df = gr.Dataframe(
-                    label="📋 All Attendance Records",
-                    headers=["Name", "Employee ID", "Date", "Time In", "Time Out", "Status"],
-                    datatype=["str", "str", "str", "str", "str", "str"],
-                    value=get_attendance_records(),
-                    height=500
+            # Instructions Tab
+            with gr.Tab("ℹ️ Instructions", elem_classes="tab-nav"):
+                gr.Markdown(
+                    """
+                    ## 📖 How to Use the Attendance Analyzer
+                    
+                    ### 1. 👥 Register Faces
+                    - Go to the **"Register Face"** tab
+                    - Upload a clear photo of the person (one face per image)
+                    - Enter the person's full name
+                    - Click **"Register Face"** to add them to the system
+                    
+                    ### 2. ✅ Mark Attendance
+                    - Go to the **"Mark Attendance"** tab
+                    - Upload a photo containing one or more registered faces
+                    - Click **"Mark Attendance"** to automatically detect and mark attendance
+                    - The system will show which people were recognized and marked present
+                    
+                    ### 3. 📊 View Reports
+                    - Go to the **"Reports & Analytics"** tab
+                    - Select a date range to generate attendance reports
+                    - Export attendance data to CSV for external analysis
+                    
+                    ### 💡 Tips for Best Results:
+                    - Use high-quality, well-lit photos
+                    - Ensure faces are clearly visible and not obscured
+                    - For registration, use photos with the person looking directly at camera
+                    - The system works best with front-facing photos
+                    - Multiple people can be detected in a single attendance photo
+                    
+                    ### 🔧 Technical Features:
+                    - **Face Detection**: Automatically locates faces in images
+                    - **Face Recognition**: Matches detected faces with registered users
+                    - **Duplicate Prevention**: Prevents multiple attendance marks for the same person on the same day
+                    - **Data Persistence**: All data is saved and persists between sessions
+                    - **Export Capability**: Generate CSV reports for external analysis
+                    
+                    ### 🚨 Troubleshooting:
+                    - **"No face detected"**: Ensure the image contains a clear, visible face
+                    - **"Multiple faces detected"** (during registration): Use images with only one person
+                    - **"Unknown face"**: The person needs to be registered first
+                    - **Poor recognition**: Try re-registering with a clearer photo
+                    """
                 )
+        
+        # Footer
+        gr.Markdown(
+            """
+            ---
+            **🔒 Privacy Note:** All face data is processed locally and securely stored. 
+            No personal data is transmitted to external servers.
+            """
+        )
     
-    # Event handlers
-    mark_btn.click(
-        fn=mark_attendance,
-        inputs=[attendance_image],
-        outputs=[attendance_result, annotated_output, attendance_df]
-    )
-    
-    register_btn.click(
-        fn=register_face,
-        inputs=[register_image, user_name, emp_id],
-        outputs=[register_result, users_df]
-    )
-    
-    delete_btn.click(
-        fn=delete_user,
-        inputs=[delete_emp_id],
-        outputs=[delete_result, manage_users_df]
-    )
-    
-    refresh_btn.click(
-        fn=lambda: get_attendance_records(),
-        outputs=[all_attendance_df]
-    )
-    
-    # Auto-refresh today's attendance
-    mark_btn.click(
-        fn=lambda: get_todays_attendance(),
-        outputs=[attendance_df]
-    )
+    return demo
 
+# Create and launch the interface
 if __name__ == "__main__":
-    app.launch(
-        share=True,
+    demo = create_interface()
+    demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_api=False
+        share=False,
+        show_error=True
     )