Update app.py

app.py

@@ -9,16 +9,25 @@ import torch
 from concurrent.futures import ThreadPoolExecutor
 from simple_salesforce import Salesforce
 import os
+import json
 import io
 import time
-import uuid
-import functools
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# Salesforce configuration (Disabled for now)
-sf = None  # Temporarily disable Salesforce
+# Salesforce configuration
+try:
+    sf = Salesforce(
+        username='multi-devicelabopsdashboard@sathkrutha.com',
+        password='Team@1234',
+        security_token=os.getenv('SF_SECURITY_TOKEN', ''),
+        domain='login'
+    )
+    logging.info("Salesforce connection established")
+except Exception as e:
+    logging.error(f"Failed to connect to Salesforce: {str(e)}")
+    sf = None
 
 # Try to import reportlab
 try:
@@ -36,13 +45,14 @@ except ImportError:
 logging.info("Preloading Hugging Face model...")
 try:
     device = 0 if torch.cuda.is_available() else -1
+    # Use a smaller model for faster inference
     summarizer = pipeline(
         "summarization",
         model="t5-small",
         device=device,
-        max_length=30,
+        max_length=50,
         min_length=10,
-        num_beams=1
+        num_beams=2
     )
     logging.info(f"Hugging Face model preloaded on {'GPU' if device == 0 else 'CPU'}")
 except Exception as e:
@@ -108,40 +118,97 @@ def get_folder_id(folder_name):
 
 LABOPS_REPORTS_FOLDER_ID = get_folder_id('LabOps Reports')
 
-# Salesforce report creation (Disabled for now)
+# Salesforce report creation
 def create_salesforce_reports(df):
-    logging.info("Salesforce report creation skipped for optimization")
-    return
+    if sf is None or not LABOPS_REPORTS_FOLDER_ID:
+        return
+    try:
+        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")
+    except Exception as e:
+        logging.error(f"Failed to create Salesforce reports: {str(e)}")
 
-# Save to Salesforce (Disabled for now)
+# Save to Salesforce
 def save_to_salesforce(df, reminders_df):
-    logging.info("Salesforce save operation skipped for optimization")
-    return
-
-# Cache summarization results
-def cache_summary(func):
-    @functools.wraps(func)
-    def wrapper(df, *args, **kwargs):
-        cache_key = f"{id(df)}_{func.__name__}"
-        if not hasattr(wrapper, 'cache'):
-            wrapper.cache = {}
-        if cache_key in wrapper.cache:
-            return wrapper.cache[cache_key]
-        result = func(df, *args, **kwargs)
-        wrapper.cache[cache_key] = result
-        return result
-    return wrapper
+    if sf is None:
+        return
+    try:
+        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()
+
+        for _, row in df.iterrows():
+            status = str(row['status'])
+            log_type = str(row['log_type'])
+            status = picklist_mapping['Status__c'].get(status.lower(), status_values[0] if status_values else None)
+            log_type = picklist_mapping['Log_Type__c'].get(log_type.lower(), log_type_values[0] if log_type_values else None)
+            if status is None or log_type is None:
+                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_dt = datetime.strptime(amc_date, '%Y-%m-%d')
+                    if status == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"AMC Reminder for Device ID {row['device_id']}")
+                except:
+                    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
+            }
+            if row['device_id'] not in reminder_device_ids:
+                records.append(record)
+
+        if records:
+            sf.bulk.SmartLog__c.insert(records)
+            logging.info(f"Saved {len(records)} records to Salesforce")
+    except Exception as e:
+        logging.error(f"Failed to save to Salesforce: {str(e)}")
 
 # Summarize logs
-@cache_summary
 def summarize_logs(df):
-    start_time = time.time()
     try:
         total_devices = df["device_id"].nunique()
         most_used = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
         prompt = f"Maintenance logs: {total_devices} devices. Most used: {most_used}."
-        summary = summarizer(prompt, max_length=30, min_length=10, do_sample=False)[0]["summary_text"]
-        logging.info(f"Summary generation took {time.time() - start_time:.2f} seconds")
+        summary = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
         return summary
     except Exception as e:
         logging.error(f"Summary generation failed: {str(e)}")
@@ -149,28 +216,24 @@ def summarize_logs(df):
 
 # Anomaly detection
 def detect_anomalies(df):
-    start_time = time.time()
     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) > 100:
-            features = features.sample(n=100, random_state=42)
-        iso_forest = IsolationForest(contamination=0.1, random_state=42, n_estimators=30)
+        if len(features) > 500:
+            features = features.sample(n=500, 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
-        result = "\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()])
-        logging.info(f"Anomaly detection took {time.time() - start_time:.2f} seconds")
-        return result, 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):
-    start_time = time.time()
     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()
