added new features removed admin access and reduced thread sleep time from 60 t0 30 sec

app.py

@@ -6,7 +6,6 @@ from google.oauth2.credentials import Credentials
 from google_auth_oauthlib.flow import InstalledAppFlow
 import json
 import gradio as gr
-import urllib.parse
 import time
 from datetime import datetime
 from pytz import timezone
@@ -16,9 +15,18 @@ from dotenv import load_dotenv
 # Load environment variables
 load_dotenv()
 
+# Time zone Conversion
+ist = timezone("Asia/Kolkata")
+
 # Scopes (read-only)
 SCOPES = ["https://www.googleapis.com/auth/spreadsheets.readonly"]
 
+# GLOBAL ANALYTICS VARIABLES - Add at the top after imports
+visit_count = 0
+searched_roll_numbers = []
+unique_searches = set()
+search_history = []  # Store with timestamps
+
 def authorize():
     creds = None
     
@@ -56,6 +64,45 @@ def authorize():
     
     return gspread.authorize(creds)
 
+# Function to increment visit count
+def increment_visit_count():
+    global visit_count
+    visit_count += 1
+
+# Function to log searched roll numbers
+def log_search(roll_no):
+    global searched_roll_numbers, unique_searches, search_history
+    
+    if roll_no and roll_no.strip():
+        roll_no = roll_no.strip().upper()
+        searched_roll_numbers.append(roll_no)
+        unique_searches.add(roll_no)
+        
+        # Add to search history with timestamp
+        search_entry = {
+            'roll_no': roll_no,
+            'timestamp': datetime.now(ist).strftime('%Y-%m-%d %H:%M:%S'),
+            'search_count': len(searched_roll_numbers)
+        }
+        search_history.append(search_entry)
+        
+# Function to get analytics data
+def get_analytics_summary():
+    """Get current analytics summary"""
+    total_searches = len(searched_roll_numbers)
+    unique_users = len(unique_searches)
+    
+    # Get recent searches (last 5)
+    recent_searches = searched_roll_numbers[-5:] if searched_roll_numbers else []
+    
+    return {
+        'visits': visit_count,
+        'total_searches': total_searches,
+        'unique_searches': unique_users,
+        'recent_searches': recent_searches,
+        'all_searches': searched_roll_numbers
+    }
+
 # Function to get data from a specific sheet
 def get_sheet_data(spreadsheet, gid, sheet_name):
     try:
@@ -118,7 +165,7 @@ def get_studentwise_data(spreadsheet):
         print(f"❌ Error loading Studentwise Reward Points: {str(e)}")
         return None
 
-# NEW FUNCTION: Load and cache reward points activity data
+# Function to load and cache reward points activity data
 def load_reward_points_data():
     """Load and cache reward points activity data"""
     try:
@@ -153,7 +200,7 @@ def load_reward_points_data():
         print(f"❌ Error loading Reward Points data: {str(e)}")
         return None
 
-# MODIFIED FUNCTION: Get activity details from cached data in breakdown format
+# Function to get activity details from cached data in breakdown format
 def get_activity_details(roll_no, reward_points_df):
     """Get activity details for a specific roll number from cached reward points data in breakdown format"""
     try:
@@ -400,7 +447,7 @@ def get_details_info(spreadsheet):
 print("🚀 Initializing application...")
 client = authorize()
 
-# 🔧 Get spreadsheet IDs from environment variables
+# Get spreadsheet IDs from environment variables
 MAIN_SHEET_ID = os.getenv('GOOGLE_SHEET_ID')  # Your main sheets (20 sheets)
 STUDENTWISE_SHEET_ID = os.getenv('STUDENTWISE_SHEET_ID')  # Studentwise Reward Points sheet
 
@@ -436,12 +483,12 @@ sheet_configs = [
     {"gid": 400900059, "name": "Sheet_20"}
 ]
 
