Spaces:

redc007
/

opp

Build error

opp / app.py

Create app.py

0d4913c verified about 1 year ago

14.2 kB

"""
FastAPI Attendance System - Production Ready
Run with: uvicorn main:app --host 0.0.0.0 --port 5001 --workers 4
"""

import base64
import io
import os
import sys
from datetime import datetime
from typing import Optional

import cv2
import numpy as np
import face_recognition
import mysql.connector
from fastapi import FastAPI, File, Form, UploadFile, HTTPException, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from PIL import Image
from pydantic import BaseModel
from mysql.connector import Error
from werkzeug.utils import secure_filename

# Import the core logic function
from attendance_marking import markAttendance

# --- Configuration ---
DB_CONFIG = {
    'user': 'root',
    'password': 'redclaws',
    'host': 'localhost',
    'database': 'NewAttn',
}

PATH_KNOWN_DATA = 'known_data'
PATH_TRAINING_IMAGES = 'Training_images'
FACE_DISTANCE_THRESHOLD = 0.5

# Ensure directories exist
os.makedirs(PATH_KNOWN_DATA, exist_ok=True)
os.makedirs(PATH_TRAINING_IMAGES, exist_ok=True)

# --- Data Models ---
class AttendanceRequest(BaseModel):
    image: str  # Base64 encoded image

class AttendanceResponse(BaseModel):
    status: str
    message: str
    emp_id: Optional[str] = None
    distance: Optional[str] = None

class RegistrationResponse(BaseModel):
    status: str
    message: str
    emp_id: Optional[str] = None

# --- Helper Functions ---
def load_known_data():
    """Loads encodings and emp_ids from the known_data directory."""
    try:
        encodings = np.load(
            os.path.join(PATH_KNOWN_DATA, 'known_encodings.npy'),
            allow_pickle=True
        )
        with open(os.path.join(PATH_KNOWN_DATA, 'known_names.txt'), 'r') as f:
            emp_ids = [line.strip() for line in f.readlines()]
        print(f"✅ Loaded {len(encodings)} faces.")
        return encodings, emp_ids
    except FileNotFoundError:
        print("⚠️ No existing known data found. Starting fresh.")
        return np.array([]), []
def findEncodings(images):
    encodeList = []
    for img in images:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        face_encodings = face_recognition.face_encodings(img)
        if face_encodings:
            encodeList.append(face_encodings[0])
        else:
            print("Warning: No face found in one of the training images!")
    return encodeList

# Function to mark attendance using MySQL
def markAttendance(emp_id):
    now = datetime.now()
    dtString = now.strftime('%H:%M:%S')
    dateString = now.strftime('%Y-%m-%d')

    cursor = None
    try:
        record_count=0
      #  cursor = db_conn.cursor()

        # # ✅ FIXED: Use COUNT(*) to get the number of matching records
        # check_query = """
        # SELECT COUNT(*) 
        # FROM dailylog
        # WHERE emp_id = %s AND date = %s
        # """
        # cursor.execute(check_query, (emp_id, dateString))

        # result = cursor.fetchone()
        # record_count = result[0] if result else 0
        # print(f"DEBUG: emp_id={emp_id}, date={dateString}, count={record_count}")

        if record_count == 0:
            # insert_query = """
            # INSERT INTO dailylog (emp_id, date, punch_in)
            # VALUES (%s, %s, %s)
            # """
            # cursor.execute(insert_query, (emp_id, dateString, dtString))
            # db_conn.commit()
            return True , "new"
        else:
            return False , "duplicate"

    except Error as e:
        # print(f"DB error: {e}")
        # db_conn.rollback()
        return False , f"error: {e}"
# def get_db_connection():
#     """Get a database connection."""
#     try:
#         return mysql.connector.connect(**DB_CONFIG)
#     except Error as e:
#         print(f"❌ Database connection error: {e}")
#         raise HTTPException(
#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
#             detail=f"Database connection failed: {str(e)}"
#         )

