Update analytics_plot_generators.py

analytics_plot_generators.py

@@ -4,6 +4,7 @@ import logging
 from io import BytesIO
 import base64
 import numpy as np
+import matplotlib.ticker as mticker
 
 # Configure logging for this module
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
@@ -18,28 +19,21 @@ def create_placeholder_plot(title="No Data or Plot Error", message="Data might b
         return fig
     except Exception as e:
         logging.error(f"Error creating placeholder plot: {e}")
-        fig, ax = plt.subplots()
-        ax.text(0.5, 0.5, "Plot generation error", ha='center', va='center')
-        ax.axis('off')
-        return fig
-    finally:
-        # plt.close(fig) # Close the specific figure to free memory
-        # More robustly, Gradio handles figure objects, explicit close might not always be needed here
-        # but plt.close('all') in calling functions or after a block of plot generations is safer.
-        pass
-
-
-def generate_posts_activity_plot(df, date_column='published_at'): # Default changed as per common use
-    """
-    Generates a plot for posts activity over time.
-    Assumes df has a date_column (e.g., 'published_at') and groups by date to count posts.
-    """
+        # Fallback placeholder if the above fails
+        fig_err, ax_err = plt.subplots()
+        ax_err.text(0.5, 0.5, "Fatal: Plot generation error", ha='center', va='center')
+        ax_err.axis('off')
+        return fig_err
+    # No plt.close(fig) here as Gradio handles the figure object.
+
+def generate_posts_activity_plot(df, date_column='published_at'):
+    """Generates a plot for posts activity over time."""
     logging.info(f"Generating posts activity plot. Date column: '{date_column}'. Input df rows: {len(df) if df is not None else 'None'}")
     if df is None or df.empty:
         logging.warning(f"Posts activity: DataFrame is empty.")
         return create_placeholder_plot(title="Posts Activity Over Time", message="No data available for the selected period.")
     if date_column not in df.columns:
-        logging.warning(f"Posts activity: Date column '{date_column}' is missing from DataFrame columns: {df.columns.tolist()}.")
+        logging.warning(f"Posts activity: Date column '{date_column}' is missing. Cols: {df.columns.tolist()}.")
         return create_placeholder_plot(title="Posts Activity Over Time", message=f"Date column '{date_column}' not found.")
 
     try:
@@ -55,8 +49,8 @@ def generate_posts_activity_plot(df, date_column='published_at'): # Default chan
         posts_over_time = df_copy.set_index(date_column).resample('D').size() 
         
         if posts_over_time.empty:
-             logging.info("Posts activity: No posts after resampling by day.")
-             return create_placeholder_plot(title="Posts Activity Over Time", message="No posts in the selected period.")
+            logging.info("Posts activity: No posts after resampling by day.")
+            return create_placeholder_plot(title="Posts Activity Over Time", message="No posts in the selected period.")
 
         fig, ax = plt.subplots(figsize=(10, 5))
         posts_over_time.plot(kind='line', ax=ax, marker='o', linestyle='-')
@@ -74,11 +68,8 @@ def generate_posts_activity_plot(df, date_column='published_at'): # Default chan
     finally:
         plt.close('all') 
 
-def generate_engagement_type_plot(df, likes_col='likes_count', comments_col='comments_count', shares_col='shares_count'):
-    """
-    Generates a bar plot for total engagement types (likes, comments, shares).
-    Input df is expected to be pre-filtered by date if necessary.
-    """
+def generate_engagement_type_plot(df, likes_col='likeCount', comments_col='commentCount', shares_col='shareCount'): # Updated col names
+    """Generates a bar plot for total engagement types (likes, comments, shares)."""
     logging.info(f"Generating engagement type plot. Input df rows: {len(df) if df is not None else 'None'}")
     
     required_cols = [likes_col, comments_col, shares_col]
@@ -93,8 +84,8 @@ def generate_engagement_type_plot(df, likes_col='likes_count', comments_col='com
         return create_placeholder_plot(title="Post Engagement Types", message=msg)
 
     try:
-        df_copy = df.copy() # Work on a copy
-        for col in required_cols: # Ensure numeric, fill NaNs with 0
+        df_copy = df.copy() 
+        for col in required_cols: 
             df_copy[col] = pd.to_numeric(df_copy[col], errors='coerce').fillna(0)
 
         total_likes = df_copy[likes_col].sum()
@@ -131,19 +122,16 @@ def generate_engagement_type_plot(df, likes_col='likes_count', comments_col='com
     finally:
         plt.close('all')
 
-def generate_mentions_activity_plot(df, date_column='date'): # Default changed as per common use
-    """
-    Generates a plot for mentions activity over time.
-    Assumes df has a date_column (e.g., 'date') and groups by date to count mentions.
-    """
+def generate_mentions_activity_plot(df, date_column='date'):
+    """Generates a plot for mentions activity over time."""
     logging.info(f"Generating mentions activity plot. Date column: '{date_column}'. Input df rows: {len(df) if df is not None else 'None'}")
     if df is None or df.empty:
         logging.warning(f"Mentions activity: DataFrame is empty.")
         return create_placeholder_plot(title="Mentions Activity Over Time", message="No data available for the selected period.")
     if date_column not in df.columns:
-        logging.warning(f"Mentions activity: Date column '{date_column}' is missing from DataFrame columns: {df.columns.tolist()}.")
+        logging.warning(f"Mentions activity: Date column '{date_column}' is missing. Cols: {df.columns.tolist()}.")
         return create_placeholder_plot(title="Mentions Activity Over Time", message=f"Date column '{date_column}' not found.")
-        
+            
     try:
         df_copy = df.copy()
         if not pd.api.types.is_datetime64_any_dtype(df_copy[date_column]):
@@ -177,10 +165,7 @@ def generate_mentions_activity_plot(df, date_column='date'): # Default changed a
         plt.close('all')
 
 def generate_mention_sentiment_plot(df, sentiment_column='sentiment_label'): 
-    """
-    Generates a pie chart for mention sentiment distribution.
-    Input df is expected to be pre-filtered by date if necessary.
-    """
+    """Generates a pie chart for mention sentiment distribution."""
     logging.info(f"Generating mention sentiment plot. Sentiment column: '{sentiment_column}'. Input df rows: {len(df) if df is not None else 'None'}")
     
     if df is None or df.empty:
@@ -199,8 +184,12 @@ def generate_mention_sentiment_plot(df, sentiment_column='sentiment_label'):
             return create_placeholder_plot(title="Mention Sentiment Distribution", message="No sentiment data available.")
 
         fig, ax = plt.subplots(figsize=(8, 5))
-        colors = {'Positive': 'lightgreen', 'Negative': 'salmon', 'Neutral': 'lightskyblue', 'Mixed': 'gold'}
-        pie_colors = [colors.get(label, '#cccccc') for label in sentiment_counts.index] # Default color for unknown sentiments
+        # Define a broader range of colors or a colormap for more sentiment types
+        colors_map = plt.cm.get_cmap('viridis', len(sentiment_counts))
+        pie_colors = [colors_map(i) for i in range(len(sentiment_counts))]
+        # Or keep your specific colors if sentiment labels are fixed:
+        # colors = {'Positive': 'lightgreen', 'Negative': 'salmon', 'Neutral': 'lightskyblue', 'Mixed': 'gold'}
+        # pie_colors = [colors.get(label, '#cccccc') for label in sentiment_counts.index]
 
 
         ax.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', startangle=90, colors=pie_colors)
@@ -215,104 +204,405 @@ def generate_mention_sentiment_plot(df, sentiment_column='sentiment_label'):
     finally:
         plt.close('all')
 
-def generate_follower_growth_plot(df, date_column='date', count_column='total_followers'): 
-    """
-    Generates a plot for follower growth over time.
-    This function receives the *unfiltered* follower DataFrame.
-    """
-    logging.info(f"Generating follower growth plot. Date col: '{date_column}', Count col: '{count_column}'. Input df rows: {len(df) if df is not None else 'None'}")
-
+# --- Existing Follower Growth Plot (can be reused or adapted) ---
+def generate_total_follower_growth_plot(df, date_column='date', count_column='total_followers'): 
+    """ Generates a plot for TOTAL follower growth over time. """
+    # This is your existing function, ensure it's called with the correct data for overall growth.
+    # For 'Follower Count Over Time (follower_gains_monthly)', we'll make a new specific one if structure differs.
+    logging.info(f"Generating total follower growth plot. Date col: '{date_column}', Count col: '{count_column}'. DF rows: {len(df) if df is not None else 'None'}")
     if df is None or df.empty:
-        logging.warning("Follower growth: DataFrame is empty.")
-        return create_placeholder_plot(title="Follower Growth Over Time", message="No follower data available.")
+        return create_placeholder_plot(title="Total Follower Growth", message="No follower data.")
     if date_column not in df.columns or count_column not in df.columns:
-        missing = []
-        if date_column not in df.columns: missing.append(date_column)
-        if count_column not in df.columns: missing.append(count_column)
-        msg = f"Follower growth: Columns missing: {missing}. Available: {df.columns.tolist()}"
-        logging.warning(msg)
-        return create_placeholder_plot(title="Follower Growth Over Time", message=msg)
+        return create_placeholder_plot(title="Total Follower Growth", message=f"Missing columns: {date_column} or {count_column}.")
+    try:
+        df_copy = df.copy()
+        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        df_copy[count_column] = pd.to_numeric(df_copy[count_column], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, count_column]).sort_values(by=date_column)
+        if df_copy.empty:
+            return create_placeholder_plot(title="Total Follower Growth", message="No valid data after cleaning.")
+        
+        fig, ax = plt.subplots(figsize=(10,5))
+        ax.plot(df_copy[date_column], df_copy[count_column], marker='o', linestyle='-', color='green')
+        ax.set_title('Total Follower Growth Over Time')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Total Followers')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error in generate_total_follower_growth_plot: {e}", exc_info=True)
+        return create_placeholder_plot(title="Total Follower Growth Error", message=str(e))
+    finally:
+        plt.close('all')
+
+# --- New Plot Functions ---
+
+def generate_followers_count_over_time_plot(df, date_column='date', count_column='follower_count_o', type_filter_column='follower_count_type', type_value='follower_gains_monthly'):
+    """Generates a plot for specific follower counts over time (e.g., monthly gains)."""
+    title = f"Followers Count Over Time ({type_value})"
+    logging.info(f"Generating {title}. Date: '{date_column}', Count: '{count_column}', Type Filter: '{type_filter_column}=={type_value}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=title, message="No follower data available.")
+    
+    required_cols = [date_column, count_column, type_filter_column]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}.")
 
     try:
         df_copy = df.copy()
-        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')
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value]
+
+        if df_filtered.empty:
+            return create_placeholder_plot(title=title, message=f"No data for type '{type_value}'.")
+
+        df_filtered[date_column] = pd.to_datetime(df_filtered[date_column], errors='coerce')
+        df_filtered[count_column] = pd.to_numeric(df_filtered[count_column], errors='coerce')
+        df_filtered = df_filtered.dropna(subset=[date_column, count_column]).sort_values(by=date_column)
+
+        if df_filtered.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning and filtering.")
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(df_filtered[date_column], df_filtered[count_column], marker='o', linestyle='-', color='dodgerblue')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Follower Count')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    finally:
+        plt.close('all')
+
+def generate_followers_growth_rate_plot(df, date_column='date', count_column='follower_count_o', type_filter_column='follower_count_type', type_value='follower_gains_monthly'):
+    """Calculates and plots follower growth rate over time."""
+    title = f"Follower Growth Rate ({type_value})"
+    logging.info(f"Generating {title}. Date: '{date_column}', Count: '{count_column}', Type Filter: '{type_filter_column}=={type_value}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=title, message="No follower data available.")
+
+    required_cols = [date_column, count_column, type_filter_column]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}.")
         
-        df_copy[count_column] = pd.to_numeric(df_copy[count_column], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column, count_column])
+    try:
+        df_copy = df.copy()
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value]
+
+        if df_filtered.empty:
+            return create_placeholder_plot(title=title, message=f"No data for type '{type_value}'.")
+
+        df_filtered[date_column] = pd.to_datetime(df_filtered[date_column], errors='coerce')
+        df_filtered[count_column] = pd.to_numeric(df_filtered[count_column], errors='coerce')
+        df_filtered = df_filtered.dropna(subset=[date_column, count_column]).sort_values(by=date_column).set_index(date_column)
+
+        if df_filtered.empty or len(df_filtered) < 2:
+            return create_placeholder_plot(title=title, message="Not enough data points to calculate growth rate.")
+
+        # Calculate growth rate: (current - previous) / previous * 100
+        # Ensure previous is not zero to avoid division by zero
+        df_filtered['growth_rate'] = df_filtered[count_column].pct_change() * 100
+        # Replace inf with NaN (e.g. if previous was 0 and current is non-zero) then drop NaNs
+        df_filtered.replace([np.inf, -np.inf], np.nan, inplace=True)
+        df_filtered.dropna(subset=['growth_rate'], inplace=True)
+
+
+        if df_filtered.empty:
+            return create_placeholder_plot(title=title, message="No valid growth rate data after calculation.")
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(df_filtered.index, df_filtered['growth_rate'], marker='o', linestyle='-', color='lightcoral')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Growth Rate (%)')
+        ax.yaxis.set_major_formatter(mticker.PercentFormatter())
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    finally:
+        plt.close('all')
+
+def generate_followers_by_demographics_plot(df, category_col='category_name', count_column='follower_count_o', type_filter_column='follower_count_type', type_value=None, plot_title="Followers by Demographics"):
+    """Generates a bar chart for follower demographics (e.g., by location, industry)."""
+    logging.info(f"Generating {plot_title}. Category: '{category_col}', Count: '{count_column}', Type Filter: '{type_filter_column}=={type_value}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=plot_title, message="No follower data available.")
+    
+    required_cols = [category_col, count_column, type_filter_column]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=plot_title, message=f"Missing columns: {missing_cols}.")
+    
+    if type_value is None: # Should be specified
+        return create_placeholder_plot(title=plot_title, message="Demographic type (type_value) not specified.")
+
+    try:
+        df_copy = df.copy()
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value]
+
+        if df_filtered.empty:
+            return create_placeholder_plot(title=plot_title, message=f"No data for demographic type '{type_value}'.")
+
+        df_filtered[count_column] = pd.to_numeric(df_filtered[count_column], errors='coerce').fillna(0)
+        
+        # Group by the category column and sum the count column
+        demographics_data = df_filtered.groupby(category_col)[count_column].sum().sort_values(ascending=False)
+
+        if demographics_data.empty:
+            return create_placeholder_plot(title=plot_title, message="No demographic data to display after filtering and aggregation.")
+        
+        # Limit to top N for readability if too many categories
+        top_n = 10 
+        if len(demographics_data) > top_n:
+            demographics_data = demographics_data.head(top_n)
+            plot_title += f" (Top {top_n})"
+
+
+        fig, ax = plt.subplots(figsize=(10, 6) if len(demographics_data) > 5 else (8,5) )
+        demographics_data.plot(kind='bar', ax=ax, color='teal')
+        ax.set_title(plot_title)
+        ax.set_xlabel(category_col.replace('_', ' ').title())
+        ax.set_ylabel('Number of Followers')
+        ax.grid(axis='y', linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45, ha="right")
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating {plot_title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{plot_title} Error", message=str(e))
+    finally:
+        plt.close('all')
+
+
+def generate_engagement_rate_over_time_plot(df, date_column='published_at', engagement_rate_col='engagement'):
+    """Generates a plot for engagement rate over time."""
+    title = "Engagement Rate Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Rate Col: '{engagement_rate_col}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=title, message="No post data for engagement rate.")
+    
+    required_cols = [date_column, engagement_rate_col]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
+
+    try:
+        df_copy = df.copy()
+        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        # Assuming 'engagement' is already a rate (e.g., 0.05 for 5%). If it's an absolute count, this logic needs change.
+        df_copy[engagement_rate_col] = pd.to_numeric(df_copy[engagement_rate_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, engagement_rate_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning.")
+
+        # Resample daily and calculate mean engagement rate
+        engagement_over_time = df_copy.resample('D')[engagement_rate_col].mean()
+        engagement_over_time = engagement_over_time.dropna() # Remove days with no data after resampling
+
+        if engagement_over_time.empty:
+            return create_placeholder_plot(title=title, message="No engagement rate data to display after resampling.")
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(engagement_over_time.index, engagement_over_time.values, marker='.', linestyle='-', color='darkorange')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Engagement Rate')
+        ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1.0 if engagement_over_time.max() <=1 else 100.0)) # Adjust based on rate scale
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    finally:
+        plt.close('all')
+
+def generate_reach_over_time_plot(df, date_column='published_at', reach_col='clickCount'): # Using clickCount as proxy for Reach
+    """Generates a plot for reach (clicks) over time."""
+    title = "Reach Over Time (Clicks)"
+    logging.info(f"Generating {title}. Date: '{date_column}', Reach Col: '{reach_col}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=title, message="No post data for reach.")
+
+    required_cols = [date_column, reach_col]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
+
+    try:
+        df_copy = df.copy()
+        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        df_copy[reach_col] = pd.to_numeric(df_copy[reach_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, reach_col]).set_index(date_column)
 
         if df_copy.empty:
-            logging.info("Follower growth: DataFrame empty after NaNs dropped from date/count columns.")
-            return create_placeholder_plot(title="Follower Growth Over Time", message="No valid data for follower growth.")
+            return create_placeholder_plot(title=title, message="No valid data after cleaning.")
 
-        df_copy = df_copy.sort_values(by=date_column)
+        reach_over_time = df_copy.resample('D')[reach_col].sum()
         
+        if reach_over_time.empty and not df_copy.empty : # if original had data but resampling resulted in empty (e.g. all NaNs for sum)
+             pass # allow plot of zeros if that's the case
+        elif reach_over_time.sum() == 0 and not df_copy.empty : # if all values are zero
+             pass
+
+
         fig, ax = plt.subplots(figsize=(10, 5))
-        ax.plot(df_copy[date_column], df_copy[count_column], marker='o', linestyle='-', color='green')
-        ax.set_title('Follower Growth Over Time')
+        ax.plot(reach_over_time.index, reach_over_time.values, marker='.', linestyle='-', color='mediumseagreen')
+        ax.set_title(title)
         ax.set_xlabel('Date')
-        ax.set_ylabel('Total Followers')
+        ax.set_ylabel('Total Clicks')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    finally:
+        plt.close('all')
+
+def generate_impressions_over_time_plot(df, date_column='published_at', impressions_col='impressionCount'):
+    """Generates a plot for impressions over time."""
+    title = "Impressions Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Impressions Col: '{impressions_col}'. DF rows: {len(df) if df is not None else 'None'}")
+
+    if df is None or df.empty:
+        return create_placeholder_plot(title=title, message="No post data for impressions.")
+
+    required_cols = [date_column, impressions_col]
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
+
+    try:
+        df_copy = df.copy()
+        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        df_copy[impressions_col] = pd.to_numeric(df_copy[impressions_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, impressions_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning.")
+
+        impressions_over_time = df_copy.resample('D')[impressions_col].sum()
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(impressions_over_time.index, impressions_over_time.values, marker='.', linestyle='-', color='slateblue')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Total Impressions')
         ax.grid(True, linestyle='--', alpha=0.7)
         plt.xticks(rotation=45)
         plt.tight_layout()
-        logging.info("Successfully generated follower growth plot.")
         return fig
     except Exception as e:
-        logging.error(f"Error generating follower growth plot: {e}", exc_info=True)
-        return create_placeholder_plot(title="Follower Growth Error", message=str(e))
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
     finally:
         plt.close('all')
 
+
 if __name__ == '__main__':
     # Create dummy data for testing
+    # Posts Data (merged with stats)
     posts_data = {
-        'published_at': pd.to_datetime(['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-03', '2023-01-03', '2023-01-03']),
-        'likes_count': [10, 5, 12, 8, 15, 3],
-        'comments_count': [2, 1, 3, 1, 4, 0],
-        'shares_count': [1, 0, 1, 1, 2, 0]
-    }
-    sample_posts_df = pd.DataFrame(posts_data)
-
-    mentions_data = {
-        'date': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03']),
-        'sentiment_label': ['Positive', 'Negative', 'Positive', 'Neutral']
+        'id': [f'post{i}' for i in range(1, 7)],
+        'published_at': pd.to_datetime(['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-03', '2023-01-03', '2023-01-03', '2023-01-04']),
+        'likeCount': [10, 5, 12, 8, 15, 3, 20],
+        'commentCount': [2, 1, 3, 1, 4, 0, 5],
+        'shareCount': [1, 0, 1, 1, 2, 0, 1],
+        'clickCount': [20, 15, 30, 22, 40, 10, 50],
+        'impressionCount': [200, 150, 300, 220, 400, 100, 500],
+        'engagement': [0.05, 0.04, 0.06, 0.055, 0.07, 0.03, 0.08] # Engagement Rate
     }
-    sample_mentions_df = pd.DataFrame(mentions_data)
+    sample_merged_posts_df = pd.DataFrame(posts_data)
 
+    # Follower Stats Data
     follower_data = {
-        'date': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05']),
-        'total_followers': [100, 105, 115, 120, 118] # Example data
+        'date': pd.to_datetime(['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15', '2023-03-01', # For time series
+                                '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01', # For demographics (snapshot)
+                                '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01',
+                                '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01', '2023-03-01'
+                                ]),
+        'follower_count_type': ['follower_gains_monthly', 'follower_gains_monthly', 'follower_gains_monthly', 'follower_gains_monthly', 'follower_gains_monthly',
+                                'follower_geo', 'follower_geo', 'follower_geo', # Location
+                                'follower_function', 'follower_function', 'follower_function', # Role
+                                'follower_industry', 'follower_industry', 'follower_industry', # Industry
+                                'follower_seniority', 'follower_seniority', 'follower_seniority', # Seniority
+                                'total_followers_snapshot', 'total_followers_snapshot', 'total_followers_snapshot' # For existing total growth
+                                ],
+        'category_name': ['Jan', 'Jan-Mid', 'Feb', 'Feb-Mid', 'Mar', # Corresponds to follower_gains_monthly
+                          'USA', 'Canada', 'UK',                     # Geo
+                          'Engineering', 'Sales', 'Marketing',        # Function/Role
+                          'Tech', 'Finance', 'Healthcare',           # Industry
+                          'Senior', 'Junior', 'Manager',             # Seniority
+                          'Overall1', 'Overall2', 'Overall3'         # For total_followers_snapshot
+                         ],
+        'follower_count_o': [100, 105, 115, 120, 130, # Counts for monthly gains
+                             500, 300, 200,          # Geo counts
+                             400, 350, 250,          # Role counts
+                             600, 200, 200,          # Industry counts
+                             300, 400, 300,          # Seniority counts
+                             1000, 1010, 1025        # For total_followers_snapshot
+                            ],
+        'total_followers': [None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,None,100,115,130] # For existing total growth plot
     }
     sample_follower_stats_df = pd.DataFrame(follower_data)
+    # Ensure 'total_followers' for generate_total_follower_growth_plot is correctly populated for its specific rows
+    sample_follower_stats_df.loc[sample_follower_stats_df['follower_count_type'] == 'total_followers_snapshot', 'total_followers'] = sample_follower_stats_df['follower_count_o']
 
-    logging.info("--- Testing Plot Generations ---")
 
-    fig1 = generate_posts_activity_plot(sample_posts_df.copy(), date_column='published_at')
-    if fig1: logging.info("Posts activity plot generated.") # plt.show() for local test
+    logging.info("--- Testing New Plot Generations ---")
 
-    fig2 = generate_engagement_type_plot(sample_posts_df.copy())
-    if fig2: logging.info("Engagement type plot generated.")
+    fig_followers_count = generate_followers_count_over_time_plot(sample_follower_stats_df.copy(), date_column='date', count_column='follower_count_o', type_value='follower_gains_monthly')
+    if fig_followers_count: logging.info("Followers Count Over Time (monthly) plot generated.")
 
-    fig3 = generate_mentions_activity_plot(sample_mentions_df.copy(), date_column='date')
-    if fig3: logging.info("Mentions activity plot generated.")
+    fig_followers_rate = generate_followers_growth_rate_plot(sample_follower_stats_df.copy(), date_column='date', count_column='follower_count_o', type_value='follower_gains_monthly')
+    if fig_followers_rate: logging.info("Followers Growth Rate (monthly) plot generated.")
 
-    fig4 = generate_mention_sentiment_plot(sample_mentions_df.copy())
-    if fig4: logging.info("Mention sentiment plot generated.")
-    
-    fig5 = generate_follower_growth_plot(sample_follower_stats_df.copy(), date_column='date', count_column='total_followers')
-    if fig5: logging.info("Follower growth plot generated.")
-    
-    logging.info("--- Testing Placeholders ---")
-    fig_placeholder = create_placeholder_plot()
-    if fig_placeholder: logging.info("Placeholder plot generated.")
+    fig_geo = generate_followers_by_demographics_plot(sample_follower_stats_df.copy(), type_value='follower_geo', plot_title="Followers by Location")
+    if fig_geo: logging.info("Followers by Location plot generated.")
     
-    empty_df = pd.DataFrame(columns=['published_at']) # Empty df with column
-    fig_empty_posts = generate_posts_activity_plot(empty_df, date_column='published_at')
-    if fig_empty_posts: logging.info("Empty posts activity plot (placeholder) generated.")
+    fig_role = generate_followers_by_demographics_plot(sample_follower_stats_df.copy(), type_value='follower_function', plot_title="Followers by Role")
+    if fig_role: logging.info("Followers by Role plot generated.")
+
+    fig_industry = generate_followers_by_demographics_plot(sample_follower_stats_df.copy(), type_value='follower_industry', plot_title="Followers by Industry")
+    if fig_industry: logging.info("Followers by Industry plot generated.")
+
+    fig_seniority = generate_followers_by_demographics_plot(sample_follower_stats_df.copy(), type_value='follower_seniority', plot_title="Followers by Seniority")
+    if fig_seniority: logging.info("Followers by Seniority plot generated.")
+
+    fig_eng_rate = generate_engagement_rate_over_time_plot(sample_merged_posts_df.copy())
+    if fig_eng_rate: logging.info("Engagement Rate Over Time plot generated.")
+
+    fig_reach = generate_reach_over_time_plot(sample_merged_posts_df.copy())
+    if fig_reach: logging.info("Reach Over Time (Clicks) plot generated.")
+
+    fig_impressions = generate_impressions_over_time_plot(sample_merged_posts_df.copy())
+    if fig_impressions: logging.info("Impressions Over Time plot generated.")
     
-    df_no_col = pd.DataFrame({'some_other_date': pd.to_datetime(['2023-01-01'])})
-    fig_no_col_posts = generate_posts_activity_plot(df_no_col, date_column='published_at')
-    if fig_no_col_posts: logging.info("Posts activity with missing column (placeholder) generated.")
+    # Test existing total follower growth plot with appropriate data
+    total_followers_df = sample_follower_stats_df[sample_follower_stats_df['follower_count_type'] == 'total_followers_snapshot'].copy()
+    total_followers_df['date'] = pd.to_datetime(total_followers_df['date']) # Ensure date is datetime
+    fig_total_growth = generate_total_follower_growth_plot(total_followers_df, date_column='date', count_column='total_followers')
+    if fig_total_growth: logging.info("Total Follower Growth plot (existing function) generated.")
 
 
-    logging.info("Test script finished.")
+    logging.info("Test script finished. Review plots if displayed locally or saved.")