@@ -180,44 +243,24 @@ def check_amc_reminders(df, current_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:
             return "No AMC reminders due within the next 30 days.", reminders
-        result = "\n".join([f"- Device ID: {row['device_id']}, Log Type: {row['log_type']}, Status: {row['status']}, Usage: {row['usage_hours']}, Downtime: {row['downtime']}, AMC Date: {row['amc_date']}" for _, row in reminders.head(5).iterrows()])
-        logging.info(f"AMC reminders generation took {time.time() - start_time:.2f} seconds")
-        return result, 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
-@cache_summary
 def generate_dashboard_insights(df):
-    start_time = time.time()
     try:
         total_devices = df["device_id"].nunique()
         avg_usage = df["usage_hours"].mean() if "usage_hours" in df.columns else 0
         prompt = f"Insights: {total_devices} devices, avg usage {avg_usage:.2f} hours."
-        insights = summarizer(prompt, max_length=30, min_length=10, do_sample=False)[0]["summary_text"]
-        logging.info(f"Insights generation took {time.time() - start_time:.2f} seconds")
+        insights = summarizer(prompt, max_length=50, min_length=10, do_sample=False)[0]["summary_text"]
         return insights
     except Exception as e:
         logging.error(f"Dashboard insights generation failed: {str(e)}")
         return f"Dashboard insights generation failed: {str(e)}"
 
-# Cache DataFrame processing
-def cache_dataframe(func):
-    @functools.wraps(func)
-    def wrapper(df, *args, **kwargs):
-        cache_key = f"{id(df)}_{func.__name__}"
-        if not hasattr(wrapper, 'cache'):
-            wrapper.cache = {}
-        if cache_key in wrapper.cache:
-            return wrapper.cache[cache_key]
-        result = func(df, *args, **kwargs)
-        wrapper.cache[cache_key] = result
-        return result
-    return wrapper
-
 # Create usage chart
-@cache_dataframe
 def create_usage_chart(df):
     try:
         if df.empty:
@@ -238,12 +281,9 @@ def create_usage_chart(df):
         logging.error(f"Failed to create usage chart: {str(e)}")
         return None
 
-# Create downtime chart (Re-enabled with optimization)
-@cache_dataframe
+# Create downtime chart
 def create_downtime_chart(df):
     try:
-        if df.empty:
-            return None
         downtime_data = df.groupby("device_id")["downtime"].sum().reset_index()
         if len(downtime_data) > 5:
             downtime_data = downtime_data.nlargest(5, "downtime")
@@ -260,16 +300,11 @@ def create_downtime_chart(df):
         logging.error(f"Failed to create downtime chart: {str(e)}")
         return None
 
-# Create daily log trends chart (Re-enabled with optimization)
-@cache_dataframe
+# Create daily log trends chart
 def create_daily_log_trends_chart(df):
     try:
-        if df.empty:
-            return None
         df['date'] = df['timestamp'].dt.date
         daily_logs = df.groupby('date').size().reset_index(name='log_count')
-        if len(daily_logs) > 30:  # Limit to 30 days for faster plotting
-            daily_logs = daily_logs.tail(30)
         fig = px.line(
             daily_logs,
             x='date',
@@ -283,20 +318,15 @@ def create_daily_log_trends_chart(df):
         logging.error(f"Failed to create daily log trends chart: {str(e)}")
         return None
 
-# Create weekly uptime chart (Re-enabled with optimization)
-@cache_dataframe
+# Create weekly uptime chart
 def create_weekly_uptime_chart(df):
     try:
-        if df.empty:
-            return None
         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()
-        if len(weekly_data) > 12:  # Limit to 12 weeks for faster plotting
-            weekly_data = weekly_data.tail(12)
         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(
@@ -312,16 +342,13 @@ def create_weekly_uptime_chart(df):
         logging.error(f"Failed to create weekly uptime chart: {str(e)}")
         return None
 
-# Create anomaly alerts chart (Re-enabled with optimization)
-@cache_dataframe
+# 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')
-        if len(anomaly_counts) > 30:  # Limit to 30 days for faster plotting
-            anomaly_counts = anomaly_counts.tail(30)
         fig = px.scatter(
             anomaly_counts,
             x='date',
@@ -368,12 +395,32 @@ def generate_device_cards(df):
         logging.error(f"Failed to generate device cards: {str(e)}")
         return f'<p>Error generating device cards: {str(e)}</p>'
 
+# Generate monthly status
+def generate_monthly_status(df, selected_month):
+    try:
+        total_devices = df['device_id'].nunique()
+        total_usage_hours = df['usage_hours'].sum()
+        total_downtime = df['downtime'].sum()
+        avg_usage = total_usage_hours / total_devices if total_devices > 0 else 0
+        avg_downtime = total_downtime / total_devices if total_devices > 0 else 0
+        return f"""
+        Monthly Status for {selected_month}:
+        - Total Devices: {total_devices}
+        - Total Usage Hours: {total_usage_hours:.2f}
+        - Total Downtime Hours: {total_downtime:.2f}
+        - Average Usage per Device: {avg_usage:.2f} hours
+        - Average Downtime per Device: {avg_downtime:.2f} hours
+        """
+    except Exception as e:
+        logging.error(f"Failed to generate monthly status: {str(e)}")
+        return f"Failed to generate monthly status: {str(e)}"
+
 # Generate PDF content
-def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards_html):
+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, df, selected_month):
     if not reportlab_available:
         return None
     try:
-        pdf_path = f"status_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        pdf_path = f"monthly_status_report_{selected_month.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
         doc = SimpleDocTemplate(pdf_path, pagesize=letter)
         styles = getSampleStyleSheet()
         story = []
@@ -381,10 +428,16 @@ def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights
         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("LabOps Monthly 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))
 
+        if selected_month != "All":
+            monthly_status = generate_monthly_status(df, selected_month)
+            story.append(Paragraph("Monthly Status Summary", styles['Heading2']))
+            story.append(safe_paragraph(monthly_status, 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))
@@ -428,6 +481,9 @@ def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights
         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
@@ -436,12 +492,11 @@ def generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights
         return None
 
 # Main processing function
-async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_range, last_modified_state, progress=gr.Progress()):
+async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_range, month_filter, last_modified_state):
     start_time = time.time()
-    progress(0, desc="Starting processing...")
     try:
         if not file_obj:
-            return "No file uploaded.", pd.DataFrame(), None, '<p>No device cardsPEM available.</p>', None, None, None, None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None, last_modified_state
+            return "No file uploaded.", pd.DataFrame(), None, '<p>No device cards available.</p>', None, None, None, None, "No anomalies detected.", "No AMC reminders.", "No insights generated.", None, last_modified_state
 
         file_path = file_obj.name
         current_modified_time = os.path.getmtime(file_path)
@@ -452,7 +507,6 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
         if not file_path.endswith(".csv"):
             return "Please upload a CSV file.", pd.DataFrame(), None, '<p>No device cards available.</p>', None, None, None, None, "", "", "", None, last_modified_state
 
-        progress(0.1, desc="Loading CSV file...")
         required_columns = ["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]
         dtypes = {
             "device_id": "string",
@@ -462,16 +516,11 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             "downtime": "float32",
             "amc_date": "string"
         }
-        df = pd.read_csv(file_path, dtype=dtypes, usecols=required_columns)
-        if len(df) > 5000:
-            df = df.sample(n=5000, random_state=42)
-            logging.warning("Dataset too large, sampled to 5,000 rows")
-
+        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}", pd.DataFrame(), None, '<p>No device cards available.</p>', None, None, None, None, None, None, None, None, last_modified_state
 
-        progress(0.2, desc="Processing timestamps...")
         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:
@@ -480,7 +529,7 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             return "No data available.", pd.DataFrame(), None, '<p>No device cards available.</p>', None, None, None, None, None, None, None, None, last_modified_state
 
         # Apply filters
-        filtered_df = df
+        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:
@@ -491,18 +540,22 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             start_date = today + pd.Timedelta(days=days_start)
             end_date = today + pd.Timedelta(days=days_end) + pd.Timedelta(days=1) - pd.Timedelta(seconds=1)
             filtered_df = filtered_df[(filtered_df['timestamp'] >= start_date) & (filtered_df['timestamp'] <= end_date)]
+        if month_filter and month_filter != "All":
+            selected_date = pd.to_datetime(month_filter, format="%B %Y")
+            filtered_df = filtered_df[
+                (filtered_df['timestamp'].dt.year == selected_date.year) &
+                (filtered_df['timestamp'].dt.month == selected_date.month)
+            ]
 
         if filtered_df.empty:
             return "No data after applying filters.", pd.DataFrame(), None, '<p>No device cards available.</p>', None, None, None, None, None, None, None, None, last_modified_state
 
         # Generate table for preview
-        progress(0.3, desc="Generating log 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 tasks concurrently
-        progress(0.4, desc="Running analysis tasks...")
-        with ThreadPoolExecutor(max_workers=4) as executor:
+        with ThreadPoolExecutor(max_workers=6) as executor:
             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())
@@ -511,35 +564,31 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             future_downtime_chart = executor.submit(create_downtime_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_anomaly_alerts_chart = executor.submit(create_anomaly_alerts_chart, pd.DataFrame())
             future_device_cards = executor.submit(generate_device_cards, filtered_df)
+            future_reports = executor.submit(create_salesforce_reports, filtered_df)
 
-            progress(0.5, desc="Collecting summary results...")
             summary = f"Step 1: Summary Report\n{future_summary.result()}"
-            progress(0.6, desc="Collecting anomaly detection results...")
             anomalies, anomalies_df = future_anomalies.result()
             anomalies = f"Anomaly Detection\n{anomalies}"
-            progress(0.7, desc="Collecting AMC reminders...")
             amc_reminders, reminders_df = future_amc.result()
             amc_reminders = f"AMC Reminders\n{amc_reminders}"
-            progress(0.8, desc="Collecting insights...")
             insights = f"Dashboard Insights (AI)\n{future_insights.result()}"
-            progress(0.9, desc="Generating charts...")
             usage_chart = future_usage_chart.result()
             downtime_chart = future_downtime_chart.result()
             daily_log_chart = future_daily_log_chart.result()
             weekly_uptime_chart = future_weekly_uptime_chart.result()
-            anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)
+            anomaly_alerts_chart = future_anomaly_alerts_chart.result()
             device_cards = future_device_cards.result()
 
-        progress(0.95, desc="Generating PDF...")
-        pdf_file = generate_pdf_content(summary, preview_df, anomalies, amc_reminders, insights, device_cards)
+        save_to_salesforce(filtered_df, reminders_df)
+        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, filtered_df, month_filter)
 
         elapsed_time = time.time() - start_time
         logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
-        if elapsed_time > 30:
-            logging.warning(f"Processing time exceeded 30 seconds: {elapsed_time:.2f} seconds")
+        if elapsed_time > 10:
+            logging.warning(f"Processing time exceeded 10 seconds: {elapsed_time:.2f} seconds")
 
-        progress(1.0, desc="Processing complete!")
         return (summary, preview_html, usage_chart, device_cards, daily_log_chart, weekly_uptime_chart, anomaly_alerts_chart, downtime_chart, anomalies, amc_reminders, insights, pdf_file, current_modified_time)
     except Exception as e:
         logging.error(f"Failed to process file: {str(e)}")
@@ -548,7 +597,7 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
 # Update filters
 def update_filters(file_obj):
     if not file_obj:
-        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All')
+        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All')
     try:
         with open(file_obj.name, 'rb') as f:
             csv_content = f.read().decode('utf-8')
@@ -557,11 +606,12 @@ def update_filters(file_obj):
 
         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']
+        month_options = ['All'] + sorted(df['timestamp'].dt.strftime('%B %Y').dropna().unique().tolist()) if 'timestamp' in df.columns else ['All']
 
-        return gr.update(choices=lab_site_options, value='All'), gr.update(choices=equipment_type_options, value='All')
+        return gr.update(choices=lab_site_options, value='All'), gr.update(choices=equipment_type_options, value='All'), gr.update(choices=month_options, value='All')
     except Exception as e:
         logging.error(f"Failed to update filters: {str(e)}")
-        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All')
+        return gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All'), gr.update(choices=['All'], value='All')
 
 # Gradio Interface
 try:
@@ -591,6 +641,7 @@ try:
                     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=[-30, 0])
+                    month_filter = gr.Dropdown(label="Select Month for Report", choices=['All'], value='All', interactive=True)
                 submit_button = gr.Button("Analyze", variant="primary")
 
             with gr.Column(scale=2):
@@ -628,18 +679,18 @@ try:
                         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")
+                        pdf_output = gr.File(label="Download Monthly Status Report as PDF")
 
         file_input.change(
             fn=update_filters,
             inputs=[file_input],
-            outputs=[lab_site_filter, equipment_type_filter],
+            outputs=[lab_site_filter, equipment_type_filter, month_filter],
             queue=False
         )
 
         submit_button.click(
             fn=process_logs,
-            inputs=[file_input, lab_site_filter, equipment_type_filter, date_range_filter, last_modified_state],
+            inputs=[file_input, lab_site_filter, equipment_type_filter, date_range_filter, month_filter, 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, last_modified_state]
         )