Update app.py

app.py

@@ -69,15 +69,27 @@ def detect_anomalies(df):
 # AMC reminders
 def check_amc_reminders(df, current_date):
     try:
+        logging.info(f"Input DataFrame for AMC reminders:\n{df.head().to_string()}")
         if "device_id" not in df.columns or "amc_date" not in df.columns:
+            logging.warning("Missing 'device_id' or 'amc_date' columns for AMC reminders.")
             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)
+        if df["amc_date"].dt.tz is None:
+            logging.info("Localizing naive AMC dates to IST")
+            df["amc_date"] = df["amc_date"].dt.tz_localize('UTC').dt.tz_convert('Asia/Kolkata')
+        
+        current_date = pd.to_datetime(current_date).tz_localize('Asia/Kolkata')
+        logging.info(f"Current date for AMC check: {current_date}")
+        
         df["days_to_amc"] = (df["amc_date"] - current_date).dt.days
+        logging.info(f"Days to AMC:\n{df[['device_id', 'amc_date', 'days_to_amc']].to_string()}")
+        
         reminders = df[(df["days_to_amc"] >= 0) & (df["days_to_amc"] <= 30)][["device_id", "log_type", "status", "timestamp", "usage_hours", "downtime", "amc_date"]]
         if reminders.empty:
             logging.info("No AMC reminders found within the next 30 days.")
             return "No AMC reminders due within the next 30 days.", reminders
+        
         reminder_lines = ["Upcoming AMC Reminders:"]
         for _, row in reminders.head(5).iterrows():
             reminder_lines.append(f"- Device ID: {row['device_id']}, AMC Date: {row['amc_date']}")
