Update app.py

app.py

@@ -1,440 +1,729 @@
 import gradio as gr
-import librosa
-import numpy as np
-import torch
-from transformers import WhisperProcessor, WhisperForConditionalGeneration
-from simple_salesforce import Salesforce
-import os
-from datetime import datetime
+import pandas as pd
+from datetime import datetime, timedelta
 import logging
-import webrtcvad
-import google.generativeai as genai
-from gtts import gTTS
-import tempfile
-import base64
-import re
-import subprocess
-from cryptography.fernet import Fernet
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
-usage_metrics = {"total_assessments": 0, "assessments_by_language": {}}
-
-# Environment variables
-SF_USERNAME = os.getenv("SF_USERNAME", "smartvoicebot@voice.com")
-SF_PASSWORD = os.getenv("SF_PASSWORD", "voicebot1")
-SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "jq4VVHUFti6TmzJDjjegv2h6b")
-SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://swe42.sfdc-cehfhs.salesforce.com")
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyBzr5vVpbe8CV1v70l3pGDp9vRJ76yCxdk")
-ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY", Fernet.generate_key().decode())
-DEFAULT_EMAIL = os.getenv("SALESFORCE_USER_EMAIL", "default@mindcare.com")
-
-# Initialize encryption
-cipher = Fernet(ENCRYPTION_KEY)
-
-# Initialize Salesforce
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.ensemble import IsolationForest
+from concurrent.futures import ThreadPoolExecutor
+import os
+import io
+import time
+import asyncio
+from simple_salesforce import Salesforce
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Salesforce configuration
 try:
     sf = Salesforce(
-        username=SF_USERNAME,
-        password=SF_PASSWORD,
-        security_token=SF_SECURITY_TOKEN,
-        instance_url=SF_INSTANCE_URL
+        username='multi-devicelabopsdashboard@sathkrutha.com',
+        password='Team@1234',
+        security_token=os.getenv('SF_SECURITY_TOKEN', ''),
+        domain='login'
     )
-    logger.info(f"Connected to Salesforce at {SF_INSTANCE_URL}")
+    logging.info("Salesforce connection established")
 except Exception as e:
-    logger.error(f"Salesforce connection failed: {str(e)}")
+    logging.error(f"Failed to connect to Salesforce: {str(e)}")
     sf = None
 
-# Initialize Google Gemini
+# Try to import reportlab
 try:
-    genai.configure(api_key=GEMINI_API_KEY)
-    gemini_model = genai.GenerativeModel('gemini-1.5-flash')
-    chat = gemini_model.start_chat(history=[])
-    logger.info("Connected to Google Gemini")
-except Exception as e:
-    logger.error(f"Google Gemini initialization failed: {str(e)}")
-    chat = None
-
-# Load Whisper model
-SUPPORTED_LANGUAGES = {"en": "english", "es": "spanish", "hi": "hindi", "zh": "mandarin"}
-SALESFORCE_LANGUAGE_MAP = {"en": "English", "es": "Spanish", "hi": "Hindi", "zh": "Mandarin"}
-whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-small")
-whisper_model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
-vad = webrtcvad.Vad(mode=2)
-
-# Context for chatbot
-base_info = """
-You are MindCare, an AI health assistant providing support in:
-- Mental health: Emotional support, stress management
-- Medical guidance: Symptom analysis, general advice
-- General health: Lifestyle and wellness recommendations
-Tone: Empathetic, supportive, informative. Always suggest professional consultation for medical issues.
-"""
-context = [base_info]
-
-def encrypt_data(data):
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+    from reportlab.lib.styles import getSampleStyleSheet
+    from reportlab.lib import colors
+    reportlab_available = True
+    logging.info("reportlab module successfully imported")
+except ImportError:
+    logging.warning("reportlab module not found. PDF generation disabled.")
+    reportlab_available = False
+
+# Cache picklist values at startup
+def get_picklist_values(field_name):
+    if sf is None:
+        return []
+    try:
+        obj_desc = sf.SmartLog__c.describe()
+        for field in obj_desc['fields']:
+            if field['name'] == field_name:
+                return [value['value'] for value in field['picklistValues'] if value['active']]
+        return []
+    except Exception as e:
+        logging.error(f"Failed to fetch picklist values for {field_name}: {str(e)}")
+        return []
+
+status_values = get_picklist_values('Status__c') or ["Active", "Inactive", "Pending"]
+log_type_values = get_picklist_values('Log_Type__c') or ["Smart Log", "Cell Analysis", "UV Verification"]
+logging.info(f"Valid Status__c values: {status_values}")
+logging.info(f"Valid Log_Type__c values: {log_type_values}")
+
+# Map invalid picklist values
+picklist_mapping = {
+    'Status__c': {
+        'normal': 'Active',
+        'error': 'Inactive',
+        'warning': 'Pending',
+        'ok': 'Active',
+        'failed': 'Inactive'
+    },
+    'Log_Type__c': {
+        'maint': 'Smart Log',
+        'error': 'Cell Analysis',
+        'ops': 'UV Verification',
+        'maintenance': 'Smart Log',
+        'cell': 'Cell Analysis',
+        'uv': 'UV Verification',
+        'weight log': 'Smart Log'
+    }
+}
+
+# Cache folder ID for Salesforce reports
+def get_folder_id(folder_name):
+    if sf is None:
+        return None
     try:
-        return cipher.encrypt(data.encode('utf-8')).decode('utf-8')
+        query = f"SELECT Id FROM Folder WHERE Name = '{folder_name}' AND Type = 'Report'"
+        result = sf.query(query)
+        if result['totalSize'] > 0:
+            folder_id = result['records'][0]['Id']
+            logging.info(f"Found folder ID for '{folder_name}': {folder_id}")
+            return folder_id
+        else:
+            logging.error(f"Folder '{folder_name}' not found in Salesforce.")
+            return None
     except Exception as e:
-        logger.error(f"Encryption failed: {str(e)}")
-        return data
+        logging.error(f"Failed to fetch folder ID for '{folder_name}': {str(e)}")
+        return None
+
+LABOPS_REPORTS_FOLDER_ID = get_folder_id('LabOps Reports')
 
