Update app.py

app.py

@@ -134,11 +134,13 @@ def create_salesforce_reports(df):
             "reportMetadata": {
                 "name": f"SmartLog_Usage_Report_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
                 "developerName": f"SmartLog_Usage_Report_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
-                "reportType": "CustomEntity$SmartLog__c",
+                "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
                 "reportFormat": "TABULAR",
-                "columns": [
-                    {"field": "SmartLog__c.Device_Id__c"},
-                    {"field": "SmartLog__c.Usage_Hours__c"}
+                "reportBooleanFilter": None,
+                "reportFilters": [],
+                "detailColumns": [
+                    "SmartLog__c.Device_Id__c",
+                    "SmartLog__c.Usage_Hours__c"
                 ],
                 "folderId": LABOPS_REPORTS_FOLDER_ID
             }
@@ -153,11 +155,13 @@ def create_salesforce_reports(df):
             "reportMetadata": {
                 "name": f"SmartLog_AMC_Reminders_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
                 "developerName": f"SmartLog_AMC_Reminders_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
-                "reportType": "CustomEntity$SmartLog__c",
+                "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
                 "reportFormat": "TABULAR",
-                "columns": [
-                    {"field": "SmartLog__c.Device_Id__c"},
-                    {"field": "SmartLog__c.AMC_Date__c"}
+                "reportBooleanFilter": None,
+                "reportFilters": [],
+                "detailColumns": [
+                    "SmartLog__c.Device_Id__c",
+                    "SmartLog__c.AMC_Date__c"
                 ],
                 "folderId": LABOPS_REPORTS_FOLDER_ID
             }
@@ -170,15 +174,20 @@ def create_salesforce_reports(df):
         logging.error(f"Failed to create Salesforce reports: {str(e)}")
 
 # Save results to Salesforce SmartLog__c (runs in backend, result not displayed)
-def save_to_salesforce(df, summary, anomalies, amc_reminders, insights):
+def save_to_salesforce(df, reminders_df, summary, anomalies, amc_reminders, insights):
     if sf is None:
         logging.info("Salesforce connection not available for saving records.")
         return
-    try:
-        records = []
-        current_date = datetime.now()
-        next_30_days = current_date + timedelta(days=30)
-        for _, row in df.head(100).iterrows():
+    
+    # First, process and save AMC reminder records
+    reminder_records = []
+    current_date = datetime.now()
+    next_30_days = current_date + timedelta(days=30)
+    
+    # Process reminders_df (records that qualify for AMC reminders)
+    if not reminders_df.empty:
+        logging.info(f"Processing {len(reminders_df)} AMC reminder records for saving to Salesforce")
+        for _, row in reminders_df.iterrows():
             # Validate and map picklist values
             status = str(row['status'])
             log_type = str(row['log_type'])
@@ -187,32 +196,28 @@ def save_to_salesforce(df, summary, anomalies, amc_reminders, insights):
             if status not in status_values:
                 status = picklist_mapping['Status__c'].get(status.lower(), status_values[0] if status_values else None)
                 if status is None:
-                    logging.warning(f"Skipping record with invalid Status__c: {row['status']}")
+                    logging.warning(f"Skipping reminder record with invalid Status__c: {row['status']}")
                     continue
             
             # Map Log_Type__c
             if log_type not in log_type_values:
                 log_type = picklist_mapping['Log_Type__c'].get(log_type.lower(), log_type_values[0] if log_type_values else None)
                 if log_type is None:
-                    logging.warning(f"Skipping record with invalid Log_Type__c: {row['log_type']}")
+                    logging.warning(f"Skipping reminder record with invalid Log_Type__c: {row['log_type']}")
                     continue
 
             # Handle AMC_Date__c with proper formatting
             amc_date_str = None
             if pd.notna(row['amc_date']):
                 try:
-                    # Try parsing as DD-MM-YYYY
-                    amc_date = pd.to_datetime(row['amc_date'], format='%d-%m-%Y', errors='coerce')
-                    if pd.isna(amc_date):
-                        # If that fails, try YYYY-MM-DD
-                        amc_date = pd.to_datetime(row['amc_date'], format='%Y-%m-%d', errors='coerce')
+                    amc_date = pd.to_datetime(row['amc_date'], errors='coerce')
                     if pd.isna(amc_date):
                         logging.error(f"Failed to parse AMC Date for Device ID {row['device_id']}: {row['amc_date']}")
                     else:
                         amc_date_str = amc_date.strftime('%Y-%m-%d')
                         amc_date_dt = datetime.strptime(amc_date_str, '%Y-%m-%d')
                         if status == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
-                            logging.info(f"Record qualifies for AMC Reminders: Device ID {row['device_id']}, AMC Date {amc_date_str}")
+                            logging.info(f"AMC Reminder record saved: Device ID {row['device_id']}, AMC Date {amc_date_str}")
                 except Exception as e:
                     logging.error(f"Failed to parse AMC Date for Device ID {row['device_id']}: {str(e)}")
                     amc_date_str = None
@@ -226,12 +231,68 @@ def save_to_salesforce(df, summary, anomalies, amc_reminders, insights):
                 'Downtime__c': float(row['downtime']) if pd.notna(row['downtime']) else 0.0,
                 'AMC_Date__c': amc_date_str
             }
-            records.append(record)
+            reminder_records.append(record)
+    
+    # Then, process remaining records from df (excluding those already in reminders_df)
+    other_records = []
+    reminder_device_ids = set(reminders_df['device_id']) if not reminders_df.empty else set()
+    for _, row in df.iterrows():
+        if row['device_id'] in reminder_device_ids:
+            continue  # Skip records already processed as reminders
+
+        # Validate and map picklist values
+        status = str(row['status'])
+        log_type = str(row['log_type'])
+        
+        # Map Status__c
+        if status not in status_values:
+            status = picklist_mapping['Status__c'].get(status.lower(), status_values[0] if status_values else None)
+            if status is None:
+                logging.warning(f"Skipping record with invalid Status__c: {row['status']}")
+                continue
         
-        # Bulk insert to reduce API calls
-        if records:
-            sf.bulk.SmartLog__c.insert(records)
-            logging.info(f"Saved {len(records)} records to Salesforce")
+        # Map Log_Type__c
+        if log_type not in log_type_values:
+            log_type = picklist_mapping['Log_Type__c'].get(log_type.lower(), log_type_values[0] if log_type_values else None)
+            if log_type is None:
+                logging.warning(f"Skipping record with invalid Log_Type__c: {row['log_type']}")
+                continue
+
+        # Handle AMC_Date__c with proper formatting
+        amc_date_str = None
+        if pd.notna(row['amc_date']):
+            try:
+                amc_date = pd.to_datetime(row['amc_date'], errors='coerce')
+                if pd.isna(amc_date):
+                    logging.error(f"Failed to parse AMC Date for Device ID {row['device_id']}: {row['amc_date']}")
+                else:
+                    amc_date_str = amc_date.strftime('%Y-%m-%d')
+                    amc_date_dt = datetime.strptime(amc_date_str, '%Y-%m-%d')
+                    if status == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"Record qualifies for AMC Reminders: Device ID {row['device_id']}, AMC Date {amc_date_str}")
+            except Exception as e:
+                logging.error(f"Failed to parse AMC Date for Device ID {row['device_id']}: {str(e)}")
+                amc_date_str = None
+
+        record = {
+            'Device_Id__c': str(row['device_id'])[:50],
+            'Log_Type__c': log_type,
+            'Status__c': status,
+            'Timestamp__c': row['timestamp'].isoformat() if pd.notna(row['timestamp']) else None,
+            'Usage_Hours__c': float(row['usage_hours']) if pd.notna(row['usage_hours']) else 0.0,
+            'Downtime__c': float(row['downtime']) if pd.notna(row['downtime']) else 0.0,
+            'AMC_Date__c': amc_date_str
+        }
+        other_records.append(record)
+
+    # Combine reminder records and other records
+    all_records = reminder_records + other_records
+    
+    # Bulk insert to reduce API calls
+    try:
+        if all_records:
+            sf.bulk.SmartLog__c.insert(all_records)
+            logging.info(f"Saved {len(all_records)} total records to Salesforce (including {len(reminder_records)} AMC reminders)")
     except Exception as e:
         logging.error(f"Failed to save to Salesforce: {str(e)}")
 
