Create home_tab_module.py

services/home_tab_module.py

@@ -0,0 +1,407 @@
+# services/home_tab_module.py
+
+import gradio as gr
+import pandas as pd
+import logging
+import matplotlib.pyplot as plt
+import numpy as np
+import html
+import ast
+from datetime import datetime, timedelta
+
+# Import the data filtering function
+from data_processing.analytics_data_processing import prepare_filtered_analytics_data
+# Import the theme-aware styler for our donut chart
+from ui.analytics_plot_generator import _apply_theme_aware_styling, create_placeholder_plot
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
+
+def _parse_eb_label(label_data):
+    if isinstance(label_data, list): return label_data
+    if isinstance(label_data, str):
+        try:
+            parsed = ast.literal_eval(label_data)
+            return parsed if isinstance(parsed, list) else [str(parsed)]
+        except (ValueError, SyntaxError):
+            return [label_data.strip()] if label_data.strip() else []
+    return [] if pd.isna(label_data) else [str(label_data)]
+
+
+def _format_kpi_list(data_series: pd.Series, unit="ER") -> str:
+    """
+    Formats a pandas Series into a clean HTML list for the Analisi Strategica.
+    """
+    if data_series is None or data_series.empty:
+        return "<div class='kpi-list-item'>Nessun dato disponibile.</div>"
+    
+    html_items = ""
+    for index, value in data_series.items():
+        html_items += f"""
+        <div class='kpi-list-item'>
+            <span class='kpi-list-label'>{html.escape(str(index))}</span>
+            <span class='kpi-list-value'>{unit}: <strong>{value:.1f}%</strong></span>
+        </div>
+        """
+    return html_items
+
+def _calculate_brand_sentiment(posts_df: pd.DataFrame, mentions_df: pd.DataFrame, comments_df: pd.DataFrame) -> float:
+    """
+    FIX KPI: Calcola sentiment medio tra commenti e menzioni (posts_df non usato più)
+    """
+    try:
+        sentiment_map = {
+            'Positive 👍': 1, 'Neutral 😐': 0, 'Negative 👎': -1,
+            'Positive': 1, 'Neutral': 0, 'Negative': -1
+        }
+        
+        # FIX: Usa comments_df invece di posts_df
+        total_comments = 0
+        comment_score = 0
+        
+        if not comments_df.empty:
+            sentiment_col = 'sentiment_label' if 'sentiment_label' in comments_df.columns else 'sentiment'
+            if sentiment_col in comments_df.columns:
+                comment_sentiments = comments_df[sentiment_col].value_counts()
+                total_comments = comment_sentiments.sum()
+                comment_score = sum(
+                    comment_sentiments.get(key, 0) * sentiment_map.get(key, 0) 
+                    for key in sentiment_map
+                )
+                logging.info(f"Comment sentiment - Total: {total_comments}, Score: {comment_score}")
+        
+        # Mentions (invariato)
+        total_mentions = 0
+        mention_score = 0
+        
+        if not mentions_df.empty and 'sentiment_label' in mentions_df.columns:
+            mention_sentiments = mentions_df['sentiment_label'].value_counts()
+            total_mentions = mention_sentiments.sum()
+            mention_score = sum(
+                mention_sentiments.get(key, 0) * sentiment_map.get(key, 0) 
+                for key in sentiment_map
+            )
+            logging.info(f"Mention sentiment - Total: {total_mentions}, Score: {mention_score}")
+
+        total_volume = total_comments + total_mentions
+        if total_volume == 0:
+            logging.warning("No sentiment data available")
+            return None
+
+        total_score = comment_score + mention_score
+        avg_score = total_score / total_volume
+        sentiment_percentage = (avg_score + 1) / 2 * 100
+        
+        logging.info(f"Final brand sentiment: {sentiment_percentage:.1f}%")
+        return sentiment_percentage
+        
+    except Exception as e:
+        logging.error(f"Error calculating brand sentiment: {e}", exc_info=True)
+        return None
+
+import plotly.graph_objects as go
+
+def generate_home_engagement_plotly(df):
+    df_copy = df.copy()
+    df_copy['date'] = pd.to_datetime(df_copy['published_at'])
+    df_copy['engagement'] = pd.to_numeric(df_copy['engagement'], errors='coerce')
+    df_copy = df_copy.dropna().sort_values('date')
+    
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=df_copy['date'],
+        y=df_copy['engagement'],
+        mode='lines+markers',
+        name='Engagement Rate',
+        line=dict(color='#F472B6', width=2),
+        marker=dict(size=6)
+    ))
+    
+    fig.update_layout(
+        #title='Performance Contenuti (Engagement Rate)',
+        xaxis_title='Date',
+        yaxis_title='Engagement Rate (%)',
+        yaxis=dict(range=[0, None]),
+        template='plotly_white',
+        height=325
+    )
+    
+    return fig
+
+
+def refresh_home_tab_ui(token_state_value, date_filter_option, custom_start_date, custom_end_date):
+    """
+    Fetches all data, calculates KPIs, and returns updates for the home tab.
+    
+    Returns 7 values:
+    1. New Followers (markdown)
+    2. Growth Rate (markdown)
+    3. Sentiment Chart (plot)
+    4. ER Plot Data (lineplot data)
+    5. Topics HTML (html)
+    6. Formats HTML (html)
+    7. Combined Follower Persona (html)
+    """
+    logging.info(f"Refreshing Home Tab. Filter: {date_filter_option}")
+    
+    # Get Filtered Data
+    try:
+        # MODIFICATO: Unpacking include comments_df
+        (filtered_merged_posts_df, 
+         filtered_mentions_df,
+         filtered_comments_df,  # AGGIUNTO
+         date_filtered_follower_stats_df,
+         raw_follower_stats_df, 
+         _, _) = prepare_filtered_analytics_data(
+            token_state_value, date_filter_option, custom_start_date, custom_end_date
+         )
+        
+        logging.info(f"Data loaded - Posts: {len(filtered_merged_posts_df)}, Mentions: {len(filtered_mentions_df)}")
+        
+    except Exception as e:
+        logging.error(f"Error during data preparation: {e}", exc_info=True)
+        placeholder_fig = create_placeholder_plot("Data Error")
+        placeholder_text = gr.update(value="<div class='kpi-value-error'>Error</div>")
+        placeholder_plot_data = pd.DataFrame(columns=['date', 'engagement', 'label'])
+        placeholder_persona = gr.update(value="""
+            <div class='persona-card'>
+                <div class='persona-avatar'>👤</div>
+                <div class='persona-details'>
+                    <div class='persona-title'>Target Follower Persona</div>
+                    <div class='persona-item'><span class='persona-label'>Error:</span><span class='persona-value'>Data unavailable</span></div>
+                </div>
+            </div>
+        """)
+        
+        return (
+            placeholder_text, placeholder_text, gr.update(value=placeholder_fig),
+            placeholder_plot_data, placeholder_text, placeholder_text, placeholder_persona
+        )
+
+    # KPI 1: Nuovi Follower
+    try:
+        gains_df = date_filtered_follower_stats_df[
+            date_filtered_follower_stats_df['follower_count_type'] == 'follower_gains_monthly'
+        ]
+        total_new_followers = pd.to_numeric(gains_df['follower_count_organic'], errors='coerce').sum() + \
+                              pd.to_numeric(gains_df['follower_count_paid'], errors='coerce').sum()
+        kpi_new_followers_update = gr.update(value=f"<div class='kpi-value'>{int(total_new_followers)}</div>")
+        logging.info(f"New followers: {int(total_new_followers)}")
+    except Exception as e:
+        total_new_followers = 0
+        logging.error(f"Error calculating new followers: {e}")
+        kpi_new_followers_update = gr.update(value="<div class='kpi-value-error'>N/A</div>")
+
+    # KPI 2: Growth Rate
+    try:
+        geo_df = raw_follower_stats_df[
+            raw_follower_stats_df['follower_count_type'] == 'follower_geo'
+        ]
+        
+        if geo_df.empty:
+            end_count = 0
+        else:
+            end_count = pd.to_numeric(geo_df['follower_count_organic'], errors='coerce').sum() + \
+                       pd.to_numeric(geo_df['follower_count_paid'], errors='coerce').sum()
+
+        gains_in_period = total_new_followers
+        start_count = end_count - gains_in_period
+        
+        if start_count > 0:
+            growth_rate = (gains_in_period / start_count) * 100
+            color = 'green' if growth_rate >= 0 else 'red'
+            sign = '+' if growth_rate >= 0 else ''
+            kpi_growth_update = gr.update(
+                value=f"<div class='kpi-value'>{growth_rate:.1f}%</div><div class='kpi-change' style='color:{color};'>{sign}{growth_rate:.1f}%</div>"
+            )
+        elif end_count > 0:
+            kpi_growth_update = gr.update(value=f"<div class='kpi-value' style='color:green;'>+100%</div><div class='kpi-change'>Nuovo</div>")
+        else:
+            kpi_growth_update = gr.update(value="<div class='kpi-value-error'>N/A</div>")
+
+    except Exception as e:
+        logging.error(f"Error calculating growth rate: {e}")
+        kpi_growth_update = gr.update(value="<div class='kpi-value-error'>N/A</div>")
+        
+    # KPI 3: Brand Sentiment
+    try:
+        sentiment_percentage = _calculate_brand_sentiment(filtered_merged_posts_df, filtered_mentions_df, filtered_comments_df)
+        donut_fig = _create_small_donut_chart(sentiment_percentage, "Positivo")
+        kpi_sentiment_update = gr.update(value=donut_fig)
+    except Exception as e:
+        logging.error(f"Donut chart error: {e}")
+        kpi_sentiment_update = gr.update(value=create_placeholder_plot("Sentiment Error"))
+
+    # KPI 4: Engagement Rate Plot - FIXED VERSION
+    try:
+        er_plot_data = generate_home_engagement_plotly(
+            filtered_merged_posts_df
+        )
+        
+        kpi_er_plot_update = gr.update(value=er_plot_data)
+        logging.info(f"Engagement plot updated with {len(filtered_merged_posts_df)} data points")
+        
+    except Exception as e:
+        logging.error(f"Error creating ER plot data: {e}", exc_info=True)
+        kpi_er_plot_update = gr.update(value=pd.DataFrame(columns=['date', 'engagement', 'label']))
+
+    # KPI 5 & 6: Topics & Formats
+    try:
+        topics_col = 'li_eb_label'
+        if not filtered_merged_posts_df.empty and topics_col in filtered_merged_posts_df.columns:
+            topics_df = filtered_merged_posts_df.copy()
+            topics_df[topics_col] = topics_df[topics_col].apply(_parse_eb_label)
+            topics_exploded = topics_df.explode(topics_col)
+            topics_exploded = topics_exploded[topics_exploded[topics_col].notna() & (topics_exploded[topics_col] != '')]
+            
+            if not topics_exploded.empty:
+                topics_er = topics_exploded.groupby(topics_col)['engagement'].mean().nlargest(4)
+                kpi_topics_update = gr.update(value=_format_kpi_list(topics_er, unit="ER"))
+            else:
+                kpi_topics_update = gr.update(value="<div class='kpi-list-item'>Nessun dato disponibile</div>")
+        else:
+            kpi_topics_update = gr.update(value="<div class='kpi-list-item'>N/A</div>")
+            
+        formats_col = 'media_type'
+        if not filtered_merged_posts_df.empty and formats_col in filtered_merged_posts_df.columns:
+            formats_df = filtered_merged_posts_df.copy()
+            formats_df = formats_df[formats_df[formats_col].notna() & (formats_df[formats_col] != '')]
+            
+            if not formats_df.empty:
+                formats_er = formats_df.groupby(formats_col)['engagement'].mean().nlargest(4)
+                kpi_formats_update = gr.update(value=_format_kpi_list(formats_er, unit="ER"))
+            else:
+                kpi_formats_update = gr.update(value="<div class='kpi-list-item'>Nessun dato disponibile</div>")
+        else:
+            kpi_formats_update = gr.update(value="<div class='kpi-list-item'>N/A</div>")
+            
+    except Exception as e:
+        logging.error(f"Error in Analisi Strategica: {e}")
+        kpi_topics_update = gr.update(value="<div class='kpi-list-item'>Error</div>")
+        kpi_formats_update = gr.update(value="<div class='kpi-list-item'>Error</div>")
+        
+    # KPI 7: Follower Persona
+    def get_top_demo(df, demo_type):
+        try:
+            if df.empty: return None
+            demo_df = df[df['follower_count_type'] == demo_type].copy()
+            if demo_df.empty: return None
+            
+            demo_df['total_follower_count'] = pd.to_numeric(demo_df['follower_count_organic'], errors='coerce').fillna(0) + \
+                                             pd.to_numeric(demo_df['follower_count_paid'], errors='coerce').fillna(0)
+            return demo_df.groupby('category_name')['total_follower_count'].sum().idxmax()
+        except Exception as e:
+            logging.error(f"Error getting top demo for {demo_type}: {e}")
+            return None
+
+    try:
+        top_role = get_top_demo(raw_follower_stats_df, 'follower_function')
+        top_industry = get_top_demo(raw_follower_stats_df, 'follower_industry')
+        top_seniority = get_top_demo(raw_follower_stats_df, 'follower_seniority')
+        top_country = get_top_demo(raw_follower_stats_df, 'follower_geo')
+        
+        role_display = html.escape(str(top_role)) if top_role else "N/A"
+        industry_display = html.escape(str(top_industry)) if top_industry else "N/A"
+        seniority_display = html.escape(str(top_seniority)) if top_seniority else "N/A"
+        country_display = html.escape(str(top_country)) if top_country else "N/A"
+        
+        persona_html = f"""
+        <div class='persona-card'>
+            <div class='persona-avatar'>👤</div>
+            <div class='persona-details'>
+                <div class='persona-item'>
+                    <span class='persona-label'>Role:</span>
+                    <span class='persona-value'>{role_display}</span>
+                </div>
+                <div class='persona-item'>
+                    <span class='persona-label'>Industry:</span>
+                    <span class='persona-value'>{industry_display}</span>
+                </div>
+                <div class='persona-item'>
+                    <span class='persona-label'>Seniority:</span>
+                    <span class='persona-value'>{seniority_display}</span>
+                </div>
+                <div class='persona-item'>
+                    <span class='persona-label'>Country:</span>
+                    <span class='persona-value'>{country_display}</span>
+                </div>
+            </div>
+        </div>
+        """
+        
+        kpi_persona_update = gr.update(value=persona_html)
+        
+    except Exception as e:
+        logging.error(f"Error creating follower persona: {e}")
+        kpi_persona_update = gr.update(value="""
+            <div class='persona-card'>
+                <div class='persona-avatar'>👤</div>
+                <div class='persona-details'>
+                    <div class='persona-title'>Target Follower Persona</div>
+                    <div class='persona-item'><span class='persona-label'>Error:</span><span class='persona-value'>Data unavailable</span></div>
+                </div>
+            </div>
+        """)
+
+    return (
+        kpi_new_followers_update,
+        kpi_growth_update,
+        kpi_sentiment_update,
+        kpi_er_plot_update,
+        kpi_topics_update,
+        kpi_formats_update,
+        kpi_persona_update
+    )
+
+
+def _create_small_donut_chart(percentage: float, title: str):
+    """
+    Creates a smaller theme-aware Matplotlib donut chart for the KPI row.
+    """
+    try:
+        fig, ax = plt.subplots(figsize=(2.5, 2.5))
+        _apply_theme_aware_styling(fig, ax, is_pie=True)
+
+        if percentage is None or pd.isna(percentage) or not 0 <= percentage <= 100:
+            percentage = 0
+            title = "No Data"
+            
+        percentage_value = percentage / 100.0
+        remaining = 1.0 - percentage_value
+        
+        PRIMARY_COLOR = plt.rcParams.get('axes.prop_cycle').by_key()['color'][0]
+        GRID_COLOR = plt.rcParams.get('grid.color', '#4B5563')
+        TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB')
+        BG_COLOR = plt.rcParams.get('figure.facecolor', '#111827')
+
+        data = [percentage_value, remaining]
+        colors = [PRIMARY_COLOR, GRID_COLOR]
+        
+        wedges, _ = ax.pie(
+            data, 
+            colors=colors, 
+            startangle=90, 
+            counterclock=False, 
+            wedgeprops=dict(width=0.3, edgecolor=BG_COLOR, linewidth=1.5)
+        )
+
+        ax.text(
+            0, 0, f"{percentage:.0f}%", 
+            ha='center', va='center', 
+            fontsize=18, fontweight='bold',
+            color=TEXT_COLOR
+        )
+        ax.text(
+            0, -0.4, title,
+            ha='center', va='center',
+            fontsize=8,
+            color=TEXT_COLOR,
+            alpha=0.8
+        )
+        
+        ax.axis('equal')
+        fig.tight_layout()
+        return fig
+
+    except Exception as e:
+        logging.error(f"Error creating small donut chart: {e}", exc_info=True)
+        return create_placeholder_plot(title="Chart Error", message=str(e))