-def decrypt_data(encrypted_data):
+# Salesforce report creation
+def create_salesforce_reports(df):
+    if sf is None or not LABOPS_REPORTS_FOLDER_ID:
+        logging.error("Cannot create Salesforce reports: No connection or folder ID")
+        return
     try:
-        return cipher.decrypt(encrypted_data.encode('utf-8')).decode('utf-8')
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        reports = [
+            {
+                "reportMetadata": {
+                    "name": f"SmartLog_Usage_Report_{timestamp}",
+                    "developerName": f"SmartLog_Usage_Report_{timestamp}",
+                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
+                    "reportFormat": "TABULAR",
+                    "reportBooleanFilter": None,
+                    "reportFilters": [],
+                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.Usage_Hours__c"],
+                    "folderId": LABOPS_REPORTS_FOLDER_ID
+                }
+            },
+            {
+                "reportMetadata": {
+                    "name": f"SmartLog_AMC_Reminders_{timestamp}",
+                    "developerName": f"SmartLog_AMC_Reminders_{timestamp}",
+                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
+                    "reportFormat": "TABULAR",
+                    "reportBooleanFilter": None,
+                    "reportFilters": [],
+                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.AMC_Date__c"],
+                    "folderId": LABOPS_REPORTS_FOLDER_ID
+                }
+            }
+        ]
+        for report in reports:
+            sf.restful('analytics/reports', method='POST', json=report)
+        logging.info("Salesforce reports created successfully")
     except Exception as e:
-        logger.error(f"Decryption failed: {str(e)}")
-        return encrypted_data
+        logging.error(f"Failed to create Salesforce reports: {str(e)}")
 
-def extract_health_features(audio, sr):
+# Save to Salesforce
+def save_to_salesforce(df, reminders_df):
+    if sf is None:
+        logging.error("No Salesforce connection available")
+        return
     try:
-        audio = audio / np.max(np.abs(audio)) if np.max(np.abs(audio)) != 0 else audio
-        frame_duration = 30
-        frame_samples = int(sr * frame_duration / 1000)
-        frames = [audio[i:i + frame_samples] for i in range(0, len(audio), frame_samples)]
-        voiced_frames = [frame for frame in frames if len(frame) == frame_samples and vad.is_speech((frame * 32768).astype(np.int16).tobytes(), sr)]
-        if not voiced_frames:
-            raise ValueError("No voiced segments detected")
-        voiced_audio = np.concatenate(voiced_frames)
-        
-        # Enhanced feature extraction
-        pitches, magnitudes = librosa.piptrack(y=voiced_audio, sr=sr, fmin=75, fmax=300)
-        valid_pitches = [p for p in pitches[magnitudes > 0] if 75 <= p <= 300]
-        pitch = np.mean(valid_pitches) if valid_pitches else 0
-        jitter = np.std(valid_pitches) / pitch if pitch and valid_pitches else 0
-        jitter = min(jitter, 10)  # Cap jitter
-        amplitudes = librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0]
-        shimmer = np.std(amplitudes) / np.mean(amplitudes) if np.mean(amplitudes) else 0
-        shimmer = min(shimmer, 10)  # Cap shimmer
-        energy = np.mean(librosa.feature.rms(y=voiced_audio, frame_length=2048, hop_length=512)[0])
-        
-        # Additional features
-        mfcc = np.mean(librosa.feature.mfcc(y=voiced_audio, sr=sr, n_mfcc=13), axis=1)
-        spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=voiced_audio, sr=sr))
-        
-        return {
-            "pitch": pitch,
-            "jitter": jitter * 100,
-            "shimmer": shimmer * 100,
-            "energy": energy,
-            "mfcc_mean": np.mean(mfcc),
-            "spectral_centroid": spectral_centroid
-        }
+        logging.info("Starting Salesforce save operation")
+        current_date = datetime.now()
+        next_30_days = current_date + timedelta(days=30)
+        records = []
+        reminder_device_ids = set(reminders_df['device_id']) if not reminders_df.empty else set()
+        logging.info(f"Processing {len(df)} records for Salesforce")
+
+        for idx, row in df.iterrows():
+            status = str(row['status']).lower()
+            log_type = str(row['log_type']).lower()
+            status_mapped = picklist_mapping['Status__c'].get(status, status_values[0] if status_values else 'Active')
+            log_type_mapped = picklist_mapping['Log_Type__c'].get(log_type, log_type_values[0] if log_type_values else 'Smart Log')
+            
+            if not status_mapped or not log_type_mapped:
+                logging.warning(f"Skipping record {idx}: Invalid status ({status}) or log_type ({log_type})")
+                continue
+
+            amc_date_str = None
+            if pd.notna(row['amc_date']):
+                try:
+                    amc_date = pd.to_datetime(row['amc_date']).strftime('%Y-%m-%d')
+                    amc_date_str = amc_date
+                    amc_date_dt = datetime.strptime(amc_date, '%Y-%m-%d')
+                    if status_mapped == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"AMC Reminder for Device ID {row['device_id']}: {amc_date}")
+                except Exception as e:
+                    logging.warning(f"Invalid AMC date for Device ID {row['device_id']}: {str(e)}")
+
+            record = {
+                'Device_Id__c': str(row['device_id'])[:50],
+                'Log_Type__c': log_type_mapped,
+                'Status__c': status_mapped,
+                '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
+            }
+            records.append(record)
+
+        if records:
+            batch_size = 100
+            for i in range(0, len(records), batch_size):
+                batch = records[i:i + batch_size]
+                try:
+                    result = sf.bulk.SmartLog__c.insert(batch)
+                    logging.info(f"Saved {len(batch)} records to Salesforce in batch {i//batch_size + 1}")
+                    for res in result:
+                        if not res['success']:
+                            logging.error(f"Failed to save record: {res['errors']}")
+                except Exception as e:
+                    logging.error(f"Failed to save batch {i//batch_size + 1}: {str(e)}")
+        else:
+            logging.warning("No records to save to Salesforce")
     except Exception as e:
