Update analytics_data_processing.py

analytics_data_processing.py

@@ -1,5 +1,5 @@
 import pandas as pd
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, time # Added time for min.time
 import logging
 
 # Configure logging for this module
@@ -16,10 +16,14 @@ def filter_dataframe_by_date(df, date_column, start_date, end_date):
     
     df_copy = df.copy() # Work on a copy to avoid SettingWithCopyWarning
     try:
+        # Convert the DataFrame's date column to pandas datetime objects first
         if not pd.api.types.is_datetime64_any_dtype(df_copy[date_column]):
             df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        # Normalize the DataFrame's date column to midnight (date part only)
+        df_copy[date_column] = df_copy[date_column].dt.normalize()
+
     except Exception as e:
-        logging.error(f"Error converting date column '{date_column}' to datetime: {e}")
+        logging.error(f"Error converting or normalizing date column '{date_column}' to datetime: {e}")
         return pd.DataFrame() # Return empty if conversion fails
 
     df_filtered = df_copy.dropna(subset=[date_column])
@@ -27,21 +31,17 @@ def filter_dataframe_by_date(df, date_column, start_date, end_date):
         logging.info(f"Filter by date: DataFrame became empty after dropping NaNs in date column '{date_column}'.")
         return pd.DataFrame()
 
-    # Convert start_date and end_date to datetime objects if they are not None
-    # Normalize to remove time part for consistent date comparisons if dates are just dates
+    # Convert start_date and end_date (which are expected to be datetime.datetime or None)
+    # to pandas Timestamps and normalize them for comparison
     start_dt_obj = pd.to_datetime(start_date, errors='coerce').normalize() if start_date else None
     end_dt_obj = pd.to_datetime(end_date, errors='coerce').normalize() if end_date else None
 
 
     if start_dt_obj and end_dt_obj:
-        # Ensure the DataFrame's date column is also normalized if it contains time
-        df_filtered[date_column] = df_filtered[date_column].dt.normalize()
         return df_filtered[(df_filtered[date_column] >= start_dt_obj) & (df_filtered[date_column] <= end_dt_obj)]
     elif start_dt_obj:
-        df_filtered[date_column] = df_filtered[date_column].dt.normalize()
         return df_filtered[df_filtered[date_column] >= start_dt_obj]
     elif end_dt_obj:
-        df_filtered[date_column] = df_filtered[date_column].dt.normalize()
         return df_filtered[df_filtered[date_column] <= end_dt_obj]
     return df_filtered # No date filtering if neither start_date nor end_date is provided
 
@@ -62,20 +62,28 @@ def prepare_filtered_analytics_data(token_state_value, date_filter_option, custo
     date_column_mentions = token_state_value.get("config_date_col_mentions", "date")
 
     # Determine date range for filtering posts and mentions
-    # Ensure end_dt is also normalized if it's datetime.now() for consistent comparison with normalized dates
-    current_time_normalized = datetime.now().normalize()
+    # Normalize current time to midnight using datetime.replace
+    current_datetime_obj = datetime.now()
+    current_time_normalized = current_datetime_obj.replace(hour=0, minute=0, second=0, microsecond=0)
+    
     end_dt_filter = current_time_normalized 
     start_dt_filter = None
 
     if date_filter_option == "Last 7 Days":
-        start_dt_filter = current_time_normalized - timedelta(days=6) # Inclusive of start day
+        start_dt_filter = current_time_normalized - timedelta(days=6) 
     elif date_filter_option == "Last 30 Days":
-        start_dt_filter = current_time_normalized - timedelta(days=29) # Inclusive of start day
+        start_dt_filter = current_time_normalized - timedelta(days=29) 
     elif date_filter_option == "Custom Range":
-        start_dt_filter = pd.to_datetime(custom_start_date, errors='coerce').normalize() if custom_start_date else None
-        # If custom_end_date is not provided, use current_time_normalized for end_dt_filter
-        end_dt_filter = pd.to_datetime(custom_end_date, errors='coerce').normalize() if custom_end_date else current_time_normalized
-    # "All Time" means start_dt_filter remains None, end_dt_filter effectively means up to now or unbounded if None
+        # custom_start_date and custom_end_date are strings from gr.DateTime(type="string")
+        # Convert to datetime objects and then normalize
+        start_dt_filter_temp = pd.to_datetime(custom_start_date, errors='coerce')
+        start_dt_filter = start_dt_filter_temp.replace(hour=0, minute=0, second=0, microsecond=0) if pd.notna(start_dt_filter_temp) else None
+        
+        end_dt_filter_temp = pd.to_datetime(custom_end_date, errors='coerce')
+        # If custom_end_date is not provided or invalid, use current_time_normalized
+        end_dt_filter = end_dt_filter_temp.replace(hour=0, minute=0, second=0, microsecond=0) if pd.notna(end_dt_filter_temp) else current_time_normalized
+    
+    # "All Time" means start_dt_filter remains None, end_dt_filter effectively means up to now.
 
     logging.info(f"Date range for filtering: Start: {start_dt_filter}, End: {end_dt_filter}")