Update analytics_plot_generator.py

analytics_plot_generator.py

@@ -184,14 +184,8 @@ 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))
-        # 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)
         ax.set_title('Mention Sentiment Distribution')
         ax.axis('equal') 
@@ -204,73 +198,54 @@ def generate_mention_sentiment_plot(df, sentiment_column='sentiment_label'):
     finally:
         plt.close('all')
 
-# --- 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:
-        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:
-        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)."""
+# --- Updated Follower Plot Functions ---
+
+def generate_followers_count_over_time_plot(df, date_info_column='category_name', 
+                                            organic_count_col='follower_count_organic', 
+                                            paid_count_col='follower_count_paid',
+                                            type_filter_column='follower_count_type', 
+                                            type_value='follower_gains_monthly'):
+    """
+    Generates a plot for specific follower counts (organic and paid) over time.
+    Date information is expected in 'date_info_column' as strings (e.g., "2024-08-01").
+    """
     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'}")
+    logging.info(f"Generating {title}. Date Info: '{date_info_column}', Organic: '{organic_count_col}', Paid: '{paid_count_col}', 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]
+    required_cols = [date_info_column, organic_count_col, paid_count_col, 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}.")
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
 
     try:
         df_copy = df.copy()
-        df_filtered = df_copy[df_copy[type_filter_column] == type_value]
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value].copy() # Use .copy() to avoid SettingWithCopyWarning
 
         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)
+        # Convert date_info_column to datetime
+        df_filtered['datetime_obj'] = pd.to_datetime(df_filtered[date_info_column], errors='coerce')
+        
+        df_filtered[organic_count_col] = pd.to_numeric(df_filtered[organic_count_col], errors='coerce').fillna(0)
+        df_filtered[paid_count_col] = pd.to_numeric(df_filtered[paid_count_col], errors='coerce').fillna(0)
+        
+        df_filtered = df_filtered.dropna(subset=['datetime_obj', organic_count_col, paid_count_col]).sort_values(by='datetime_obj')
 
         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.plot(df_filtered['datetime_obj'], df_filtered[organic_count_col], marker='o', linestyle='-', color='dodgerblue', label='Organic Followers')
+        ax.plot(df_filtered['datetime_obj'], df_filtered[paid_count_col], marker='x', linestyle='--', color='seagreen', label='Paid Followers')
+        
         ax.set_title(title)
         ax.set_xlabel('Date')
         ax.set_ylabel('Follower Count')
+        ax.legend()
         ax.grid(True, linestyle='--', alpha=0.7)
         plt.xticks(rotation=45)
         plt.tight_layout()
@@ -281,50 +256,69 @@ def generate_followers_count_over_time_plot(df, date_column='date', count_column
     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."""
+def generate_followers_growth_rate_plot(df, date_info_column='category_name', 
+                                        organic_count_col='follower_count_organic', 
+                                        paid_count_col='follower_count_paid',
+                                        type_filter_column='follower_count_type', 
+                                        type_value='follower_gains_monthly'):
+    """
+    Calculates and plots follower growth rate (organic and paid) over time.
+    Date information is expected in 'date_info_column' as strings (e.g., "2024-08-01").
+    """
     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'}")
+    logging.info(f"Generating {title}. Date Info: '{date_info_column}', Organic: '{organic_count_col}', Paid: '{paid_count_col}', 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]
+    required_cols = [date_info_column, organic_count_col, paid_count_col, 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}.")
+        return create_placeholder_plot(title=title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
         
     try:
         df_copy = df.copy()
-        df_filtered = df_copy[df_copy[type_filter_column] == type_value]
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value].copy()
 
         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)
+        df_filtered['datetime_obj'] = pd.to_datetime(df_filtered[date_info_column], errors='coerce')
+        df_filtered[organic_count_col] = pd.to_numeric(df_filtered[organic_count_col], errors='coerce')
+        df_filtered[paid_count_col] = pd.to_numeric(df_filtered[paid_count_col], errors='coerce')
+        
+        df_filtered = df_filtered.dropna(subset=['datetime_obj']).sort_values(by='datetime_obj').set_index('datetime_obj')
 
-        if df_filtered.empty or len(df_filtered) < 2:
+        if df_filtered.empty or len(df_filtered) < 2: # Need at least 2 points for pct_change
             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['organic_growth_rate'] = df_filtered[organic_count_col].pct_change() * 100