-        logger.error(f"Feature extraction failed: {str(e)}")
-        raise
+        logging.error(f"Failed to save to Salesforce: {str(e)}")
 
-def transcribe_audio(audio, language="en"):
+# Summarize logs
+def summarize_logs(df):
     try:
-        whisper_model.config.forced_decoder_ids = whisper_processor.get_decoder_prompt_ids(
-            language=SUPPORTED_LANGUAGES.get(language, "english"), task="transcribe"
+        total_devices = df["device_id"].nunique()
+        total_usage = df["usage_hours"].sum() if "usage_hours" in df.columns else 0
+        return f"{total_devices} devices processed with {total_usage:.2f} total usage hours."
+    except Exception as e:
+        logging.error(f"Summary generation failed: {str(e)}")
+        return "Failed to generate summary."
+
+# Anomaly detection
+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.", pd.DataFrame()
+        features = df[["usage_hours", "downtime"]].fillna(0)
+        if len(features) > 50:
+            features = features.sample(n=50, random_state=42)
+        iso_forest = IsolationForest(contamination=0.1, random_state=42)
+        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.", anomalies
+        return "\n".join([f"- Device ID: {row['device_id']}, Usage: {row['usage_hours']}, Downtime: {row['downtime']}, Timestamp: {row['timestamp']}" for _, row in anomalies.head(5).iterrows()]), anomalies
+    except Exception as e:
+        logging.error(f"Anomaly detection failed: {str(e)}")
+        return f"Anomaly detection failed: {str(e)}", pd.DataFrame()
+
+# AMC reminders
+def check_amc_reminders(df, current_date):
+    try:
+        if "device_id" not in df.columns or "amc_date" not in df.columns:
+            return "AMC reminders require 'device_id' and 'amc_date' columns.", pd.DataFrame()
+        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", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]]
+        if reminders.empty:
+            return "No AMC reminders due within the next 30 days.", reminders
+        return "\n".join([f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}" for _, row in reminders.head(5).iterrows()]), reminders
+    except Exception as e:
+        logging.error(f"AMC reminder generation failed: {str(e)}")
+        return f"AMC reminder generation failed: {str(e)}", pd.DataFrame()
+
+# Dashboard insights
+def generate_dashboard_insights(df):
+    try:
+        total_devices = df["device_id"].nunique()
+        avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
+        return f"{total_devices} devices with average usage of {avg_usage:.2f} hours."
+    except Exception as e:
+        logging.error(f"Dashboard insights generation failed: {str(e)}")
+        return "Failed to generate insights."
+
+# Placeholder chart for empty data
+def create_placeholder_chart(title):
+    fig = go.Figure()
+    fig.add_annotation(
+        text="No data available for this chart",
+        xref="paper", yref="paper",
+        x=0.5, y=0.5, showarrow=False,
+        font=dict(size=16)
+    )
+    fig.update_layout(title=title, margin=dict(l=20, r=20, t=40, b=20))
+    return fig
+
+# Create usage chart
+def create_usage_chart(df):
+    try:
+        if df.empty or "usage_hours" not in df.columns or "device_id" not in df.columns:
+            logging.warning("Insufficient data for usage chart")
+            return create_placeholder_chart("Usage Hours per Device")
+        usage_data = df.groupby("device_id")["usage_hours"].sum().reset_index()
+        if len(usage_data) > 5:
+            usage_data = usage_data.nlargest(5, "usage_hours")
+        fig = px.bar(
+            usage_data,
+            x="device_id",
+            y="usage_hours",
+            title="Usage Hours per Device",
+            labels={"device_id": "Device ID", "usage_hours": "Usage Hours"}
         )
-        inputs = whisper_processor(audio, sampling_rate=16000, return_tensors="pt")
-        with torch.no_grad():
-            generated_ids = whisper_model.generate(inputs["input_features"])
-        transcription = whisper_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-        logger.info(f"Transcription (language: {language}): {transcription}")
-        return transcription
+        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
+        return fig
     except Exception as e:
-        logger.error(f"Transcription failed: {str(e)}")
-        return None
+        logging.error(f"Failed to create usage chart: {str(e)}")
+        return create_placeholder_chart("Usage Hours per Device")
 
-def get_chatbot_response(message, language="en"):
-    if not chat or not message:
-        return "Unable to generate response.", None
-    full_context = "\n".join(context) + f"\nUser: {message}\nMindCare:"
+# Create downtime chart
+def create_downtime_chart(df):
     try:
-        response = chat.send_message(full_context).text
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as temp_audio:
-            tts = gTTS(text=response, lang=language, slow=False)
-            tts.save(temp_audio.name)
-            audio_path = temp_audio.name
-        return response, audio_path
+        if df.empty or "downtime" not in df.columns or "device_id" not in df.columns:
+            logging.warning("Insufficient data for downtime chart")
+            return create_placeholder_chart("Downtime per Device")
+        downtime_data = df.groupby("device_id")["downtime"].sum().reset_index()
+        if len(downtime_data) > 5:
+            downtime_data = downtime_data.nlargest(5, "downtime")
+        fig = px.bar(
+            downtime_data,
+            x="device_id",
+            y="downtime",
+            title="Downtime per Device",
+            labels={"device_id": "Device ID", "downtime": "Downtime (Hours)"}
+        )
+        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
+        return fig
     except Exception as e:
-        logger.error(f"Chatbot response failed: {str(e)}")
-        return "Error generating response.", None
-
-def analyze_symptoms(text, features):
-    feedback = []
-    text = text.lower() if text else ""
-    
-    # Voice-based health assessment
-    if features["jitter"] > 2.0:
-        feedback.append(f"Elevated jitter ({features['jitter']:.2f}%) detected, which may indicate respiratory strain or vocal cord issues. Consult a doctor.")
-    if features["shimmer"] > 3.0:
-        feedback.append(f"High shimmer ({features['shimmer']:.2f}%) suggests possible emotional stress or vocal fatigue. Consider professional evaluation.")
-    if features["energy"] < 0.01:
-        feedback.append(f"Low vocal energy ({features['energy']:.4f}) detected, which might indicate fatigue or low mood. Rest and medical advice recommended.")
-    if features["pitch"] < 100 or features["pitch"] > 250:
-        feedback.append(f"Unusual pitch ({features['pitch']:.2f} Hz) may indicate vocal cord issues or emotional stress.")
-    if features["spectral_centroid"] > 2000:
-        feedback.append(f"High spectral centroid ({features['spectral_centroid']:.2f} Hz) suggests tense speech, possibly linked to stress or anxiety.")
-    
-    # Text-based symptom analysis
-    if "cough" in text or "breath" in text:
-        feedback.append("Your description suggests respiratory symptoms. Possible conditions include bronchitis or asthma. Please consult a doctor.")
-    if "stress" in text or "anxious" in text:
-        feedback.append("You mentioned stress or anxiety. Try deep breathing or mindfulness. Consider speaking with a mental health professional.")
-    if "pain" in text:
-        feedback.append("Pain reported. For mild pain, consider Paracetamol; for inflammation, Ibuprofen may help. Consult a doctor before taking medication.")
-    if not feedback:
-        feedback.append("No specific health concerns detected from voice or text. Maintain a healthy lifestyle and consult a doctor if symptoms arise.")
-    
-    return "\n".join(feedback)
-
-def store_user_consent(language):
-    if not sf:
-        logger.warning("Salesforce not connected; skipping consent storage")
-        return None
+        logging.error(f"Failed to create downtime chart: {str(e)}")
+        return create_placeholder_chart("Downtime per Device")
+
+# Create daily log trends chart
+def create_daily_log_trends_chart(df):
     try:
-        user = sf.query(f"SELECT Id FROM HealthUser__c WHERE Email__c = '{DEFAULT_EMAIL}'")
-        user_id = None
-        if user["totalSize"] == 0:
-            user = sf.HealthUser__c.create({
-                "Email__c": DEFAULT_EMAIL,
-                "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English"),
-                "ConsentGiven__c": True
-            })
-            user_id = user["id"]
-            logger.info(f"Created new user with email: {DEFAULT_EMAIL}")
-        else:
-            user_id = user["records"][0]["Id"]
-            sf.HealthUser__c.update(user_id, {
-                "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English"),
-                "ConsentGiven__c": True
-            })
-            logger.info(f"Updated user with email: {DEFAULT_EMAIL}")
-        sf.ConsentLog__c.create({
-            "HealthUser__c": user_id,
-            "ConsentType__c": "Voice Analysis",
-            "ConsentDate__c": datetime.utcnow().isoformat()
-        })
-        return user_id
+        if df.empty or "timestamp" not in df.columns:
+            logging.warning("Insufficient data for daily log trends chart")
+            return create_placeholder_chart("Daily Log Trends")
+        df['date'] = pd.to_datetime(df['timestamp'], errors='coerce').dt.date
+        daily_logs = df.groupby('date').size().reset_index(name='log_count')
+        if daily_logs.empty:
+            return create_placeholder_chart("Daily Log Trends")
+        fig = px.line(
+            daily_logs,
+            x='date',
+            y='log_count',
+            title="Daily Log Trends",
+            labels={"date": "Date", "log_count": "Number of Logs"}
+        )
+        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
+        return fig
     except Exception as e:
-        logger.error(f"Consent storage failed: {str(e)}")
-        return None
+        logging.error(f"Failed to create daily log trends chart: {str(e)}")
+        return create_placeholder_chart("Daily Log Trends")
 
-def generate_pdf_report(feedback, transcription, features, language):
+# Create weekly uptime chart
+def create_weekly_uptime_chart(df):
     try:
-        # Sanitize inputs for LaTeX
-        feedback = feedback.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#')
-        transcription = transcription.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#') if transcription else "None"
-        email = DEFAULT_EMAIL.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#')
-        language_display = SALESFORCE_LANGUAGE_MAP.get(language, "English")
-        
-        latex_content = (
-            "\\documentclass[a4paper,12pt]{article}\n"
-            "\\usepackage[utf8]{inputenc}\n"
-            "\\usepackage{geometry}\n"
-            "\\usepackage{parskip}\n"
-            "\\usepackage{titlesec}\n"
-            "\\usepackage{times}\n"
-            "\\usepackage{datetime}\n"
-            "\\newdateformat{isodate}{\\THEDAY{} \\shortmonthname[\\THEMONTH] \\THEYEAR}\n"
-            "\\geometry{margin=1in}\n"
-            "\\titleformat{\\section}{\\large\\bfseries}{\\thesection}{1em}{}\n"
-            "\\titleformat{\\subsection}{\\bfseries}{\\thesubsection}{1em}{}\n"
-            "\\begin{document}\n"
-            "\\begin{center}\n"
-            "    \\textbf{\\large MindCare Health Assistant Report} \\\\\n"
-            "    \\vspace{0.5cm}\n"
-            "    Generated on \\isodate\\today\\ at \\currenttime\n"
-            "\\end{center}\n"
-            "\\section*{User Information}\n"
-            "\\begin{itemize}\n"
-            f"    \\item \\textbf{{Email}}: {email}\n"
-            f"    \\item \\textbf{{Language}}: {language_display}\n"
-            "\\end{itemize}\n"
-            "\\section*{Voice Analysis Results}\n"
-            "\\subsection*{Health Assessment}\n"
-            f"{feedback}\n"
-            "\\subsection*{Transcription}\n"
-            f"{transcription}\n"
-            "\\subsection*{Voice Metrics}\n"
-            "\\begin{itemize}\n"
-            f"    \\item \\textbf{{Pitch}}: {features['pitch']:.2f} Hz\n"
-            f"    \\item \\textbf{{Jitter}}: {features['jitter']:.2f}\\%\n"
-            f"    \\item \\textbf{{Shimmer}}: {features['shimmer']:.2f}\\%\n"
-            f"    \\item \\textbf{{Energy}}: {features['energy']:.4f}\n"
-            f"    \\item \\textbf{{MFCC Mean}}: {features['mfcc_mean']:.2f}\n"
-            f"    \\item \\textbf{{Spectral Centroid}}: {features['spectral_centroid']:.2f} Hz\n"
-            "\\end{itemize}\n"
-            "\\section*{Disclaimer}\n"
-            "This report is a preliminary analysis and not a medical diagnosis. Always consult a healthcare provider.\n"
-            "\\end{document}\n"
+        if df.empty or "timestamp" not in df.columns or "usage_hours" not in df.columns or "downtime" not in df.columns:
+            logging.warning("Insufficient data for weekly uptime chart")
+            return create_placeholder_chart("Weekly Uptime Percentage")
+        df['week'] = pd.to_datetime(df['timestamp'], errors='coerce').dt.isocalendar().week
+        df['year'] = pd.to_datetime(df['timestamp'], errors='coerce').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)
+        if weekly_data.empty:
+            return create_placeholder_chart("Weekly Uptime Percentage")
+        fig = px.bar(
+            weekly_data,
+            x='year_week',
+            y='uptime_percent',
+            title="Weekly Uptime Percentage",
+            labels={"year_week": "Year-Week", "uptime_percent": "Uptime %"}
         )
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".tex") as tex_file:
-            tex_file.write(latex_content.encode('utf-8'))
-            tex_file_path = tex_file.name
-        pdf_path = tex_file_path.replace('.tex', '.pdf')
-        result = subprocess.run(
-            ['latexmk', '-pdf', '-pdflatex=pdflatex', '-interaction=nonstopmode', tex_file_path],
-            capture_output=True, text=True, check=True
+        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create weekly uptime chart: {str(e)}")
+        return create_placeholder_chart("Weekly Uptime Percentage")
+
+# Create anomaly alerts chart
+def create_anomaly_alerts_chart(anomalies_df):
+    try:
+        if anomalies_df is None or anomalies_df.empty or "timestamp" not in anomalies_df.columns:
+            logging.warning("Insufficient data for anomaly alerts chart")
+            return create_placeholder_chart("Anomaly Alerts Over Time")
+        anomalies_df['date'] = pd.to_datetime(anomalies_df['timestamp'], errors='coerce').dt.date
+        anomaly_counts = anomalies_df.groupby('date').size().reset_index(name='anomaly_count')
+        if anomaly_counts.empty:
+            return create_placeholder_chart("Anomaly Alerts Over Time")
+        fig = px.scatter(
+            anomaly_counts,
+            x='date',
+            y='anomaly_count',
+            title="Anomaly Alerts Over Time",
+            labels={"date": "Date", "anomaly_count": "Number of Anomalies"}
         )
-        logger.info(f"PDF generation output: {result.stdout}")
-        for ext in ['.aux', '.log', '.out', '.fls', '.fdb_latexmk']:
-            try:
-                os.remove(tex_file_path.replace('.tex', ext))
-            except:
-                pass
-        if os.path.exists(pdf_path):
-            logger.info(f"Generated PDF report: {pdf_path}")
-            return pdf_path
-        else:
-            logger.error("PDF file was not created")
-            return None
-    except subprocess.CalledProcessError as e:
-        logger.error(f"PDF generation failed: {e.stderr}")
+        fig.update_layout(title_font_size=16, margin=dict(l=20, r=20, t=40, b=20))
+        return fig
+    except Exception as e:
+        logging.error(f"Failed to create anomaly alerts chart: {str(e)}")
+        return create_placeholder_chart("Anomaly Alerts Over Time")
+
+# Generate device cards
+def generate_device_cards(df):
+    try:
+        if df.empty:
+            return '<p>No devices available to display.</p>'
+        device_stats = df.groupby('device_id').agg({
+            'status': 'last',
+            'timestamp': 'max',
+        }).reset_index()
+        device_stats['count'] = df.groupby('device_id').size().reindex(device_stats['device_id']).values
+        device_stats['health'] = device_stats['status'].map({
+            'Active': 'Healthy',
+            'Inactive': 'Unhealthy',
+            'Pending': 'Warning'
+        }).fillna('Unknown')
+        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')
+            timestamp_str = str(row['timestamp']) if pd.notna(row['timestamp']) else 'Unknown'
+            cards_html += 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['count']}</p>
+                    <p><b>Last Log:</b> {timestamp_str}</p>
+                </div>
+            """
+        cards_html += '</div>'
+        return cards_html
+    except Exception as e:
+        logging.error(f"Failed to generate device cards: {str(e)}")
+        return f'<p>Error generating device cards: {str(e)}</p>'
+
+# Generate PDF content
+def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards_html, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart):
+    if not reportlab_available:
         return None
+    try:
+        pdf_path = f"status_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        doc = SimpleDocTemplate(pdf_path, pagesize=letter)
+        styles = getSampleStyleSheet()
+        story = []
+
+        def safe_paragraph(text, style):
+            return Paragraph(str(text).replace('\n', '<br/>'), style) if text else Paragraph("", style)
+
+        story.append(Paragraph("LabOps Status Report", styles['Title']))
+        story.append(Paragraph(f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Summary Report", styles['Heading2']))
+        story.append(safe_paragraph(summary, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Log Preview", styles['Heading2']))
+        if not preview_df.empty:
+            data = [preview_df.columns.tolist()] + preview_df.head(5).values.tolist()
+            table = Table(data)
+            table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 12),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('TEXTCOLOR', (0, 1), (-1, -1), colors.black),
+                ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
+                ('FONTSIZE', (0, 1), (-1, -1), 10),
+                ('GRID', (0, 0), (-1, -1), 1, colors.black)
+            ]))
+            story.append(table)
+        else:
+            story.append(safe_paragraph("No preview available.", styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Device Cards", styles['Heading2']))
+        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, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Anomaly Detection", styles['Heading2']))
+        story.append(safe_paragraph(anomalies, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("AMC Reminders", styles['Heading2']))
+        story.append(safe_paragraph(amc_reminders, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Dashboard Insights", styles['Heading2']))
+        story.append(safe_paragraph(insights, styles['Normal']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph("Charts", styles['Heading2']))
+        story.append(Paragraph("[Chart placeholders - see dashboard for visuals]", styles['Normal']))
+
+        doc.build(story)
+        logging.info(f"PDF generated at {pdf_path}")
+        return pdf_path
     except Exception as e:
-        logger.error(f"PDF generation failed: { five(str(e))}")
+        logging.error(f"Failed to generate PDF: {str(e)}")
         return None
 
-def store_in_salesforce(user_id, audio_file, feedback, respiratory_score, mental_health_score, features, transcription, language):
-    if not sf:
-        logger.warning("Salesforce not connected; skipping storage")
-        return
+# Main processing function
+async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_range, cached_df_state, last_modified_state):
+    start_time = time.time()
     try:
-        with open(audio_file, "rb") as f:
-            audio_content = base64.b64encode(f.read()).decode()
-        content_version = sf.ContentVersion.create({
-            "Title": f"Voice_Assessment_{datetime.utcnow().isoformat()}",
-            "PathOnClient": os.path.basename(audio_file),
-            "VersionData": audio_content,
-            "IsMajorVersion": True
-        })
-        content_document_id = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version['id']}'")["records"][0]["ContentDocumentId"]
-        file_url = f"{SF_INSTANCE_URL}/lightning/r/ContentDocument/{content_document_id}/view"
-
-        feedback_str = feedback.encode('utf-8').decode('utf-8')
-        encrypted_feedback = encrypt_data(feedback_str)
-        if len(encrypted_feedback) > 131072:
-            encrypted_feedback = encrypted_feedback[:131072]
-
-        assessment = sf.VoiceAssessment__c.create({
-            "HealthUser__c": user_id,
-            "VoiceRecording__c": file_url,
-            "AssessmentResult__c": encrypted_feedback,
-            "AssessmentDate__c": datetime.utcnow().isoformat(),
-            "ConfidenceScore__c": 95.0,
-            "RespiratoryScore__c": float(respiratory_score),
-            "MentalHealthScore__c": float(mental_health_score),
-            "Pitch__c": float(features["pitch"]),
-            "Jitter__c": float(features["jitter"]),
-            "Shimmer__c": float(features["shimmer"]),
-            "Energy__c": float(features["energy"]),
-            "Transcription__c": transcription or "None",
-            "Language__c": SALESFORCE_LANGUAGE_MAP.get(language, "English")
-        })
-        sf.ContentDocumentLink.create({
-            "ContentDocumentId": content_document_id,
-            "LinkedEntityId": assessment["id"],
-            "ShareType": "V"
-        })
-        logger.info(f"Stored assessment in Salesforce: {assessment['id']}")
+        if not file_obj:
+            return "No file uploaded.", "<p>No data available.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None, cached_df_state, last_modified_state
+
+        file_path = file_obj.name
+        current_modified_time = os.path.getmtime(file_path)
+
+        # Read file only if it's new or modified
+        if cached_df_state is None or current_modified_time != last_modified_state:
+            logging.info(f"Processing new or modified file: {file_path}")
+            if not file_path.endswith(".csv"):
+                return "Please upload a CSV file.", "<p>Invalid file format.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
+
+            required_columns = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
+            dtypes = {
+                "device_id": "string",
+                "log_type": "string",
+                "status": "string",
+                "usage_hours": "float32",
+                "downtime": "float32",
+                "amc_date": "string"
+            }
+            df = pd.read_csv(file_path, 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}", "<p>Missing required columns.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
+
+            df["timestamp"] = pd.to_datetime(df["timestamp"], errors='coerce')
+            df["amc_date"] = pd.to_datetime(df["amc_date"], errors='coerce')
+            if df["timestamp"].dt.tz is None:
+                df["timestamp"] = df["timestamp"].dt.tz_localize('UTC').dt.tz_convert('Asia/Kolkata')
+            if df.empty:
+                return "No data available.", "<p>No data available.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
+        else:
+            df = cached_df_state
+
+        # Apply filters
+        filtered_df = df.copy()
+        if lab_site_filter and lab_site_filter != 'All' and 'lab_site' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['lab_site'] == lab_site_filter]
+        if equipment_type_filter and equipment_type_filter != 'All' and 'equipment_type' in filtered_df.columns:
+            filtered_df = filtered_df[filtered_df['equipment_type'] == equipment_type_filter]
+        if date_range is not None:
+            if isinstance(date_range, (int, float)):
+                # Convert single value to a range for a single day
+                days = int(date_range)
+                date_range = [days, days]
+                logging.info(f"Converted single value {days} to range {date_range}")
+            if len(date_range) != 2 or not all(isinstance(x, (int, float)) for x in date_range):
+                logging.error(f"Invalid date range format: {date_range}. Expected [start, end] or single integer.")
+                return "Invalid date range format. Please use [start, end] (e.g., [-7, 0]) or a single integer (e.g., -1).", "<p>Error processing data.</p>", None, '<p>Error processing data.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
+            days_start, days_end = date_range
+            today = pd.to_datetime(datetime.now()).tz_localize('Asia/Kolkata')
+            start_date = today + pd.Timedelta(days=days_start)
+            end_date = today + pd.Timedelta(days=days_end) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1)
+            start_date = start_date.tz_convert('Asia/Kolkata') if start_date.tzinfo else start_date.tz_localize('Asia/Kolkata')
+            end_date = end_date.tz_convert('Asia/Kolkata') if end_date.tzinfo else end_date.tz_localize('Asia/Kolkata')
+            logging.info(f"Date range filter applied: start_date={start_date}, end_date={end_date}")
+            logging.info(f"Before date filter: {len(filtered_df)} rows")
+            filtered_df = filtered_df[(filtered_df['timestamp'] >= start_date) & (filtered_df['timestamp'] <= end_date)]
+            logging.info(f"After date filter: {len(filtered_df)} rows")
+            if days_start > days_end:
+                logging.warning("Start date is after end date; results may be empty or unexpected.")
+
+        if filtered_df.empty:
+            return "No data after applying filters.", "<p>No data after filters.</p>", None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, df, current_modified_time
+
+        # Generate table for preview
+        preview_df = filtered_df[['device_id', 'log_type', 'status', 'timestamp', 'usage_hours', 'downtime', 'amc_date']].head(5)
+        preview_html = preview_df.to_html(index=False, classes='table table-striped', border=0)
+
+        # Run critical tasks concurrently
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            future_anomalies = executor.submit(detect_anomalies, filtered_df)
+            future_amc = executor.submit(check_amc_reminders, filtered_df, datetime.now())
+
+            summary = f"Step 1: Summary Report\n{summarize_logs(filtered_df)}"
+            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\n{generate_dashboard_insights(filtered_df)}"
+
+        # Generate charts sequentially
+        usage_chart = create_usage_chart(filtered_df)
+        downtime_chart = create_downtime_chart(filtered_df)
+        daily_log_chart = create_daily_log_trends_chart(filtered_df)
+        weekly_uptime_chart = create_weekly_uptime_chart(filtered_df)
+        anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)
+        device_cards = generate_device_cards(filtered_df)
+
+        # Save to Salesforce after all other processing
+        save_to_salesforce(filtered_df, reminders_df)
+        create_salesforce_reports(filtered_df)
+
+        elapsed_time = time.time() - start_time
+        logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
+        if elapsed_time > 3:
+            logging.warning(f"Processing time exceeded 3 seconds: {elapsed_time:.2f} seconds")
+
+        return (summary, preview_html, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart, anomalies, amc_reminders, insights, None, df, current_modified_time)
     except Exception as e:
-        logger.error(f"Salesforce storage failed: {str(e)}")
-        raise
+        logging.error(f"Failed to process file: {str(e)}")
+        return f"Error: {str(e)}", "<p>Error processing data.</p>", None, '<p>Error processing data.</p>', None, None, None, None, "", "", "", None, cached_df_state, last_modified_state
 
-def analyze_voice(audio_file=None, language="en"):
-    global usage_metrics
-    usage_metrics["total_assessments"] += 1
-    usage_metrics["assessments_by_language"][language] = usage_metrics["assessments_by_language"].get(language, 0) + 1
+# Generate PDF separately
+async def generate_pdf(summary, preview_html, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart, anomalies, amc_reminders, insights):
+    try:
+        preview_df = pd.read_html(preview_html)[0]
+        pdf_file = generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart)
+        return pdf_file
+    except Exception as e:
+        logging.error(f"Failed to generate PDF: {str(e)}")
+        return None
 
+# Update filters
+def update_filters(file_obj, current_file_state):
+    if not file_obj or file_obj.name == current_file_state:
+        return gr.update(), gr.update(), current_file_state
     try:
-        if not audio_file or not os.path.exists(audio_file):
-            raise ValueError("No valid audio file provided")
-        
-        audio, sr = librosa.load(audio_file, sr=16000)
-        if len(audio) < sr:
-            raise ValueError("Audio too short (minimum 1 second)")
-
-        user_id = store_user_consent(language)
-        if not user_id:
-            return "Error: Failed to store user consent.", None
-
-        features = extract_health_features(audio, sr)
-        transcription = transcribe_audio(audio, language)
-        feedback = analyze_symptoms(transcription, features)
-
-        respiratory_score = features["jitter"]
-        mental_health_score = features["shimmer"]
-        
-        feedback += f"\n\n**Voice Analysis Details**:\n"
-        feedback += f"- Pitch: {features['pitch']:.2f} Hz\n"
-        feedback += f"- Jitter: {features['jitter']:.2f}% (voice stability)\n"
-        feedback += f"- Shimmer: {features['shimmer']:.2f}% (amplitude variation)\n"
-        feedback += f"- Energy: {features['energy']:.4f} (vocal intensity)\n"
-        feedback += f"- MFCC Mean: {features['mfcc_mean']:.2f} (timbre quality)\n"
-        feedback += f"- Spectral Centroid: {features['spectral_centroid']:.2f} Hz (voice brightness)\n"
-        feedback += f"- Transcription: {transcription if transcription else 'None'}\n"
-        feedback += "\n**Disclaimer**: This is a preliminary analysis. Consult a healthcare provider for professional evaluation."
-
-        if sf:
-            store_in_salesforce(user_id, audio_file, feedback, respiratory_score, mental_health_score, features, transcription, language)
-
-        pdf_path = generate_pdf_report(feedback, transcription, features, language)
-
-        try:
-            os.remove(audio_file)
-            logger.info(f"Deleted audio file: {audio_file}")
-        except Exception as e:
-            logger.error(f"Failed to delete audio file: {str(e)}")
-
-        return feedback, pdf_path
+        with open(file_obj.name, 'rb') as f:
+            csv_content = f.read().decode('utf-8')
+        df = pd.read_csv(io.StringIO(csv_content))
+        df['timestamp'] = pd.to_datetime(df['timestamp'], errors='coerce')
+
+        lab_site_options = ['All'] + [site for site in df['lab_site'].dropna().astype(str).unique().tolist() if site.strip()] if 'lab_site' in df.columns else ['All']
+        equipment_type_options = ['All'] + [equip for equip in df['equipment_type'].dropna().astype(str).unique().tolist() if equip.strip()] if 'equipment_type' in df.columns else ['All']
+
+        return gr.update(choices=lab_site_options, value='All'), gr.update(choices=equipment_type_options, value='All'), file_obj.name
     except Exception as e:
-        logger.error(f"Audio processing failed: {str(e)}")
-        return f"Error: {str(e)}", None
+        logging.error(f"Failed to update filters: {str(e)}")
+        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All'), current_file_state
 
-def launch():
-    with gr.Blocks(title="MindCare Health Assistant", css=".gradio-container {max-width: 1200px; margin: auto; font-family: Arial, sans-serif;}") as demo:
-        gr.Markdown("# MindCare Health Assistant")
-        gr.Markdown("Record your voice or type a message for health assessments and suggestions.")
+# Gradio Interface
+try:
+    logging.info("Initializing Gradio interface...")
+    with gr.Blocks(css="""
+        .dashboard-container {border: 1px solid #e0e0e0; padding: 10px; border-radius: 5px;}
+        .dashboard-title {font-size: 24px; font-weight: bold; margin-bottom: 5px;}
+        .dashboard-section {margin-bottom: 20px;}
+        .dashboard-section h3 {font-size: 18px; margin-bottom: 2px;}
+        .dashboard-section p {margin: 1px 0; line-height: 1.2;}
+        .dashboard-section ul {margin: 2px 0; padding-left: 20px;}
+        .table {width: 100%; border-collapse: collapse;}
+        .table th, .table td {border: 1px solid #ddd; padding: 8px; text-align: left;}
+        .table th {background-color: #f2f2f2;}
+        .table tr:nth-child(even) {background-color: #f9f9f9;}
+    """) as iface:
+        gr.Markdown("<h1>LabOps Log Analyzer Dashboard</h1>")
+        gr.Markdown("Upload a CSV file to analyze. Click 'Analyze' to refresh the dashboard. Use 'Export PDF' for report download. Date Range can be [start, end] (e.g., [-7, 0] for June 11 to June 18) or a single integer (e.g., -1 for June 17).")
+
+        last_modified_state = gr.State(value=None)
+        current_file_state = gr.State(value=None)
+        cached_df_state = gr.State(value=None)
 
         with gr.Row():
-            with gr.Column():
-                gr.Markdown("### Voice Analysis")
-                gr.Markdown("Record or upload voice (1+ sec) describing symptoms (e.g., 'I have a cough' or 'I feel stressed').")
-                language_input = gr.Dropdown(choices=list(SUPPORTED_LANGUAGES.keys()), label="Select Language", value="en")
-                consent_input = gr.Checkbox(label="I consent to data storage and voice analysis", value=True, interactive=False)
-                audio_input = gr.Audio(type="filepath", label="Record or Upload Voice (WAV, MP3, FLAC)", format="wav")
-                voice_output = gr.Textbox(label="Health Assessment Results", elem_id="health-results")
-                pdf_output = gr.File(label="Download Assessment Report (PDF)")
-                submit_btn = gr.Button("Submit")
-                clear_btn = gr.Button("Clear")
-
-            with gr.Column():
-                gr.Markdown("### Health Suggestions")
-                gr.Markdown("Enter a message for personalized health advice.")
-                text_input = gr.Textbox(label="Enter your message")
-                text_output = gr.Textbox(label="Response")
-                audio_output = gr.Audio(label="Response Audio")
-                suggest_submit_btn = gr.Button("Submit")
-                suggest_clear_btn = gr.Button("Clear")
-
-        submit_btn.click(
-            fn=analyze_voice,
-            inputs=[audio_input, language_input],
-            outputs=[voice_output, pdf_output]
-        )
-        clear_btn.click(
-            fn=lambda: (gr.update(value=None), gr.update(value="en"), gr.update(value=""), gr.update(value=None)),
-            inputs=None,
-            outputs=[audio_input, language_input, voice_output, pdf_output]
+            with gr.Column(scale=1):
+                file_input = gr.File(label="Upload Logs (CSV)", file_types=[".csv"])
+                with gr.Group():
+                    gr.Markdown("### Filters")
+                    lab_site_filter = gr.Dropdown(label="Lab Site", choices=['All'], value='All', interactive=True)
+                    equipment_type_filter = gr.Dropdown(label="Equipment Type", choices=['All'], value='All', interactive=True)
+                    date_range_filter = gr.Slider(label="Date Range (Days from Today)", minimum=-365, maximum=0, step=1, value=[-7, 0], interactive=True)
+                    submit_button = gr.Button("Analyze", variant="primary")
+                    pdf_button = gr.Button("Export PDF", variant="secondary")
+
+            with gr.Column(scale=2):
+                with gr.Group(elem_classes="dashboard-container"):
+                    gr.Markdown("<div class='dashboard-title'>Analysis Results</div>")
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 1: Summary Report")
+                        summary_output = gr.Markdown()
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 2: Log Preview")
+                        preview_output = gr.HTML()
+                    with gr.Group(elem_classes="dashboard-section"):
+                        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("Downtime per Device"):
+                            downtime_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")
+                        anomaly_output = gr.Markdown()
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 5: AMC Reminders")
+                        amc_output = gr.Markdown()
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Step 6: Insights")
+                        insights_output = gr.Markdown()
+                    with gr.Group(elem_classes="dashboard-section"):
+                        gr.Markdown("### Export Report")
+                        pdf_output = gr.File(label="Download Status Report as PDF")
+
+        file_input.change(
+            fn=update_filters,
+            inputs=[file_input, current_file_state],
+            outputs=[lab_site_filter, equipment_type_filter, current_file_state],
+            queue=False
         )
-        suggest_submit_btn.click(
-            fn=get_chatbot_response,
-            inputs=[text_input, language_input],
-            outputs=[text_output, audio_output]
+
+        submit_button.click(
+            fn=process_logs,
+            inputs=[file_input, lab_site_filter, equipment_type_filter, date_range_filter, cached_df_state, last_modified_state],
+            outputs=[summary_output, preview_output, usage_chart_output, device_cards_output, daily_log_trends_output, weekly_uptime_output, anomaly_alerts_output, downtime_chart_output, anomaly_output, amc_output, insights_output, pdf_output, cached_df_state, last_modified_state]
         )
-        suggest_clear_btn.click(
-            fn=lambda: (gr.update(value=""), gr.update(value=""), gr.update(value=None)),
-            inputs=None,
-            outputs=[text_input, text_output, audio_output]
+
+        pdf_button.click(
+            fn=generate_pdf,
+            inputs=[summary_output, preview_output, usage_chart_output, device_cards_output, daily_log_trends_output, weekly_uptime_output, anomaly_alerts_output, downtime_chart_output, anomaly_output, amc_output, insights_output],
+            outputs=[pdf_output]
         )
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+
+        logging.info("Gradio interface initialized successfully")
+except Exception as e:
+    logging.error(f"Failed to initialize Gradio interface: {str(e)}")
+    raise e
 
 if __name__ == "__main__":
-    launch()
+    try:
+        logging.info("Launching Gradio interface...")
+        iface.launch(server_name="0.0.0.0", server_port=7860, debug=True, share=False)
+        logging.info("Gradio interface launched successfully")
+    except Exception as e:
+        logging.error(f"Failed to launch Gradio interface: {str(e)}")
+        print(f"Error launching app: {str(e)}")
+        raise e