Create analytics_plot_generators.py

analytics_plot_generators.py

@@ -0,0 +1,318 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import logging
+from io import BytesIO
+import base64
+import numpy as np
+
+# Configure logging for this module
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
+
+def create_placeholder_plot(title="No Data or Plot Error", message="Data might be empty or an error occurred."):
+    """Creates a placeholder Matplotlib plot indicating no data or an error."""
+    try:
+        fig, ax = plt.subplots(figsize=(8, 4)) 
+        ax.text(0.5, 0.5, f"{title}\n{message}", ha='center', va='center', fontsize=10, wrap=True)
+        ax.axis('off') 
+        plt.tight_layout()
+        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.
+    """
+    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()}.")
+        return create_placeholder_plot(title="Posts 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]):
+            df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        
+        df_copy = df_copy.dropna(subset=[date_column])
+        if df_copy.empty:
+            logging.info("Posts activity: DataFrame empty after NaNs dropped from date column.")
+            return create_placeholder_plot(title="Posts Activity Over Time", message="No valid date entries found.")
+
+        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.")
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        posts_over_time.plot(kind='line', ax=ax, marker='o', linestyle='-')
+        ax.set_title('Posts Activity Over Time')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Number of Posts')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        logging.info("Successfully generated posts activity plot.")
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating posts activity plot: {e}", exc_info=True)
+        return create_placeholder_plot(title="Posts Activity Error", message=str(e))
+    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.
+    """
+    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]
+    if df is None or df.empty:
+        logging.warning("Engagement type: DataFrame is empty.")
+        return create_placeholder_plot(title="Post Engagement Types", message="No data available for the selected period.")
+    
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    if missing_cols:
+        msg = f"Engagement type: Columns missing: {missing_cols}. Available: {df.columns.tolist()}"
+        logging.warning(msg)
+        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[col] = pd.to_numeric(df_copy[col], errors='coerce').fillna(0)
+
+        total_likes = df_copy[likes_col].sum()
+        total_comments = df_copy[comments_col].sum()
+        total_shares = df_copy[shares_col].sum()
+
+        if total_likes == 0 and total_comments == 0 and total_shares == 0:
+            logging.info("Engagement type: All engagement counts are zero.")
+            return create_placeholder_plot(title="Post Engagement Types", message="No engagement data (likes, comments, shares) in the selected period.")
+
+        engagement_data = {
+            'Likes': total_likes,
+            'Comments': total_comments,
+            'Shares': total_shares
+        }
+        
+        fig, ax = plt.subplots(figsize=(8, 5))
+        bars = ax.bar(engagement_data.keys(), engagement_data.values(), color=['skyblue', 'lightgreen', 'salmon'])
+        ax.set_title('Total Post Engagement Types')
+        ax.set_xlabel('Engagement Type')
+        ax.set_ylabel('Total Count')
+        ax.grid(axis='y', linestyle='--', alpha=0.7)
+        
+        for bar in bars:
+            yval = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2.0, yval + (0.01 * max(engagement_data.values(), default=10)), str(int(yval)), ha='center', va='bottom')
+            
+        plt.tight_layout()
+        logging.info("Successfully generated engagement type plot.")
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating engagement type plot: {e}", exc_info=True)
+        return create_placeholder_plot(title="Engagement Type Error", message=str(e))
+    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.
+    """
+    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()}.")
+        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]):
+            df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
+        
+        df_copy = df_copy.dropna(subset=[date_column])
+        if df_copy.empty:
+            logging.info("Mentions activity: DataFrame empty after NaNs dropped from date column.")
+            return create_placeholder_plot(title="Mentions Activity Over Time", message="No valid date entries found.")
+
+        mentions_over_time = df_copy.set_index(date_column).resample('D').size()
+        
+        if mentions_over_time.empty:
+            logging.info("Mentions activity: No mentions after resampling by day.")
+            return create_placeholder_plot(title="Mentions Activity Over Time", message="No mentions in the selected period.")
+
+        fig, ax = plt.subplots(figsize=(10, 5))
+        mentions_over_time.plot(kind='line', ax=ax, marker='o', linestyle='-', color='purple')
+        ax.set_title('Mentions Activity Over Time')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Number of Mentions')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        logging.info("Successfully generated mentions activity plot.")
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating mentions activity plot: {e}", exc_info=True)
+        return create_placeholder_plot(title="Mentions Activity Error", message=str(e))
+    finally:
+        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.
+    """
+    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:
+        logging.warning("Mention sentiment: DataFrame is empty.")
+        return create_placeholder_plot(title="Mention Sentiment Distribution", message="No data available for the selected period.")
+    if sentiment_column not in df.columns:
+        msg = f"Mention sentiment: Column '{sentiment_column}' is missing. Available: {df.columns.tolist()}"
+        logging.warning(msg)
+        return create_placeholder_plot(title="Mention Sentiment Distribution", message=msg)
+
+    try:
+        df_copy = df.copy()
+        sentiment_counts = df_copy[sentiment_column].value_counts()
+        if sentiment_counts.empty:
+            logging.info("Mention sentiment: No sentiment data after value_counts.")
+            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
+
+
+        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') 
+        plt.tight_layout()
+        logging.info("Successfully generated mention sentiment plot.")
+        return fig
+    except Exception as e:
+        logging.error(f"Error generating mention sentiment plot: {e}", exc_info=True)
+        return create_placeholder_plot(title="Mention Sentiment Error", message=str(e))
+    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'}")
+
+    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.")
+    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)
+
+    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_copy[count_column] = pd.to_numeric(df_copy[count_column], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, count_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.")
+
+        df_copy = df_copy.sort_values(by=date_column)
+        
+        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.set_xlabel('Date')
+        ax.set_ylabel('Total Followers')
+        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))
+    finally:
+        plt.close('all')
+
+if __name__ == '__main__':
+    # Create dummy data for testing
+    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']
+    }
+    sample_mentions_df = pd.DataFrame(mentions_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
+    }
+    sample_follower_stats_df = pd.DataFrame(follower_data)
+
+    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
+
+    fig2 = generate_engagement_type_plot(sample_posts_df.copy())
+    if fig2: logging.info("Engagement type plot generated.")
+
+    fig3 = generate_mentions_activity_plot(sample_mentions_df.copy(), date_column='date')
+    if fig3: logging.info("Mentions activity 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.")
+    
+    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.")
+    
+    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.")
+
+
+    logging.info("Test script finished.")