+        df_filtered['paid_growth_rate'] = df_filtered[paid_count_col].pct_change() * 100
+        
+        # Replace inf with NaN then drop NaNs for growth rates
         df_filtered.replace([np.inf, -np.inf], np.nan, inplace=True)
-        df_filtered.dropna(subset=['growth_rate'], inplace=True)
+        # df_filtered.dropna(subset=['organic_growth_rate', 'paid_growth_rate'], how='all', inplace=True) # Keep row if at least one rate is valid
 
+        fig, ax = plt.subplots(figsize=(10, 5))
+        
+        plotted_organic = False
+        if 'organic_growth_rate' in df_filtered.columns and not df_filtered['organic_growth_rate'].dropna().empty:
+            ax.plot(df_filtered.index, df_filtered['organic_growth_rate'], marker='o', linestyle='-', color='lightcoral', label='Organic Growth Rate')
+            plotted_organic = True
+            
+        plotted_paid = False
+        if 'paid_growth_rate' in df_filtered.columns and not df_filtered['paid_growth_rate'].dropna().empty:
+            ax.plot(df_filtered.index, df_filtered['paid_growth_rate'], marker='x', linestyle='--', color='mediumpurple', label='Paid Growth Rate')
+            plotted_paid = True
 
-        if df_filtered.empty:
-            return create_placeholder_plot(title=title, message="No valid growth rate data after calculation.")
+        if not plotted_organic and not plotted_paid:
+            return create_placeholder_plot(title=title, message="No valid growth rate data to display 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.legend()
         ax.grid(True, linestyle='--', alpha=0.7)
         plt.xticks(rotation=45)
         plt.tight_layout()
@@ -335,50 +329,78 @@ def generate_followers_growth_rate_plot(df, date_column='date', count_column='fo
     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'}")
+def generate_followers_by_demographics_plot(df, category_col='category_name', 
+                                            organic_count_col='follower_count_organic', 
+                                            paid_count_col='follower_count_paid',
+                                            type_filter_column='follower_count_type', 
+                                            type_value=None, plot_title="Followers by Demographics"):
+    """
+    Generates a grouped bar chart for follower demographics (organic and paid).
+    'category_col' here is the demographic attribute (e.g., Location, Industry).
+    """
+    logging.info(f"Generating {plot_title}. Category: '{category_col}', Organic: '{organic_count_col}', Paid: '{paid_count_col}', 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]
+    required_cols = [category_col, organic_count_col, paid_count_col, 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}.")
+        return create_placeholder_plot(title=plot_title, message=f"Missing columns: {missing_cols}. Available: {df.columns.tolist()}")
     
-    if type_value is None: # Should be specified
+    if type_value is None: 
         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]
+        df_filtered = df_copy[df_copy[type_filter_column] == type_value].copy()
 
         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)
+        df_filtered[organic_count_col] = pd.to_numeric(df_filtered[organic_count_col], errors='coerce').fillna(0)
+        df_filtered[paid_count_col] = pd.to_numeric(df_filtered[paid_count_col], 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)
+        demographics_data = df_filtered.groupby(category_col)[[organic_count_col, paid_count_col]].sum()
+        # Sort by total followers (organic + paid) for better visualization
+        demographics_data['total_for_sort'] = demographics_data[organic_count_col] + demographics_data[paid_count_col]
+        demographics_data = demographics_data.sort_values(by='total_for_sort', ascending=False).drop(columns=['total_for_sort'])
+
 
         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})"
+            plot_title_updated = f"{plot_title} (Top {top_n})"
+        else:
+            plot_title_updated = plot_title
 
+        fig, ax = plt.subplots(figsize=(12, 7) if len(demographics_data) > 5 else (10,6) )
+        
+        bar_width = 0.35
+        index = np.arange(len(demographics_data.index))
 
-        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)
+        bars1 = ax.bar(index - bar_width/2, demographics_data[organic_count_col], bar_width, label='Organic', color='skyblue')
+        bars2 = ax.bar(index + bar_width/2, demographics_data[paid_count_col], bar_width, label='Paid', color='lightcoral')
+
+        ax.set_title(plot_title_updated)
         ax.set_xlabel(category_col.replace('_', ' ').title())
         ax.set_ylabel('Number of Followers')