# --- Initialize FastAPI App ---
app = FastAPI(
    title="Facial Attendance System API",
    description="Production-ready facial recognition attendance system",
    version="1.0.0"
)

# Configure CORS
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # In production, replace with specific origins
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Global variables for encodings (loaded at startup)
encodeListKnown = np.array([])
classNames = []

# --- Startup Event ---
@app.on_event("startup")
async def startup_event():
    """Load known face encodings on startup."""
    global encodeListKnown, classNames
    encodeListKnown, classNames = load_known_data()
    print("🚀 FastAPI Attendance System Started")

# --- Health Check Endpoint ---
@app.get("/health")
async def health_check():
    """Health check endpoint."""
    return {
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "registered_employees": len(classNames)
    }

# --- Attendance Marking Endpoint ---
@app.post("/api/mark_attendance", response_model=AttendanceResponse)
async def mark_attendance_api(request: AttendanceRequest):
    """
    Mark attendance using facial recognition.
    
    Args:
        request: AttendanceRequest containing base64 encoded image
    
    Returns:
        AttendanceResponse with status and details
    """
    if not request.image:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="No image data provided"
        )

    #db_conn = None
    try:
        # 1. Decode and Convert Image
        image_bytes = base64.b64decode(request.image)
        img = Image.open(io.BytesIO(image_bytes)).convert('RGB')
        img_np = np.array(img)
        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
        
        # 2. Process Image (resize for faster detection)
        imgS = cv2.resize(img_bgr, (0, 0), None, 0.25, 0.25)
        imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)

        # 3. Detect faces
        facesCurFrame = face_recognition.face_locations(imgS)
        encodesCurFrame = face_recognition.face_encodings(imgS, facesCurFrame)
        
        if not facesCurFrame:
            return AttendanceResponse(
                status="failure",
                message="No face detected in the image."
            )
        
        # 4. Match face
        encodeFace = encodesCurFrame[0]
        matches = face_recognition.compare_faces(encodeListKnown, encodeFace)
        faceDis = face_recognition.face_distance(encodeListKnown, encodeFace)
        
        if len(faceDis) == 0:
            return AttendanceResponse(
                status="failure",
                message="No registered employees in the system."
            )
        
        matchIndex = np.argmin(faceDis)
        min_distance = faceDis[matchIndex]

        # 5. Check threshold and mark attendance
        if matches[matchIndex] and min_distance < FACE_DISTANCE_THRESHOLD:
            employee_id = classNames[matchIndex].upper()
            
            # Get DB connection
     #       db_conn = get_db_connection()
            
            # Mark attendance
            was_marked, status_msg = markAttendance(employee_id)
            
            if was_marked:
                return AttendanceResponse(
                    status="success",
                    message=f"Attendance marked for {employee_id}.",
                    emp_id=employee_id,
                    distance=f"{min_distance:.2f}"
                )
            elif status_msg == "duplicate":
                return AttendanceResponse(
                    status="info",
                    message=f"{employee_id} already logged today.",
                    emp_id=employee_id,
                    distance=f"{min_distance:.2f}"
                )
            else:
                return AttendanceResponse(
                    status="error",
                    message=f"Failed to mark attendance: {status_msg}"
                )
        else:
            return AttendanceResponse(
                status="failure",
                message=f"Unknown person detected. Min Distance: {min_distance:.2f}"
            )

    except Error as err:
        print(f"❌ Database Error: {db_err}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Database error: {str(db_err)}"
        )
    except Exception as e:
        print(f"❌ Exception: {e}")
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Internal server error: {str(e)}"
        )
    # finally:
    #     if db_conn is not None and db_conn.is_connected():
    #         db_conn.close()

