Upload app from GitHub

Insightface_Model/Models/buffalo_s/1k3d68.onnx

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

Insightface_Model/Models/buffalo_s/2d106det.onnx

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

Insightface_Model/Models/buffalo_s/det_500m.onnx

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

Insightface_Model/Models/buffalo_s/genderage.onnx

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

Insightface_Model/Models/buffalo_s/w600k_mbf.onnx

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

configure.sh

@@ -0,0 +1,30 @@
+echo "
+  <VirtualHost *:80>
+      ServerName <domain or ip address>
+      Redirect / https://<domain or ip address>
+  </VirtualHost> 
+      
+  <VirtualHost  *:443>
+      
+      ServerName <domain or ip address>
+      SSLEngine on
+      SSLProxyEngine On
+      SSLCertificateFile      /etc/ssl/certs/ssl-cert-snakeoil.pem
+      SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key
+      
+      ProxyRequests     Off
+      ProxyPreserveHost On
+      #AllowEncodedSlashes NoDecode
+      <Proxy *>
+          Order deny,allow
+          Allow from all
+      </Proxy>
+      
+      ProxyPass         /_stcore        ws://localhost:8501/_stcore
+      ProxyPassReverse  /_stcore        ws://localhost:8501/_stcore
+      
+      # The order is important here
+      ProxyPass         /        http://localhost:8501/
+      ProxyPassReverse  /        http://localhost:8501/
+      
+  </VirtualHost>" > /etc/apache2/sites-available/deploy_attendance_app.conf

face_rec.py