-# 🕒 GLOBAL DATA CACHE WITH 12-HOUR AUTO-REFRESH (NOW INCLUDES REWARD POINTS DATA)
+# GLOBAL DATA CACHE WITH 12-HOUR AUTO-REFRESH
 data_cache = {
     "combined_df": None,
     "studentwise_data": None,
     "details_info": None,
-    "reward_points_df": None,  # NEW: Cache for reward points data
+    "reward_points_df": None,
     "last_update": None,
     "cache_duration_hours": 12,  # 12 hours cache
     "is_loading": False
@@ -517,14 +564,14 @@ def load_all_data():
         # Load details info from main spreadsheet
         details_info = get_details_info(main_spreadsheet)
         
-        # NEW: Load reward points activity data
+        # Load reward points activity data
         reward_points_df = load_reward_points_data()
         
         # Update cache
         data_cache["combined_df"] = combined_df
         data_cache["studentwise_data"] = studentwise_data
         data_cache["details_info"] = details_info
-        data_cache["reward_points_df"] = reward_points_df  # NEW: Cache reward points data
+        data_cache["reward_points_df"] = reward_points_df
         data_cache["last_update"] = datetime.now()
         
         load_time = time.time() - start_time
@@ -573,38 +620,34 @@ def auto_refresh_worker():
             # If error, wait 1 hour before trying again
             time.sleep(3600)
 
-# Auto Refersh When Time changes is found
-# Replace the details_sheet_watcher function (lines 577-610)
-
 def details_sheet_watcher():
-    """Background watcher: checks every 1 minute if 'POINTS LAST UPDATED' changed - FIXED TOKEN SPAM & THREADING"""
+    """Background watcher: checks every 30 seconds if 'POINTS LAST UPDATED' changed - optimized timing"""
     last_seen_update = None
     consecutive_errors = 0
     max_errors = 3
-    
-    # Persistent connection variables to prevent token regeneration
+
     watcher_client = None
     watcher_spreadsheet = None
     last_connection_time = None
-    connection_duration = 2700  # 45 minutes in seconds
-    
-    print("👀 Starting optimized details sheet watcher (checks every 1 minute)...")
-    
+    connection_duration = 2700  # 45 minutes
+
+    check_interval = 30  # seconds
+
+    print(f"👀 Starting optimized details sheet watcher (checks every {check_interval} seconds)...")
+
     while True:
         try:
-            # Skip if data is currently being loaded to prevent conflicts
             if data_cache["is_loading"]:
                 print("⏳ Watcher: Skipping check - data loading in progress")
-                time.sleep(60)
+                time.sleep(check_interval)
                 continue
-            
-            # Create/refresh connection only when needed (every 45 minutes)
+
             current_time = datetime.now()
             if (watcher_client is None or 
                 watcher_spreadsheet is None or
                 last_connection_time is None or 
                 (current_time - last_connection_time).total_seconds() > connection_duration):
-                
+
                 try:
                     print("🔄 Watcher: Refreshing connection...")
                     watcher_client = authorize()
@@ -616,24 +659,22 @@ def details_sheet_watcher():
                     consecutive_errors += 1
                     watcher_client = None
                     watcher_spreadsheet = None
-                    time.sleep(60)
+                    time.sleep(check_interval)
                     continue
-            
-            # Use persistent connection to get details info
+
             try:
                 details_info = get_details_info(watcher_spreadsheet)
             except Exception as sheet_error:
                 print(f"⚠️ Watcher sheet error: {str(sheet_error)[:100]}...")
                 consecutive_errors += 1
-                # Force connection refresh on next iteration
                 watcher_client = None
                 watcher_spreadsheet = None
-                time.sleep(60)
+                time.sleep(check_interval)
                 continue
-            
+
             if details_info and 'last_updated' in details_info:
                 current_update = details_info['last_updated'].strip()
-                
+
                 if last_seen_update is None:
                     last_seen_update = current_update
                     print(f"🕒 Watcher: Monitoring established")
@@ -642,10 +683,8 @@ def details_sheet_watcher():
                     print(f"🔄 CHANGE DETECTED!")
                     print(f"    Old: {last_seen_update[:60]}...")
                     print(f"    New: {current_update[:60]}...")
-                    
                     last_seen_update = current_update
-                    
-                    # FIXED: Direct reload without creating new thread
+
                     if not data_cache["is_loading"]:
                         print("🔄 Reloading data directly...")
                         try:
@@ -656,35 +695,29 @@ def details_sheet_watcher():
                     else:
                         print("⏳ Data already loading, skipping reload")
                 else:
-                    # Only log status every 10 minutes to reduce spam
-                    if datetime.now().minute % 10 == 0:
-                        print(f"✅ Watcher: No changes detected ({datetime.now().strftime('%H:%M')})")
+                    # Show heartbeat every 5 minutes instead of 10
+                    if datetime.now().minute % 5 == 0 and datetime.now(ist).second < check_interval:
+                        print(f"✅ Watcher: No changes detected ({datetime.now(ist).strftime('%H:%M')})")
             else:
                 print("⚠️ Watcher: Could not extract last_updated info")
                 consecutive_errors += 1
-            
-            # Reset error counter on successful operation
+
             if details_info and consecutive_errors > 0:
                 print(f"✅ Watcher: Connection restored (cleared {consecutive_errors} errors)")
                 consecutive_errors = 0
-            
+
         except Exception as e:
             consecutive_errors += 1
             print(f"⚠️ Watcher error #{consecutive_errors}: {str(e)[:100]}...")
-            
-            # Force connection refresh after errors
             watcher_client = None
             watcher_spreadsheet = None
-            
-            # Progressive backoff for multiple errors
             if consecutive_errors >= max_errors:
                 error_wait = 300  # 5 minutes
                 print(f"❌ Too many watcher errors, waiting {error_wait//60} minutes...")
                 time.sleep(error_wait)
                 consecutive_errors = 0
-        
-        # Wait 1 minute before next check
-        time.sleep(60)
+
+        time.sleep(check_interval)
 
 def get_detailed_student_points(roll_no, studentwise_data):
     """Get detailed points breakdown from studentwise data"""
@@ -761,7 +794,7 @@ def get_detailed_student_points(roll_no, studentwise_data):
 
 def calculate_yearwise_average_points():
     """Calculate year-wise average points from the combined data"""
-    combined_df, _, _, _ = get_cached_data()  # FIX: Get all 4 return values
+    combined_df, _, _, _ = get_cached_data()
     if combined_df.empty:
         return "❌ No data available to calculate averages"
 
@@ -816,8 +849,6 @@ def calculate_yearwise_average_points():
     output.append("=" * 90)
     return "\n".join(output)
 
-
-
 # Load initial data
 print("📊 Loading initial data...")
 load_all_data()
@@ -827,7 +858,7 @@ refresh_thread = threading.Thread(target=auto_refresh_worker, daemon=True)
 refresh_thread.start()
 print("🕒 Auto-refresh thread started (updates every 12 hours)")
 
-# 1 min auto-refresh thread to watch details sheet changes
+# Start details sheet watcher thread
 watcher_thread = threading.Thread(target=details_sheet_watcher, daemon=True)
 watcher_thread.start()
 print("👀 Details sheet watcher started (checks every 1 minute)")
@@ -840,6 +871,9 @@ def search_student(roll_no):
     # Convert roll number to uppercase for consistent searching
     roll_no = roll_no.strip().upper()
     
+    # Log the search
+    log_search(roll_no)
+    
     # Get cached data (fast response, auto-refreshes every 12 hours)
     combined_df, studentwise_data, details_info, reward_points_df = get_cached_data()
     
@@ -865,16 +899,15 @@ def search_student(roll_no):
     student_name = str(record.get('STUDENT NAME', 'Unknown')).strip()
     student_year = str(record.get('YEAR', '')).strip()
 
-    # Time zone Conversion
-    ist = timezone("Asia/Kolkata")
     now_ist = datetime.now(ist).strftime("%Y-%m-%d %H:%M:%S")
     # Log to see which roll number and student name is searched by user
     print(f"Roll No Searched: {roll_no} | Student Name: {student_name} | Time (IST): {now_ist}")
     
     # Format output - Simplified version
     output = []
+    output.append(f"Hello {student_name} 👋")
     output.append("=" * 80)
-    output.append("STUDENT DETAILS")
+    output.append("YOUR DETAILS")
     output.append("=" * 80)
     
     # Main student details
@@ -927,7 +960,7 @@ def search_student(roll_no):
                     output.append("   Keep up the great work! 🌟")
                     output.append("   Refer Reward points Breakdown for more details")
     
-    # MODIFIED: Add individual activity details from cached reward points data
+    # Add individual activity details from cached reward points data
     activity_details = get_activity_details(roll_no, reward_points_df)
     if activity_details:
         output.append(activity_details)
@@ -937,7 +970,6 @@ def search_student(roll_no):
     if detailed_points:
         output.append(detailed_points)
     
-    
     # Add last updated info
     if details_info and 'last_updated' in details_info:
         output.append("\n" + "-" * 60)
@@ -967,14 +999,16 @@ def get_system_info():
     if not details_info:
         return "❌ No system information available"
     
+    # Get analytics data
+    analytics = get_analytics_summary()
+    
     output = []
     output.append("=" * 80)
     output.append("SYSTEM INFORMATION")
     output.append("=" * 80)
-
     # Average Points
     if 'average_points' in details_info:
-        output.append("\nAVERAGE REWARD POINTS BY YEAR:")
+        output.append("\n🎯 AVERAGE REWARD POINTS BY YEAR:")
         output.append("-" * 40)
         for year, points in details_info['average_points'].items():
             if points:
@@ -987,21 +1021,21 @@ def get_system_info():
     
     # Redemption Dates
     if 'ip1_redemption' in details_info:
-        output.append("\nIP 1 REDEMPTION DATES:")
+        output.append("\n📅 IP 1 REDEMPTION DATES:")
         output.append("-" * 40)
         for semester, date in details_info['ip1_redemption'].items():
             if date and date != '-':
                 output.append(f"{semester:<10}: {date}")
     
     if 'ip2_redemption' in details_info:
-        output.append("\nIP 2 REDEMPTION DATES:")
+        output.append("\n📅 IP 2 REDEMPTION DATES:")
         output.append("-" * 40)
         for semester, date in details_info['ip2_redemption'].items():
             if date and date != '-':
                 output.append(f"{semester:<10}: {date}")
     
     if 'last_updated' in details_info:
-        output.append(f"\nLAST UPDATED:")
+        output.append(f"\n🕒 LAST UPDATED:")
         output.append("-" * 40)
         output.append(details_info['last_updated'])
     
@@ -1020,86 +1054,42 @@ def get_system_info():
     
     return "\n".join(output)
 
-# Admin UI Controls
-def build_admin_section():
-    """Build admin controls section"""
-    with gr.Accordion("🔧 Admin Controls", open=False, visible=True) as admin_accordion:
-        admin_key = gr.Textbox(
-            label="Enter Admin Key", 
-            type="password", 
-            placeholder="Admin Only",
-            value=""
-        )
-        load_button = gr.Button("🔁 Reload All Data", visible=False, variant="primary")
-        admin_status = gr.Markdown("ℹ️ Enter admin key to access controls", visible=True)
-
-        def verify_admin_key(key):
-            """Verify admin key and show/hide controls"""
-            if key.strip() == os.getenv("ADMIN_KEY", ""):
-                return (
-                    gr.update(visible=True),  # Show reload button
-                    "✅ Access granted. You can reload data now."
-                )
-            elif key.strip() == "":
-                return (
-                    gr.update(visible=False),  # Hide reload button
-                    "ℹ️ Enter admin key to access controls"
-                )
-            else:
-                return (
-                    gr.update(visible=False),  # Hide reload button
-                    "❌ Invalid admin key."
-                )
+# Function to get live analytics for header display
+def get_live_analytics():
+    """Get current analytics for header display"""
+    analytics = get_analytics_summary()
+    return f"📊 Visits: {analytics['visits']} | 🔍 Searches: {analytics['total_searches']} | 👥 Unique Users: {analytics['unique_searches']}"
 
-        def admin_reload():
-            """Admin function to reload all data"""
-            try:
-                print("🔧 Admin reload triggered...")
-                combined_df, studentwise_data, details_info, reward_points_df = load_all_data()
-                
-                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                return f"✅ Data reloaded successfully at {timestamp}\n📊 Total records: {len(combined_df) if not combined_df.empty else 0}"
-            except Exception as e:
-                return f"❌ Error reloading data: {str(e)}"
-
-        # Event handlers
-        admin_key.change(
-            fn=verify_admin_key, 
-            inputs=admin_key, 
-            outputs=[load_button, admin_status]
-        )
-        
-        load_button.click(
-            fn=admin_reload, 
-            outputs=admin_status
-        )
+# Create Gradio interface with analytics
+with gr.Blocks(
+    title="Student Reward Points Check", 
+    theme=gr.themes.Soft(),
+) as app:
     
-    return admin_accordion, admin_key, load_button, admin_status
-
-# Function to determine if admin mode is enabled via URL parameter
-def check_admin_mode(request: gr.Request) -> bool:
-    """Check if admin mode is enabled via URL parameter"""
-    try:
-        query_params = urllib.parse.parse_qs(str(request.url).split('?')[1] if '?' in str(request.url) else "")
-        admin_param = query_params.get("admin", [""])[0]
-        admin_mode_key = os.getenv("ADMIN_MODE_KEY", "")
+    # Header with analytics
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("# 🎓 Student Reward Points Checker")
+            gr.Markdown("### Search for Student details including Reward points with detailed information and Redemption dates")
+            gr.Markdown("### எல்லா புகழும் இறைவனுக்கே ✝ 🕉 ☪")
+            gr.Markdown("🕒 **Auto-Updates**: Data automatically refreshes when there is a change in Reward Points Sheet")
+            gr.Markdown("### Fill this form for any Issue/Feedback: [Issue/Feedback Form](https://docs.google.com/forms/d/e/1FAIpQLScnl0udcN2pUDENHl45HIj5HZbvDuwZ0g2eepBbp8tJYg-NvQ/viewform)")
         
-        is_admin = admin_param == admin_mode_key and admin_mode_key != ""
-        if is_admin:
-            print(f"🔧 Admin mode activated via URL parameter")
-        return is_admin
-    except Exception as e:
-        print(f"⚠️ Error checking admin mode: {str(e)}")
-        return False
-
-# Create Gradio interface
-with gr.Blocks(title="Student Reward Points Check", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🎓 Student Reward Points Check")
-    gr.Markdown("### Search for student details including reward points and redemption dates")
-    gr.Markdown("🕒 **Auto-Updates**: Data automatically refreshes when there is a change in Reward Points Sheet")
-    gr.Markdown("### Fill this form for any issues/Feedback: [Issue/Feedback Form](https://docs.google.com/forms/d/e/1FAIpQLScnl0udcN2pUDENHl45HIj5HZbvDuwZ0g2eepBbp8tJYg-NvQ/viewform)")
-    # Store admin components for conditional visibility
-    admin_components = gr.State(None)
+        with gr.Column(scale=1):
+            # Live analytics display
+            analytics_display = gr.HTML(
+                value=f"""
+                <div class="analytics-display">
+                    <h2 style="margin: 0; color: black;">📊 Live Analytics</h2>
+                    <div style="margin: 10px 0;">
+                        <div>📊 Visits: {visit_count}</div>
+                        <div>🔍 Searches: {len(searched_roll_numbers)}</div>
+                        <div>👥 Unique Users: {len(unique_searches)}</div>
+                    </div>
+                </div>
+                """,
+                elem_id="analytics_display"
+            )
     
     with gr.Tabs():
         with gr.TabItem("🔍 Student Search"):
@@ -1118,7 +1108,8 @@ with gr.Blocks(title="Student Reward Points Check", theme=gr.themes.Soft()) as a
                 lines=50,
                 max_lines=60,
                 show_copy_button=True,
-                autoscroll=False
+                autoscroll=False,
+                elem_id="result_output"
             )
             
         with gr.TabItem("ℹ️ System Information"):
@@ -1130,90 +1121,44 @@ with gr.Blocks(title="Student Reward Points Check", theme=gr.themes.Soft()) as a
                 show_copy_button=True,
                 autoscroll=False,
                 interactive=False,
-                show_label=True
-            )
-        
-        # NEW: Admin Controls as a separate tab
-        with gr.TabItem("🔧 Admin Controls", visible=False) as admin_tab:  # Start hidden by default
-            gr.Markdown("### 🔐 Administrative Functions")
-            gr.Markdown("⚠️ **Access restricted to authorized personnel only**")
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    admin_key = gr.Textbox(
-                        label="Enter Admin Key", 
-                        type="password", 
-                        placeholder="Enter admin password",
-                        value=""
-                    )
-                    
-                with gr.Column(scale=1):
-                    load_button = gr.Button("🔁 Reload All Data", visible=False, variant="primary", size="lg")
-            
-            admin_status = gr.Markdown("ℹ️ Enter admin key to access controls", visible=True)
-            
-            # Admin functions
-            def verify_admin_key(key):
-                """Verify admin key and show/hide controls"""
-                if key.strip() == os.getenv("ADMIN_KEY", ""):
-                    return (
-                        gr.update(visible=True),  # Show reload button
-                        "✅ **Access Granted!** You can now reload data."
-                    )
-                elif key.strip() == "":
-                    return (
-                        gr.update(visible=False),  # Hide reload button
-                        "ℹ️ Enter admin key to access controls"
-                    )
-                else:
-                    return (
-                        gr.update(visible=False),  # Hide reload button
-                        "❌ **Access Denied!** Invalid admin key."
-                    )
-
-            def admin_reload():
-                """Admin function to reload all data"""
-                try:
-                    print("🔧 Admin reload triggered...")
-                    combined_df, studentwise_data, details_info, reward_points_df = load_all_data()
-                    
-                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                    total_records = len(combined_df) if not combined_df.empty else 0
-                    
-                    return f"""✅ **Data Reload Successful!**
-                    
-📅 **Timestamp:** {timestamp}
-📊 **Total Records:** {total_records:,}
-🔄 **Status:** All data sources refreshed
-⏰ **Next Auto-refresh:** 12 hours from now
-
-🎯 **Data Sources Updated:**
-• Main spreadsheet ({len(sheet_configs)} sheets)
-• Studentwise reward points data
-• Activity breakdown data
-• System information"""
-                    
-                except Exception as e:
-                    return f"❌ **Error reloading data:** {str(e)}"
-
-            # Event handlers for admin tab
-            admin_key.change(
-                fn=verify_admin_key, 
-                inputs=admin_key, 
-                outputs=[load_button, admin_status]
-            )
-            
-            load_button.click(
-                fn=admin_reload, 
-                outputs=admin_status
+                show_label=True,
+                elem_id="system_output"
             )
     