# --- Employee Registration Endpoint ---
@app.post("/api/register_employee", response_model=RegistrationResponse)
async def register_employee(
    emp_id: str = Form(...),
    image: UploadFile = File(...)
):
    """
    Register a new employee with facial recognition.
    
    Args:
        emp_id: Employee ID
        image: Employee face image file
    
    Returns:
        RegistrationResponse with status and details
    """
    global encodeListKnown, classNames
    
    db_conn = None
    cursor = None
    image_path = None
    
    try:
        # Validate inputs
        if not emp_id or not image:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Employee ID and image are required."
            )
        
        # Sanitize employee ID
        emp_id = emp_id.strip().upper()
        
        # Check if employee already exists
        if emp_id in classNames:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail=f"Employee {emp_id} already exists in the system."
            )
        
        # Validate image file
        if not image.content_type.startswith('image/'):
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Invalid file type. Please upload an image."
            )
        
        # Save the image
        filename = secure_filename(f"{emp_id}.jpg")
        image_path = os.path.join(PATH_TRAINING_IMAGES, filename)
        
        # Read and save image
        contents = await image.read()
        with open(image_path, 'wb') as f:
            f.write(contents)
        
        # Load and process the image
        img = cv2.imread(image_path)
        if img is None:
            if os.path.exists(image_path):
                os.remove(image_path)
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Failed to read the uploaded image."
            )
        
        # Convert to RGB for face_recognition
        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        
        # Detect faces and generate encoding
        face_encodings = face_recognition.face_encodings(img_rgb)
        
        if not face_encodings:
            os.remove(image_path)
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="No face detected in the image. Please upload a clear face photo."
            )
        
        if len(face_encodings) > 1:
            os.remove(image_path)
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="Multiple faces detected. Please upload an image with only one face."
            )
        
        # Get the encoding
        new_encoding = face_encodings[0]
        
        # Update global arrays
        if len(encodeListKnown) == 0:
            encodeListKnown = np.array([new_encoding])
        else:
            encodeListKnown = np.vstack([encodeListKnown, new_encoding])
        
        classNames.append(emp_id)
        
        # Save updated encodings and names
        np.save(
            os.path.join(PATH_KNOWN_DATA, 'known_encodings.npy'),
            encodeListKnown
        )
        
        with open(os.path.join(PATH_KNOWN_DATA, 'known_names.txt'), 'w') as f:
            for name in classNames:
                f.write(f"{name}\n")
        
        # Insert into database
     #   db_conn = get_db_connection()
     #   cursor = db_conn.cursor()
        
        # query = """
        #     INSERT INTO employees (emp_id, name, email, department) 
        #     VALUES (%s, %s, %s, %s)
        # """
        # cursor.execute(query, (emp_id, "DUMMY", "dummy@mail.com", "DummyDept"))
        # db_conn.commit()
        
        print(f"✅ Successfully registered employee: {emp_id}")
        
        return RegistrationResponse(
            status="success",
            message=f"Employee {emp_id} registered successfully!",
            emp_id=emp_id
        )
        
    except HTTPException:
        # Re-raise HTTP exceptions
        raise
    except Exception as e:
        print(f"❌ Error during registration: {e}")
        if db_conn:
            db_conn.rollback()
        if image_path and os.path.exists(image_path):
            os.remove(image_path)
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Registration failed: {str(e)}"
        )
    # finally:
    #     if cursor:
    #         cursor.close()
    #     if db_conn is not None and db_conn.is_connected():
    #         db_conn.close()

# --- Get Registered Employees Endpoint ---
@app.get("/api/employees")
async def get_employees():
    """Get list of all registered employees."""
    return {
        "status": "success",
        "count": len(classNames),
        "employees": classNames
    }