@@ -0,0 +1,239 @@
+import numpy as np
+import pandas as pd
+import cv2
+
+import redis
+
+from insightface.app import FaceAnalysis
+from sklearn.metrics import pairwise
+
+import time
+from datetime import datetime
+import os
+
+hostname = 'redis-18916.c83.us-east-1-2.ec2.redns.redis-cloud.com'
+port = 18916
+password = 'vTig9W0x2XtLCyR3MDFQFyZjSMSId6Gr'
+r = redis.StrictRedis(host=hostname,
+                      port=port,
+                      password=password)
+# extracting data from redis database
+def retrive_data(name):
+    retrive_dict = r.hgetall(name)
+    retrive_series = pd.Series(retrive_dict)
+    retrive_series = retrive_series.apply(lambda x:np.frombuffer(x,dtype=np.float32))
+    index = retrive_series.index
+    index = list(map(lambda x: x.decode(),index))
+    retrive_series.index = index
+    retrive_df = retrive_series.to_frame().reset_index()
+    retrive_df.columns = ['name_role','Facial Feature']
+    retrive_df[['Name','Role']] = retrive_df['name_role'].apply(lambda x : x.split('@')).apply(pd.Series)
+    return retrive_df[['Name','Role','Facial Feature']]
+
+# Configure face analysis
+face_app = FaceAnalysis(name='buffalo_s',
+                        root='insightface_model',
+                        providers=['CPUExecutionProvider'])
+face_app.prepare(ctx_id=0,det_size=(640,640),det_thresh=0.5)
+
+# def ml_search_algorithm(dataframe,feature_column,test_vector,name_role=['Name','Role'],thresh=0.5):
+    
+#     # cosine similarity based search algorithm
+#     # feature_column --> column name that contains features(embeddings) in dataframe
+
+#     dataframe = dataframe.copy()
+
+#     X_list = dataframe[feature_column].tolist()
+#     x = np.asarray(X_list)
+
+#     # Debugging step: print shape of each embedding
+#     for idx, item in enumerate(X_list):
+#         print(f"Item {idx} shape: {np.array(item).shape}")
+ 
+#     try:
+#         x = np.asarray(X_list)
+#     except ValueError as e:
+#         print("Error converting X_list to array:", e)
+#         # Handle inconsistent shapes here, for example, by filtering out invalid items
+#         return 'Unknown', 'Unknown'
+ 
+
+#     similar = pairwise.cosine_similarity(x,test_vector.reshape(1,-1))
+#     similar_arr = np.array(similar).flatten()
+#     dataframe['cosine'] = similar_arr
+
+#     data_filter = dataframe.query(f'cosine >= {thresh}')
+#     if(len(data_filter) > 0):
+#         data_filter.reset_index(drop=True,inplace=True)
+#         argmax = data_filter['cosine'].argmax()
+#         person_name,person_role = data_filter.loc[argmax][name_role]
+#     else:
+#         person_name = 'Unknown'
+#         person_role = 'Unknown'
+        
+#     return person_name,person_role
+
+def ml_search_algorithm(dataframe, feature_column, test_vector, name_role=['Name', 'Role'], thresh=0.5):
+    # cosine similarity based search algorithm
+    dataframe = dataframe.copy()
+    X_list = dataframe[feature_column].tolist()
+    
+    # Check if all embeddings have the same shape as the test vector
+    valid_indices = []
+    valid_embeddings = []
+    
+    # Get test vector shape (usually 512 for InsightFace)
+    test_dim = test_vector.shape[0]
+    
+    # Filter out embeddings with inconsistent shapes
+    for idx, item in enumerate(X_list):
+        try:
+            item_array = np.array(item)
+            if item_array.shape[0] == test_dim:
+                valid_indices.append(idx)
+                valid_embeddings.append(item_array)
+        except:
+            print(f"Skipping item {idx} due to shape issue")
+    
+    if len(valid_embeddings) == 0:
+        print("No valid embeddings found in database")
+        return 'Unknown', 'Unknown'
+    
+    # Create a new array with only valid embeddings
+    x = np.vstack(valid_embeddings)
+    
+    # Create a new filtered dataframe
+    filtered_df = dataframe.iloc[valid_indices].copy()
+    
+    # Calculate similarity
+    similar = pairwise.cosine_similarity(x, test_vector.reshape(1, -1))
+    similar_arr = np.array(similar).flatten()
+    
+    # Add similarity scores to filtered dataframe
+    filtered_df['cosine'] = similar_arr
+    
+    # Filter by threshold
+    data_filter = filtered_df.query(f'cosine >= {thresh}')
+    
+    if len(data_filter) > 0:
+        data_filter.reset_index(drop=True, inplace=True)
+        argmax = data_filter['cosine'].argmax()
+        person_name, person_role = data_filter.loc[argmax][name_role]
+    else:
+        person_name = 'Unknown'
+        person_role = 'Unknown'
+        
+    return person_name, person_role
+class RealTimePred:
+    def __init__(self):
+        self.logs = dict(name=[],role=[],current_time=[])
+
+    def reset_dict(self):
+        self.logs = dict(name=[],role=[],current_time=[])
+
+    def saveLogs_redis(self):
+        dataframe = pd.DataFrame(self.logs)
+
+        dataframe.drop_duplicates('name',inplace=True)
+
+        name_list = dataframe['name'].tolist()
+        role_list = dataframe['role'].tolist()
+        ctime_list = dataframe['current_time'].tolist()
+        encoded_data = []
+
+        for name,role,ctime in zip(name_list,role_list,ctime_list):
+            if name != 'Unknown':
+                concat_string = f'{name}@{role}@{ctime}'
+                encoded_data.append(concat_string)
+
+        if len(encoded_data) > 0:
+            r.lpush('attendance:logs',*encoded_data)   
+
+        self.reset_dict()    
+
+
+    def face_prediction(self,test_image,dataframe,feature_column,name_role=['Name','Role'],thresh=0.5):
+        current_time = str(datetime.now().strftime('%Y-%m-%d %H:%M'))
+        results = face_app.get(test_image)
+        test_copy = test_image.copy()
+        for res in results:
+            x1,y1,x2,y2 = res['bbox'].astype(int)
+            embeddings = res['embedding']
+
+            person_name,person_role = ml_search_algorithm(dataframe,'Facial Feature',
+                                                            test_vector=embeddings,
+                                                            name_role=name_role,
+                                                            thresh=thresh)
+
+            if person_name=='Unknown':
+                color = (0,0,255)
+            else:
+                color = (0,255,0)
+            cv2.rectangle(test_copy,(x1,y1),(x2,y2),color,2)
+            text_gen = person_name
+            cv2.putText(test_copy,text_gen,(x1,y1),cv2.FONT_HERSHEY_DUPLEX,0.7,color,2)
+            cv2.putText(test_copy,current_time,(x1,y2+20),cv2.FONT_HERSHEY_DUPLEX,0.7,color,2)
+
+            # save info in logs dict
+            self.logs['name'].append(person_name)
+            self.logs['role'].append(person_role)
+            self.logs['current_time'].append(current_time)
+
+        return test_copy
+
+
+
+# Registration Form
+class RegistrationForm:
+    def __init__(self):
+        self.sample = 0 
+
+    def reset(self):
+        self.sample = 0
+
+    def get_embedding(self,frame):
+        # get results from insightface model
+        results = face_app.get(frame,max_num=1)
+        embeddings = None
+        for res in results:
+            self.sample = self.sample + 1
+            x1,y1,x2,y2 = res['bbox'].astype(int)
+            cv2.rectangle(frame,(x1,y1),(x2,y2),(0,255,0),2)
+            
+            # put text samples info
+            text = f"samples : {self.sample}"
+            cv2.putText(frame,text,(x1,y1),cv2.FONT_HERSHEY_DUPLEX,0.6,(0,255,0),2)
+            
+            embeddings = res['embedding']
+
+        return frame,embeddings
+    
+
+    def save_data_in_redis_db(self,name,role):
+        if name is not None:
+            if name.strip() != '':
+                key = f'{name}@{role}'
+            else:
+                return 'name_false'
+        else:
+            return  'name_false'
+        
+        if 'face_embedding.txt' not in os.listdir():
+            return 'file_false'
+        # step 1 : load "face_embedding.txt"
+        x_array = np.loadtxt('face_embedding.txt',dtype=np.float32) # flatten array
+
+        # step 2 : convert into array (proper shape)
+        received_samples = int(x_array.size/512)
+        x_array = x_array.reshape(received_samples,512)
+
+        # step 3 : cal. mean embeddings
+        x_mean = x_array.mean(axis=0)
+        x_mean_bytes = x_mean.tobytes()
+
+        # step 4 : save this into redis database (redis hashes)
+        r.hset(name='academy:register',key=key,value=x_mean_bytes)
+
+        os.remove('face_embedding.txt')
+        self.reset()
+        return True

home.py