@@ -175,10 +187,10 @@ def create_downtime_chart(agg_data):
             color_discrete_map={"green": "#96CEB4", "red": "#FF0000"}
         )
         fig.update_traces(
-            marker_line_color='#333333',
-            marker_line_width=1.5,
-            opacity=0.9
-        )
+掍
+        marker_line_color='#333333',
+        marker_line_width=1.5,
+        opacity=0.9
         fig.update_layout(
             title_font=dict(size=18, family="Arial", color="#333333"),
             font=dict(family="Arial", size=12, color="#333333"),
@@ -207,7 +219,7 @@ def create_downtime_chart(agg_data):
         logging.error(f"Failed to create downtime chart: {str(e)}")
         return None
 
-# Create Daily Log Trends chart
+# Create Daily Log Trends chart (changed to area chart with markers)
 def create_daily_log_trends_chart(df):
     try:
         if df.empty or 'timestamp' not in df.columns:
@@ -218,16 +230,21 @@ def create_daily_log_trends_chart(df):
         df['date'] = df['timestamp'].dt.date
         log_counts = df.groupby('date').size().reset_index(name='log_count')
         
-        fig = px.line(
+        fig = px.area(
             log_counts,
             x='date',
             y='log_count',
             title="Daily Log Trends",
             labels={"date": "Date", "log_count": "Number of Logs"}
         )
+        # Add markers
         fig.update_traces(
+            fill='tozeroy',
             line_color='#4ECDC4',
-            line_width=2
+            line_width=2,
+            mode='lines+markers',
+            marker=dict(size=8, color='#4ECDC4', line=dict(width=1, color='#333333')),
+            fillcolor='rgba(78, 205, 196, 0.3)'  # Gradient fill with transparency
         )
         fig.update_layout(
             title_font=dict(size=18, family="Arial", color="#333333"),
@@ -261,18 +278,31 @@ def create_weekly_uptime_chart(df):
             logging.warning("DataFrame is empty or missing required columns for Weekly Uptime Percentage.")
             return None
         
-        # Group by week
-        df['week'] = df['timestamp'].dt.isocalendar().week
+        logging.info(f"DataFrame for Weekly Uptime:\n{df[['timestamp', 'downtime']].to_string()}")
+        
+        # Group by week (handle pandas 2.x compatibility)
+        try:
+            df['week'] = df['timestamp'].dt.isocalendar().week
+        except AttributeError:
+            # For pandas 2.x, use .dt.weekofyear or manual calculation
+            df['week'] = df['timestamp'].dt.isocalendar()['week']
         df['year'] = df['timestamp'].dt.year
         weekly_data = df.groupby(['year', 'week']).agg({
             'downtime': 'sum'
         }).reset_index()
         
+        logging.info(f"Weekly data:\n{weekly_data.to_string()}")
+        
         # Calculate uptime percentage (assuming 24*7 = 168 hours per week)
         total_hours_per_week = 168
         weekly_data['uptime_percentage'] = ((total_hours_per_week - weekly_data['downtime']) / total_hours_per_week) * 100
+        weekly_data['uptime_percentage'] = weekly_data['uptime_percentage'].clip(0, 100)  # Ensure percentage is between 0 and 100
         weekly_data['week_label'] = weekly_data.apply(lambda x: f"{x['year']}-W{x['week']:02d}", axis=1)
         
+        if weekly_data.empty:
+            logging.warning("No weekly data available for Weekly Uptime Percentage chart.")
+            return None
+        
         fig = px.bar(
             weekly_data,
             x='week_label',
@@ -315,14 +345,14 @@ def create_weekly_uptime_chart(df):
         logging.error(f"Failed to create Weekly Uptime Percentage chart: {str(e)}")
         return None
 
-# Create Anomaly Alerts chart
+# Create Anomaly Alerts chart (changed to bubble chart)
 def create_anomaly_alerts_chart(df, anomalies_df):
     try:
         if df.empty or anomalies_df.empty:
             logging.warning("DataFrame or anomalies DataFrame is empty for Anomaly Alerts chart.")
             return None
         
-        # Prepare data for scatter plot
+        # Prepare data for bubble chart
         df['is_anomaly'] = df.index.isin(anomalies_df.index)
         df['color'] = df['is_anomaly'].map({True: 'red', False: 'blue'})
         
@@ -330,13 +360,18 @@ def create_anomaly_alerts_chart(df, anomalies_df):
             df,
             x='usage_hours',
             y='downtime',
+            size='usage_hours',  # Bubble size based on usage hours
             color='color',
             title="Anomaly Alerts (Red = Anomaly)",
             labels={"usage_hours": "Usage Hours", "downtime": "Downtime (Hours)"},
             color_discrete_map={'blue': '#4ECDC4', 'red': '#FF0000'}
         )
         fig.update_traces(
-            marker=dict(size=8, line=dict(width=1, color='#333333')),
+            marker=dict(
+                sizemode='area',
+                sizeref=0.1,  # Adjust bubble size scaling
+                line=dict(width=1, color='#333333')
+            ),
             opacity=0.7
         )
         fig.update_layout(
@@ -614,9 +649,9 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
         }
         df = pd.read_csv(file_path, dtype=dtypes)
         # Downsample early if dataset is too large
-        if len(df) > 10000:
-            df = df.sample(n=10000, random_state=42)
-            logging.info(f"Downsampled DataFrame to 10,000 rows immediately after loading.")
+        if len(df) > 5000:
+            df = df.sample(n=5000, random_state=42)
+            logging.info(f"Downsampled DataFrame to 5,000 rows immediately after loading.")
         missing_columns = [col for col in required_columns if col not in df.columns]
         if missing_columns:
             return f"Missing columns: {missing_columns}", None, None, '<p>No device cards available.</p>', None, None, None, None, None, None, None, None, last_modified_state, None, None, None, None, None, None, f"Missing required columns: {missing_columns}"
@@ -664,11 +699,11 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
             logging.warning("Filtered DataFrame is empty after applying filters.")
             return "No data after applying filters.", None, None, '<p>No device cards available.</p>', None, None, None, None, None, None, None, None, last_modified_state, None, None, None, None, None, None, "No data available after applying filters."
 
-        logging.info(f"Filtered DataFrame:\n{filtered_df.head().to_string()}")
+        logging.info(f"Filtered DataFrame before AMC check:\n{filtered_df[['device_id', 'amc_date']].to_string()}")
 
-        if len(filtered_df) > 10000:
-            filtered_df = filtered_df.sample(n=10000, random_state=42)
-            logging.info(f"Downsampled DataFrame to 10,000 rows for chart generation.")
+        if len(filtered_df) > 1000:
+            filtered_df = filtered_df.sample(n=1000, random_state=42)
+            logging.info(f"Downsampled filtered DataFrame to 1,000 rows for chart generation.")
 
         # Pre-aggregate data for charts
         agg_data = {