@@ -252,7 +313,7 @@ def summarize_logs(df):
 def detect_anomalies(df):
     try:
         if "usage_hours" not in df.columns or "downtime" not in df.columns:
-            return "Anomaly detection requires 'usage_hours' and 'downtime' columns."
+            return "Anomaly detection requires 'usage_hours' and 'downtime' columns.", pd.DataFrame()
         if len(df) > 1000:
             df = df.sample(n=1000, random_state=42)
         features = df[["usage_hours", "downtime"]].fillna(0)
@@ -260,17 +321,17 @@ def detect_anomalies(df):
         df["anomaly"] = iso_forest.fit_predict(features)
         anomalies = df[df["anomaly"] == -1][["device_id", "usage_hours", "downtime", "timestamp"]]
         if anomalies.empty:
-            return "No anomalies detected."
+            return "No anomalies detected.", anomalies
         anomaly_lines = ["Detected Anomalies:"]
         for _, row in anomalies.head(5).iterrows():
             anomaly_lines.append(
                 f"- Device ID: {row['device_id']}, Usage Hours: {row['usage_hours']}, "
                 f"Downtime: {row['downtime']}, Timestamp: {row['timestamp']}"
             )
-        return "\n".join(anomaly_lines)
+        return "\n".join(anomaly_lines), anomalies
     except Exception as e:
         logging.error(f"Anomaly detection failed: {str(e)}")