+    # Function to update analytics display
+    def update_analytics_display():
+        analytics = get_analytics_summary()
+        return f"""
+        <div class="analytics-display">
+            <h2 style="margin: 0; color: black;">📊 Live Analytics</h3>
+            <div style="margin: 10px 0;">
+                <div>📊 Visits: {analytics['visits']}</div>
+                <div>🔍 Searches: {analytics['total_searches']}</div>
+                <div>👥 Unique Users: {analytics['unique_searches']}</div>
+            </div>
+        </div>
+        """
+    
+    # Enhanced search function that updates analytics
+    def search_student_with_analytics(roll_no):
+        result = search_student(roll_no)
+        updated_analytics = update_analytics_display()
+        return result, updated_analytics
+    
     # Event handlers
-    search_btn.click(fn=search_student, inputs=roll_input, outputs=result_output)
-    roll_input.submit(fn=search_student, inputs=roll_input, outputs=result_output)
+    search_btn.click(
+        fn=search_student_with_analytics, 
+        inputs=roll_input, 
+        outputs=[result_output, analytics_display]
+    )
+    roll_input.submit(
+        fn=search_student_with_analytics, 
+        inputs=roll_input, 
+        outputs=[result_output, analytics_display]
+    )
     system_btn.click(fn=get_system_info, outputs=system_output)
     
