Update analytics_plot_generator.py

analytics_plot_generator.py

@@ -184,8 +184,13 @@ 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_map = plt.cm.get_cmap('viridis', len(sentiment_counts))
+        # Using a more distinct color map if available, or fallback
+        try:
+            colors_map = plt.cm.get_cmap('Pastel1', len(sentiment_counts))
+        except ValueError: # Fallback if Pastel1 doesn't have enough colors or isn't available
+            colors_map = plt.cm.get_cmap('viridis', len(sentiment_counts))
         pie_colors = [colors_map(i) for i in range(len(sentiment_counts))]
+        
         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') 
@@ -444,10 +449,10 @@ def generate_engagement_rate_over_time_plot(df, date_column='published_at', enga
         ax.set_xlabel('Date')
         ax.set_ylabel('Engagement Rate')
         # 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
+        max_rate_val = engagement_over_time.max() if not engagement_over_time.empty else 0
+        formatter_xmax = 1.0 if max_rate_val <= 1.5 and max_rate_val !=0 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
+            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)
@@ -520,7 +525,7 @@ def generate_impressions_over_time_plot(df, date_column='published_at', impressi
         df_copy = df_copy.dropna(subset=[date_column, impressions_col]).set_index(date_column)
 
         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.")
+            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()
 
@@ -539,21 +544,248 @@ def generate_impressions_over_time_plot(df, date_column='published_at', impressi
     finally:
         plt.close('all')
 
+# --- NEW PLOT FUNCTIONS ---
+
+def generate_likes_over_time_plot(df, date_column='published_at', likes_col='likeCount'):
+    """Generates a plot for likes (reactions) over time."""
+    title = "Reactions (Likes) Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Likes Col: '{likes_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 likes.")
+
+    required_cols = [date_column, likes_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[likes_col] = pd.to_numeric(df_copy[likes_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, likes_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning for likes plot.")
+
+        likes_over_time = df_copy.resample('D')[likes_col].sum()
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(likes_over_time.index, likes_over_time.values, marker='.', linestyle='-', color='crimson')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Total Likes')
+        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_clicks_over_time_plot(df, date_column='published_at', clicks_col='clickCount'):
+    """Generates a plot for clicks over time (distinct from general reach if needed)."""
+    title = "Clicks Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Clicks Col: '{clicks_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 clicks.")
+
+    required_cols = [date_column, clicks_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[clicks_col] = pd.to_numeric(df_copy[clicks_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, clicks_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning for clicks plot.")
+
+        clicks_over_time = df_copy.resample('D')[clicks_col].sum()
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(clicks_over_time.index, clicks_over_time.values, marker='.', linestyle='-', color='teal')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        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_shares_over_time_plot(df, date_column='published_at', shares_col='shareCount'):
+    """Generates a plot for shares over time."""
+    title = "Shares Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Shares Col: '{shares_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 shares.")
+
+    required_cols = [date_column, shares_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[shares_col] = pd.to_numeric(df_copy[shares_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, shares_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning for shares plot.")
+
+        shares_over_time = df_copy.resample('D')[shares_col].sum()
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(shares_over_time.index, shares_over_time.values, marker='.', linestyle='-', color='goldenrod')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Total Shares')
+        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_comments_over_time_plot(df, date_column='published_at', comments_col='commentCount'):
+    """Generates a plot for comments over time."""
+    title = "Comments Over Time"
+    logging.info(f"Generating {title}. Date: '{date_column}', Comments Col: '{comments_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 comments.")
+
+    required_cols = [date_column, comments_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[comments_col] = pd.to_numeric(df_copy[comments_col], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, comments_col]).set_index(date_column)
+
+        if df_copy.empty:
+            return create_placeholder_plot(title=title, message="No valid data after cleaning for comments plot.")
+
+        comments_over_time = df_copy.resample('D')[comments_col].sum()
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.plot(comments_over_time.index, comments_over_time.values, marker='.', linestyle='-', color='forestgreen')
+        ax.set_title(title)
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Total Comments')
+        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_comments_sentiment_breakdown_plot(df, sentiment_column='comment_sentiment', text_column_for_check='comment_text'):
+    """
+    Generates a pie chart for comment sentiment distribution.
+    Expects a DataFrame with a 'sentiment_column' for sentiment labels of individual comments.
+    'text_column_for_check' is used to infer if the DataFrame might contain comment-level data.
+    """
+    title = "Breakdown of Comments by Sentiment"
+    logging.info(f"Generating {title}. Sentiment Col: '{sentiment_column}'. 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 data available for comment sentiment analysis.")
+    
+    # Check if the expected sentiment column exists.
+    # Also check for a text column as a heuristic, as sentiment often comes with text.
+    if sentiment_column not in df.columns:
+        msg = (f"Column '{sentiment_column}' for comment sentiment not found. "
+               f"This plot requires a DataFrame with pre-analyzed comment sentiments. "
+               f"Available columns: {df.columns.tolist()}")
+        logging.warning(msg)
+        return create_placeholder_plot(title=title, message=msg)
+    
+    # Optional: A light check if it seems like post-level data instead of comment-level
+    # if text_column_for_check not in df.columns and 'commentCount' in df.columns:
+    #     logging.warning(f"'{sentiment_column}' found, but '{text_column_for_check}' is missing. Ensure '{sentiment_column}' refers to individual comment sentiments, not post sentiment.")
+
+
+    try:
+        df_copy = df.copy()
+        # Ensure sentiment column is treated as categorical/string
+        df_copy[sentiment_column] = df_copy[sentiment_column].astype(str)
+        sentiment_counts = df_copy[sentiment_column].value_counts()
+
+        if sentiment_counts.empty or sentiment_counts.sum() == 0:
+            return create_placeholder_plot(title=title, message="No comment sentiment data to display after processing.")
+
+        fig, ax = plt.subplots(figsize=(8, 5))
+        try:
+            colors_map = plt.cm.get_cmap('Pastel2', len(sentiment_counts))
+        except ValueError:
+            colors_map = plt.cm.get_cmap('Accent', len(sentiment_counts))
+
+        pie_colors = [colors_map(i) for i in range(len(sentiment_counts))]
+        
+        ax.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', startangle=140, colors=pie_colors)
+        ax.set_title(title)
+        ax.axis('equal') 
+        plt.tight_layout()
+        logging.info(f"Successfully generated {title} plot.")
+        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')
+
 
 if __name__ == '__main__':
     # Create dummy data for testing
     posts_data = {
-        'id': [f'post{i}' for i in range(1, 7)],
+        'id': [f'post{i}' for i in range(1, 8)], # Extended to 7 for more data points
         '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], # Assuming this is the correct column name from your data
+        '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] 
     }
     sample_merged_posts_df = pd.DataFrame(posts_data)
 
+    # Dummy data for comments with sentiment (hypothetical)
+    comments_sentiment_data = {
+        'comment_id': range(10),
+        'post_id': ['post1']*3 + ['post2']*2 + ['post3']*5,
+        'comment_text': ['Great post!', 'I disagree.', 'Nice work.', 'Interesting.', 'Could be better.', 'Loved it!', 'Not sure.', 'Thanks!', 'Helpful.', 'Okay.'],
+        'comment_sentiment': ['Positive', 'Negative', 'Positive', 'Neutral', 'Negative', 'Positive', 'Neutral', 'Positive', 'Positive', 'Neutral']
+    }
+    sample_comments_with_sentiment_df = pd.DataFrame(comments_sentiment_data)
+
+
     # Updated Follower Stats Data
     follower_data = {
         'follower_count_type': [
@@ -566,24 +798,24 @@ if __name__ == '__main__':
         # '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
+            '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
+            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
+            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)
@@ -594,48 +826,48 @@ if __name__ == '__main__':
         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.")
+    if fig_followers_count and not isinstance(fig_followers_count, str): 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.")
+    if fig_followers_rate and not isinstance(fig_followers_rate, str): 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.")
+    if fig_geo and not isinstance(fig_geo, str): 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 (Organic/Paid)"
     )
-    if fig_role: logging.info("Followers by Role (grouped organic/paid) plot generated.")
+    if fig_role and not isinstance(fig_role, str): 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.")
+    if fig_industry and not isinstance(fig_industry, str): 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.")
+    if fig_seniority and not isinstance(fig_seniority, str): 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.")
+    if fig_posts_activity and not isinstance(fig_posts_activity, str): 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.")
+    if fig_engagement_type and not isinstance(fig_engagement_type, str): logging.info("Engagement type plot generated.")
 
     # Dummy mentions for testing
     mentions_data = {
@@ -644,17 +876,37 @@ if __name__ == '__main__':
     }
     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.")
+    if fig_mentions_activity and not isinstance(fig_mentions_activity, str): 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.")
+    if fig_mention_sentiment and not isinstance(fig_mention_sentiment, str): 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.")
+    if fig_eng_rate and not isinstance(fig_eng_rate, str): 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.")
+    if fig_reach and not isinstance(fig_reach, str): 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.")
+    if fig_impressions and not isinstance(fig_impressions, str): logging.info("Impressions Over Time plot generated.")
+
+    logging.info("--- Testing NEW Plot Generations ---")
+    fig_likes_time = generate_likes_over_time_plot(sample_merged_posts_df.copy())
+    if fig_likes_time and not isinstance(fig_likes_time, str): logging.info("Likes Over Time plot generated.")
+
+    fig_clicks_time = generate_clicks_over_time_plot(sample_merged_posts_df.copy())
+    if fig_clicks_time and not isinstance(fig_clicks_time, str): logging.info("Clicks Over Time plot generated.")
+
+    fig_shares_time = generate_shares_over_time_plot(sample_merged_posts_df.copy())
+    if fig_shares_time and not isinstance(fig_shares_time, str): logging.info("Shares Over Time plot generated.")
+
+    fig_comments_time = generate_comments_over_time_plot(sample_merged_posts_df.copy())
+    if fig_comments_time and not isinstance(fig_comments_time, str): logging.info("Comments Over Time plot generated.")
+
+    fig_comments_sentiment = generate_comments_sentiment_breakdown_plot(sample_comments_with_sentiment_df.copy())
+    if fig_comments_sentiment and not isinstance(fig_comments_sentiment, str): logging.info("Comments Sentiment Breakdown plot generated (with dummy comment sentiment data).")
+    
+    fig_comments_sentiment_no_data = generate_comments_sentiment_breakdown_plot(sample_merged_posts_df.copy()) # Test with df lacking the sentiment col
+    if fig_comments_sentiment_no_data and not isinstance(fig_comments_sentiment_no_data, str) : logging.info("Comments Sentiment Breakdown plot generated (placeholder, as expected).")
+
 
     logging.info("Test script finished. Review plots if displayed locally or saved.")