Update insight_and_tasks/agents/post_agent.py

insight_and_tasks/agents/post_agent.py

@@ -0,0 +1,531 @@
+# agents/post_agent.py
+import pandas as pd
+from typing import Dict, List, Any, Optional
+import logging
+import pandasai as pai # Assuming pandasai is imported as pai globally or configured
+
+from google.adk.agents import LlmAgent # Assuming this is the correct import path
+
+# Project-specific imports
+from utils.retry_mechanism import RetryMechanism
+from data_models.metrics import AgentMetrics, TimeSeriesMetric
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+DEFAULT_AGENT_MODEL = "gemini-2.5-flash-preview-05-20"
+
+class EnhancedPostPerformanceAgent:
+    """
+    Enhanced post performance agent with time-series metric extraction and detailed analysis.
+    """
+    AGENT_NAME = "post_analyst"
+    AGENT_DESCRIPTION = "Expert analyst specializing in content performance trends and engagement patterns."
+    AGENT_INSTRUCTION = """
+    You are a specialized LinkedIn content performance expert focused on temporal engagement patterns, 
+    content type effectiveness, and audience interaction.
+
+    Your role includes:
+    
+    1. ENGAGEMENT TREND ANALYSIS (monthly, using 'published_at'):
+       - Analyze trends for key engagement metrics: likes, comments, shares, overall engagement ('engagement' column), impressions, clicks.
+       - Calculate and analyze engagement rate (engagement / impressionCount) over time.
+       - Calculate and analyze click-through rate (CTR: clickCount / impressionCount) over time.
+       - Identify periods of high/low engagement and potential drivers.
+       
+    2. CONTENT TYPE & TOPIC PERFORMANCE:
+       - Compare performance across different media types (using 'media_type' column).
+       - Analyze performance by content topic/pillar (using 'li_eb_label' column).
+       - Identify which content types/topics drive the most engagement, impressions, or clicks.
+       - Analyze if the effectiveness of certain media types or topics changes over time.
+       
+    3. POSTING BEHAVIOR ANALYSIS:
+       - Analyze posting frequency (e.g., posts per week/month) and its potential impact on overall engagement or reach.
+       - Identify if there are optimal posting times or days based on engagement patterns (if 'published_at' provides time detail).
+       
+    4. SENTIMENT ANALYSIS (if 'sentiment' column is available):
+       - Analyze the distribution of sentiment (e.g., positive, negative, neutral) associated with posts.
+       - Track how average sentiment of posts evolves over time.
+       
+    5. AD PERFORMANCE (if 'is_ad' column is available):
+       - Compare performance (engagement, reach, CTR) of ad posts vs. organic posts.
+
+    6. METRIC EXTRACTION (for AgentMetrics):
+       - Extract time-series data for average monthly engagement metrics (likes, comments, engagement rate, CTR, etc.).
+       - Provide aggregate performance metrics (e.g., overall average engagement rate, total impressions, top performing media type).
+       - Include distributions for content types, topics, and sentiment as categorical metrics.
+       
+    Focus on actionable insights. What content resonates most? When is the audience most active? How can strategy be improved?
+    Structure your analysis clearly. Use the provided DataFrame columns ('published_at', 'media_type', 'li_eb_label', 
+    'likeCount', 'commentCount', 'shareCount', 'engagement', 'impressionCount', 'clickCount', 'sentiment', 'is_ad').
+    """
+
+    def __init__(self, api_key: str, model_name: Optional[str] = None):
+        self.api_key = api_key
+        self.model_name = model_name or DEFAULT_AGENT_MODEL
+        self.agent = LlmAgent(
+            name=self.AGENT_NAME,
+            model=self.model_name,
+            description=self.AGENT_DESCRIPTION,
+            instruction=self.AGENT_INSTRUCTION
+        )
+        self.retry_mechanism = RetryMechanism()
+        logger.info(f"{self.AGENT_NAME} initialized with model {self.model_name}.")
+
+    def _preprocess_post_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Cleans and prepares post data for analysis."""
+        if df is None or df.empty:
+            return pd.DataFrame()
+        
+        df_processed = df.copy()
+
+        # Convert 'published_at' to datetime
+        if 'published_at' in df_processed.columns:
+            df_processed['published_at'] = pd.to_datetime(df_processed['published_at'], errors='coerce')
+            # df_processed.dropna(subset=['published_at'], inplace=True) # Keep rows even if date is NaT for other metrics
+        else:
+            logger.warning("'published_at' column not found. Time-series analysis will be limited.")
+            # Add a placeholder if critical for downstream, or handle absence gracefully
+            # df_processed['published_at'] = pd.NaT 
+
+        # Ensure numeric types for engagement metrics, coercing errors and filling NaNs
+        metric_cols = ['likeCount', 'commentCount', 'shareCount', 'engagement', 'impressionCount', 'clickCount']
+        for col in metric_cols:
+            if col in df_processed.columns:
+                df_processed[col] = pd.to_numeric(df_processed[col], errors='coerce').fillna(0)
+            else:
+                logger.info(f"Metric column '{col}' not found in post data. Will be treated as 0.")
+                df_processed[col] = 0 # Add column with zeros if missing
+
+        # Calculate Engagement Rate and CTR where possible
+        if 'impressionCount' in df_processed.columns and 'engagement' in df_processed.columns:
+            df_processed['engagement_rate'] = df_processed.apply(
+                lambda row: (row['engagement'] / row['impressionCount']) if row['impressionCount'] > 0 else 0.0, axis=1
+            )
+        else:
+            df_processed['engagement_rate'] = 0.0
+            
+        if 'impressionCount' in df_processed.columns and 'clickCount' in df_processed.columns:
+            df_processed['ctr'] = df_processed.apply(
+                lambda row: (row['clickCount'] / row['impressionCount']) if row['impressionCount'] > 0 else 0.0, axis=1
+            )
+        else:
+            df_processed['ctr'] = 0.0
+            
+        # Handle 'is_ad' boolean conversion if it exists
+        if 'is_ad' in df_processed.columns:
+            df_processed['is_ad'] = df_processed['is_ad'].astype(bool)
+        else:
+            df_processed['is_ad'] = False # Assume organic if not specified
+
+        # Handle 'sentiment' - ensure it's string, fill NaNs
+        if 'sentiment' in df_processed.columns:
+            df_processed['sentiment'] = df_processed['sentiment'].astype(str).fillna('Unknown')
+        else:
+            df_processed['sentiment'] = 'Unknown'
+            
+        # Handle 'media_type' and 'li_eb_label' - ensure string, fill NaNs
+        for col in ['media_type', 'li_eb_label']:
+            if col in df_processed.columns:
+                df_processed[col] = df_processed[col].astype(str).fillna('Unknown')
+            else:
+                df_processed[col] = 'Unknown'
+
+        return df_processed
+
+    def _extract_time_series_metrics(self, df_processed: pd.DataFrame) -> List[TimeSeriesMetric]:
+        """Extracts monthly time-series metrics from processed post data."""
+        ts_metrics = []
+        if df_processed.empty or 'published_at' not in df_processed.columns or df_processed['published_at'].isnull().all():
+            logger.info("Cannot extract time-series metrics for posts: 'published_at' is missing or all null.")
+            return ts_metrics
+
+        # Filter out rows where 'published_at' is NaT for time-series aggregation
+        df_ts = df_processed.dropna(subset=['published_at']).copy()
+        if df_ts.empty:
+            logger.info("No valid 'published_at' dates for post time-series metrics after filtering NaT.")
+            return ts_metrics
+            
+        df_ts['year_month'] = df_ts['published_at'].dt.strftime('%Y-%m')
+        
+        # Metrics to average monthly
+        metrics_to_agg = {
+            'likeCount': 'mean', 'commentCount': 'mean', 'shareCount': 'mean',
+            'engagement': 'mean', 'impressionCount': 'mean', 'clickCount': 'mean',
+            'engagement_rate': 'mean', 'ctr': 'mean'
+        }
+        # Filter out metrics not present in the DataFrame
+        available_metrics_to_agg = {k: v for k, v in metrics_to_agg.items() if k in df_ts.columns}
+
+        if not available_metrics_to_agg:
+            logger.info("No standard engagement metric columns found for time-series aggregation.")
+        else:
+            monthly_stats = df_ts.groupby('year_month').agg(available_metrics_to_agg).reset_index()
+            timestamps = monthly_stats['year_month'].tolist()
+
+            for metric_col, agg_type in available_metrics_to_agg.items():
+                # Use original column name, or a more descriptive one like "avg_monthly_likes"
+                ts_metrics.append(TimeSeriesMetric(
+                    metric_name=f"avg_monthly_{metric_col.lower()}",
+                    values=monthly_stats[metric_col].fillna(0).tolist(),
+                    timestamps=timestamps,
+                    metric_type="time_series",
+                    time_granularity="monthly",
+                    unit="%" if "_rate" in metric_col or "ctr" in metric_col else "count"
+                ))
+
+        # Time series for sentiment distribution (count of posts by sentiment per month)
+        if 'sentiment' in df_ts.columns and df_ts['sentiment'].nunique() > 1 : # if sentiment data exists
+            # Ensure 'sentiment' is not all 'Unknown'
+            if not (df_ts['sentiment'] == 'Unknown').all():
+                sentiment_by_month = df_ts.groupby(['year_month', 'sentiment']).size().unstack(fill_value=0)
+                for sentiment_value in sentiment_by_month.columns:
+                    if sentiment_value == 'Unknown' and (sentiment_by_month[sentiment_value] == 0).all():
+                        continue # Skip if 'Unknown' sentiment has no posts
+                    ts_metrics.append(TimeSeriesMetric(
+                        metric_name=f"monthly_post_count_sentiment_{str(sentiment_value).lower().replace(' ', '_')}",
+                        values=sentiment_by_month[sentiment_value].tolist(),
+                        timestamps=sentiment_by_month.index.tolist(), # year_month is the index
+                        metric_type="time_series",
+                        time_granularity="monthly",
+                        unit="count"
+                    ))
+            else:
+                logger.info("Sentiment data is all 'Unknown', skipping sentiment time series.")
+        
+        # Time series for post count
+        monthly_post_counts = df_ts.groupby('year_month').size().reset_index(name='post_count')
+        if not monthly_post_counts.empty:
+            ts_metrics.append(TimeSeriesMetric(
+                metric_name="monthly_post_count",
+                values=monthly_post_counts['post_count'].tolist(),
+                timestamps=monthly_post_counts['year_month'].tolist(),
+                metric_type="time_series",
+                time_granularity="monthly",
+                unit="count"
+            ))
+
+        return ts_metrics
+
+    def _calculate_aggregate_metrics(self, df_processed: pd.DataFrame) -> Dict[str, Any]:
+        """Calculates aggregate performance metrics for posts."""
+        agg_metrics = {}
+        if df_processed.empty:
+            return agg_metrics
+
+        # Overall averages and totals
+        metric_cols_for_agg = ['likeCount', 'commentCount', 'shareCount', 'engagement', 
+                               'impressionCount', 'clickCount', 'engagement_rate', 'ctr']
+        for col in metric_cols_for_agg:
+            if col in df_processed.columns and pd.api.types.is_numeric_dtype(df_processed[col]):
+                agg_metrics[f'overall_avg_{col.lower()}'] = float(df_processed[col].mean())
+                if col not in ['engagement_rate', 'ctr']: # Totals make sense for counts
+                     agg_metrics[f'overall_total_{col.lower()}'] = float(df_processed[col].sum())
+            
+        agg_metrics['total_posts_analyzed'] = float(len(df_processed))
+
+        # Posting frequency (posts per week)
+        if 'published_at' in df_processed.columns and not df_processed['published_at'].isnull().all():
+            df_dated = df_processed.dropna(subset=['published_at']).sort_values('published_at')
+            if len(df_dated) > 1:
+                # Calculate total duration in days
+                duration_days = (df_dated['published_at'].max() - df_dated['published_at'].min()).days
+                if duration_days > 0:
+                    agg_metrics['avg_posts_per_week'] = float(len(df_dated) / (duration_days / 7.0))
+                elif len(df_dated) > 0: # All posts on the same day or within a day
+                    agg_metrics['avg_posts_per_week'] = float(len(df_dated) * 7) # Extrapolate
+            elif len(df_dated) == 1:
+                 agg_metrics['avg_posts_per_week'] = 7.0 # One post, extrapolate to 7 per week
+
+        # Performance by media type and topic (as tables/structured dicts)
+        agg_metrics['performance_by_media_type'] = self._create_performance_table(df_processed, 'media_type')
+        agg_metrics['performance_by_topic'] = self._create_performance_table(df_processed, 'li_eb_label')
+            
+        return agg_metrics
+
+    def _create_performance_table(self, df: pd.DataFrame, group_column: str) -> Dict[str, Any]:
+        """Helper to create a structured performance table for categorical analysis."""
+        if group_column not in df.columns or df[group_column].isnull().all() or (df[group_column] == 'Unknown').all():
+            return {"message": f"No data or only 'Unknown' values for grouping by {group_column}."}
+        
+        # Filter out 'Unknown' category if it's the only one or for cleaner tables
+        df_filtered = df[df[group_column] != 'Unknown']
+        if df_filtered.empty: # If filtering 'Unknown' leaves no data, use original df but acknowledge
+            df_filtered = df 
+            logger.info(f"Performance table for {group_column} includes 'Unknown' as it's the only/main category.")
+
+        # Define metrics to aggregate
+        agg_config = {
+            'engagement': 'mean',
+            'impressionCount': 'mean',
+            'clickCount': 'mean',
+            'likeCount': 'mean',
+            'commentCount': 'mean',
+            'shareCount': 'mean',
+            'engagement_rate': 'mean',
+            'ctr': 'mean',
+            'published_at': 'count'  # To get number of posts per category
+        }
+        # Filter config for columns that actually exist in df_filtered
+        valid_agg_config = {k: v for k, v in agg_config.items() if k in df_filtered.columns or k == 'published_at'} # 'published_at' for count
+
+        if not valid_agg_config or 'published_at' not in valid_agg_config : # Need at least one metric or count
+             return {"message": f"Not enough relevant metric columns to create performance table for {group_column}."}
+
+
+        try:
+            # Group by the specified column and aggregate
+            # Rename 'published_at' count to 'num_posts' for clarity
+            grouped = df_filtered.groupby(group_column).agg(valid_agg_config).rename(
+                columns={'published_at': 'num_posts'}
+            ).reset_index()
+
+            # Sort by a primary engagement metric, e.g., average engagement rate or num_posts
+            sort_key = 'num_posts'
+            if 'engagement_rate' in grouped.columns:
+                sort_key = 'engagement_rate'
+            elif 'engagement' in grouped.columns:
+                 sort_key = 'engagement'
+            
+            grouped = grouped.sort_values(by=sort_key, ascending=False)
+
+            # Prepare for JSON serializable output
+            table_data = []
+            for _, row in grouped.iterrows():
+                row_dict = {'category': row[group_column]}
+                for col in grouped.columns:
+                    if col == group_column: continue
+                    value = row[col]
+                    if isinstance(value, (int, float)):
+                        if "_rate" in col or "ctr" in col:
+                            row_dict[col] = f"{value:.2%}" # Percentage
+                        else:
+                            row_dict[col] = round(value, 2) if isinstance(value, float) else value
+                    else:
+                        row_dict[col] = str(value)
+                table_data.append(row_dict)
+            
+            return {
+                "grouping_column": group_column,
+                "columns_reported": [col for col in grouped.columns.tolist() if col != group_column],
+                "data": table_data,
+                "note": f"Top categories by {sort_key}."
+            }
+
+        except Exception as e:
+            logger.error(f"Error creating performance table for {group_column}: {e}", exc_info=True)
+            return {"error": f"Could not generate table for {group_column}: {e}"}
+
+
+    def _extract_categorical_metrics(self, df_processed: pd.DataFrame) -> Dict[str, Any]:
+        """Extracts distributions and other categorical insights for posts."""
+        cat_metrics = {}
+        if df_processed.empty:
+            return cat_metrics
+
+        # Media type distribution
+        if 'media_type' in df_processed.columns and df_processed['media_type'].nunique() > 0:
+            cat_metrics['media_type_distribution'] = df_processed['media_type'].value_counts(normalize=True).apply(lambda x: f"{x:.2%}").to_dict()
+            cat_metrics['media_type_counts'] = df_processed['media_type'].value_counts().to_dict()
+
+
+        # Topic distribution (li_eb_label)
+        if 'li_eb_label' in df_processed.columns and df_processed['li_eb_label'].nunique() > 0:
+            cat_metrics['topic_distribution'] = df_processed['li_eb_label'].value_counts(normalize=True).apply(lambda x: f"{x:.2%}").to_dict()
+            cat_metrics['topic_counts'] = df_processed['li_eb_label'].value_counts().to_dict()
+
+        # Sentiment distribution
+        if 'sentiment' in df_processed.columns and df_processed['sentiment'].nunique() > 0:
+            cat_metrics['sentiment_distribution'] = df_processed['sentiment'].value_counts(normalize=True).apply(lambda x: f"{x:.2%}").to_dict()
+            cat_metrics['sentiment_counts'] = df_processed['sentiment'].value_counts().to_dict()
+
+        # Ad vs. Organic performance summary
+        if 'is_ad' in df_processed.columns:
+            ad_summary = {}
+            for ad_status in [True, False]:
+                subset = df_processed[df_processed['is_ad'] == ad_status]
+                if not subset.empty:
+                    label = "ad" if ad_status else "organic"
+                    ad_summary[f'{label}_post_count'] = int(len(subset))
+                    ad_summary[f'{label}_avg_engagement_rate'] = float(subset['engagement_rate'].mean())
+                    ad_summary[f'{label}_avg_impressions'] = float(subset['impressionCount'].mean())
+                    ad_summary[f'{label}_avg_ctr'] = float(subset['ctr'].mean())
+            if ad_summary:
+                cat_metrics['ad_vs_organic_summary'] = ad_summary
+        
+        return cat_metrics
+
+    def _extract_time_periods(self, df_processed: pd.DataFrame) -> List[str]:
+        """Extracts unique year-month time periods covered by the post data."""
+        if df_processed.empty or 'published_at' not in df_processed.columns or df_processed['published_at'].isnull().all():
+            return ["Data period not available or N/A"]
+        
+        # Use already created 'year_month' if available from preprocessing, or derive it
+        if 'year_month' in df_processed.columns:
+             periods = sorted(df_processed['year_month'].dropna().unique().tolist(), reverse=True)
+        elif 'published_at' in df_processed.columns: # Derive if not present
+            dates = df_processed['published_at'].dropna()
+            if not dates.empty:
+                periods = sorted(dates.dt.strftime('%Y-%m').unique().tolist(), reverse=True)
+            else: return ["N/A"]
+        else: return ["N/A"]
+        
+        return periods[:12] # Return up to the last 12 months
+
+    def analyze_post_data(self, post_df: pd.DataFrame) -> AgentMetrics:
+        """
+        Generates comprehensive post performance analysis.
+        """
+        if post_df is None or post_df.empty:
+            logger.warning("Post DataFrame is empty. Returning empty metrics.")
+            return AgentMetrics(
+                agent_name=self.AGENT_NAME,
+                analysis_summary="No post data provided for analysis.",
+                time_periods_covered=["N/A"]
+            )
+
+        # 1. Preprocess data
+        df_processed = self._preprocess_post_data(post_df)
+        if df_processed.empty and not post_df.empty : # Preprocessing resulted in empty df
+             logger.warning("Post DataFrame became empty after preprocessing. Original data might have issues.")
+             return AgentMetrics(
+                agent_name=self.AGENT_NAME,
+                analysis_summary="Post data could not be processed (e.g., all dates invalid).",
+                time_periods_covered=["N/A"]
+            )
+        elif df_processed.empty and post_df.empty: # Was already empty
+            # This case is handled by the initial check, but as a safeguard:
+            return AgentMetrics(agent_name=self.AGENT_NAME, analysis_summary="No post data provided.")
+
+
+        # 2. Generate textual analysis using PandasAI (similar to follower agent)
+        df_description_for_pandasai = "LinkedIn post performance data. Key columns: 'published_at' (date of post), 'media_type' (e.g., IMAGE, VIDEO, ARTICLE), 'li_eb_label' (content topic/pillar), 'likeCount', 'commentCount', 'shareCount', 'engagement' (sum of reactions, comments, shares), 'impressionCount', 'clickCount', 'sentiment' (post sentiment), 'is_ad' (boolean), 'engagement_rate', 'ctr'."
+        
+        analysis_result_text = "PandasAI analysis for posts could not be performed."
+        try:
+            # Ensure PandasAI is configured
+            pandas_ai_df = pai.DataFrame(df_processed, description=df_description_for_pandasai)
+
+            analysis_query = f"""
+            Analyze the provided LinkedIn post performance data. Focus on:
+            1. Monthly trends for key metrics (engagement, impressions, engagement rate, CTR).
+            2. Performance comparison by 'media_type' and 'li_eb_label'. Which ones are most effective?
+            3. Impact of posting frequency (if derivable from 'published_at' timestamps).
+            4. Sentiment trends and distribution.
+            5. Differences in performance between ad posts ('is_ad'=True) and organic posts.
+            Provide a concise summary of findings and actionable recommendations.
+            """
+            def chat_operation():
+                if not pai.config.llm:
+                    logger.warning("PandasAI LLM not configured for post agent. Attempting to configure.")
+                    from utils.pandasai_setup import configure_pandasai
+                    configure_pandasai(self.api_key, self.model_name)
+                    if not pai.config.llm:
+                        raise RuntimeError("PandasAI LLM could not be configured for post chat operation.")
+                logger.info(f"Executing PandasAI chat for post analysis with LLM: {pai.config.llm}")
+                return pandas_ai_df.chat(analysis_query)
+
+            analysis_result_raw = self.retry_mechanism.retry_with_backoff(
+                func=chat_operation, max_retries=2, base_delay=2.0, exceptions=(Exception,)
+            )
+            analysis_result_text = str(analysis_result_raw) if analysis_result_raw else "No textual analysis for posts generated by PandasAI."
+            logger.info("Post performance analysis via PandasAI completed.")
+
+        except Exception as e:
+            logger.error(f"Post analysis with PandasAI failed: {e}", exc_info=True)
+            analysis_result_text = f"Post analysis using PandasAI failed. Error: {str(e)[:200]}"
+
+        # 3. Extract structured metrics
+        time_series_metrics = self._extract_time_series_metrics(df_processed)
+        aggregate_metrics = self._calculate_aggregate_metrics(df_processed)
+        categorical_metrics = self._extract_categorical_metrics(df_processed)
+        time_periods = self._extract_time_periods(df_processed)
+        
+        return AgentMetrics(
+            agent_name=self.AGENT_NAME,
+            analysis_summary=analysis_result_text[:2000],
+            time_series_metrics=time_series_metrics,
+            aggregate_metrics=aggregate_metrics,
+            categorical_metrics=categorical_metrics,
+            time_periods_covered=time_periods,
+            data_sources_used=[f"post_df (shape: {post_df.shape}) -> df_processed (shape: {df_processed.shape})"]
+        )
+
+if __name__ == '__main__':
+    try:
+        from utils.logging_config import setup_logging
+        setup_logging()
+        logger.info("Logging setup for EnhancedPostPerformanceAgent test.")
+    except ImportError:
+        logging.basicConfig(level=logging.INFO)
+        logger.warning("Could not import setup_logging. Using basicConfig.")
+
+    MOCK_API_KEY = os.environ.get("GOOGLE_API_KEY", "test_api_key_posts")
+    MODEL_NAME = DEFAULT_AGENT_MODEL
+
+    try:
+        from utils.pandasai_setup import configure_pandasai
+        if MOCK_API_KEY != "test_api_key_posts":
+            configure_pandasai(MOCK_API_KEY, MODEL_NAME)
+            logger.info("PandasAI configured for testing EnhancedPostPerformanceAgent.")
+        else:
+            logger.warning("Using mock API key for posts. PandasAI chat will likely fail or use a mock.")
+            class MockPandasAIDataFrame:
+                def __init__(self, df, description): self.df = df; self.description = description
+                def chat(self, query): return f"Mock PandasAI post response to: {query}"
+            pai.DataFrame = MockPandasAIDataFrame
+    except ImportError:
+        logger.error("utils.pandasai_setup not found. PandasAI will not be configured for posts.")
+        class MockPandasAIDataFrame:
+            def __init__(self, df, description): self.df = df; self.description = description
+            def chat(self, query): return f"Mock PandasAI post response to: {query}"
+        pai.DataFrame = MockPandasAIDataFrame
+
+    sample_post_data = {
+        'published_at': pd.to_datetime(['2023-01-15', '2023-01-20', '2023-02-10', '2023-02-25', '2023-03-05', None]),
+        'media_type': ['IMAGE', 'VIDEO', 'IMAGE', 'ARTICLE', 'IMAGE', 'IMAGE'],
+        'li_eb_label': ['Product Update', 'Company Culture', 'Product Update', 'Industry Insights', 'Company Culture', 'Product Update'],
+        'likeCount': [100, 150, 120, 80, 200, 50],
+        'commentCount': [10, 20, 15, 5, 25, 3],
+        'shareCount': [5, 10, 8, 2, 12, 1],
+        'engagement': [115, 180, 143, 87, 237, 54], # Sum of likes, comments, shares
+        'impressionCount': [1000, 1500, 1200, 900, 2000, 600],
+        'clickCount': [50, 70, 60, 30, 90, 20],
+        'sentiment': ['Positive 👍', 'Positive 👍', 'Neutral 😐', 'Positive 👍', 'Negative 👎', 'Positive 👍'],
+        'is_ad': [False, False, True, False, False, True]
+    }
+    sample_df_posts = pd.DataFrame(sample_post_data)
+
+    post_agent = EnhancedPostPerformanceAgent(api_key=MOCK_API_KEY, model_name=MODEL_NAME)
+    
+    logger.info("Analyzing sample post data...")
+    post_metrics_result = post_agent.analyze_post_data(sample_df_posts)
+
+    print("\n--- EnhancedPostPerformanceAgent Results ---")
+    print(f"Agent Name: {post_metrics_result.agent_name}")
+    print(f"Analysis Summary: {post_metrics_result.analysis_summary}")
+    print("\nTime Series Metrics (Post):")
+    for ts_metric in post_metrics_result.time_series_metrics:
+         print(f"  - {ts_metric.metric_name}: {len(ts_metric.values)} data points, e.g., {ts_metric.values[:3]} for ts {ts_metric.timestamps[:3]} (Unit: {ts_metric.unit})")
+    print("\nAggregate Metrics (Post):")
+    for key, value in post_metrics_result.aggregate_metrics.items():
+        if isinstance(value, dict) and 'data' in value: # Performance table
+            print(f"  - {key}: (Table - {value.get('grouping_column', '')}) - {len(value['data'])} categories")
+            for item in value['data'][:1]: # Print first item for brevity
+                print(f"      Example Category '{item.get('category')}': { {k:v for k,v in item.items() if k!='category'} }")
+        else:
+            print(f"  - {key}: {value}")
+    print("\nCategorical Metrics (Post):")
+    for key, value in post_metrics_result.categorical_metrics.items():
+        print(f"  - {key}:")
+        if isinstance(value, dict):
+            for sub_key, sub_value in list(value.items())[:2]:
+                 print(f"    - {sub_key}: {sub_value}")
+        else:
+             print(f"    {value}")
+    print(f"\nTime Periods Covered (Post): {post_metrics_result.time_periods_covered}")
+
+    # Test with empty DataFrame
+    logger.info("\n--- Testing Post Agent with empty DataFrame ---")
+    empty_post_metrics = post_agent.analyze_post_data(pd.DataFrame())
+    print(f"Empty Post DF Analysis Summary: {empty_post_metrics.analysis_summary}")