-    # 🌟 FOOTER SECTION
+    # Footer section
     gr.Markdown("---")
     with gr.Row():
         with gr.Column():
@@ -1242,39 +1187,22 @@ with gr.Blocks(title="Student Reward Points Check", theme=gr.themes.Soft()) as a
                 elem_id="footer"
             )
 
-    # FIXED: Admin mode handler on app load (for tab visibility) - SIMPLIFIED
-    def setup_admin_mode(request: gr.Request):
-        """Setup admin mode based on URL parameters"""
-        try:
-            is_admin = check_admin_mode(request)
-            if is_admin:
-                print("🔧 Admin tab will be visible")
-                return gr.update(visible=True)  # Show admin tab
-            else:
-                return gr.update(visible=False)  # Hide admin tab
-        except Exception as e:
-            print(f"⚠️ Error in setup_admin_mode: {str(e)}")
-            return gr.update(visible=False)  # Hide admin tab on error
-    
-    # FIXED: System info initialization function
+    # System info initialization function
     def initialize_system_info():
-        """Initialize system information display"""
+        """Initialize system information display and increment visit count"""
+        increment_visit_count()
         try:
-            return get_system_info()
+            result = get_system_info()
+            updated_analytics = update_analytics_display()
+            return result, updated_analytics
         except Exception as e:
             print(f"⚠️ Error initializing system info: {str(e)}")
-            return "⚠️ System information will be available after data loads completely."
-    
-    # Apply admin mode check on load (only affects admin tab visibility)
-    app.load(
-        fn=setup_admin_mode,
-        outputs=admin_tab
-    )
+            return "⚠️ System information will be available after data loads completely.", update_analytics_display()
     
-    # Load system info on startup (separate from admin mode)
+    # Load system info on startup and update analytics
     app.load(
         fn=initialize_system_info,
-        outputs=system_output
+        outputs=[system_output, analytics_display]
     )
 
 # Launch the app