Update app.py

app.py

@@ -1,165 +1,166 @@
-from flask import Flask, request, jsonify
-import requests
+import gradio as gr
 import pandas as pd
-import numpy as np
-from sklearn.ensemble import IsolationForest
-from datetime import datetime, timedelta
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
-from reportlab.lib.styles import getSampleStyleSheet
-import io
-import base64
+import plotly.express as px
+from weasyprint import HTML
+import datetime
 import os
 
-app = Flask(__name__)
-
-# Salesforce credentials (use environment variables in production)
-SF_USERNAME = os.getenv('SF_USERNAME', 'YOUR_USERNAME')
-SF_PASSWORD = os.getenv('SF_PASSWORD', 'YOUR_PASSWORD_WITH_TOKEN')
-SF_AUTH_URL = 'https://login.salesforce.com/services/oauth2/token'
-
-# Get Salesforce access token
-def get_sf_access_token():
-    try:
-        response = requests.post(SF_AUTH_URL, data={
-            'grant_type': 'password',
-            'username': SF_USERNAME,
-            'password': SF_PASSWORD
-        })
-        response.raise_for_status()
-        return response.json()['access_token'], response.json()['instance_url']
-    except Exception as e:
-        print(f"Error getting Salesforce token: {e}")
-        return None, None
-
-# Anomaly detection using Isolation Forest
-def detect_anomalies(log_data):
+# Cache data loading with detailed error handling
+def load_data():
     try:
-        df = pd.DataFrame(log_data)
-        if df.empty:
-            return []
-        df['Timestamp__c'] = pd.to_datetime(df['Timestamp__c'])
-        df['Timestamp_numeric'] = df['Timestamp__c'].apply(lambda x: x.timestamp())
-        features = df[['Usage__c', 'Timestamp_numeric']]
-        model = IsolationForest(contamination=0.1, random_state=42)
-        model.fit(features)
-        df['is_anomaly'] = model.predict(features) == -1
-        return df[['Id', 'is_anomaly']].to_dict('records')
-    except Exception as e:
-        print(f"Error in anomaly detection: {e}")
-        return []
-
-# Dashboard data endpoint
-@app.route('/api/dashboard', methods=['GET'])
-def get_dashboard_data():
-    lab = request.args.get('lab', '')
-    equipment_type = request.args.get('equipmentType', '')
-    date_range = request.args.get('dateRange', '7')
-
-    access_token, instance_url = get_sf_access_token()
-    if not access_token:
-        return jsonify({'error': 'Failed to authenticate with Salesforce'}), 500
-
-    # Fetch devices
-    soql = 'SELECT Id, Name, Status__c, Usage__c, Last_Log_Timestamp__c, Lab__c, Type FROM Equipment__c WHERE '
-    if lab:
-        soql += f"Lab__c = '{lab}' AND "
-    if equipment_type:
-        soql += f"Type = '{equipment_type}' AND "
-    soql += f"Last_Log_Timestamp__c = LAST_N_DAYS:{date_range} LIMIT 100"
-
-    try:
-        response = requests.get(f'{instance_url}/services/data/v52.0/query?q={soql}', headers={'Authorization': f'Bearer {access_token}'})
-        response.raise_for_status()
-        devices = response.json()['records']
-
-        # Fetch logs for anomaly detection
-        log_soql = 'SELECT Id, Usage__c, Timestamp__c, Equipment__c FROM SmartLog__c WHERE '
-        if lab:
-            log_soql += f"Equipment__r.Lab__c = '{lab}' AND "
-        if equipment_type:
-            log_soql += f"Equipment__r.Type = '{equipment_type}' AND "
-        log_soql += f"Timestamp__c = LAST_N_DAYS:{date_range}"
-
-        log_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={log_soql}', headers={'Authorization': f'Bearer {access_token}'})
-        log_response.raise_for_status()
-        logs = log_response.json()['records']
-
-        # Detect anomalies
-        anomalies = detect_anomalies(logs)
-        anomaly_map = {a['Id']: a['is_anomaly'] for a in anomalies}
-        devices_with_anomalies = [
-            {**d, 'isAnomaly': any(l['Equipment__c'] == d['Id'] and anomaly_map.get(l['Id'], False) for l in logs)}
-            for d in devices
+        required_files = [
+            "data/smartlog.csv",
+            "data/cell_analysis.csv",
+            "data/weight_log.csv",
+            "data/uv_verification.csv",
+            "data/equipment.csv"
         ]
-
-        # Fetch chart data (daily log trends)
-        chart_soql = f"SELECT CALENDAR_DATE(Timestamp__c) logDate, COUNT(Id) logCount FROM SmartLog__c WHERE Timestamp__c = LAST_N_DAYS:{date_range} GROUP BY CALENDAR_DATE(Timestamp__c)"
-        chart_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={chart_soql}', headers={'Authorization': f'Bearer {access_token}'})
-        chart_response.raise_for_status()
-        chart_data = chart_response.json()['records']
-        labels = [str(r['logDate']) for r in chart_data]
-        data = [r['logCount'] for r in chart_data]
-
-        # Calculate weekly uptime %
-        uptime_soql = f"SELECT Equipment__c, COUNT(Id) upCount FROM SmartLog__c WHERE Status__c = 'Active' AND Timestamp__c = LAST_N_DAYS:{date_range} GROUP BY Equipment__c"
-        uptime_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={uptime_soql}', headers={'Authorization': f'Bearer {access_token}'})
-        uptime_response.raise_for_status()
-        uptime_data = uptime_response.json()['records']
-        total_logs = sum(r['logCount'] for r in chart_data)
-        uptime = sum(r['upCount'] for r in uptime_data) / total_logs * 100 if total_logs > 0 else 0
-
-        return jsonify({
-            'devices': devices_with_anomalies,
-            'chartData': {
-                'dailyTrends': {'labels': labels, 'data': data},
-                'weeklyUptime': round(uptime, 2)
-            }
-        })
-    except Exception as e:
-        print(f"Error fetching dashboard data: {e}")
-        return jsonify({'error': 'Failed to fetch data'}), 500
-
-# PDF generation endpoint
-@app.route('/api/generate-pdf', methods=['POST'])
-def generate_pdf():
-    dashboard_data = request.json.get('dashboardData', [])
-    try:
-        output = io.BytesIO()
-        doc = SimpleDocTemplate(output, pagesize=letter)
-        styles = getSampleStyleSheet()
-        elements = [Paragraph("LabOps Monthly Report", styles['Title']), Spacer(1, 12)]
-
-        for device in dashboard_data:
-            text = f"Device: {device['Name']}<br/>Health: {device['Status__c']}<br/>Usage: {device['Usage__c']}<br/>Last Log: {device['Last_Log_Timestamp__c']}<br/>Anomaly: {'Yes' if device['isAnomaly'] else 'No'}"
-            elements.append(Paragraph(text, styles['Normal']))
-            elements.append(Spacer(1, 12))
-
-        doc.build(elements)
-        pdf_base64 = base64.b64encode(output.getvalue()).decode('utf-8')
-        output.close()
-        return jsonify({'pdf': pdf_base64})
-    except Exception as e:
-        print(f"Error generating PDF: {e}")
-        return jsonify({'error': 'Failed to generate PDF'}), 500
-
-# AMC expiry checker
-@app.route('/api/check-amc', methods=['POST'])
-def check_amc_expiry():
-    access_token, instance_url = get_sf_access_token()
-    if not access_token:
-        return jsonify({'error': 'Failed to authenticate with Salesforce'}), 500
-
-    try:
-        expiry_date = (datetime.now() + timedelta(days=14)).strftime('%Y-%m-%d')
-        soql = f"SELECT Id, Name, AMC_Expiry_Date__c, Lab__c FROM Equipment__c WHERE AMC_Expiry_Date__c <= {expiry_date}"
-        response = requests.get(f'{instance_url}/services/data/v52.0/query?q={soql}', headers={'Authorization': f'Bearer {access_token}'})
-        response.raise_for_status()
-        equipment = response.json()['records']
-        return jsonify({'status': 'Success', 'expiringAMCs': equipment})
+        missing_files = [file for file in required_files if not os.path.exists(file)]
+        if missing_files:
+            return None, f"Missing files: {', '.join(missing_files)}"
+        
+        # Load logs with error handling for each file
+        log_files = [
+            "data/smartlog.csv",
+            "data/cell_analysis.csv",
+            "data/weight_log.csv",
+            "data/uv_verification.csv"
+        ]
+        logs_list = []
+        for file in log_files:
+            try:
+                df = pd.read_csv(file)
+                if not all(col in df.columns for col in ["device_id", "timestamp", "status", "metrics"]):
+                    return None, f"Invalid columns in {file}. Expected: device_id, timestamp, status, metrics"
+                logs_list.append(df)
+            except Exception as e:
+                return None, f"Error reading {file}: {str(e)}"
+        
+        logs = pd.concat(logs_list, ignore_index=True)
+        logs["timestamp"] = pd.to_datetime(logs["timestamp"], errors='coerce')
+        if logs["timestamp"].isna().any():
+            return None, "Error parsing timestamps in logs"
+
+        # Load equipment data
+        equipment = pd.read_csv("data/equipment.csv")
+        if not all(col in equipment.columns for col in ["device_id", "type", "lab_id", "amc_expiry"]):
+            return None, "Invalid columns in equipment.csv. Expected: device_id, type, lab_id, amc_expiry"
+        equipment["amc_expiry"] = pd.to_datetime(equipment["amc_expiry"], errors='coerce')
+        if equipment["amc_expiry"].isna().any():
+            return None, "Error parsing amc_expiry in equipment.csv"
+
+        return logs, equipment
     except Exception as e:
-        print(f"Error checking AMC: {e}")
-        return jsonify({'error': 'Failed to check AMC expiries'}), 500
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=8080)
+        return None, f"Unexpected error: {str(e)}"
+
+# Generate PDF report
+def generate_pdf_report(data):
+    os.makedirs("reports", exist_ok=True)
+    html = f"""
+    <h1>LabOps Dashboard Report</h1>
+    <h2>Filtered Data</h2>
+    {data.to_html()}
+    """
+    filename = f"reports/report_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    HTML(string=html).write_pdf(filename)
+    return filename
+
+# Main dashboard function
+def render_dashboard(lab, device_type, date_start, date_end):
+    logs, equipment = load_data()
+    
+    if logs is None:
+        return f"<div style='color: red;'>Error: {equipment}</div>", None, None, f"Data loading failed: {equipment}", None, f"Error: {equipment}"
+
+    # Apply filters
+    filtered_logs = logs
+    if lab != "All":
+        device_ids = equipment[equipment["lab_id"] == lab]["device_id"]
+        filtered_logs = filtered_logs[filtered_logs["device_id"].isin(device_ids)]
+    if device_type != "All":
+        device_ids = equipment[equipment["type"] == device_type]["device_id"]
+        filtered_logs = filtered_logs[filtered_logs["device_id"].isin(device_ids)]
+    filtered_logs = filtered_logs[
+        (filtered_logs["timestamp"].dt.date >= pd.to_datetime(date_start).date()) &
+        (filtered_logs["timestamp"].dt.date <= pd.to_datetime(date_end).date())
+    ]
+
+    # Device Cards (FR-002)
+    device_cards = ""
+    for device_id in filtered_logs["device_id"].unique():
+        device_data = filtered_logs[filtered_logs["device_id"] == device_id]
+        if not device_data.empty:
+            status = device_data["status"].iloc[-1]
+            color = "green" if status == "UP" else "red"
+            device_cards += f"""
+                <div style='border: 1px solid {color}; padding: 10px; margin: 10px; border-radius: 5px;'>
+                    <h3>Device: {device_id}</h3>
+                    <p>Status: <span style='color: {color};'>{status}</span></p>
+                    <p>Last Log: {device_data['timestamp'].iloc[-1]}</p>
+                    <p>Usage Count: {len(device_data)}</p>
+                </div>
+            """
+
+    # Charts (FR-003)
+    downtime = filtered_logs[filtered_logs["status"] == "DOWN"].groupby("device_id").size().reset_index(name="downtime_count")
+    downtime_fig = px.bar(downtime, x="device_id", y="downtime_count", title="Downtime Events by Device")
+
+    usage = filtered_logs.groupby([filtered_logs["timestamp"].dt.date, "device_id"])["metrics"].mean().reset_index()
+    usage_fig = px.line(usage, x="timestamp", y="metrics", color="device_id", title="Daily Usage Metrics")
+
+    # AMC Reminders (FR-004)
+    today = datetime.datetime.now().date()
+    two_weeks = today + datetime.timedelta(days=14)
+    amc_alerts = equipment[equipment["amc_expiry"].dt.date <= two_weeks]
+    amc_text = amc_alerts[['device_id', 'type', 'lab_id', 'amc_expiry']].to_string() if not amc_alerts.empty else "No AMC expirations within 2 weeks."
+
+    # PDF Export (FR-004)
+    report_file = generate_pdf_report(filtered_logs)
+
+    return device_cards, downtime_fig, usage_fig, amc_text, report_file, "Data loaded successfully"
+
+# Load data for dropdowns with fallback
+logs, equipment_or_error = load_data()
+if logs is None:
+    lab_choices = ["All"]
+    device_type_choices = ["All"]
+    initial_error = f"Error loading data: {equipment_or_error}"
+else:
+    lab_choices = ["All"] + list(equipment_or_error["lab_id"].unique())
+    device_type_choices = ["All"] + list(equipment_or_error["type"].unique())
+    initial_error = "Data loaded successfully"
+
+# Gradio interface
+with gr.Blocks(css=".gradio-container {max-width: 100%;}") as demo:
+    gr.Markdown("# LabOps Dashboard")
+    
+    # Filters
+    with gr.Row():
+        lab = gr.Dropdown(choices=lab_choices, label="Select Lab", value="All")
+        device_type = gr.Dropdown(choices=device_type_choices, label="Device Type", value="All")
+    with gr.Row():
+        date_start = gr.DateTime(label="Start Date", value=logs["timestamp"].min() if logs is not None else "2025-05-30")
+        date_end = gr.DateTime(label="End Date", value=logs["timestamp"].max() if logs is not None else "2025-05-30")
+    
+    refresh_btn = gr.Button("Refresh")
+    
+    # Outputs
+    device_cards = gr.HTML(label="Device Status")
+    downtime_plot = gr.Plot(label="Downtime Trends")
+    usage_plot = gr.Plot(label="Usage Trends")
+    amc_reminders = gr.Textbox(label="AMC Expiry Reminders")
+    report_download = gr.File(label="Download Report")
+    debug_info = gr.Textbox(label="Debug Info", value=initial_error)
+
+    # Bind inputs to outputs
+    input_components = [lab, device_type, date_start, date_end]
+    outputs = [device_cards, downtime_plot, usage_plot, amc_reminders, report_download, debug_info]
+    
+    # Bind change events for input components
+    for input_component in input_components:
+        input_component.change(fn=render_dashboard, inputs=[lab, device_type, date_start, date_end], outputs=outputs)
+    
+    # Bind click event for refresh button
+    refresh_btn.click(fn=render_dashboard, inputs=[lab, device_type, date_start, date_end], outputs=outputs)
+
+demo.launch()