-        return f"Anomaly detection failed: {str(e)}"
+        return f"Anomaly detection failed: {str(e)}", pd.DataFrame()
 
 # AMC reminders (for display purposes only, email handled by Salesforce trigger)
 def check_amc_reminders(df, current_date):
@@ -280,7 +341,7 @@ def check_amc_reminders(df, current_date):
         df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
         current_date = pd.to_datetime(current_date)
         df["days_to_amc"] = (df["amc_date"] - current_date).dt.days
-        reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "amc_date"]]
+        reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]]
         if reminders.empty:
             logging.info("No AMC reminders found within the next 30 days.")
             return "No AMC reminders due within the next 30 days.", reminders
@@ -305,7 +366,7 @@ def generate_dashboard_insights(df):
         logging.error(f"Dashboard insights generation failed: {str(e)}")
         return f"Dashboard insights generation failed: {str(e)}"
 
-# Create usage chart
+# Create usage chart (existing chart for usage hours per device)
 def create_usage_chart(df):
     try:
         usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
@@ -333,8 +394,133 @@ def create_usage_chart(df):
         logging.error(f"Failed to create usage chart: {str(e)}")
         return None
 
-# Generate PDF content
-def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights):
+# Create daily log trends chart
+def create_daily_log_trends_chart(df):
+    try:
+        df['date'] = df['timestamp'].dt.date
+        daily_logs = df.groupby('date').size().reset_index(name='log_count')
+        fig = px.line(
+            daily_logs,
+            x='date',
+            y='log_count',
+            title="Daily Log Trends",
+            labels={"date": "Date", "log_count": "Number of Logs"},
+            color_discrete_sequence=['#FF6B6B']
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create daily log trends chart: {str(e)}")
+        return None
+
+# Create weekly uptime percentage chart
+def create_weekly_uptime_chart(df):
+    try:
+        df['week'] = df['timestamp'].dt.isocalendar().week
+        df['year'] = df['timestamp'].dt.year
+        weekly_data = df.groupby(['year', 'week']).agg({
+            'usage_hours': 'sum',
+            'downtime': 'sum'
+        }).reset_index()
+        weekly_data['uptime_percent'] = (weekly_data['usage_hours'] / (weekly_data['usage_hours'] + weekly_data['downtime'])) * 100
+        weekly_data['year_week'] = weekly_data['year'].astype(str) + '-W' + weekly_data['week'].astype(str)
+        fig = px.bar(
+            weekly_data,
+            x='year_week',
+            y='uptime_percent',
+            title="Weekly Uptime Percentage",
+            labels={"year_week": "Year-Week", "uptime_percent": "Uptime %"},
+            color_discrete_sequence=['#4ECDC4']
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create weekly uptime chart: {str(e)}")
+        return None
+
+# Create anomaly alerts chart
+def create_anomaly_alerts_chart(anomalies_df):
+    try:
+        if anomalies_df.empty:
+            return None
+        anomalies_df['date'] = anomalies_df['timestamp'].dt.date
+        anomaly_counts = anomalies_df.groupby('date').size().reset_index(name='anomaly_count')
+        fig = px.scatter(
+            anomaly_counts,
+            x='date',
+            y='anomaly_count',
+            title="Anomaly Alerts Over Time",
+            labels={"date": "Date", "anomaly_count": "Number of Anomalies"},
+            color_discrete_sequence=['#45B7D1']
+        )
+        fig.update_layout(
+            title_font_size=16,
+            margin=dict(l=20, r=20, t=40, b=20),
+            plot_bgcolor="white",
+            paper_bgcolor="white",
+            font=dict(size=12)
+        )
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create anomaly alerts chart: {str(e)}")
+        return None
+
+# Generate Device Cards HTML
+def generate_device_cards(df):
+    try:
+        # Calculate device stats
+        device_stats = df.groupby('device_id').agg({
+            'status': 'last',  # Most recent status
+            'timestamp': 'max',  # Last log timestamp
+            'device_id': 'count'  # Usage count (number of logs)
+        }).reset_index()
+        device_stats.rename(columns={'device_id': 'usage_count'}, inplace=True)
+        
+        # Map status to health
+        device_stats['health'] = device_stats['status'].map({
+            'Active': 'Healthy',
+            'Inactive': 'Unhealthy',
+            'Pending': 'Warning'
+        }).fillna('Unknown')
+
+        # Generate HTML for device cards
+        cards_html = '<div style="display: flex; flex-wrap: wrap; gap: 20px;">'
+        for _, row in device_stats.iterrows():
+            health_color = {
+                'Healthy': 'green',
+                'Unhealthy': 'red',
+                'Warning': 'orange',
+                'Unknown': 'gray'
+            }.get(row['health'], 'gray')
+            card = f"""
+            <div style="border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px; width: 200px;">
+                <h4>Device: {row['device_id']}</h4>
+                <p><b>Health:</b> <span style="color: {health_color}">{row['health']}</span></p>
+                <p><b>Usage Count:</b> {row['usage_count']}</p>
+                <p><b>Last Log:</b> {row['timestamp']}</p>
+            </div>
+            """
+            cards_html += card
+        cards_html += '</div>'
+        return cards_html
+    except Exception as e:
+        logging.error(f"Failed to generate device cards: {str(e)}")
+        return '<p>Error generating device cards.</p>'
+
+# Generate PDF content (updated to include new dashboard data)
+def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights, device_cards_html, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart):
     if not reportlab_available:
         return None
     try:
@@ -358,6 +544,12 @@ def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights):
         story.append(safe_paragraph(preview or "No preview available.", styles['Normal']))
         story.append(Spacer(1, 12))
 