+        ax.set_xticks(index)
+        ax.set_xticklabels(demographics_data.index, rotation=45, ha="right")
+        ax.legend()
         ax.grid(axis='y', linestyle='--', alpha=0.7)
-        plt.xticks(rotation=45, ha="right")
+        
+        # Add labels on top of bars
+        for bar_group in [bars1, bars2]:
+            for bar in bar_group:
+                yval = bar.get_height()
+                if yval > 0: # Only add label if value is not zero
+                    ax.text(bar.get_x() + bar.get_width()/2.0, yval + (0.01 * ax.get_ylim()[1]), 
+                            str(int(yval)), ha='center', va='bottom', fontsize=8)
+
         plt.tight_layout()
         return fig
     except Exception as e:
@@ -404,16 +426,14 @@ def generate_engagement_rate_over_time_plot(df, date_column='published_at', enga
     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
+        engagement_over_time = engagement_over_time.dropna() 
 
         if engagement_over_time.empty:
             return create_placeholder_plot(title=title, message="No engagement rate data to display after resampling.")
@@ -423,7 +443,12 @@ def generate_engagement_rate_over_time_plot(df, date_column='published_at', enga
         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
+        # Adjust xmax for PercentFormatter based on whether rate is 0-1 or 0-100
+        max_rate_val = engagement_over_time.max()
+        formatter_xmax = 1.0 if max_rate_val <= 1.5 else 100.0 # Heuristic: if max is small, assume 0-1 scale
+        if max_rate_val > 100 and formatter_xmax == 1.0: # If data is clearly > 100 but we assumed 0-1
+             formatter_xmax = max_rate_val # Or some other sensible upper bound for formatting
+        ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=formatter_xmax)) 
         ax.grid(True, linestyle='--', alpha=0.7)
         plt.xticks(rotation=45)
         plt.tight_layout()