# --- Root Endpoint ---
@app.get("/")
async def root():
    """Root endpoint."""
    return {
        "message": "Facial Attendance System API",
        "version": "1.0.0",
        "docs": "/docs",
        "health": "/health"
    }


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "app:app",
        host="0.0.0.0",
        port=5001,
        reload=False,  # Set to False in production
        workers=1  # Increase for production (e.g., 4)

    )


	"""
	FastAPI Attendance System - Production Ready
	Run with: uvicorn main:app --host 0.0.0.0 --port 5001 --workers 4
	"""

	import base64
	import io
	import os
	import sys
	from datetime import datetime
	from typing import Optional

	import cv2
	import numpy as np
	import face_recognition
	import mysql.connector
	from fastapi import FastAPI, File, Form, UploadFile, HTTPException, status
	from fastapi.middleware.cors import CORSMiddleware
	from fastapi.responses import JSONResponse
	from PIL import Image
	from pydantic import BaseModel
	from mysql.connector import Error
	from werkzeug.utils import secure_filename

	# Import the core logic function
	from attendance_marking import markAttendance

	# --- Configuration ---
	DB_CONFIG = {
	'user': 'root',
	'password': 'redclaws',
	'host': 'localhost',
	'database': 'NewAttn',
	}

	PATH_KNOWN_DATA = 'known_data'
	PATH_TRAINING_IMAGES = 'Training_images'
	FACE_DISTANCE_THRESHOLD = 0.5

	# Ensure directories exist
	os.makedirs(PATH_KNOWN_DATA, exist_ok=True)
	os.makedirs(PATH_TRAINING_IMAGES, exist_ok=True)

	# --- Data Models ---
	class AttendanceRequest(BaseModel):
	image: str # Base64 encoded image

	class AttendanceResponse(BaseModel):
	status: str
	message: str
	emp_id: Optional[str] = None
	distance: Optional[str] = None

	class RegistrationResponse(BaseModel):
	status: str
	message: str
	emp_id: Optional[str] = None

	# --- Helper Functions ---
	def load_known_data():
	"""Loads encodings and emp_ids from the known_data directory."""
	try:
	encodings = np.load(
	os.path.join(PATH_KNOWN_DATA, 'known_encodings.npy'),
	allow_pickle=True
	)
	with open(os.path.join(PATH_KNOWN_DATA, 'known_names.txt'), 'r') as f:
	emp_ids = [line.strip() for line in f.readlines()]
	print(f"✅ Loaded {len(encodings)} faces.")
	return encodings, emp_ids
	except FileNotFoundError:
	print("⚠️ No existing known data found. Starting fresh.")
	return np.array([]), []
	def findEncodings(images):
	encodeList = []
	for img in images:
	img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
	face_encodings = face_recognition.face_encodings(img)
	if face_encodings:
	encodeList.append(face_encodings[0])
	else:
	print("Warning: No face found in one of the training images!")
	return encodeList

	# Function to mark attendance using MySQL
	def markAttendance(emp_id):
	now = datetime.now()
	dtString = now.strftime('%H:%M:%S')
	dateString = now.strftime('%Y-%m-%d')

	cursor = None
	try:
	record_count=0
	# cursor = db_conn.cursor()

	# # ✅ FIXED: Use COUNT(*) to get the number of matching records
	# check_query = """
	# SELECT COUNT(*)
	# FROM dailylog
	# WHERE emp_id = %s AND date = %s
	# """
	# cursor.execute(check_query, (emp_id, dateString))

	# result = cursor.fetchone()
	# record_count = result[0] if result else 0
	# print(f"DEBUG: emp_id={emp_id}, date={dateString}, count={record_count}")

	if record_count == 0:
	# insert_query = """
	# INSERT INTO dailylog (emp_id, date, punch_in)
	# VALUES (%s, %s, %s)
	# """
	# cursor.execute(insert_query, (emp_id, dateString, dtString))
	# db_conn.commit()
	return True , "new"
	else:
	return False , "duplicate"

	except Error as e:
	# print(f"DB error: {e}")
	# db_conn.rollback()
	return False , f"error: {e}"
	# def get_db_connection():
	# """Get a database connection."""
	# try:
	# return mysql.connector.connect(**DB_CONFIG)
	# except Error as e:
	# print(f"❌ Database connection error: {e}")
	# raise HTTPException(
	# status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
	# detail=f"Database connection failed: {str(e)}"
	# )

	# --- Initialize FastAPI App ---
	app = FastAPI(
	title="Facial Attendance System API",
	description="Production-ready facial recognition attendance system",
	version="1.0.0"
	)

	# Configure CORS
	app.add_middleware(
	CORSMiddleware,
	allow_origins=["*"], # In production, replace with specific origins
	allow_credentials=True,
	allow_methods=["*"],
	allow_headers=["*"],
	)

	# Global variables for encodings (loaded at startup)
	encodeListKnown = np.array([])
	classNames = []

	# --- Startup Event ---
	@app.on_event("startup")
	async def startup_event():
	"""Load known face encodings on startup."""
	global encodeListKnown, classNames
	encodeListKnown, classNames = load_known_data()
	print("🚀 FastAPI Attendance System Started")

	# --- Health Check Endpoint ---
	@app.get("/health")
	async def health_check():
	"""Health check endpoint."""
	return {
	"status": "healthy",
	"timestamp": datetime.now().isoformat(),
	"registered_employees": len(classNames)
	}

	# --- Attendance Marking Endpoint ---
	@app.post("/api/mark_attendance", response_model=AttendanceResponse)
	async def mark_attendance_api(request: AttendanceRequest):
	"""
	Mark attendance using facial recognition.

	Args:
	request: AttendanceRequest containing base64 encoded image

	Returns:
	AttendanceResponse with status and details
	"""
	if not request.image:
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="No image data provided"
	)

	#db_conn = None
	try:
	# 1. Decode and Convert Image
	image_bytes = base64.b64decode(request.image)
	img = Image.open(io.BytesIO(image_bytes)).convert('RGB')
	img_np = np.array(img)
	img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)

	# 2. Process Image (resize for faster detection)
	imgS = cv2.resize(img_bgr, (0, 0), None, 0.25, 0.25)
	imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)

	# 3. Detect faces
	facesCurFrame = face_recognition.face_locations(imgS)
	encodesCurFrame = face_recognition.face_encodings(imgS, facesCurFrame)

	if not facesCurFrame:
	return AttendanceResponse(
	status="failure",
	message="No face detected in the image."
	)

	# 4. Match face
	encodeFace = encodesCurFrame[0]
	matches = face_recognition.compare_faces(encodeListKnown, encodeFace)
	faceDis = face_recognition.face_distance(encodeListKnown, encodeFace)

	if len(faceDis) == 0:
	return AttendanceResponse(
	status="failure",
	message="No registered employees in the system."
	)

	matchIndex = np.argmin(faceDis)
	min_distance = faceDis[matchIndex]

	# 5. Check threshold and mark attendance
	if matches[matchIndex] and min_distance < FACE_DISTANCE_THRESHOLD:
	employee_id = classNames[matchIndex].upper()

	# Get DB connection
	# db_conn = get_db_connection()

	# Mark attendance
	was_marked, status_msg = markAttendance(employee_id)

	if was_marked:
	return AttendanceResponse(
	status="success",
	message=f"Attendance marked for {employee_id}.",
	emp_id=employee_id,
	distance=f"{min_distance:.2f}"
	)
	elif status_msg == "duplicate":
	return AttendanceResponse(
	status="info",
	message=f"{employee_id} already logged today.",
	emp_id=employee_id,
	distance=f"{min_distance:.2f}"
	)
	else:
	return AttendanceResponse(
	status="error",
	message=f"Failed to mark attendance: {status_msg}"
	)
	else:
	return AttendanceResponse(
	status="failure",
	message=f"Unknown person detected. Min Distance: {min_distance:.2f}"
	)

	except Error as err:
	print(f"❌ Database Error: {db_err}")
	raise HTTPException(
	status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
	detail=f"Database error: {str(db_err)}"
	)
	except Exception as e:
	print(f"❌ Exception: {e}")
	raise HTTPException(
	status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
	detail=f"Internal server error: {str(e)}"
	)
	# finally:
	# if db_conn is not None and db_conn.is_connected():
	# db_conn.close()

	# --- Employee Registration Endpoint ---
	@app.post("/api/register_employee", response_model=RegistrationResponse)
	async def register_employee(
	emp_id: str = Form(...),
	image: UploadFile = File(...)
	):
	"""
	Register a new employee with facial recognition.

	Args:
	emp_id: Employee ID
	image: Employee face image file

	Returns:
	RegistrationResponse with status and details
	"""
	global encodeListKnown, classNames

	db_conn = None
	cursor = None
	image_path = None

	try:
	# Validate inputs
	if not emp_id or not image:
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="Employee ID and image are required."
	)

	# Sanitize employee ID
	emp_id = emp_id.strip().upper()

	# Check if employee already exists
	if emp_id in classNames:
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail=f"Employee {emp_id} already exists in the system."
	)

	# Validate image file
	if not image.content_type.startswith('image/'):
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="Invalid file type. Please upload an image."
	)

	# Save the image
	filename = secure_filename(f"{emp_id}.jpg")
	image_path = os.path.join(PATH_TRAINING_IMAGES, filename)

	# Read and save image
	contents = await image.read()
	with open(image_path, 'wb') as f:
	f.write(contents)

	# Load and process the image
	img = cv2.imread(image_path)
	if img is None:
	if os.path.exists(image_path):
	os.remove(image_path)
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="Failed to read the uploaded image."
	)

	# Convert to RGB for face_recognition
	img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

	# Detect faces and generate encoding
	face_encodings = face_recognition.face_encodings(img_rgb)

	if not face_encodings:
	os.remove(image_path)
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="No face detected in the image. Please upload a clear face photo."
	)

	if len(face_encodings) > 1:
	os.remove(image_path)
	raise HTTPException(
	status_code=status.HTTP_400_BAD_REQUEST,
	detail="Multiple faces detected. Please upload an image with only one face."
	)

	# Get the encoding
	new_encoding = face_encodings[0]

	# Update global arrays
	if len(encodeListKnown) == 0:
	encodeListKnown = np.array([new_encoding])
	else:
	encodeListKnown = np.vstack([encodeListKnown, new_encoding])

	classNames.append(emp_id)

	# Save updated encodings and names
	np.save(
	os.path.join(PATH_KNOWN_DATA, 'known_encodings.npy'),
	encodeListKnown
	)

	with open(os.path.join(PATH_KNOWN_DATA, 'known_names.txt'), 'w') as f:
	for name in classNames:
	f.write(f"{name}\n")

	# Insert into database
	# db_conn = get_db_connection()
	# cursor = db_conn.cursor()

	# query = """
	# INSERT INTO employees (emp_id, name, email, department)
	# VALUES (%s, %s, %s, %s)
	# """
	# cursor.execute(query, (emp_id, "DUMMY", "dummy@mail.com", "DummyDept"))
	# db_conn.commit()

	print(f"✅ Successfully registered employee: {emp_id}")

	return RegistrationResponse(
	status="success",
	message=f"Employee {emp_id} registered successfully!",
	emp_id=emp_id
	)

	except HTTPException:
	# Re-raise HTTP exceptions
	raise
	except Exception as e:
	print(f"❌ Error during registration: {e}")
	if db_conn:
	db_conn.rollback()
	if image_path and os.path.exists(image_path):
	os.remove(image_path)
	raise HTTPException(
	status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
	detail=f"Registration failed: {str(e)}"
	)
	# finally:
	# if cursor:
	# cursor.close()
	# if db_conn is not None and db_conn.is_connected():
	# db_conn.close()

	# --- Get Registered Employees Endpoint ---
	@app.get("/api/employees")
	async def get_employees():
	"""Get list of all registered employees."""
	return {
	"status": "success",
	"count": len(classNames),
	"employees": classNames
	}

	# --- Root Endpoint ---
	@app.get("/")
	async def root():
	"""Root endpoint."""
	return {
	"message": "Facial Attendance System API",
	"version": "1.0.0",
	"docs": "/docs",
	"health": "/health"
	}


	if __name__ == "__main__":
	import uvicorn
	uvicorn.run(
	"app:app",
	host="0.0.0.0",
	port=5001,
	reload=False, # Set to False in production
	workers=1 # Increase for production (e.g., 4)

	)