+        story.append(Paragraph("Device Cards", styles['Heading2']))
+        # Simplify HTML for PDF (reportlab doesn't render HTML well, so we extract text)
+        device_cards_text = device_cards_html.replace('<div>', '').replace('</div>', '\n').replace('<h4>', '').replace('</h4>', '\n').replace('<p>', '').replace('</p>', '\n').replace('<b>', '').replace('</b>', '').replace('<span style="color: green">', '').replace('<span style="color: red">', '').replace('<span style="color: orange">', '').replace('<span style="color: gray">', '').replace('</span>', '')
+        story.append(safe_paragraph(device_cards_text or "No device cards available.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
         story.append(Paragraph("Anomaly Detection", styles['Heading2']))
         story.append(safe_paragraph(anomalies or "No anomalies detected.", styles['Normal']))
         story.append(Spacer(1, 12))
@@ -368,6 +560,19 @@ def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights):
 
         story.append(Paragraph("Dashboard Insights", styles['Heading2']))
         story.append(safe_paragraph(insights or "No insights generated.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        # Charts can't be directly embedded in PDF, so we add placeholders
+        story.append(Paragraph("Daily Log Trends Chart", styles['Heading2']))
+        story.append(Paragraph("[Chart placeholder - see dashboard for Daily Log Trends]", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Weekly Uptime Percentage Chart", styles['Heading2']))
+        story.append(Paragraph("[Chart placeholder - see dashboard for Weekly Uptime Percentage]", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Anomaly Alerts Chart", styles['Heading2']))
+        story.append(Paragraph("[Chart placeholder - see dashboard for Anomaly Alerts]", styles['Normal']))
 
         doc.build(story)
         logging.info(f"PDF generated at {pdf_path}")
@@ -377,17 +582,17 @@ def generate_pdf_content(summary, preview, anomalies, amc_reminders, insights):
         return None
 
 # Main Gradio function with optimized performance
-async def process_logs(file_obj):
+async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_range):
     try:
         start_time = datetime.now()
         if not file_obj:
-            return "No file uploaded.", "No data to preview.", None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None
+            return "No file uploaded.", "No data to preview.", None, '<p>No device cards available.</p>', None, None, None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None
 
         file_name = file_obj.name
         logging.info(f"Processing file: {file_name}")
         
         if not file_name.endswith(".csv"):
-            return "Please upload a CSV file.", "", None, "", "", "", None
+            return "Please upload a CSV file.", "", None, '<p>No device cards available.</p>', None, None, None, "", "", "", None
 
         required_columns = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
         dtypes = {
@@ -401,30 +606,63 @@ async def process_logs(file_obj):
         df = pd.read_csv(file_obj, dtype=dtypes)
         missing_columns = [col for col in required_columns if col not in df.columns]
         if missing_columns:
-            return f"Missing columns: {missing_columns}", None, None, None, None, None, None
+            return f"Missing columns: {missing_columns}", None, None, '<p>No device cards available.</p>', None, None, None, None, None, None, None
+        
+        # Convert timestamp and amc_date to datetime
         df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
         df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
         if df.empty:
-            return "No data available.", None, None, None, None, None, None
+            return "No data available.", None, None, '<p>No device cards available.</p>', None, None, None, None, None, None, None
+
+        # Apply filters
+        filtered_df = df.copy()
+        
+        # Lab site filter
+        if lab_site_filter and 'lab_site' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['lab_site'] == lab_site_filter]
+        
+        # Equipment type filter
+        if equipment_type_filter and 'equipment_type' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['equipment_type'] == equipment_type_filter]
+        
+        # Date range filter
+        if date_range and len(date_range) == 2:
+            start_date, end_date = date_range
+            start_date = pd.to_datetime(start_date)
+            end_date = pd.to_datetime(end_date)
+            filtered_df = filtered_df[(filtered_df['timestamp'] >= start_date) & (filtered_df['timestamp'] <= end_date)]
+
+        if filtered_df.empty:
+            return "No data after applying filters.", None, None, '<p>No device cards available.</p>', None, None, None, None, None, None, None
 
         # Run tasks concurrently
         with ThreadPoolExecutor(max_workers=4) as executor:
-            future_summary = executor.submit(summarize_logs, df)
-            future_anomalies = executor.submit(detect_anomalies, df)
-            future_amc = executor.submit(check_amc_reminders, df, datetime.now())
-            future_insights = executor.submit(generate_dashboard_insights, df)
-            future_chart = executor.submit(create_usage_chart, df)
-            future_reports = executor.submit(create_salesforce_reports, df)
+            future_summary = executor.submit(summarize_logs, filtered_df)
+            future_anomalies = executor.submit(detect_anomalies, filtered_df)
+            future_amc = executor.submit(check_amc_reminders, filtered_df, datetime.now())
+            future_insights = executor.submit(generate_dashboard_insights, filtered_df)
+            future_usage_chart = executor.submit(create_usage_chart, filtered_df)
+            future_daily_log_chart = executor.submit(create_daily_log_trends_chart, filtered_df)
+            future_weekly_uptime_chart = executor.submit(create_weekly_uptime_chart, filtered_df)
+            future_device_cards = executor.submit(generate_device_cards, filtered_df)
+            future_reports = executor.submit(create_salesforce_reports, filtered_df)
 
             summary = f"Step 1: Summary Report\n{future_summary.result()}"
-            anomalies = f"Anomaly Detection\n{future_anomalies.result()}"
+            anomalies, anomalies_df = future_anomalies.result()
+            anomalies = f"Anomaly Detection\n{anomalies}"
             amc_reminders, reminders_df = future_amc.result()
             amc_reminders = f"AMC Reminders\n{amc_reminders}"
             insights = f"Dashboard Insights (AI)\n{future_insights.result()}"
-            chart = future_chart.result()
+            usage_chart = future_usage_chart.result()
+            daily_log_chart = future_daily_log_chart.result()
+            weekly_uptime_chart = future_weekly_uptime_chart.result()
+            device_cards = future_device_cards.result()
+
+        # Create anomaly alerts chart after getting anomalies_df
+        anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)
 
         preview_lines = ["Step 2: Log Preview (First 5 Rows)"]
-        for idx, row in df.head(5).iterrows():
+        for idx, row in filtered_df.head(5).iterrows():
             preview_lines.append(
                 f"Row {idx + 1}: Device ID: {row['device_id']}, "
                 f"Log Type: {row['log_type']}, Status: {row['status']}, "
@@ -434,15 +672,17 @@ async def process_logs(file_obj):
         preview = "\n".join(preview_lines)
 
         # Save to Salesforce in the backend
-        save_to_salesforce(df, summary, anomalies, amc_reminders, insights)
-        pdf_file = generate_pdf_content(summary, preview, anomalies, amc_reminders, insights)
+        save_to_salesforce(filtered_df, reminders_df, summary, anomalies, amc_reminders, insights)
+        
+        # Generate PDF with updated content
+        pdf_file = generate_pdf_content(summary, preview, anomalies, amc_reminders, insights, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart)
 
         elapsed_time = (datetime.now() - start_time).total_seconds()
-        logging.info(f"Processing completed in {elapsed_time:.2f} secondsIS")
-        return summary, preview, chart, anomalies, amc_reminders, insights, pdf_file
+        logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
+        return summary, preview, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, anomalies, amc_reminders, insights, pdf_file
     except Exception as e:
         logging.error(f"Failed to process file: {str(e)}")
-        return f"Error: {str(e)}", None, None, None, None, None, None
+        return f"Error: {str(e)}", None, None, '<p>Error processing data.</p>', None, None, None, None, None, None, None
 
 # Gradio Interface
 try:
@@ -461,6 +701,34 @@ try:
         with gr.Row():
             with gr.Column(scale=1):
                 file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
+                
+                # Filters
+                with gr.Group():
+                    gr.Markdown("### Filters")
+                    # Lab site filter (assuming lab_site column exists)
+                    lab_site_options = ['All']  # Default option
+                    # Equipment type filter (assuming equipment_type column exists)
+                    equipment_type_options = ['All']
+                    # We'll populate these dynamically if possible, but for now, assume static options
+                    lab_site_filter = gr.Dropdown(
+                        label="Lab Site",
+                        choices=lab_site_options,
+                        value='All'
+                    )
+                    equipment_type_filter = gr.Dropdown(
+                        label="Equipment Type",
+                        choices=equipment_type_options,
+                        value='All'
+                    )
+                    date_range_filter = gr.Slider(
+                        label="Date Range (Days from Today)",
+                        minimum=-365,
+                        maximum=0,
+                        step=1,
+                        value=[-30, 0],  # Default: last 30 days
+                        info="Select the range of days relative to today (e.g., -30 to 0 for the last 30 days)."
+                    )
+                
                 submit_button = gr.Button("Analyze", variant="primary")
 
             with gr.Column(scale=2):
@@ -476,8 +744,19 @@ try:
                         preview_output = gr.Markdown()
                         
                     with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Step 3: Usage Chart")
-                        chart_output = gr.Plot()
+                        gr.Markdown("### Device Cards")
+                        device_cards_output = gr.HTML()
+                        
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Charts")
+                        with gr.Tab("Usage Hours per Device"):
+                            usage_chart_output = gr.Plot()
+                        with gr.Tab("Daily Log Trends"):
+                            daily_log_trends_output = gr.Plot()
+                        with gr.Tab("Weekly Uptime Percentage"):
+                            weekly_uptime_output = gr.Plot()
+                        with gr.Tab("Anomaly Alerts"):
+                            anomaly_alerts_output = gr.Plot()
                         
                     with gr.Group(elem_classes="dashboard-section"):
                         gr.Markdown("### Step 4: Anomaly Detection")
@@ -492,16 +771,44 @@ try:
                         insights_output = gr.Markdown()
                         
                     with gr.Group(elem_classes="dashboard-section"):
-                        gr.Markdown("### Download Report")
+                        gr.Markdown("### Export Report")
                         pdf_output = gr.File(label="Download Analysis Report as PDF")
 
+        # Dynamically update filter options (if columns exist in the uploaded CSV)
+        def update_filters(file_obj):
+            if not file_obj:
+                return ['All'], ['All']
+            try:
+                df = pd.read_csv(file_obj)
+                lab_site_options = ['All'] + (df['lab_site'].dropna().unique().tolist() if 'lab_site' in df.columns else [])
+                equipment_type_options = ['All'] + (df['equipment_type'].dropna().unique().tolist() if 'equipment_type' in df.columns else [])
+                return lab_site_options, equipment_type_options
+            except Exception as e:
+                logging.error(f"Failed to update filters: {str(e)}")
+                return ['All'], ['All']
+
+        file_input.change(
+            fn=update_filters,
+            inputs=[file_input],
+            outputs=[lab_site_filter, equipment_type_filter]
+        )
+
         submit_button.click(
             fn=process_logs,
-            inputs=[file_input],
+            inputs=[
+                file_input,
+                lab_site_filter,
+                equipment_type_filter,
+                date_range_filter
+            ],
             outputs=[
                 summary_output,
                 preview_output,
-                chart_output,
+                usage_chart_output,
+                device_cards_output,
+                daily_log_trends_output,
+                weekly_uptime_output,
+                anomaly_alerts_output,
                 anomaly_output,
                 amc_output,
                 insights_output,