@@ -434,7 +459,7 @@ def generate_engagement_rate_over_time_plot(df, date_column='published_at', enga
     finally:
         plt.close('all')
 
-def generate_reach_over_time_plot(df, date_column='published_at', reach_col='clickCount'): # Using clickCount as proxy for Reach
+def generate_reach_over_time_plot(df, date_column='published_at', reach_col='clickCount'): 
     """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'}")
@@ -453,16 +478,12 @@ def generate_reach_over_time_plot(df, date_column='published_at', reach_col='cli
         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:
-            return create_placeholder_plot(title=title, message="No valid data after cleaning.")
+        if df_copy.empty: # After dropping NaNs for essential columns
+            return create_placeholder_plot(title=title, message="No valid data after cleaning for reach plot.")
 
         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
-
+        # No need to check if reach_over_time is empty if df_copy wasn't, sum of NaNs is 0.
+        # Plot will show 0 if all sums are 0.
 
         fig, ax = plt.subplots(figsize=(10, 5))
         ax.plot(reach_over_time.index, reach_over_time.values, marker='.', linestyle='-', color='mediumseagreen')
@@ -498,8 +519,8 @@ def generate_impressions_over_time_plot(df, date_column='published_at', impressi
         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.")
+        if df_copy.empty: # After dropping NaNs for essential columns
+             return create_placeholder_plot(title=title, message="No valid data after cleaning for impressions plot.")
 
         impressions_over_time = df_copy.resample('D')[impressions_col].sum()
 
@@ -521,73 +542,111 @@ def generate_impressions_over_time_plot(df, date_column='published_at', impressi
 
 if __name__ == '__main__':
     # Create dummy data for testing
-    # Posts Data (merged with stats)
     posts_data = {
         '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],
+        'shareCount': [1, 0, 1, 1, 2, 0, 1], # Assuming this is the correct column name from your data
         '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
+        'engagement': [0.05, 0.04, 0.06, 0.055, 0.07, 0.03, 0.08] 
     }
     sample_merged_posts_df = pd.DataFrame(posts_data)
 
-    # Follower Stats Data
+    # Updated Follower Stats Data
     follower_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
+        'follower_count_type': [
+            'follower_gains_monthly', 'follower_gains_monthly', 'follower_gains_monthly', 
+            'follower_geo', 'follower_geo', 'follower_geo',
+            'follower_function', 'follower_function',
+            'follower_industry', 'follower_industry',
+            'follower_seniority', 'follower_seniority'
+        ],
+        # 'category_name' now holds dates for time-series, and actual categories for demographics
+        'category_name': [
+            '2024-01-01', '2024-02-01', '2024-03-01', # Dates for monthly gains
+            'USA', 'Canada', 'UK',                     # Geo
+            'Engineering', 'Sales',                   # Function/Role
+            'Tech', 'Finance',                        # Industry
+            'Senior', 'Junior'                        # Seniority
+        ],
+        'follower_count_organic': [
+            100, 110, 125,      # Organic monthly gains
+            500, 300, 150,      # Organic Geo counts
+            400, 200,           # Organic Role counts
+            250, 180,           # Organic Industry counts
+            300, 220            # Organic Seniority counts
+        ],
+        'follower_count_paid': [
+            20, 30, 25,         # Paid monthly gains
+            50, 40, 60,         # Paid Geo counts
+            30, 20,             # Paid Role counts
+            45, 35,             # Paid Industry counts
+            60, 40              # Paid Seniority counts
+        ]
     }
     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 New Plot Generations ---")
-
-    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.")
 
-    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.")
-
-    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.")
+    logging.info("--- Testing Updated Follower Plot Generations ---")
+
+    fig_followers_count = generate_followers_count_over_time_plot(
+        sample_follower_stats_df.copy(), 
+        type_value='follower_gains_monthly' # date_info_column defaults to 'category_name'
+    )
+    if fig_followers_count: logging.info("Followers Count Over Time (monthly, organic/paid) plot generated.")
+
+    fig_followers_rate = generate_followers_growth_rate_plot(
+        sample_follower_stats_df.copy(),
+        type_value='follower_gains_monthly' # date_info_column defaults to 'category_name'
+    )
+    if fig_followers_rate: logging.info("Followers Growth Rate (monthly, organic/paid) plot generated.")
+
+    fig_geo = generate_followers_by_demographics_plot(
+        sample_follower_stats_df.copy(), 
+        type_value='follower_geo', # category_col defaults to 'category_name'
+        plot_title="Followers by Location (Organic/Paid)"
+    )
+    if fig_geo: logging.info("Followers by Location (grouped organic/paid) plot 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_role = generate_followers_by_demographics_plot(
+        sample_follower_stats_df.copy(), 
+        type_value='follower_function', 
+        plot_title="Followers by Role (Organic/Paid)"
+    )
+    if fig_role: logging.info("Followers by Role (grouped organic/paid) plot generated.")
+
+    fig_industry = generate_followers_by_demographics_plot(
+        sample_follower_stats_df.copy(), 
+        type_value='follower_industry', 
+        plot_title="Followers by Industry (Organic/Paid)"
+    )
+    if fig_industry: logging.info("Followers by Industry (grouped organic/paid) plot generated.")
+
+    fig_seniority = generate_followers_by_demographics_plot(
+        sample_follower_stats_df.copy(), 
+        type_value='follower_seniority', 
+        plot_title="Followers by Seniority (Organic/Paid)"
+    )
+    if fig_seniority: logging.info("Followers by Seniority (grouped organic/paid) plot generated.")
+
+    logging.info("--- Testing Other Plot Generations (No Changes to these) ---")
+    fig_posts_activity = generate_posts_activity_plot(sample_merged_posts_df.copy())
+    if fig_posts_activity: logging.info("Posts activity plot generated.")
+    
+    fig_engagement_type = generate_engagement_type_plot(sample_merged_posts_df.copy())
+    if fig_engagement_type: logging.info("Engagement type 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.")
+    # Dummy mentions for testing
+    mentions_data = {
+        'date': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03']),
+        'sentiment_label': ['Positive', 'Negative', 'Positive', 'Neutral']
+    }
+    sample_mentions_df = pd.DataFrame(mentions_data)
+    fig_mentions_activity = generate_mentions_activity_plot(sample_mentions_df.copy())
+    if fig_mentions_activity: logging.info("Mentions activity plot generated.")
+    fig_mention_sentiment = generate_mention_sentiment_plot(sample_mentions_df.copy())
+    if fig_mention_sentiment: logging.info("Mention sentiment 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.")
@@ -597,12 +656,5 @@ if __name__ == '__main__':
 
     fig_impressions = generate_impressions_over_time_plot(sample_merged_posts_df.copy())
     if fig_impressions: logging.info("Impressions Over Time plot 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. Review plots if displayed locally or saved.")