@@ -0,0 +1,131 @@
+import streamlit as st
+import time
+from PIL import Image
+import base64
+
+# Page configuration
+st.set_page_config(
+    page_title="AI Attendance System",
+    page_icon="👁️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better appearance
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #1E88E5;
+        text-align: center;
+        margin-bottom: 1rem;
+        font-weight: 700;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        color: #424242;
+        margin-top: 2rem;
+        font-weight: 600;
+    }
+    .card {
+        border-radius: 5px;
+        padding: 20px;
+        background-color: #f8f9fa;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        margin-bottom: 20px;
+    }
+    .success-box {
+        background-color: #d4edda;
+        color: #155724;
+        padding: 15px;
+        border-radius: 5px;
+        margin-bottom: 20px;
+    }
+    .feature-icon {
+        font-size: 1.8rem;
+        margin-right: 10px;
+    }
+    .footer {
+        text-align: center;
+        margin-top: 50px;
+        padding: 20px;
+        color: #6c757d;
+        border-top: 1px solid #e9ecef;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header with logo
+col1, col2, col3 = st.columns([1, 3, 1])
+with col2:
+    st.markdown("<h1 class='main-header'>🔷 AI-Powered Attendance System</h1>", unsafe_allow_html=True)
+    st.markdown("<p style='text-align: center; font-size: 1.2rem;'>Smart Recognition • Secure • Efficient</p>", unsafe_allow_html=True)
+
+# Create two columns for content
+left_col, right_col = st.columns([2, 1])
+
+with left_col:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    with st.spinner('🔄 Loading Models and Connecting to Database...'):
+        try:
+            import face_rec
+            time.sleep(2)  # Simulating loading time
+            st.markdown("<div class='success-box'><b>✅ Face Recognition Model:</b> Loaded Successfully</div>", unsafe_allow_html=True)
+            st.markdown("<div class='success-box'><b>✅ Database Connection:</b> Connected to Redis DB</div>", unsafe_allow_html=True)
+        except Exception as e:
+            st.error(f"Error loading system components: {e}")
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # System features
+    st.markdown("<h2 class='sub-header'>System Features</h2>", unsafe_allow_html=True)
+    
+    features = [
+        ("👁️ Real-time Face Recognition", "Instant identification of registered users using advanced ML models"),
+        ("⏱️ Automatic Attendance Logging", "Timestamps recorded automatically with entry and exit times"),
+        ("🔐 Role-based Access Management", "Different access levels for students and teachers"),
+        ("📊 Comprehensive Reports", "Generate detailed attendance reports with various filters"),
+        ("⚡ High Performance", "Optimized for speed even with multiple simultaneous recognitions")
+    ]
+    
+    for icon_title, description in features:
+        st.markdown(f"""
+        <div style='display: flex; align-items: center; margin-bottom: 15px;'>
+            <div class='feature-icon'>{icon_title.split()[0]}</div>
+            <div>
+                <b>{" ".join(icon_title.split()[1:])}</b><br>
+                <span style='color: #6c757d; font-size: 0.9rem;'>{description}</span>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+
+with right_col:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h3 style='text-align: center;'>Quick Navigation</h3>", unsafe_allow_html=True)
+    
+    # Quick action buttons
+    if st.button("📝 Register New User", use_container_width=True):
+        st.switch_page("pages/2_registration_form.py")
+        
+    if st.button("🟢 Start Attendance Tracking", use_container_width=True):
+        st.switch_page("pages/1_real_time_prediction.py")
+        
+    if st.button("📊 View Attendance Reports", use_container_width=True):
+        st.switch_page("pages/3_report.py")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # System status
+    st.markdown("<div class='card' style='margin-top: 20px;'>", unsafe_allow_html=True)
+    st.markdown("<h3 style='text-align: center;'>System Status</h3>", unsafe_allow_html=True)
+    
+    # Display some system metrics
+    col1, col2 = st.columns(2)
+    with col1:
+        st.metric(label="System Status", value="Online", delta="Active")
+    with col2:
+        st.metric(label="Database Status", value="Connected", delta="Active")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# Footer
+st.markdown("<div class='footer'>AI-Powered Attendance System • © 2025</div>", unsafe_allow_html=True)

main.sh

@@ -0,0 +1,2 @@
+bash configure.sh
+streamlit run home.py

pages/1_real_time_prediction.py

@@ -0,0 +1,292 @@
+import streamlit as st
+from home import face_rec
+from streamlit_webrtc import webrtc_streamer
+import av
+import time
+import pandas as pd
+from datetime import datetime
+
+# Page configuration
+st.set_page_config(
+    page_title="Live Attendance | AI Attendance",
+    page_icon="🟢",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.2rem;
+        color: #4CAF50;
+        text-align: center;
+        margin-bottom: 1.5rem;
+        font-weight: 700;
+    }
+    .card {
+        border-radius: 8px;
+        padding: 25px;
+        background-color: #f8f9fa;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        margin-bottom: 20px;
+    }
+    .webcam-container {
+        border: 2px solid #4CAF50;
+        border-radius: 8px;
+        padding: 15px;
+        background-color: #f1f8e9;
+    }
+    .status-indicator {
+        display: flex;
+        align-items: center;
+        margin-bottom: 10px;
+    }
+    .status-dot {
+        width: 12px;
+        height: 12px;
+        border-radius: 50%;
+        margin-right: 8px;
+    }
+    .active {
+        background-color: #4CAF50;
+        box-shadow: 0 0 8px #4CAF50;
+        animation: pulse 2s infinite;
+    }
+    @keyframes pulse {
+        0% { box-shadow: 0 0 0 0 rgba(76, 175, 80, 0.7); }
+        70% { box-shadow: 0 0 0 10px rgba(76, 175, 80, 0); }
+        100% { box-shadow: 0 0 0 0 rgba(76, 175, 80, 0); }
+    }
+    .inactive {
+        background-color: #9e9e9e;
+    }
+    .section-title {
+        font-size: 1.3rem;
+        font-weight: 600;
+        color: #424242;
+        margin-bottom: 15px;
+        padding-bottom: 8px;
+        border-bottom: 2px solid #e0e0e0;
+    }
+    .attendance-table {
+        font-size: 0.9rem;
+    }
+    .footer {
+        text-align: center;
+        margin-top: 30px;
+        padding: 20px;
+        color: #6c757d;
+        border-top: 1px solid #e9ecef;
+    }
+    .stats-box {
+        background-color: #f8f9fa;
+        border-radius: 8px;
+        padding: 15px;
+        text-align: center;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    .stats-number {
+        font-size: 1.8rem;
+        font-weight: bold;
+        color: #4CAF50;
+    }
+    .stats-label {
+        color: #757575;
+        font-size: 0.9rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+st.markdown("<h1 class='main-header'>🟢 Live Attendance Tracking</h1>", unsafe_allow_html=True)
+
+# System status indicators
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Recognition System: <b>Active</b></div>
+    </div>
+    """, unsafe_allow_html=True)
+with col2:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Database Connection: <b>Active</b></div>
+    </div>
+    """, unsafe_allow_html=True)
+with col3:
+    st.markdown("""
+    <div class="status-indicator">
+        <div class="status-dot active"></div>
+        <div>Auto-Logging: <b>Enabled</b></div>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Main content
+left_col, right_col = st.columns([3, 2])
+
+with left_col:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>📹 Live Recognition Feed</h2>", unsafe_allow_html=True)
+    
+    # Retrieve registered data
+    with st.spinner('Retrieving data from Redis database...'):
+        try:
+            redis_face_db = face_rec.retrive_data(name='academy:register')
+            if not redis_face_db.empty:
+                st.success('✅ User data retrieved successfully!')
+            else:
+                st.warning('⚠️ No registered users found in the database.')
+        except Exception as e:
+            st.error(f"Error retrieving data: {e}")
+            redis_face_db = pd.DataFrame()
+    
+    # Configuration options
+    with st.expander("Recognition Settings"):
+        wait_time = st.slider("Log Update Interval (seconds)", 10, 120, 30)
+        confidence_threshold = st.slider("Recognition Confidence Threshold", 0.3, 0.9, 0.5, 0.05)
+    
+    # Initialize real-time prediction
+    set_time = time.time()
+    realtime_pred = face_rec.RealTimePred()
+    
+    # Video frame callback function
+    def video_frame_callback(frame):
+        global set_time
+        img = frame.to_ndarray(format="bgr24")
+        
+        # Perform face prediction
+        pred_img = realtime_pred.face_prediction(
+            img, 
+            redis_face_db, 
+            'Facial Feature', 
+            ['Name', 'Role'], 
+            thresh=confidence_threshold
+        )
+        
+        # Check if it's time to save logs
+        time_now = time.time()
+        diff_time = time_now - set_time
+        if diff_time >= wait_time:
+            realtime_pred.saveLogs_redis()
+            set_time = time.time()  # Reset timer
+            
+        return av.VideoFrame.from_ndarray(pred_img, format="bgr24")
+    
+    # Webcam feed with face recognition
+    st.markdown("<div class='webcam-container'>", unsafe_allow_html=True)
+    webrtc_streamer(
+        key="realTimePrediction", 
+        video_frame_callback=video_frame_callback,
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
+        media_stream_constraints={"video": True, "audio": False},
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Instructions
+    st.info("""
+    **Instructions:**
+    1. Stand in front of the camera
+    2. Wait for the system to recognize your face
+    3. Your attendance will be logged automatically
+    4. The system records entry and exit times
+    """)
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+with right_col:
+    # User database card
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>👥 Registered Users</h2>", unsafe_allow_html=True)
+    
+    # Display registered users
+    if not redis_face_db.empty:
+        st.dataframe(
+            redis_face_db[['Name', 'Role']].sort_values('Name'),
+            use_container_width=True,
+            hide_index=True,
+            height=200
+        )
+        
+        # Display statistics
+        total_users = len(redis_face_db)
+        students = len(redis_face_db[redis_face_db['Role'] == 'Student'])
+        teachers = len(redis_face_db[redis_face_db['Role'] == 'Teacher'])
+        
+        st.markdown("<br>", unsafe_allow_html=True)
+        stats_cols = st.columns(3)
+        with stats_cols[0]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{total_users}</div>
+                <div class="stats-label">Total Users</div>
+            </div>
+            """, unsafe_allow_html=True)
+        with stats_cols[1]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{students}</div>
+                <div class="stats-label">Students</div>
+            </div>
+            """, unsafe_allow_html=True)
+        with stats_cols[2]:
+            st.markdown(f"""
+            <div class="stats-box">
+                <div class="stats-number">{teachers}</div>
+                <div class="stats-label">Teachers</div>
+            </div>
+            """, unsafe_allow_html=True)
+    else:
+        st.warning("No registered users found in the database.")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Recent activity card
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>🕒 Recent Activity</h2>", unsafe_allow_html=True)
+    
+    # Load and display recent logs
+    try:
+        logs_list = face_rec.r.lrange('attendance:logs', 0, 9)  # Get last 10 logs
+        
+        if logs_list:
+            # Convert bytes to string and create dataframe
+            logs_string = [log.decode('utf-8').split('@') for log in logs_list]
+            logs_df = pd.DataFrame(logs_string, columns=['Name', 'Role', 'Timestamp'])
+            
+            # Format timestamp
+            logs_df['Timestamp'] = pd.to_datetime(logs_df['Timestamp'],format='ISO8601')
+            logs_df['Time'] = logs_df['Timestamp'].dt.strftime('%H:%M:%S')
+            logs_df['Date'] = logs_df['Timestamp'].dt.strftime('%Y-%m-%d')
+            
+            # Display recent logs
+            st.dataframe(
+                logs_df[['Name', 'Role', 'Time', 'Date']],
+                use_container_width=True,
+                hide_index=True
+            )
+        else:
+            st.info("No recent activity logged.")
+    except Exception as e:
+        st.error(f"Error loading logs: {e}")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Quick actions
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<h2 class='section-title'>⚡ Quick Actions</h2>", unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("📊 View Reports", use_container_width=True):
+            st.switch_page("pages/report.py")
+    with col2:
+        if st.button("📝 Add New User", use_container_width=True):
+            st.switch_page("pages/page1.py")
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# Footer
+st.markdown("<div class='footer'>AI-Powered Attendance System • © 2025</div>", unsafe_allow_html=True)

pages/2_registration_form.py

@@ -0,0 +1,197 @@
+import streamlit as st
+import face_rec
+import cv2
+import numpy as np
+from streamlit_webrtc import webrtc_streamer
+import av
+import time
+
+# Page configuration
+st.set_page_config(
+    page_title="User Registration | AI Attendance",
+    page_icon="📝",
+    layout="wide"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.2rem;
+        color: #1E88E5;
+        text-align: center;
+        margin-bottom: 1.5rem;
+        font-weight: 700;
+    }
+    .card {
+        border-radius: 8px;
+        padding: 25px;
+        background-color: #f8f9fa;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        margin-bottom: 20px;
+    }
+    .instructions {
+        background-color: #e8f4f8;
+        border-left: 4px solid #1E88E5;
+        padding: 15px;
+        margin-bottom: 20px;
+        border-radius: 4px;
+    }
+    .submit-button {
+        background-color: #4CAF50;
+        color: white;
+        padding: 12px 24px;
+        font-size: 16px;
+        border-radius: 4px;
+        border: none;
+        cursor: pointer;
+        width: 100%;
+    }
+    .input-label {
+        font-weight: 600;
+        color: #424242;
+        margin-bottom: 8px;
+    }
+    .webcam-container {
+        border: 2px dashed #1E88E5;
+        border-radius: 8px;
+        padding: 10px;
+        margin-top: 10px;
+    }
+    .step-counter {
+        background-color: #1E88E5;
+        color: white;
+        border-radius: 50%;
+        width: 25px;
+        height: 25px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        margin-right: 10px;
+    }
+    .step-title {
+        font-size: 1.2rem;
+        font-weight: 600;
+        color: #1E88E5;
+    }
+    .footer {
+        text-align: center;
+        margin-top: 30px;
+        padding: 20px;
+        color: #6c757d;
+        border-top: 1px solid #e9ecef;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+st.markdown("<h1 class='main-header'>📝 User Registration Form</h1>", unsafe_allow_html=True)
+
+# Progress bar for registration process
+step = 1
+steps = ["Enter Information", "Capture Face", "Submit Registration"]
+progress = (step / len(steps))
+
+st.progress(progress, text=f"Step {step} of {len(steps)}: {steps[step-1]}")
+
+# Main content in columns
+left_col, right_col = st.columns([3, 2])
+
+with left_col:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    
+    # Instructions
+    st.markdown("<div class='instructions'>", unsafe_allow_html=True)
+    st.markdown("""
+    🔹 Please complete all fields below
+    🔹 Face capture requires good lighting
+    🔹 Look directly at the camera
+    🔹 Remove glasses and face coverings
+    """)
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Initialize registration form
+    registration_form = face_rec.RegistrationForm()
+    
+    # Step 1: Collect person name and role
+    st.markdown("<div class='step-title'><span class='step-counter'>1</span> Personal Information</div>", unsafe_allow_html=True)
+    st.markdown("<p class='input-label'>Full Name</p>", unsafe_allow_html=True)
+    person_name = st.text_input(label="", placeholder="Enter your first and last name", label_visibility="collapsed")
+    
+    st.markdown("<p class='input-label'>Select Role</p>", unsafe_allow_html=True)
+    role = st.selectbox(label="", options=("Student", "Teacher"), label_visibility="collapsed")
+    
+    # Additional information (optional)
+    with st.expander("Additional Information (Optional)"):
+        st.text_input("Email Address")
+        st.text_input("ID Number")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.date_input("Date of Birth")
+        with col2:
+            st.selectbox("Department", ["Computer Science", "Engineering", "Business", "Arts", "Science"])
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+with right_col:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    
+    # Step 2: Collect facial embedding of that person
+    st.markdown("<div class='step-title'><span class='step-counter'>2</span> Face Capture</div>", unsafe_allow_html=True)
+    st.write("Please position your face in the frame and wait for the system to capture your facial features.")
+    
+    # Face capture status indicators
+    status_placeholder = st.empty()
+    
+    # Custom face capture function
+    def video_callback_func(frame):
+        img = frame.to_ndarray(format='bgr24')
+        reg_img, embedding = registration_form.get_embedding(img)
+        
+        # Save embedding if available
+        if embedding is not None:
+            with open('face_embedding.txt', mode='ab') as f:
+                np.savetxt(f, embedding)
+            status_placeholder.success("✅ Face captured successfully!")
+        
+        return av.VideoFrame.from_ndarray(reg_img, format='bgr24')
+    
+    # Webcam feed
+    st.markdown("<div class='webcam-container'>", unsafe_allow_html=True)
+    webrtc_streamer(
+        key='registration', 
+        video_frame_callback=video_callback_func,
+        rtc_configuration={"iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]},
+        media_stream_constraints={"video": True, "audio": False},
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# Step 3: Submit button and save the data
+st.markdown("<div class='card'>", unsafe_allow_html=True)
+st.markdown("<div class='step-title'><span class='step-counter'>3</span> Complete Registration</div>", unsafe_allow_html=True)
+
+col1, col2, col3 = st.columns([1, 2, 1])
+with col2:
+    if st.button("Register User", key="submit_button", use_container_width=True):
+        with st.spinner("Processing registration..."):
+            time.sleep(1)  # Simulate processing
+            return_val = registration_form.save_data_in_redis_db(person_name, role)
+            
+            if return_val == True:
+                st.success(f"✅ {person_name} registered successfully!")
+                st.balloons()
+                # Add a timer for redirecting
+                st.write("Redirecting to home page in 5 seconds...")
+                time.sleep(5)
+                st.switch_page("home.py")
+            elif return_val == 'name_false':
+                st.error("❌ Please enter a valid name. Name cannot be empty or contain only spaces.")
+            elif return_val == 'file_false':
+                st.error("❌ Face embedding data not found. Please refresh the page and try again.")
+
+st.markdown("</div>", unsafe_allow_html=True)
+
+# Footer
+st.markdown("<div class='footer'>AI-Powered Attendance System • © 2025</div>", unsafe_allow_html=True)

pages/3_report.py

@@ -0,0 +1,402 @@
+import streamlit as st
+import pandas as pd
+import datetime
+import plotly.express as px
+from home import face_rec
+import time
+
+# Page configuration
+st.set_page_config(
+    page_title="Attendance Dashboard",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #1E3A8A;
+        margin-bottom: 1rem;
+        text-align: center;
+        padding: 1rem;
+        border-bottom: 2px solid #E5E7EB;
+    }
+    .sub-header {
+        font-size: 1.8rem;
+        color: #1E3A8A;
+        margin-top: 1rem;
+    }
+    .card {
+        background-color: #F9FAFB;
+        border-radius: 10px;
+        padding: 1.5rem;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        margin-bottom: 1rem;
+    }
+    .metric-card {
+        background-color: #EFF6FF;
+        border-radius: 10px;
+        padding: 1rem;
+        text-align: center;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+    }
+    .metric-value {
+        font-size: 2rem;
+        font-weight: bold;
+        color: #1E40AF;
+    }
+    .metric-label {
+        font-size: 1rem;
+        color: #6B7280;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 10px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        border-radius: 4px 4px 0px 0px;
+        padding: 10px 16px;
+        background-color: #F3F4F6;
+    }
+    .stTabs [aria-selected="true"] {
+        background-color: #DBEAFE;
+        border-bottom: 2px solid #2563EB;
+    }
+    .dataframe {
+        font-size: 14px;
+    }
+    .refresh-btn {
+        background-color: #3B82F6;
+        color: white;
+        font-weight: bold;
+        border-radius: 6px;
+        padding: 8px 16px;
+    }
+    .filter-section {
+        background-color: #F9FAFB;
+        padding: 15px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header section
+st.markdown('<h1 class="main-header">Attendance Management Dashboard</h1>', unsafe_allow_html=True)
+
+# Function to load logs
+def load_logs(name, end=-1):
+    with st.spinner('Loading attendance logs...'):
+        logs_list = face_rec.r.lrange(name, start=0, end=end)
+        return logs_list
+
+# Function to process logs into DataFrame
+def process_logs(logs_list):
+    # Convert bytes to string
+    logs_list_string = [log.decode('utf-8') for log in logs_list]
+    
+    # Split string by @ and create nested list
+    logs_nested_list = [log.split('@') for log in logs_list_string]
+    
+    # Convert nested list into dataframe
+    logs_df = pd.DataFrame(logs_nested_list, columns=['Name', 'Role', 'Timestamp'])
+    
+    # Time based analysis
+    logs_df['Timestamp'] = pd.to_datetime(logs_df['Timestamp'], format='mixed')
+    logs_df['Date'] = logs_df['Timestamp'].dt.date
+    
+    # Calculate Intime and outtime
+    report_df = logs_df.groupby(by=['Date', 'Name', 'Role']).agg(
+        In_time=pd.NamedAgg('Timestamp', 'min'),
+        Out_time=pd.NamedAgg('Timestamp', 'max')
+    ).reset_index()
+    
+    report_df['In_time'] = pd.to_datetime(report_df['In_time'])
+    report_df['Out_time'] = pd.to_datetime(report_df['Out_time'])
+    report_df['duration'] = report_df['Out_time'] - report_df['In_time']
+    
+    # Mark attendance status
+    all_dates = report_df['Date'].unique()
+    name_role = report_df[['Name', 'Role']].drop_duplicates().values.tolist()
+    date_name_role_zip = []
+    for dt in all_dates:
+        for name, role in name_role:
+            date_name_role_zip.append([dt, name, role])
+            
+    full_df = pd.DataFrame(date_name_role_zip, columns=['Date', 'Name', 'Role'])
+    full_df = pd.merge(full_df, report_df, how='left', on=['Date', 'Name', 'Role'])
+    full_df['Duration_seconds'] = full_df['duration'].dt.total_seconds()
+    full_df['Duration_hours'] = full_df['Duration_seconds'] / (60 * 60)
+    
+    def status_marker(x):
+        if pd.isna(x):
+            return 'Absent'
+        elif x >= 0 and x < 1:
+            return 'Absent (Less than 1 hour)'
+        elif x >= 1 and x < 4:
+            return 'Half Day (less than 4 hours)'
+        elif x >= 4 and x < 6:
+            return 'Half Day'
+        elif x >= 6:
+            return "Present"
+    
+    full_df['Status'] = full_df['Duration_hours'].apply(status_marker)
+    return logs_df, full_df
+
+# Create tabs with more visual appeal
+tab1, tab2, tab3 = st.tabs(["📊 Dashboard", "📋 Attendance Records", "🔍 Search & Filter"])
+
+# Tab 1: Dashboard
+with tab1:
+    st.markdown('<div class="card">', unsafe_allow_html=True)
+    st.markdown('<h2 class="sub-header">Registered Personnel</h2>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([1, 3])
+    
+    with col1:
+        if st.button('Refresh Data', key='refresh_data', help="Load the latest data from database"):
+            with st.spinner('Retrieving data from database...'):
+                redis_face_db = face_rec.retrive_data(name='academy:register')
+                total_registered = len(redis_face_db)
+                st.success(f"Successfully loaded {total_registered} records")
+        
+    with col2:
+        try:
+            redis_face_db = face_rec.retrive_data(name='academy:register')
+            st.dataframe(redis_face_db[['Name', 'Role']], use_container_width=True)
+            
+            # Count by role for visualization
+            role_counts = redis_face_db['Role'].value_counts().reset_index()
+            role_counts.columns = ['Role', 'Count']
+            
+            fig = px.pie(role_counts, values='Count', names='Role', 
+                         title='Distribution by Role',
+                         color_discrete_sequence=px.colors.qualitative.Pastel)
+            st.plotly_chart(fig, use_container_width=True)
+        except Exception as e:
+            st.info("Click 'Refresh Data' to load registered personnel")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Recent attendance logs
+    st.markdown('<div class="card">', unsafe_allow_html=True)
+    st.markdown('<h2 class="sub-header">Recent Attendance Activity</h2>', unsafe_allow_html=True)
+    
+    if st.button('Load Recent Activity', key='load_recent'):
+        logs_list = load_logs(name='attendance:logs', end=10)
+        if logs_list:
+            st.success(f"Showing {len(logs_list)} recent logs")
+            logs_list_string = [log.decode('utf-8') for log in logs_list]
+            
+            # Create a more structured view of logs
+            for i, log in enumerate(logs_list_string):
+                parts = log.split('@')
+                if len(parts) >= 3:
+                    name, role, timestamp = parts[0], parts[1], parts[2]
+                    col1, col2, col3 = st.columns([1, 1, 2])
+                    with col1:
+                        st.write(f"**{name}**")
+                    with col2:
+                        st.write(f"{role}")
+                    with col3:
+                        st.write(f"{timestamp}")
+                    st.divider()
+        else:
+            st.info("No recent logs found")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Tab 2: Attendance Records 
+with tab2:
+    st.markdown('<div class="card">', unsafe_allow_html=True)
+    st.markdown('<h2 class="sub-header">Complete Attendance Report</h2>', unsafe_allow_html=True)
+    
+    if st.button('Generate Full Report', key='gen_report'):
+        with st.spinner("Processing attendance data..."):
+            # Load and process logs
+            logs_list = load_logs(name='attendance:logs')
+            if logs_list:
+                logs_df, full_df = process_logs(logs_list)
+                
+                # Summary metrics
+                col1, col2, col3, col4 = st.columns(4)
+                with col1:
+                    st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                    st.markdown(f'<div class="metric-value">{len(full_df["Date"].unique())}</div>', unsafe_allow_html=True)
+                    st.markdown('<div class="metric-label">Total Days</div>', unsafe_allow_html=True)
+                    st.markdown('</div>', unsafe_allow_html=True)
+                
+                with col2:
+                    st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                    st.markdown(f'<div class="metric-value">{len(full_df["Name"].unique())}</div>', unsafe_allow_html=True)
+                    st.markdown('<div class="metric-label">Total Personnel</div>', unsafe_allow_html=True)
+                    st.markdown('</div>', unsafe_allow_html=True)
+                
+                with col3:
+                    present_count = len(full_df[full_df['Status'] == 'Present'])
+                    st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                    st.markdown(f'<div class="metric-value">{present_count}</div>', unsafe_allow_html=True)
+                    st.markdown('<div class="metric-label">Present Records</div>', unsafe_allow_html=True)
+                    st.markdown('</div>', unsafe_allow_html=True)
+                
+                with col4:
+                    absent_count = len(full_df[full_df['Status'] == 'Absent'])
+                    st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+                    st.markdown(f'<div class="metric-value">{absent_count}</div>', unsafe_allow_html=True)
+                    st.markdown('<div class="metric-label">Absent Records</div>', unsafe_allow_html=True)
+                    st.markdown('</div>', unsafe_allow_html=True)
+                
+                # Status distribution visualization
+                status_counts = full_df['Status'].value_counts().reset_index()
+                status_counts.columns = ['Status', 'Count']
+                
+                fig = px.bar(status_counts, x='Status', y='Count', 
+                             title='Attendance Status Distribution',
+                             color='Status',
+                             color_discrete_sequence=px.colors.qualitative.Bold)
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Display the complete report table
+                st.subheader("Detailed Attendance Records")
+                
+                # Format columns for better display
+                display_df = full_df.copy()
+                display_df['Date'] = pd.to_datetime(display_df['Date']).dt.strftime('%Y-%m-%d')
+                display_df['In_time'] = pd.to_datetime(display_df['In_time']).dt.strftime('%H:%M:%S')
+                display_df['Out_time'] = pd.to_datetime(display_df['Out_time']).dt.strftime('%H:%M:%S')
+                display_df['Duration_hours'] = display_df['Duration_hours'].round(2)
+                
+                # Choose columns to display
+                display_cols = ['Date', 'Name', 'Role', 'In_time', 'Out_time', 'Duration_hours', 'Status']
+                st.dataframe(display_df[display_cols], use_container_width=True)
+                
+                # Option to download the report
+                csv = display_df[display_cols].to_csv(index=False).encode('utf-8')
+                st.download_button(
+                    label="Download Report as CSV",
+                    data=csv,
+                    file_name=f"attendance_report_{datetime.datetime.now().strftime('%Y%m%d')}.csv",
+                    mime="text/csv",
+                )
+            else:
+                st.warning("No attendance logs found. Make sure the system is recording attendance.")
+    else:
+        st.info("Click 'Generate Full Report' to process and display attendance data")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Tab 3: Search & Filter
+with tab3:
+    st.markdown('<div class="card">', unsafe_allow_html=True)
+    st.markdown('<h2 class="sub-header">Search Records</h2>', unsafe_allow_html=True)
+    
+    # Load data first before showing filters
+    load_data_btn = st.button("Load Data for Filtering", key="load_filter_data")
+    
+    if load_data_btn:
+        with st.spinner("Loading data..."):
+            logs_list = load_logs(name='attendance:logs')
+            if logs_list:
+                logs_df, full_df = process_logs(logs_list)
+                st.session_state['full_df'] = full_df
+                st.success("Data loaded successfully! You can now filter the records.")
+            else:
+                st.warning("No attendance logs found to filter.")
+    
+    if 'full_df' in st.session_state:
+        full_df = st.session_state['full_df']
+        
+        st.markdown('<div class="filter-section">', unsafe_allow_html=True)
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Date filter
+            date_options = sorted([str(date) for date in full_df['Date'].unique()])
+            date_in = st.selectbox('Select Date', ['ALL'] + date_options, index=0)
+            
+            # Name filter
+            name_list = sorted(full_df['Name'].unique().tolist())
+            name_in = st.selectbox('Select Name', ['ALL'] + name_list)
+        
+        with col2:
+            # Role filter
+            role_list = sorted(full_df['Role'].unique().tolist())
+            role_in = st.selectbox('Select Role', ['ALL'] + role_list)
+            
+            # Status filter
+            status_list = sorted(full_df['Status'].unique().tolist())
+            status_in = st.multiselect('Select Status', ['ALL'] + status_list, default=['Present'])
+        
+        # Duration filter with slider
+        duration_in = st.slider('Filter by minimum duration in hours', 0, 12, 0)
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Apply filters
+        if st.button('Apply Filters', key='apply_filters'):
+            with st.spinner("Filtering records..."):
+                # Convert date column to string for comparison
+                filter_df = full_df.copy()
+                filter_df['Date'] = filter_df['Date'].astype(str)
+                
+                # Apply each filter
+                if date_in != 'ALL':
+                    filter_df = filter_df[filter_df['Date'] == date_in]
+                
+                if name_in != 'ALL':
+                    filter_df = filter_df[filter_df['Name'] == name_in]
+                
+                if role_in != 'ALL':
+                    filter_df = filter_df[filter_df['Role'] == role_in]
+                
+                if duration_in > 0:
+                    filter_df = filter_df[filter_df['Duration_hours'] > duration_in]
+                
+                if 'ALL' not in status_in and len(status_in) > 0:
+                    filter_df = filter_df[filter_df['Status'].isin(status_in)]
+                
+                if len(filter_df) > 0:
+                    # Format display columns
+                    display_df = filter_df.copy()
+                    display_df['Date'] = pd.to_datetime(display_df['Date']).dt.strftime('%Y-%m-%d') if 'datetime' in str(type(display_df['Date'].iloc[0])) else display_df['Date']
+                    if not pd.isna(display_df['In_time'].iloc[0]):
+                        display_df['In_time'] = pd.to_datetime(display_df['In_time']).dt.strftime('%H:%M:%S')
+                        display_df['Out_time'] = pd.to_datetime(display_df['Out_time']).dt.strftime('%H:%M:%S')
+                    display_df['Duration_hours'] = display_df['Duration_hours'].round(2)
+                    
+                    display_cols = ['Date', 'Name', 'Role', 'In_time', 'Out_time', 'Duration_hours', 'Status']
+                    st.dataframe(display_df[display_cols], use_container_width=True)
+                    
+                    # Option to download filtered results
+                    csv = display_df[display_cols].to_csv(index=False).encode('utf-8')
+                    st.download_button(
+                        label="Download Filtered Results",
+                        data=csv,
+                        file_name=f"filtered_attendance_{datetime.datetime.now().strftime('%Y%m%d')}.csv",
+                        mime="text/csv",
+                    )
+                    
+                    # Visual summary of filtered results
+                    if len(display_df) > 1:
+                        status_filtered = display_df['Status'].value_counts().reset_index()
+                        status_filtered.columns = ['Status', 'Count']
+                        
+                        fig = px.pie(status_filtered, values='Count', names='Status', 
+                                    title='Status Distribution in Filtered Results',
+                                    hole=0.4,
+                                    color_discrete_sequence=px.colors.qualitative.Pastel)
+                        st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.warning("No records match your filter criteria.")
+    else:
+        st.info("Please click 'Load Data for Filtering' first to enable search functionality.")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Footer
+st.markdown("""
+<div style="text-align: center; margin-top: 30px; padding: 20px; background-color: #F3F4F6; border-radius: 10px;">
+    <p style="color: #6B7280; font-size: 14px;">Attendance Management System © 2025</p>
+</div>
+""", unsafe_allow_html=True)

upload_logs.py

@@ -0,0 +1,19 @@
+import redis
+
+# Connect to Redis Client
+hostname = 'redis-18916.c83.us-east-1-2.ec2.redns.redis-cloud.com'
+portnumber = 18916
+password = 'vTig9W0x2XtLCyR3MDFQFyZjSMSId6Gr'
+
+r = redis.StrictRedis(host=hostname,
+                      port=portnumber,
+                      password=password)
+
+# Simulated Logs
+with open('simulated_logs.txt', 'r') as f:
+    logs_text = f.read()
+
+encoded_logs = logs_text.split('\n')
+
+# Push into Redis database
+r.lpush('attendance:logs', *encoded_logs)