morph-da / data /agent_programs.jsonl
prateekkohli1992's picture
Add MORPH-DA dataset, paper and poster
fb006bf verified
Raw History Blame Contribute Delete
256 kB
{"model": "claude-haiku-4-5", "task_id": "market01_l1_029", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "market01_l1_030", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "market01_l1_031", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['seller_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_032", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Group by category and sum the order_value\n category_order_value = df.groupby('category')['order_value'].sum()\n \n # Find the category with the highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_033", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Filter for eligible records (non-null seller_id based on schema)\n eligible = df[df['seller_id'].notna()]\n \n # Group by category and sum the order_value\n category_order_value = eligible.groupby('category')['order_value'].sum()\n \n # Find the category with the highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_034", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Group by category and sum the order_value\n category_order_value = df.groupby('category')['order_value'].sum()\n \n # Find the category with the highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_035", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Filter for eligible records - assuming eligible means order_status is not 'returned'\n # and order_date represents the current period (all records are considered current)\n eligible_df = df[df['order_status'] != 'returned'].copy()\n \n # Group by category and sum order_value\n category_order_value = eligible_df.groupby('category')['order_value'].sum()\n \n # Find the category with highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_036", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Filter for eligible records (non-null seller_id)\n eligible = df[df['seller_id'].notna()]\n \n # Group by category and sum order_value\n category_order_value = eligible.groupby('category')['order_value'].sum()\n \n # Find category with lowest total order_value\n lowest_category = category_order_value.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "market01_l2_037", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Filter eligible records - assuming eligible means non-null seller_id\n eligible_df = df[df['seller_id'].notna()]\n \n # Group by category and sum order_value\n category_order_value = eligible_df.groupby('category')['order_value'].sum().sort_values(ascending=False)\n \n # Get top 3 categories\n top_3 = category_order_value.head(3).index.tolist()\n \n return top_3", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "market01_l3_038", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> str:\n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Filter for 2025 orders\n df_2025 = df[df['order_date'].dt.year == 2025]\n \n # Filter for eligible orders (assuming \"eligible\" means not returned based on context)\n # But let's check all orders and calculate average order_value per category\n # \"eligible order\" typically means orders with delivered/completed status\n eligible_statuses = ['delivered', 'completed', 'shipped']\n df_eligible = df_2025[df_2025['order_status'].isin(eligible_statuses)]\n \n # If no eligible orders with those statuses, use all orders (as per schema there are 4 statuses)\n if len(df_eligible) == 0:\n df_eligible = df_2025\n \n # Calculate average order_value per category\n avg_order_value_by_category = df_eligible.groupby('category')['order_value'].mean()\n \n # Find category with highest average order_value\n category_with_highest_avg = avg_order_value_by_category.idxmax()\n \n return category_with_highest_avg", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "market01_l4_039", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Extract year and quarter\n df['year'] = df['order_date'].dt.year\n df['quarter'] = df['order_date'].dt.quarter\n \n # Filter for Q2 (April, May, June) data\n df_q2 = df[df['quarter'] == 2].copy()\n \n # Group by category and year, sum order_value\n order_value_by_category_year = df_q2.groupby(['category', 'year'])['order_value'].sum().reset_index()\n \n # Pivot to get years as columns\n order_value_pivot = order_value_by_category_year.pivot(index='category', columns='year', values='order_value')\n \n # Calculate year-over-year percentage increase\n # We need to compare 2025 vs 2024\n if 2024 in order_value_pivot.columns and 2025 in order_value_pivot.columns:\n order_value_pivot['yoy_pct_increase'] = ((order_value_pivot[2025] - order_value_pivot[2024]) / order_value_pivot[2024]) * 100\n \n # Handle cases where 2024 value is 0 or missing\n order_value_pivot['yoy_pct_increase'] = order_value_pivot['yoy_pct_increase'].replace([float('inf'), float('-inf')], float('nan'))\n \n # Find category with largest year-over-year percentage increase\n max_category = order_value_pivot['yoy_pct_increase'].idxmax()\n \n return max_category\n \n # If we don't have both years, return None or handle edge case\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "market01_l4_040", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Extract year and quarter\n df['year'] = df['order_date'].dt.year\n df['quarter'] = df['order_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) data\n q3_data = df[df['quarter'] == 3]\n \n # Separate Q3 2025 and Q3 2024\n q3_2025 = q3_data[q3_data['year'] == 2025]\n q3_2024 = q3_data[q3_data['year'] == 2024]\n \n # Calculate total GMV by category for Q3 2025\n order_value_2025 = q3_2025.groupby('category')['order_value'].sum()\n \n # Calculate total GMV by category for Q3 2024\n order_value_2024 = q3_2024.groupby('category')['order_value'].sum()\n \n # Calculate year-over-year percentage increase\n # Only consider categories that exist in both years\n common_categories = set(order_value_2025.index) & set(order_value_2024.index)\n \n yoy_increase = {}\n for category in common_categories:\n if order_value_2024[category] > 0:\n pct_increase = ((order_value_2025[category] - order_value_2024[category]) / order_value_2024[category]) * 100\n yoy_increase[category] = pct_increase\n \n # Also consider categories only in 2025 (infinite growth from 0)\n only_2025 = set(order_value_2025.index) - set(order_value_2024.index)\n for category in only_2025:\n yoy_increase[category] = float('inf')\n \n # Find category with largest YoY percentage increase\n if yoy_increase:\n max_category = max(yoy_increase, key=yoy_increase.get)\n return max_category\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l1_053", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n return campaigns['spend'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l1_054", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n mean_spend = campaigns['spend'].mean()\n return round(mean_spend, 2)", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l1_055", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns_df = tables['campaigns']\n count_distinct_campaign_id = campaigns_df['campaign_id'].nunique()\n return count_distinct_campaign_id", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_056", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n channel_spend = campaigns.groupby('channel')['spend'].sum()\n highest_channel = channel_spend.idxmax()\n return highest_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_057", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Group by channel and sum the spend\n channel_spend = df.groupby('channel')['spend'].sum()\n \n # Find the channel with the highest total spend\n highest_channel = channel_spend.idxmax()\n \n return highest_channel", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_058", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Filter for 2025 data\n df['event_date'] = pd.to_datetime(df['event_date'])\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and sum the spend\n channel_spend = df_2025.groupby('channel')['spend'].sum()\n \n # Find the channel with highest total spend\n highest_channel = channel_spend.idxmax()\n \n return highest_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_059", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Filter for 2025 records\n df['event_date'] = pd.to_datetime(df['event_date'])\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n channel_spend = df_2025.groupby('channel')['spend'].sum()\n \n # Find channel with highest total spend\n highest_channel = channel_spend.idxmax()\n \n return highest_channel", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_060", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Filter for 2025 records\n df['event_date'] = pd.to_datetime(df['event_date'])\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n channel_spend = df_2025.groupby('channel')['spend'].sum()\n \n # Find the channel with the lowest total spend\n lowest_channel = channel_spend.idxmin()\n \n return lowest_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l2_061", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Filter for 2025 records\n df['event_date'] = pd.to_datetime(df['event_date'])\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and sum the spend\n channel_spend = df_2025.groupby('channel')['spend'].sum().sort_values(ascending=False)\n \n # Get top 3 channels\n top_3_channels = channel_spend.head(3).index.tolist()\n \n return top_3_channels", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l3_062", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Filter for 2025 records\n df['event_date'] = pd.to_datetime(df['event_date'])\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and calculate average spend and count\n channel_stats = df_2025.groupby('channel').agg(\n avg_spend=('spend', 'mean'),\n count=('spend', 'count')\n ).reset_index()\n \n # Filter for channels with at least 30 records\n eligible = channel_stats[channel_stats['count'] >= 30]\n \n # Find channel with highest average spend\n if len(eligible) > 0:\n result = eligible.loc[eligible['avg_spend'].idxmax(), 'channel']\n else:\n result = None\n \n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l4_063", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Convert event_date to datetime\n df['event_date'] = pd.to_datetime(df['event_date'])\n \n # Extract year and quarter\n df['year'] = df['event_date'].dt.year\n df['quarter'] = df['event_date'].dt.quarter\n \n # Filter for Q2 (April, May, June) data for 2024 and 2025\n q2_data = df[df['quarter'] == 2].copy()\n \n # Group by channel and year to get total spend\n spend_by_channel_year = q2_data.groupby(['channel', 'year'])['spend'].sum().reset_index()\n \n # Pivot to get 2024 and 2025 spend side by side\n spend_pivot = spend_by_channel_year.pivot(index='channel', columns='year', values='spend').fillna(0)\n \n # Ensure both years exist\n if 2024 not in spend_pivot.columns or 2025 not in spend_pivot.columns:\n return None\n \n # Calculate year-over-year percentage increase\n spend_pivot['yoy_pct_increase'] = ((spend_pivot[2025] - spend_pivot[2024]) / spend_pivot[2024] * 100)\n \n # Find channel with largest increase\n max_increase_channel = spend_pivot['yoy_pct_increase'].idxmax()\n \n return max_increase_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "mktg01_l4_064", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['campaigns']\n \n # Convert event_date to datetime\n df['event_date'] = pd.to_datetime(df['event_date'])\n \n # Extract year and quarter\n df['year'] = df['event_date'].dt.year\n df['quarter'] = df['event_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) data\n q3_2024 = df[(df['year'] == 2024) & (df['quarter'] == 3)]\n q3_2025 = df[(df['year'] == 2025) & (df['quarter'] == 3)]\n \n # Calculate total spend by channel for Q3 2024\n spend_2024 = q3_2024.groupby('channel')['spend'].sum()\n \n # Calculate total spend by channel for Q3 2025\n spend_2025 = q3_2025.groupby('channel')['spend'].sum()\n \n # Align the indices to ensure we can calculate YoY for channels present in both years\n channels_2024 = set(spend_2024.index)\n channels_2025 = set(spend_2025.index)\n common_channels = channels_2024.intersection(channels_2025)\n \n # Calculate year-over-year percentage increase for channels in both years\n yoy_increases = {}\n for channel in common_channels:\n if spend_2024[channel] > 0:\n yoy_pct_increase = ((spend_2025[channel] - spend_2024[channel]) / spend_2024[channel]) * 100\n yoy_increases[channel] = yoy_pct_increase\n \n # Handle channels only in 2025 (infinite growth from 0)\n for channel in channels_2025 - channels_2024:\n yoy_increases[channel] = float('inf')\n \n # Find the channel with the largest year-over-year percentage increase\n if yoy_increases:\n max_channel = max(yoy_increases, key=yoy_increases.get)\n return max_channel\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l1_077", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n shipments = tables['shipments']\n return shipments['cost'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l1_078", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n return df['cost'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l1_079", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n shipments = tables['shipments']\n return shipments['order_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_080", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n total_cost_by_category = df.groupby('category')['cost'].sum()\n highest_category = total_cost_by_category.idxmax()\n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_081", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Group by category and sum the costs\n category_costs = df.groupby('category')['cost'].sum()\n \n # Find the category with the highest total cost\n highest_category = category_costs.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_082", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for year 2025\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = df_2025.groupby('category')['cost'].sum()\n \n # Find the category with the highest total cost\n highest_category = category_costs.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_083", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = df_2025.groupby('category')['cost'].sum()\n \n # Find the category with the highest total cost\n highest_category = category_costs.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_084", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = df_2025.groupby('category')['cost'].sum()\n \n # Find the category with the lowest total cost\n lowest_category = category_costs.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l2_085", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = df_2025.groupby('category')['cost'].sum().reset_index()\n \n # Sort by cost in descending order\n category_costs = category_costs.sort_values('cost', ascending=False)\n \n # Get top 3 categories\n top_3 = category_costs.head(3)['category'].tolist()\n \n return top_3", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l3_086", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and calculate average cost and count\n category_stats = df_2025.groupby('category').agg(\n avg_cost=('cost', 'mean'),\n count=('cost', 'count')\n )\n \n # Filter for categories with at least 30 records\n eligible_categories = category_stats[category_stats['count'] >= 30]\n \n # Find the category with highest average cost\n if len(eligible_categories) > 0:\n highest_avg_category = eligible_categories['avg_cost'].idxmax()\n return highest_avg_category\n \n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l4_087", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Extract year and quarter\n df['year'] = df['ship_date'].dt.year\n df['quarter'] = df['ship_date'].dt.quarter\n \n # Filter for Q2 (quarter 2)\n df_q2 = df[df['quarter'] == 2]\n \n # Group by category and year, sum the costs\n q2_by_year = df_q2.groupby(['category', 'year'])['cost'].sum().reset_index()\n q2_by_year.columns = ['category', 'year', 'total_cost']\n \n # Pivot to get 2024 and 2025 side by side\n q2_pivot = q2_by_year.pivot(index='category', columns='year', values='total_cost')\n \n # Handle cases where a category might not have data in both years\n q2_pivot = q2_pivot.fillna(0)\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # YoY increase = ((2025 - 2024) / 2024) * 100\n if 2024 in q2_pivot.columns and 2025 in q2_pivot.columns:\n q2_pivot['yoy_increase'] = ((q2_pivot[2025] - q2_pivot[2024]) / q2_pivot[2024].replace(0, float('nan'))) * 100\n else:\n # If only 2025 data exists, handle separately\n q2_pivot['yoy_increase'] = float('-inf')\n \n # Find the category with the largest YoY percentage increase\n # Only consider categories that have valid YoY calculation (both years present)\n valid_yoy = q2_pivot[q2_pivot['yoy_increase'].notna() & (q2_pivot['yoy_increase'] != float('-inf'))]\n \n if len(valid_yoy) > 0:\n max_category = valid_yoy['yoy_increase'].idxmax()\n return max_category\n else:\n # If no valid YoY calculation, return None or handle edge case\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "ops01_l4_088", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Extract year and quarter\n df['year'] = df['ship_date'].dt.year\n df['quarter'] = df['ship_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) data for both 2024 and 2025\n df_q3 = df[df['quarter'] == 3]\n \n # Group by category and year, sum the cost\n cost_by_category_year = df_q3.groupby(['category', 'year'])['cost'].sum().reset_index()\n \n # Pivot to have years as columns\n pivot_df = cost_by_category_year.pivot(index='category', columns='year', values='cost').fillna(0)\n \n # Check which years are available\n if 2024 not in pivot_df.columns or 2025 not in pivot_df.columns:\n # If both years not available, return None or handle appropriately\n return None\n \n # Calculate year-over-year percentage increase\n pivot_df['yoy_pct_increase'] = ((pivot_df[2025] - pivot_df[2024]) / pivot_df[2024]) * 100\n \n # Handle infinite values (when 2024 cost is 0)\n pivot_df['yoy_pct_increase'] = pivot_df['yoy_pct_increase'].replace([float('inf'), float('-inf')], 0)\n \n # Find category with largest YoY percentage increase\n max_category = pivot_df['yoy_pct_increase'].idxmax()\n \n return max_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "payments01_l1_065", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n transactions = tables['transactions']\n return transactions['amount'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l1_066", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n return df['amount'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l1_067", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n transactions = tables['transactions']\n return transactions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_068", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n total_by_payment_method = df.groupby('payment_method')['amount'].sum()\n payment_method_highest = total_by_payment_method.idxmax()\n return payment_method_highest", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_069", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Filter for eligible records (assuming eligible means status='completed')\n eligible = df[df['status'] == 'completed']\n \n # Group by payment_method and sum the amounts\n payment_totals = eligible.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with the highest total amount\n highest_payment_method = payment_totals.idxmax()\n \n return highest_payment_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_070", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025 transactions\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum the amounts\n payment_totals = df_2025.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with the highest total amount\n highest_payment_method = payment_totals.idxmax()\n \n return highest_payment_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_071", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Filter for 2025 records\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Filter for eligible records (assuming eligible means status='completed')\n df_eligible = df_2025[df_2025['status'] == 'completed']\n \n # Group by payment_method and sum the amounts\n payment_method_totals = df_eligible.groupby('payment_method')['amount'].sum()\n \n # Return the payment_method with highest total amount\n highest_payment_method = payment_method_totals.idxmax()\n \n return highest_payment_method", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_072", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Filter for 2025 records\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum the amounts\n payment_totals = df_2025.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with the lowest total amount\n lowest_payment_method = payment_totals.idxmin()\n \n return lowest_payment_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "payments01_l2_073", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Filter for 2025 records\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Filter for eligible records (completed status and payment type)\n df_eligible = df_2025[(df_2025['status'] == 'completed') & (df_2025['txn_type'] == 'payment')]\n \n # Group by payment_method and sum the amounts\n payment_method_totals = df_eligible.groupby('payment_method')['amount'].sum().reset_index()\n payment_method_totals.columns = ['payment_method', 'total_amount']\n \n # Sort by total_amount in descending order and get top 3\n top_3 = payment_method_totals.sort_values('total_amount', ascending=False).head(3)\n \n # Return as list of payment methods\n return top_3['payment_method'].tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "payments01_l3_074", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and calculate count and average amount\n grouped = df_2025.groupby('payment_method').agg(\n count=('amount', 'count'),\n avg_amount=('amount', 'mean')\n ).reset_index()\n \n # Filter for payment methods with at least 30 records\n eligible = grouped[grouped['count'] >= 30]\n \n # Find the payment method with highest average amount\n if len(eligible) == 0:\n return None\n \n result = eligible.loc[eligible['avg_amount'].idxmax(), 'payment_method']\n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-haiku-4-5", "task_id": "payments01_l4_075", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Extract year and quarter\n df['year'] = df['txn_date'].dt.year\n df['quarter'] = df['txn_date'].dt.quarter\n \n # Filter for Q2 (April, May, June = month 4, 5, 6)\n df['month'] = df['txn_date'].dt.month\n q2_mask = df['month'].isin([4, 5, 6])\n \n # Get Q2 2025 and Q2 2024\n q2_2025 = df[(df['year'] == 2025) & q2_mask]\n q2_2024 = df[(df['year'] == 2024) & q2_mask]\n \n # Calculate total amount by payment_method for each year\n q2_2025_totals = q2_2025.groupby('payment_method')['amount'].sum()\n q2_2024_totals = q2_2024.groupby('payment_method')['amount'].sum()\n \n # Calculate year-over-year percentage increase\n # Get all payment methods that appear in either year\n all_methods = set(q2_2025_totals.index) | set(q2_2024_totals.index)\n \n yoy_increases = {}\n for method in all_methods:\n amount_2025 = q2_2025_totals.get(method, 0)\n amount_2024 = q2_2024_totals.get(method, 0)\n \n # Only calculate if 2024 had non-zero amount\n if amount_2024 > 0:\n pct_increase = ((amount_2025 - amount_2024) / amount_2024) * 100\n yoy_increases[method] = pct_increase\n elif amount_2024 == 0 and amount_2025 > 0:\n # If 2024 was 0 but 2025 is positive, consider it infinite growth\n yoy_increases[method] = float('inf')\n else:\n yoy_increases[method] = 0\n \n # Find the payment method with the largest increase\n max_method = max(yoy_increases, key=yoy_increases.get)\n \n return max_method", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "payments01_l4_076", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Extract year and quarter\n df['year'] = df['txn_date'].dt.year\n df['quarter'] = df['txn_date'].dt.quarter\n \n # Filter for Q3 (quarter 3)\n q3_2025 = df[(df['year'] == 2025) & (df['quarter'] == 3)]\n q3_2024 = df[(df['year'] == 2024) & (df['quarter'] == 3)]\n \n # Group by payment_method and sum amounts for Q3 2025\n q3_2025_totals = q3_2025.groupby('payment_method')['amount'].sum()\n \n # Group by payment_method and sum amounts for Q3 2024\n q3_2024_totals = q3_2024.groupby('payment_method')['amount'].sum()\n \n # Calculate year-over-year percentage increase\n yoy_increase = {}\n \n for payment_method in q3_2025_totals.index:\n if payment_method in q3_2024_totals.index:\n amount_2025 = q3_2025_totals[payment_method]\n amount_2024 = q3_2024_totals[payment_method]\n \n if amount_2024 != 0:\n pct_increase = ((amount_2025 - amount_2024) / amount_2024) * 100\n yoy_increase[payment_method] = pct_increase\n else:\n # Handle case where 2024 amount is 0\n if amount_2025 > 0:\n yoy_increase[payment_method] = float('inf')\n \n # Find the payment method with largest increase\n if yoy_increase:\n max_payment_method = max(yoy_increase, key=yoy_increase.get)\n return max_payment_method\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l1_000", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n return orders['revenue'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l1_001", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n mean_revenue = orders['revenue'].mean()\n return mean_revenue", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l1_002", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n return orders['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_003", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n total_revenue_by_category = orders.groupby('category')['revenue'].sum()\n highest_category = total_revenue_by_category.idxmax()\n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_004", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n \n # Group by category and sum revenue\n category_revenue = df.groupby('category')['revenue'].sum()\n \n # Find the category with highest total revenue\n highest_category = category_revenue.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_005", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n \n # Group by category and sum the revenue\n category_revenue = df.groupby('category')['revenue'].sum()\n \n # Find the category with the highest total revenue\n highest_category = category_revenue.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_006", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n \n # Determine current period based on the data\n df['order_date'] = pd.to_datetime(df['order_date'])\n max_date = df['order_date'].max()\n min_date = df['order_date'].min()\n \n # Define current period as the most recent month or quarter\n # Using the most recent month as current period\n current_year = max_date.year\n current_month = max_date.month\n \n # Filter for current period records\n eligible_records = df[\n (df['order_date'].dt.year == current_year) & \n (df['order_date'].dt.month == current_month)\n ]\n \n # If no records in current month, try current quarter\n if len(eligible_records) == 0:\n current_quarter = (max_date.month - 1) // 3 + 1\n eligible_records = df[\n (df['order_date'].dt.year == current_year) & \n ((df['order_date'].dt.month - 1) // 3 + 1 == current_quarter)\n ]\n \n # If still no records, use all data after a certain threshold\n if len(eligible_records) == 0:\n eligible_records = df\n \n # Group by category and sum revenue\n category_revenue = eligible_records.groupby('category')['revenue'].sum()\n \n # Find category with highest revenue\n highest_category = category_revenue.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_007", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Group by category and sum the revenue\n category_revenue = orders.groupby('category')['revenue'].sum()\n \n # Find the category with the lowest total revenue\n lowest_category = category_revenue.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "retail01_l2_008", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> list:\n df = tables['orders']\n \n # Group by category and sum the revenue\n category_revenue = df.groupby('category')['revenue'].sum().sort_values(ascending=False)\n \n # Get top 3 categories\n top_3 = category_revenue.head(3).index.tolist()\n \n return top_3", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "retail01_l3_009", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Filter for 2025 orders\n orders_2025 = orders[orders['order_date'].dt.year == 2025]\n \n # Filter for eligible orders (assuming \"eligible\" means not refunded)\n eligible_orders = orders_2025[orders_2025['order_status'] != 'refunded']\n \n # Group by category and calculate average revenue per order\n avg_revenue_by_category = eligible_orders.groupby('category')['revenue'].mean()\n \n # Find category with highest average revenue\n category_with_highest_avg = avg_revenue_by_category.idxmax()\n \n return category_with_highest_avg", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "retail01_l4_010", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Extract year and quarter\n orders['year'] = orders['order_date'].dt.year\n orders['quarter'] = orders['order_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) data\n q2_orders = orders[orders['quarter'] == 2]\n \n # Group by category and year, sum revenue\n q2_revenue = q2_orders.groupby(['category', 'year'])['revenue'].sum().reset_index()\n \n # Pivot to get 2024 and 2025 revenues side by side\n pivot_revenue = q2_revenue.pivot(index='category', columns='year', values='revenue').fillna(0)\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n if 2024 in pivot_revenue.columns and 2025 in pivot_revenue.columns:\n pivot_revenue['yoy_pct_increase'] = ((pivot_revenue[2025] - pivot_revenue[2024]) / pivot_revenue[2024].replace(0, float('nan'))) * 100\n else:\n # If we don't have both years, handle the case\n return None\n \n # Handle cases where 2024 revenue was 0 (division by zero)\n # Filter only categories that had revenue in 2024\n valid_categories = pivot_revenue[pivot_revenue[2024] > 0].copy()\n \n # Find the category with the largest YoY percentage increase\n max_category = valid_categories['yoy_pct_increase'].idxmax()\n \n return max_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "retail01_l4_011", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Extract year and quarter\n orders['year'] = orders['order_date'].dt.year\n orders['quarter'] = orders['order_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) data\n q3_2024 = orders[(orders['year'] == 2024) & (orders['quarter'] == 3)]\n q3_2025 = orders[(orders['year'] == 2025) & (orders['quarter'] == 3)]\n \n # Calculate total revenue by category for Q3 2024\n q3_2024_revenue = q3_2024.groupby('category')['revenue'].sum()\n \n # Calculate total revenue by category for Q3 2025\n q3_2025_revenue = q3_2025.groupby('category')['revenue'].sum()\n \n # Calculate year-over-year percentage increase\n # For categories that exist in both years\n yoy_increase = {}\n \n for category in q3_2025_revenue.index:\n if category in q3_2024_revenue.index:\n rev_2024 = q3_2024_revenue[category]\n rev_2025 = q3_2025_revenue[category]\n \n if rev_2024 > 0:\n pct_increase = ((rev_2025 - rev_2024) / rev_2024) * 100\n yoy_increase[category] = pct_increase\n else:\n # If 2024 revenue is 0, consider it as infinite increase\n yoy_increase[category] = float('inf') if rev_2025 > 0 else 0\n else:\n # Category didn't exist in Q3 2024\n yoy_increase[category] = float('inf')\n \n # Find category with largest increase\n if yoy_increase:\n max_category = max(yoy_increase, key=yoy_increase.get)\n return max_category\n \n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "saas01_l1_041", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n return subscriptions['mrr'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l1_042", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n mean_mrr = df['mrr'].mean()\n return mean_mrr", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l1_043", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n return subscriptions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_044", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n total_mrr_by_plan = subscriptions.groupby('plan')['mrr'].sum()\n plan_with_highest_mrr = total_mrr_by_plan.idxmax()\n return plan_with_highest_mrr", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_045", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Filter for eligible records - assuming \"eligible\" means active status\n # (records that haven't churned or are not paused)\n eligible_df = df[df['status'] == 'active']\n \n # Group by plan and sum the mrr\n plan_mrr = eligible_df.groupby('plan')['mrr'].sum()\n \n # Find the plan with the highest total mrr\n highest_plan = plan_mrr.idxmax()\n \n return highest_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_046", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for subscriptions that started in 2025\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum the mrr\n mrr_by_plan = df_2025.groupby('plan')['mrr'].sum()\n \n # Find the plan with the highest total mrr\n plan_with_highest_mrr = mrr_by_plan.idxmax()\n \n return plan_with_highest_mrr", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_047", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for records that started in 2025\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum the mrr\n plan_mrr = df_2025.groupby('plan')['mrr'].sum()\n \n # Find the plan with the highest total mrr\n highest_plan = plan_mrr.idxmax()\n \n return highest_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_048", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for records starting in 2025\n eligible_records = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum the MRR\n plan_mrr = eligible_records.groupby('plan')['mrr'].sum()\n \n # Find the plan with the lowest total MRR\n lowest_plan = plan_mrr.idxmin()\n \n return lowest_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l2_049", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for records in 2025 (started in 2025)\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Filter for eligible records (active status)\n eligible = df_2025[df_2025['status'] == 'active']\n \n # Group by plan and sum MRR\n plan_mrr = eligible.groupby('plan')['mrr'].sum().reset_index()\n plan_mrr.columns = ['plan', 'total_mrr']\n \n # Sort by total_mrr descending\n plan_mrr = plan_mrr.sort_values('total_mrr', ascending=False)\n \n # Get top 3\n top_3 = plan_mrr.head(3)['plan'].tolist()\n \n return top_3", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "saas01_l3_050", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['subscriptions']\n \n # Convert start_date and churn_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce')\n \n # Filter for records in 2025\n # A record is in 2025 if start_date is in 2025, or if it started before 2025 and churn_date is in 2025 or no churn_date\n df_2025 = df[\n ((df['start_date'].dt.year == 2025) | \n ((df['start_date'].dt.year < 2025) & \n ((df['churn_date'].dt.year == 2025) | (df['churn_date'].isna()))))\n ]\n \n # Group by plan and calculate average MRR and count\n plan_stats = df_2025.groupby('plan').agg({\n 'mrr': ['mean', 'count']\n }).reset_index()\n \n plan_stats.columns = ['plan', 'avg_mrr', 'count']\n \n # Filter plans with at least 30 records\n eligible_plans = plan_stats[plan_stats['count'] >= 30]\n \n # Find the plan with the highest average MRR\n if len(eligible_plans) > 0:\n result = eligible_plans.loc[eligible_plans['avg_mrr'].idxmax(), 'plan']\n return result\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l4_051", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert date columns to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n df['churn_date'] = pd.to_datetime(df['churn_date'])\n \n # Filter for active subscriptions in Q2 2025 (Apr 1 - Jun 30, 2025)\n q2_2025_start = pd.to_datetime('2025-04-01')\n q2_2025_end = pd.to_datetime('2025-06-30')\n \n # Filter for active subscriptions in Q2 2024 (Apr 1 - Jun 30, 2024)\n q2_2024_start = pd.to_datetime('2024-04-01')\n q2_2024_end = pd.to_datetime('2024-06-30')\n \n # For Q2 2025: subscription must have started before or during Q2 2025 and either not churned or churned after Q2 2025\n df_q2_2025 = df[\n (df['start_date'] <= q2_2025_end) &\n ((df['churn_date'].isna()) | (df['churn_date'] > q2_2025_start))\n ].copy()\n \n # For Q2 2024: subscription must have started before or during Q2 2024 and either not churned or churned after Q2 2024\n df_q2_2024 = df[\n (df['start_date'] <= q2_2024_end) &\n ((df['churn_date'].isna()) | (df['churn_date'] > q2_2024_start))\n ].copy()\n \n # Calculate total MRR by plan for Q2 2025\n mrr_q2_2025 = df_q2_2025.groupby('plan')['mrr'].sum()\n \n # Calculate total MRR by plan for Q2 2024\n mrr_q2_2024 = df_q2_2024.groupby('plan')['mrr'].sum()\n \n # Calculate year-over-year percentage increase\n yoy_increase = {}\n for plan in mrr_q2_2025.index:\n if plan in mrr_q2_2024.index and mrr_q2_2024[plan] > 0:\n pct_increase = ((mrr_q2_2025[plan] - mrr_q2_2024[plan]) / mrr_q2_2024[plan]) * 100\n yoy_increase[plan] = pct_increase\n elif plan not in mrr_q2_2024.index or mrr_q2_2024[plan] == 0:\n # If no MRR in Q2 2024, it's infinite growth if Q2 2025 has MRR\n if mrr_q2_2025[plan] > 0:\n yoy_increase[plan] = float('inf')\n else:\n yoy_increase[plan] = 0\n \n # Find plan with largest increase\n if yoy_increase:\n max_plan = max(yoy_increase, key=yoy_increase.get)\n return max_plan\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "saas01_l4_052", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n from datetime import datetime\n \n df = tables['subscriptions'].copy()\n \n # Convert date columns to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce')\n \n # Filter for Q3 2025 (July 1 - September 30, 2025)\n q3_2025_start = pd.to_datetime('2025-07-01')\n q3_2025_end = pd.to_datetime('2025-09-30')\n \n # Filter for Q3 2024 (July 1 - September 30, 2024)\n q3_2024_start = pd.to_datetime('2024-07-01')\n q3_2024_end = pd.to_datetime('2024-09-30')\n \n # For Q3 2025: subscription was active during Q3 2025\n # Active if: start_date <= Q3_end AND (churn_date is null OR churn_date > Q3_start)\n q3_2025_active = df[\n (df['start_date'] <= q3_2025_end) & \n ((df['churn_date'].isna()) | (df['churn_date'] > q3_2025_start))\n ]\n \n # For Q3 2024: subscription was active during Q3 2024\n q3_2024_active = df[\n (df['start_date'] <= q3_2024_end) & \n ((df['churn_date'].isna()) | (df['churn_date'] > q3_2024_start))\n ]\n \n # Calculate total MRR by plan for Q3 2025\n mrr_q3_2025 = q3_2025_active.groupby('plan')['mrr'].sum()\n \n # Calculate total MRR by plan for Q3 2024\n mrr_q3_2024 = q3_2024_active.groupby('plan')['mrr'].sum()\n \n # Calculate year-over-year percentage increase\n yoy_increase = {}\n for plan in mrr_q3_2025.index:\n if plan in mrr_q3_2024.index and mrr_q3_2024[plan] > 0:\n pct_increase = ((mrr_q3_2025[plan] - mrr_q3_2024[plan]) / mrr_q3_2024[plan]) * 100\n yoy_increase[plan] = pct_increase\n elif plan not in mrr_q3_2024.index and mrr_q3_2025[plan] > 0:\n # If no data in Q3 2024 but data in Q3 2025, treat as infinite growth\n yoy_increase[plan] = float('inf')\n \n # Find plan with largest increase\n if yoy_increase:\n max_plan = max(yoy_increase, key=yoy_increase.get)\n return max_plan\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "support01_l1_089", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n return df['resolution_hours'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l1_090", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n mean_resolution_hours = df['resolution_hours'].mean()\n return mean_resolution_hours", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l1_091", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n tickets = tables['tickets']\n return tickets['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_092", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n # Group by category and sum resolution_hours, excluding NaN values\n category_totals = df.groupby('category')['resolution_hours'].sum()\n # Find the category with the highest total\n highest_category = category_totals.idxmax()\n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_093", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n \n # Filter for eligible records (non-null resolution_hours)\n eligible = df[df['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = eligible.groupby('category')['resolution_hours'].sum()\n \n # Find category with highest total\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_094", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n \n # Filter for 2025 data\n df['created_date'] = pd.to_datetime(df['created_date'])\n df_2025 = df[df['created_date'].dt.year == 2025]\n \n # Remove rows with null resolution_hours\n df_2025 = df_2025.dropna(subset=['resolution_hours'])\n \n # Group by category and sum resolution_hours\n category_totals = df_2025.groupby('category')['resolution_hours'].sum()\n \n # Find the category with the highest total\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_095", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n \n # Filter for 2025 records\n df['created_date'] = pd.to_datetime(df['created_date'])\n df_2025 = df[df['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n df_eligible = df_2025[df_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = df_eligible.groupby('category')['resolution_hours'].sum()\n \n # Find category with highest total resolution_hours\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_096", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n \n # Filter for 2025 records\n df['created_date'] = pd.to_datetime(df['created_date'])\n df_2025 = df[df['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n df_eligible = df_2025[df_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = df_eligible.groupby('category')['resolution_hours'].sum()\n \n # Find category with lowest total resolution_hours\n lowest_category = category_totals.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l2_097", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n \n # Filter for 2025 records\n df['created_date'] = pd.to_datetime(df['created_date'])\n df_2025 = df[df['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n df_eligible = df_2025[df_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = df_eligible.groupby('category')['resolution_hours'].sum().reset_index()\n category_totals.columns = ['category', 'total_resolution_hours']\n \n # Sort by total_resolution_hours in descending order and get top 3\n top_3 = category_totals.sort_values('total_resolution_hours', ascending=False).head(3)\n \n # Return as list of category names\n return top_3['category'].tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "support01_l3_098", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['tickets']\n \n # Filter for 2025 records\n df['created_date'] = pd.to_datetime(df['created_date'])\n df_2025 = df[df['created_date'].dt.year == 2025]\n \n # Filter for eligible records (not null resolution_hours)\n df_eligible = df_2025[df_2025['resolution_hours'].notna()]\n \n # Group by category and calculate average resolution_hours and count\n category_stats = df_eligible.groupby('category').agg({\n 'resolution_hours': ['mean', 'count']\n }).reset_index()\n \n category_stats.columns = ['category', 'avg_resolution_hours', 'count']\n \n # Filter for categories with at least 30 records\n category_stats = category_stats[category_stats['count'] >= 30]\n \n # Find the category with the highest average resolution_hours\n if len(category_stats) == 0:\n return None\n \n highest_category = category_stats.loc[category_stats['avg_resolution_hours'].idxmax(), 'category']\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l4_099", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['tickets'].copy()\n \n # Convert created_date to datetime\n df['created_date'] = pd.to_datetime(df['created_date'])\n \n # Extract year and quarter\n df['year'] = df['created_date'].dt.year\n df['quarter'] = df['created_date'].dt.quarter\n \n # Filter for Q2 (April, May, June) data only\n df['month'] = df['created_date'].dt.month\n df_q2 = df[(df['month'] >= 4) & (df['month'] <= 6)].copy()\n \n # Remove rows with null resolution_hours\n df_q2 = df_q2.dropna(subset=['resolution_hours'])\n \n # Group by category and year, sum resolution_hours\n q2_by_category_year = df_q2.groupby(['category', 'year'])['resolution_hours'].sum().reset_index()\n \n # Get Q2 2024 and Q2 2025 data\n q2_2024 = q2_by_category_year[q2_by_category_year['year'] == 2024].copy()\n q2_2025 = q2_by_category_year[q2_by_category_year['year'] == 2025].copy()\n \n # Merge to compare\n comparison = pd.merge(\n q2_2024[['category', 'resolution_hours']],\n q2_2025[['category', 'resolution_hours']],\n on='category',\n how='inner',\n suffixes=('_2024', '_2025')\n )\n \n # Calculate year-over-year percentage increase\n comparison['yoy_increase_pct'] = (\n (comparison['resolution_hours_2025'] - comparison['resolution_hours_2024']) \n / comparison['resolution_hours_2024'] * 100\n )\n \n # Find category with largest increase\n max_idx = comparison['yoy_increase_pct'].idxmax()\n category_with_max_increase = comparison.loc[max_idx, 'category']\n \n return category_with_max_increase", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "support01_l4_100", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['tickets'].copy()\n \n # Convert created_date to datetime\n df['created_date'] = pd.to_datetime(df['created_date'])\n \n # Extract year and quarter\n df['year'] = df['created_date'].dt.year\n df['quarter'] = df['created_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) data\n df_q3 = df[df['quarter'] == 3]\n \n # Group by category and year, sum resolution_hours\n # Skip nulls in resolution_hours\n q3_data = df_q3.groupby(['category', 'year'])['resolution_hours'].sum().reset_index()\n \n # Get years present in Q3 data\n years_in_q3 = sorted(q3_data['year'].unique())\n \n # We need at least 2 years to calculate YoY\n if len(years_in_q3) < 2:\n return None\n \n # Get the two most recent years\n year_current = years_in_q3[-1]\n year_previous = years_in_q3[-2]\n \n # Create pivot table\n pivot = q3_data.pivot(index='category', columns='year', values='resolution_hours').fillna(0)\n \n # Calculate YoY percentage increase\n if year_previous in pivot.columns and year_current in pivot.columns:\n pivot['yoy_increase'] = ((pivot[year_current] - pivot[year_previous]) / pivot[year_previous]) * 100\n \n # Handle cases where previous year was 0 (avoid division by zero)\n pivot['yoy_increase'] = pivot['yoy_increase'].replace([float('inf'), float('-inf')], float('-inf'))\n \n # Find category with largest YoY increase\n max_category = pivot['yoy_increase'].idxmax()\n \n return max_category\n \n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l1_012", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['page_views'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l1_013", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['page_views'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l1_014", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_015", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n total_page_views_by_category = sessions.groupby('category')['page_views'].sum()\n category_with_highest_page_views = total_page_views_by_category.idxmax()\n return category_with_highest_page_views", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_016", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Find eligible records - sessions that have corresponding conversions\n eligible_session_ids = set(conversions['session_id'].unique())\n eligible_sessions = sessions[sessions['session_id'].isin(eligible_session_ids)]\n \n # Group by category and sum page_views\n category_page_views = eligible_sessions.groupby('category')['page_views'].sum()\n \n # Find category with highest total page_views\n highest_category = category_page_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_017", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Group by category and sum page_views\n category_views = sessions.groupby('category')['page_views'].sum()\n \n # Find the category with the highest total page_views\n highest_category = category_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_018", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Merge sessions with conversions to identify eligible records\n # Eligible records are those that have a conversion\n eligible_sessions = sessions[sessions['session_id'].isin(conversions['session_id'])]\n \n # Group by category and sum page_views\n category_page_views = eligible_sessions.groupby('category')['page_views'].sum()\n \n # Find category with highest total page_views\n highest_category = category_page_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_019", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Get eligible records - those that have a conversion\n eligible_session_ids = set(conversions['session_id'].unique())\n eligible_sessions = sessions[sessions['session_id'].isin(eligible_session_ids)]\n \n # Group by category and sum page_views\n category_page_views = eligible_sessions.groupby('category')['page_views'].sum()\n \n # Find category with lowest total page_views\n lowest_category = category_page_views.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l2_020", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Get eligible records (sessions that have a conversion)\n eligible_session_ids = set(conversions['session_id'].unique())\n eligible_sessions = sessions[sessions['session_id'].isin(eligible_session_ids)]\n \n # Group by category and sum page_views\n category_page_views = eligible_sessions.groupby('category')['page_views'].sum().sort_values(ascending=False)\n \n # Get top 3 categories\n top_3_categories = category_page_views.head(3).index.tolist()\n \n return top_3_categories", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l3_021", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Filter for new users only\n new_users = sessions[sessions['customer_type'] == 'new']\n \n # Get session_ids that converted\n converted_session_ids = set(conversions['session_id'])\n \n # For each category, calculate conversion rate among new users\n category_conversion_rates = {}\n \n for category in new_users['category'].unique():\n category_sessions = new_users[new_users['category'] == category]\n total_sessions = len(category_sessions)\n \n if total_sessions == 0:\n continue\n \n converted_sessions = len(category_sessions[category_sessions['session_id'].isin(converted_session_ids)])\n conversion_rate = converted_sessions / total_sessions\n category_conversion_rates[category] = conversion_rate\n \n # Find category with highest conversion rate\n if category_conversion_rates:\n highest_category = max(category_conversion_rates, key=category_conversion_rates.get)\n return highest_category\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l3_022", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Convert event_date to datetime for filtering\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for 2025 sessions with new users\n sessions_2025_new = sessions[\n (sessions['event_date'].dt.year == 2025) & \n (sessions['customer_type'] == 'new')\n ]\n \n # Get conversion data for 2025\n conversions_2025 = conversions[conversions['event_date'].dt.year == 2025]\n \n # Merge to find which sessions converted\n sessions_with_conversion = sessions_2025_new.merge(\n conversions_2025[['session_id']], \n on='session_id', \n how='left',\n indicator=True\n )\n \n # Mark conversions (1 if converted, 0 if not)\n sessions_with_conversion['converted'] = (sessions_with_conversion['_merge'] == 'both').astype(int)\n \n # Group by category and calculate conversion rate\n category_conversion = sessions_with_conversion.groupby('category').agg(\n total_sessions=('session_id', 'count'),\n converted_sessions=('converted', 'sum')\n )\n \n category_conversion['conversion_rate'] = category_conversion['converted_sessions'] / category_conversion['total_sessions']\n \n # Find category with highest conversion rate\n highest_conversion_category = category_conversion['conversion_rate'].idxmax()\n \n return highest_conversion_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l3_023", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for 2025 sessions\n sessions_2025 = sessions[sessions['event_date'].dt.year == 2025].copy()\n \n # Exclude test traffic\n sessions_2025 = sessions_2025[sessions_2025['traffic_source'] != 'test']\n \n # Merge with conversions to identify converted sessions\n sessions_with_conversions = sessions_2025.merge(\n conversions[['session_id']], \n on='session_id', \n how='left',\n indicator=True\n )\n \n # Calculate conversion rate by category\n conversion_by_category = sessions_with_conversions.groupby('category').apply(\n lambda x: (x['_merge'] == 'both').sum() / len(x)\n )\n \n # Find category with highest conversion rate\n highest_category = conversion_by_category.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l3_024", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for 2025 sessions\n sessions_2025 = sessions[sessions['event_date'].dt.year == 2025].copy()\n \n # Filter for new users\n new_users = sessions_2025[sessions_2025['customer_type'] == 'new'].copy()\n \n # Filter for mobile devices\n mobile_sessions = new_users[new_users['device'] == 'mobile'].copy()\n \n # Merge with conversions to get mobile conversions\n conversions_2025 = conversions[conversions['event_date'].dt.year == 2025].copy()\n mobile_with_conversions = mobile_sessions.merge(\n conversions_2025[['session_id']], \n on='session_id', \n how='left', \n indicator=True\n )\n \n # Calculate conversion rate by category\n conversion_rates = []\n \n for category in mobile_sessions['category'].unique():\n category_sessions = mobile_sessions[mobile_sessions['category'] == category]\n total_sessions = len(category_sessions)\n \n if total_sessions == 0:\n continue\n \n converted_sessions = len(category_sessions[category_sessions['session_id'].isin(conversions_2025['session_id'])])\n conversion_rate = converted_sessions / total_sessions\n \n conversion_rates.append({\n 'category': category,\n 'conversion_rate': conversion_rate,\n 'total_sessions': total_sessions,\n 'conversions': converted_sessions\n })\n \n if not conversion_rates:\n return None\n \n # Find category with highest conversion rate\n conversion_df = pd.DataFrame(conversion_rates)\n highest_category = conversion_df.loc[conversion_df['conversion_rate'].idxmax(), 'category']\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-haiku-4-5", "task_id": "web01_l4_025", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n # Filter for Q2 (April, May, June = months 4, 5, 6)\n sessions['month'] = sessions['event_date'].dt.month\n sessions['is_q2'] = (sessions['month'] >= 4) & (sessions['month'] <= 6)\n \n q2_sessions = sessions[sessions['is_q2']].copy()\n \n # Group by category and year to get total page_views\n q2_by_category_year = q2_sessions.groupby(['category', 'year'])['page_views'].sum().reset_index()\n \n # Pivot to get years as columns\n pivot_df = q2_by_category_year.pivot(index='category', columns='year', values='page_views').fillna(0)\n \n # Calculate year-over-year percentage increase\n # We need to find the largest increase from one year to the next\n yoy_increases = {}\n \n for category in pivot_df.index:\n years = sorted(pivot_df.columns)\n for i in range(len(years) - 1):\n prev_year = years[i]\n next_year = years[i + 1]\n \n prev_views = pivot_df.loc[category, prev_year]\n next_views = pivot_df.loc[category, next_year]\n \n if prev_views > 0:\n pct_increase = ((next_views - prev_views) / prev_views) * 100\n key = (category, prev_year, next_year)\n yoy_increases[key] = pct_increase\n \n # Find the maximum year-over-year increase\n if yoy_increases:\n max_key = max(yoy_increases, key=yoy_increases.get)\n category_with_max_increase = max_key[0]\n return category_with_max_increase\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l4_026", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n from datetime import datetime\n \n sessions = tables['sessions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n # Filter for Q3 (July, August, September) of both 2024 and 2025\n q3_sessions = sessions[(sessions['quarter'] == 3)]\n \n # Group by category, year and sum page_views\n q3_by_category_year = q3_sessions.groupby(['category', 'year'])['page_views'].sum().reset_index()\n \n # Pivot to get 2024 and 2025 side by side\n pivot_df = q3_by_category_year.pivot(index='category', columns='year', values='page_views')\n \n # Calculate year-over-year percentage increase\n # YoY % increase = ((2025 - 2024) / 2024) * 100\n if 2024 in pivot_df.columns and 2025 in pivot_df.columns:\n pivot_df['yoy_increase'] = ((pivot_df[2025] - pivot_df[2024]) / pivot_df[2024]) * 100\n \n # Find category with largest YoY percentage increase\n max_category = pivot_df['yoy_increase'].idxmax()\n return max_category\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-haiku-4-5", "task_id": "web01_l5_027", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for new customers only\n sessions = sessions[sessions['customer_type'] == 'new']\n \n # Exclude test traffic\n sessions = sessions[sessions['traffic_source'] != 'test']\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n conversions['year'] = conversions['event_date'].dt.year\n conversions['quarter'] = conversions['event_date'].dt.quarter\n \n # Get Q2 sessions (Q2 = months 4, 5, 6)\n sessions['month'] = sessions['event_date'].dt.month\n sessions_q2 = sessions[(sessions['month'] >= 4) & (sessions['month'] <= 6)].copy()\n \n # Count eligible sessions per category per year in Q2\n session_counts = sessions_q2.groupby(['year', 'category']).size().reset_index(name='session_count')\n \n # Merge conversions with sessions to get conversion data\n conversions_with_category = conversions.merge(sessions[['session_id', 'category', 'year', 'quarter', 'month']], \n on='session_id', how='inner')\n \n # Filter conversions for Q2\n conversions_q2 = conversions_with_category[(conversions_with_category['month'] >= 4) & \n (conversions_with_category['month'] <= 6)].copy()\n \n # Count conversions per category per year in Q2\n conversion_counts = conversions_q2.groupby(['year', 'category']).size().reset_index(name='conversion_count')\n \n # Merge session counts with conversion counts\n merged = session_counts.merge(conversion_counts, on=['year', 'category'], how='left')\n merged['conversion_count'] = merged['conversion_count'].fillna(0)\n \n # Calculate conversion rate\n merged['conversion_rate'] = merged['conversion_count'] / merged['session_count']\n \n # Filter for categories with at least 30 eligible sessions\n merged = merged[merged['session_count'] >= 30]\n \n # Pivot to get 2024 and 2025 data side by side\n pivot = merged.pivot(index='category', columns='year', values='conversion_rate').reset_index()\n \n # Calculate year-over-year percentage change (2024 to 2025)\n # YoY % change = ((2025_rate - 2024_rate) / 2024_rate) * 100\n if 2024 in pivot.columns and 2025 in pivot.columns:\n pivot['yoy_pct_change'] = ((pivot[2025] - pivot[2024]) / pivot[2024]) * 100\n else:\n # If one year is missing, return None\n return None\n \n # Remove rows with NaN values (categories that don't have both years)\n pivot = pivot.dropna(subset=['yoy_pct_change'])\n \n # Find category with largest year-over-year percentage change\n if len(pivot) == 0:\n return None\n \n max_idx = pivot['yoy_pct_change'].idxmax()\n result_category = pivot.loc[max_idx, 'category']\n \n return result_category", "executed_on_seed42": false, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-haiku-4-5", "task_id": "web01_l5_028", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for new customers only\n sessions = sessions[sessions['customer_type'] == 'new'].copy()\n \n # Exclude test traffic (assuming traffic_source != 'test' or similar)\n sessions = sessions[sessions['traffic_source'] != 'test'].copy()\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n # Mark sessions that have conversions\n conversion_sessions = set(conversions['session_id'].unique())\n sessions['has_conversion'] = sessions['session_id'].isin(conversion_sessions)\n \n # Group by category and year-quarter to count sessions and conversions\n sessions['year_quarter'] = sessions['year'].astype(str) + '-Q' + sessions['quarter'].astype(str)\n \n grouped = sessions.groupby(['category', 'year', 'quarter']).agg(\n eligible_sessions=('session_id', 'count'),\n converted_sessions=('has_conversion', 'sum')\n ).reset_index()\n \n # Filter for categories with at least 30 eligible sessions in each period\n grouped = grouped[grouped['eligible_sessions'] >= 30]\n \n # Calculate conversion rate\n grouped['conversion_rate'] = grouped['converted_sessions'] / grouped['eligible_sessions']\n \n # Find Q3 2025 and Q3 2024 data\n q3_2025 = grouped[(grouped['year'] == 2025) & (grouped['quarter'] == 3)].copy()\n q3_2024 = grouped[(grouped['year'] == 2024) & (grouped['quarter'] == 3)].copy()\n \n # Merge to get YoY comparison\n yoy_data = q3_2025.merge(\n q3_2024[['category', 'conversion_rate']],\n on='category',\n suffixes=('_2025', '_2024')\n )\n \n # Calculate YoY percentage change\n yoy_data['yoy_pct_change'] = (\n (yoy_data['conversion_rate_2025'] - yoy_data['conversion_rate_2024']) / \n yoy_data['conversion_rate_2024'] * 100\n )\n \n # Find category with largest YoY percentage change\n if len(yoy_data) > 0:\n max_idx = yoy_data['yoy_pct_change'].abs().idxmax()\n result = yoy_data.loc[max_idx, 'category']\n return result\n \n return None", "executed_on_seed42": false, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-sonnet-4-6", "task_id": "market01_l1_029", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l1_030", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l1_031", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['seller_id'].nunique(dropna=True)", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_032", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df.groupby('category')['order_value'].sum().idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_033", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n eligible = df[df['order_status'] != 'cancelled'].dropna(subset=['seller_id', 'category', 'order_value'])\n result = eligible.groupby('category')['order_value'].sum().sort_values(ascending=False)\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_034", "scenario_id": "market01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n max_date = df['order_date'].max()\n # current period defined as the most recent month in the data\n period_start = max_date.replace(day=1)\n current = df[df['order_date'] >= period_start]\n if current.empty:\n current = df\n result = current.groupby('category')['order_value'].sum().sort_values(ascending=False)\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_035", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['seller_orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n # Eligible records: exclude cancelled/returned orders\n eligible = df[~df['order_status'].isin(['cancelled', 'returned'])].copy()\n\n # Current period: most recent calendar month in the data\n max_date = eligible['order_date'].max()\n current_period = eligible[\n (eligible['order_date'].dt.year == max_date.year) &\n (eligible['order_date'].dt.month == max_date.month)\n ]\n\n result = current_period.groupby('category')['order_value'].sum().sort_values(ascending=False)\n\n if result.empty:\n return None\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_036", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n eligible = df[df['order_status'] != 'returned']\n result = eligible.groupby('category')['order_value'].sum()\n return result.idxmin()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l2_037", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n eligible = df[df['order_status'] != 'cancelled']\n result = (\n eligible.groupby('category')['order_value']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n return result.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "market01_l3_038", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['seller_orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n df = df[df['order_date'].dt.year == 2025]\n\n # Eligible orders: exclude cancelled orders\n df = df[df['order_status'].str.lower() != 'cancelled']\n\n if df.empty:\n return None\n\n avg_order_value = df.groupby('category')['order_value'].mean().sort_values(ascending=False)\n return avg_order_value.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "market01_l4_039", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['seller_orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n def q2(year):\n return df[(df['order_date'].dt.year == year) &\n (df['order_date'].dt.month.isin([4, 5, 6]))]\n\n q2_2025 = q2(2025).groupby('category')['order_value'].sum()\n q2_2024 = q2(2024).groupby('category')['order_value'].sum()\n\n categories = set(q2_2025.index) & set(q2_2024.index)\n\n pct_change = {}\n for cat in categories:\n prev = q2_2024[cat]\n curr = q2_2025[cat]\n if prev != 0:\n pct_change[cat] = (curr - prev) / prev * 100\n\n if not pct_change:\n return None\n\n best_cat = max(pct_change, key=pct_change.get)\n return best_cat", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "market01_l4_040", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['seller_orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n q3_2025 = df[(df['order_date'] >= '2025-07-01') & (df['order_date'] <= '2025-09-30')]\n q3_2024 = df[(df['order_date'] >= '2024-07-01') & (df['order_date'] <= '2024-09-30')]\n\n order_value_2025 = q3_2025.groupby('category')['order_value'].sum()\n order_value_2024 = q3_2024.groupby('category')['order_value'].sum()\n\n categories = set(order_value_2025.index) | set(order_value_2024.index)\n pct_change = {}\n for cat in categories:\n prev = order_value_2024.get(cat, 0)\n curr = order_value_2025.get(cat, 0)\n if prev > 0:\n pct_change[cat] = (curr - prev) / prev * 100\n\n if not pct_change:\n return None\n\n best_cat = max(pct_change, key=pct_change.get)\n return best_cat", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l1_053", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n return df['spend'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l1_054", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n return df['spend'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l1_055", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n return tables['campaigns']['campaign_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_056", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['campaigns']\n result = df.groupby('channel')['spend'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_057", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['campaigns']\n\n eligible = df[df['status'].isin(['active', 'completed'])]\n\n result = eligible.groupby('channel')['spend'].sum().sort_values(ascending=False)\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_058", "scenario_id": "mktg01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'], errors='coerce')\n df_2025 = df[df['event_date'].dt.year == 2025]\n result = df_2025.groupby('channel')['spend'].sum().sort_values(ascending=False)\n if result.empty:\n return None\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_059", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'], errors='coerce')\n df = df[df['event_date'].dt.year == 2025]\n\n if 'status' in df.columns:\n df = df[df['status'].str.lower() != 'cancelled']\n\n result = df.groupby('channel')['spend'].sum().sort_values(ascending=False)\n\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_060", "scenario_id": "mktg01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'], errors='coerce')\n \n eligible = df[\n (df['event_date'].dt.year == 2025) &\n (df['status'].isin(['active', 'completed'])) &\n (df['spend'].notna())\n ]\n \n if eligible.empty:\n return None\n \n totals = eligible.groupby('channel')['spend'].sum().sort_values()\n return totals.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l2_061", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'], errors='coerce')\n\n eligible = df[\n (df['event_date'].dt.year == 2025) &\n (df['status'].isin(['active', 'completed']))\n ]\n\n result = (\n eligible.groupby('channel')['spend']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n\n return result.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l3_062", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'], errors='coerce')\n df = df[df['event_date'].dt.year == 2025]\n\n grouped = df.groupby('channel')['spend'].agg(['mean', 'count'])\n grouped = grouped[grouped['count'] >= 30]\n\n if grouped.empty:\n return None\n\n result = grouped.sort_values('mean', ascending=False).index[0]\n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l4_063", "scenario_id": "mktg01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'])\n\n def q2_mask(year):\n return (df['event_date'].dt.year == year) & (df['event_date'].dt.month.isin([4, 5, 6]))\n\n q2_2025 = df[q2_mask(2025)].groupby('channel')['spend'].sum()\n q2_2024 = df[q2_mask(2024)].groupby('channel')['spend'].sum()\n\n channels = q2_2025.index.union(q2_2024.index)\n pct_change = {}\n for ch in channels:\n prev = q2_2024.get(ch, np.nan)\n curr = q2_2025.get(ch, np.nan)\n if pd.isna(prev) or prev == 0 or pd.isna(curr):\n continue\n pct_change[ch] = (curr - prev) / prev * 100\n\n if not pct_change:\n return None\n\n sorted_channels = sorted(pct_change.items(), key=lambda x: x[1], reverse=True)\n return sorted_channels[0][0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "mktg01_l4_064", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['campaigns'].copy()\n df['event_date'] = pd.to_datetime(df['event_date'])\n\n q3_2025 = df[(df['event_date'] >= '2025-07-01') & (df['event_date'] <= '2025-09-30')]\n q3_2024 = df[(df['event_date'] >= '2024-07-01') & (df['event_date'] <= '2024-09-30')]\n\n spend_2025 = q3_2025.groupby('channel')['spend'].sum()\n spend_2024 = q3_2024.groupby('channel')['spend'].sum()\n\n combined = pd.DataFrame({'spend_2025': spend_2025, 'spend_2024': spend_2024}).dropna()\n combined = combined[combined['spend_2024'] > 0]\n\n combined['pct_change'] = (combined['spend_2025'] - combined['spend_2024']) / combined['spend_2024'] * 100\n\n combined = combined.sort_values('pct_change', ascending=False)\n\n if combined.empty:\n return None\n\n return combined.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l1_077", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n return df['cost'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l1_078", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n return df['cost'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l1_079", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n return df['order_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_080", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n result = df.groupby('category')['cost'].sum().idxmax()\n return result", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_081", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['shipments']\n eligible = df[df['status'] != 'lost'].dropna(subset=['cost', 'category'])\n result = eligible.groupby('category')['cost'].sum().sort_values(ascending=False)\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_082", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'], errors='coerce')\n df_2025 = df[df['ship_date'].dt.year == 2025]\n result = df_2025.groupby('category')['cost'].sum().sort_values(ascending=False)\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_083", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'], errors='coerce')\n\n eligible = df[(df['ship_date'].dt.year == 2025) & (df['actual_days'].notna())]\n\n if eligible.empty:\n return None\n\n result = eligible.groupby('category')['cost'].sum().sort_values(ascending=False)\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_084", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'], errors='coerce')\n df = df[df['status'] != 'lost']\n df_2025 = df[df['ship_date'].dt.year == 2025]\n if df_2025.empty:\n return None\n totals = df_2025.groupby('category')['cost'].sum().sort_values()\n return totals.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l2_085", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'], errors='coerce')\n df_eligible = df[(df['ship_date'].dt.year == 2025) & (df['actual_days'].notnull())]\n\n result = (\n df_eligible.groupby('category')['cost']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n\n return list(result.index)", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l3_086", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'], errors='coerce')\n df = df[df['ship_date'].dt.year == 2025]\n \n grouped = df.groupby('category')['cost'].agg(['mean', 'count'])\n grouped = grouped[grouped['count'] >= 30]\n \n if grouped.empty:\n return None\n \n grouped = grouped.sort_values('mean', ascending=False)\n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l4_087", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n q2_2025 = df[(df['ship_date'] >= '2025-04-01') & (df['ship_date'] <= '2025-06-30')]\n q2_2024 = df[(df['ship_date'] >= '2024-04-01') & (df['ship_date'] <= '2024-06-30')]\n \n cost_2025 = q2_2025.groupby('category')['cost'].sum()\n cost_2024 = q2_2024.groupby('category')['cost'].sum()\n \n categories = set(cost_2025.index) & set(cost_2024.index)\n \n pct_change = {}\n for cat in categories:\n old = cost_2024[cat]\n new = cost_2025[cat]\n if old != 0:\n pct_change[cat] = (new - old) / old * 100\n \n if not pct_change:\n return None\n \n result = sorted(pct_change.items(), key=lambda x: x[1], reverse=True)\n return result[0][0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "ops01_l4_088", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n q3_2025 = df[(df['ship_date'] >= '2025-07-01') & (df['ship_date'] <= '2025-09-30')]\n q3_2024 = df[(df['ship_date'] >= '2024-07-01') & (df['ship_date'] <= '2024-09-30')]\n \n cost_2025 = q3_2025.groupby('category')['cost'].sum()\n cost_2024 = q3_2024.groupby('category')['cost'].sum()\n \n categories = set(cost_2025.index) & set(cost_2024.index)\n \n pct_changes = {}\n for cat in categories:\n old = cost_2024[cat]\n new = cost_2025[cat]\n if old != 0:\n pct_changes[cat] = (new - old) / old * 100\n \n if not pct_changes:\n return None\n \n result = max(pct_changes.items(), key=lambda x: x[1])\n return result[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l1_065", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n return df['amount'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l1_066", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n return df['amount'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l1_067", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n return df['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_068", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n result = df.groupby('payment_method')['amount'].sum().sort_values(ascending=False)\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_069", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n eligible = df[df['status'] == 'completed']\n result = eligible.groupby('payment_method')['amount'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_070", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n df_2025 = df[df['txn_date'].dt.year == 2025]\n\n result = df_2025.groupby('payment_method')['amount'].sum().sort_values(ascending=False)\n\n if result.empty:\n return None\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_071", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n\n eligible = df[\n (df['txn_date'].dt.year == 2025) &\n (df['status'] == 'completed') &\n (df['txn_type'] == 'payment')\n ]\n\n if eligible.empty:\n return None\n\n totals = eligible.groupby('payment_method')['amount'].sum().sort_values(ascending=False)\n return totals.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_072", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n\n eligible = df[(df['txn_date'].dt.year == 2025) & (df['status'] == 'completed')]\n\n grouped = eligible.groupby('payment_method')['amount'].sum()\n\n if grouped.empty:\n return None\n\n return grouped.idxmin()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l2_073", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n\n eligible = df[\n (df['txn_date'].dt.year == 2025) &\n (df['status'] == 'completed')\n ]\n\n result = (\n eligible.groupby('payment_method')['amount']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n\n return list(result.index)", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l3_074", "scenario_id": "payments01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n df = df[df['txn_date'].dt.year == 2025]\n df = df[df['status'] == 'completed']\n \n grouped = df.groupby('payment_method')['amount'].agg(['mean', 'count'])\n grouped = grouped[grouped['count'] >= 30]\n \n if grouped.empty:\n return None\n \n result = grouped['mean'].idxmax()\n return result", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l4_075", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n\n def q2_mask(year):\n return (df['txn_date'].dt.year == year) & (df['txn_date'].dt.month.isin([4, 5, 6]))\n\n q2_2025 = df[q2_mask(2025)].groupby('payment_method')['amount'].sum()\n q2_2024 = df[q2_mask(2024)].groupby('payment_method')['amount'].sum()\n\n pct_change = {}\n for method in q2_2025.index.union(q2_2024.index):\n prev = q2_2024.get(method, 0)\n curr = q2_2025.get(method, 0)\n if prev > 0:\n pct_change[method] = (curr - prev) / prev * 100\n\n if not pct_change:\n return None\n\n result = sorted(pct_change.items(), key=lambda x: x[1], reverse=True)[0][0]\n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "payments01_l4_076", "scenario_id": "payments01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions'].copy()\n df['txn_date'] = pd.to_datetime(df['txn_date'], errors='coerce')\n \n def q3_mask(year):\n return (df['txn_date'].dt.year == year) & (df['txn_date'].dt.month.isin([7, 8, 9]))\n \n q3_2025 = df[q3_mask(2025)]\n q3_2024 = df[q3_mask(2024)]\n \n sum_2025 = q3_2025.groupby('payment_method')['amount'].sum()\n sum_2024 = q3_2024.groupby('payment_method')['amount'].sum()\n \n methods = set(sum_2025.index) | set(sum_2024.index)\n \n best_method = None\n best_pct = -np.inf\n \n for m in methods:\n v2025 = sum_2025.get(m, 0)\n v2024 = sum_2024.get(m, 0)\n if v2024 == 0:\n continue\n pct = (v2025 - v2024) / v2024 * 100\n if pct > best_pct:\n best_pct = pct\n best_method = m\n \n return best_method", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l1_000", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n return df['revenue'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l1_001", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n return df['revenue'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l1_002", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n return df['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_003", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n result = df.groupby('category')['revenue'].sum().idxmax()\n return result", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_004", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n eligible = df[df['order_status'] != 'cancelled']\n result = eligible.groupby('category')['revenue'].sum().sort_values(ascending=False)\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_005", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n df = df.dropna(subset=['order_date'])\n\n max_date = df['order_date'].max()\n current_period = df[\n (df['order_date'].dt.year == max_date.year) &\n (df['order_date'].dt.month == max_date.month)\n ]\n\n revenue_by_category = current_period.groupby('category')['revenue'].sum().sort_values(ascending=False)\n\n if revenue_by_category.empty:\n return None\n\n return revenue_by_category.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_006", "scenario_id": "retail01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n # exclude cancelled/refunded orders - only eligible statuses\n eligible = df[~df['order_status'].isin(['cancelled', 'refunded'])].copy()\n\n # current period = most recent year-month in the data\n if eligible['order_date'].notna().any():\n max_date = eligible['order_date'].max()\n current_period = eligible[\n (eligible['order_date'].dt.year == max_date.year) &\n (eligible['order_date'].dt.month == max_date.month)\n ]\n else:\n current_period = eligible\n\n if current_period.empty:\n current_period = eligible\n\n revenue_by_category = current_period.groupby('category')['revenue'].sum().sort_values(ascending=False)\n\n if revenue_by_category.empty:\n return None\n\n return revenue_by_category.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_007", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n eligible = df[df['order_status'] != 'cancelled']\n result = eligible.groupby('category')['revenue'].sum().sort_values()\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l2_008", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['orders']\n eligible = df[df['order_status'] != 'cancelled']\n result = (\n eligible.groupby('category')['revenue']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n return result.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l3_009", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n df = df[df['order_date'].dt.year == 2025]\n df = df[df['order_status'] != 'cancelled']\n\n if df.empty:\n return None\n\n avg_rev = df.groupby('category')['revenue'].mean().sort_values(ascending=False)\n\n return avg_rev.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l4_010", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n\n q2_2025 = df[(df['order_date'].dt.year == 2025) & (df['order_date'].dt.quarter == 2)]\n q2_2024 = df[(df['order_date'].dt.year == 2024) & (df['order_date'].dt.quarter == 2)]\n\n rev_2025 = q2_2025.groupby('category')['revenue'].sum()\n rev_2024 = q2_2024.groupby('category')['revenue'].sum()\n\n categories = set(rev_2025.index) & set(rev_2024.index)\n\n pct_change = {}\n for cat in categories:\n prev = rev_2024[cat]\n curr = rev_2025[cat]\n if prev != 0:\n pct_change[cat] = (curr - prev) / prev * 100\n\n if not pct_change:\n return None\n\n best_category = max(pct_change, key=pct_change.get)\n return best_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "retail01_l4_011", "scenario_id": "retail01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['orders'].copy()\n df['order_date'] = pd.to_datetime(df['order_date'], errors='coerce')\n df['year'] = df['order_date'].dt.year\n df['quarter'] = df['order_date'].dt.quarter\n\n q3_2025 = df[(df['year'] == 2025) & (df['quarter'] == 3)]\n q3_2024 = df[(df['year'] == 2024) & (df['quarter'] == 3)]\n\n rev_2025 = q3_2025.groupby('category')['revenue'].sum()\n rev_2024 = q3_2024.groupby('category')['revenue'].sum()\n\n categories = set(rev_2025.index).union(set(rev_2024.index))\n\n best_category = None\n best_pct = -math.inf\n\n for cat in categories:\n r2025 = rev_2025.get(cat, 0)\n r2024 = rev_2024.get(cat, 0)\n if r2024 == 0:\n continue\n pct_change = (r2025 - r2024) / r2024 * 100\n if pct_change > best_pct:\n best_pct = pct_change\n best_category = cat\n\n return best_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l1_041", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n return df['mrr'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l1_042", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n return df['mrr'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l1_043", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n return tables['subscriptions']['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_044", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n return df.groupby('plan')['mrr'].sum().idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_045", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n df = df.drop_duplicates(subset='sub_id')\n df = df[df['mrr'].notna() & (df['mrr'] >= 0)]\n result = df.groupby('plan')['mrr'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_046", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n df_2025 = df[df['start_date'].dt.year == 2025]\n result = df_2025.groupby('plan')['mrr'].sum().sort_values(ascending=False)\n return result.index[0] if not result.empty else None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_047", "scenario_id": "saas01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions'].copy()\n \n # Parse dates\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce')\n \n # Eligible records in 2025: consider records active/relevant during 2025\n # Interpret \"eligible in 2025\" as start_date in 2025 OR (active during 2025 window)\n # A common definition: subscription is eligible/active in 2025 if start_date <= 2025-12-31 \n # and (churn_date is null or churn_date >= 2025-01-01)\n year_start = pd.Timestamp('2025-01-01')\n year_end = pd.Timestamp('2025-12-31')\n \n eligible = df[\n (df['start_date'] <= year_end) &\n (df['churn_date'].isna() | (df['churn_date'] >= year_start))\n ]\n \n if eligible.empty:\n return None\n \n grouped = eligible.groupby('plan')['mrr'].sum().sort_values(ascending=False)\n \n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_048", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n\n eligible = df[df['start_date'].dt.year == 2025]\n\n totals = eligible.groupby('plan')['mrr'].sum()\n\n return totals.idxmin()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l2_049", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n\n eligible = df[df['start_date'].dt.year == 2025]\n\n result = (\n eligible.groupby('plan')['mrr']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n\n return list(result.index)", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l3_050", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n\n eligible = df[df['start_date'].dt.year == 2025]\n\n grouped = eligible.groupby('plan')['mrr'].agg(['mean', 'count'])\n grouped = grouped[grouped['count'] >= 30]\n\n if grouped.empty:\n return None\n\n return grouped['mean'].idxmax()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l4_051", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce')\n\n def total_mrr_for_quarter(q_start, q_end):\n active = df[(df['start_date'] <= q_end) &\n (df['churn_date'].isna() | (df['churn_date'] >= q_start))]\n return active.groupby('plan')['mrr'].sum()\n\n q2_2025_start = pd.Timestamp('2025-04-01')\n q2_2025_end = pd.Timestamp('2025-06-30')\n q2_2024_start = pd.Timestamp('2024-04-01')\n q2_2024_end = pd.Timestamp('2024-06-30')\n\n mrr_2025 = total_mrr_for_quarter(q2_2025_start, q2_2025_end)\n mrr_2024 = total_mrr_for_quarter(q2_2024_start, q2_2024_end)\n\n plans = set(mrr_2025.index).union(set(mrr_2024.index))\n pct_change = {}\n for plan in plans:\n prev = mrr_2024.get(plan, 0)\n curr = mrr_2025.get(plan, 0)\n if prev > 0:\n pct_change[plan] = (curr - prev) / prev * 100\n elif curr > 0:\n pct_change[plan] = float('inf')\n else:\n pct_change[plan] = 0.0\n\n if not pct_change:\n return None\n\n best_plan = max(pct_change, key=lambda p: pct_change[p])\n return best_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "saas01_l4_052", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['subscriptions'].copy()\n df['start_date'] = pd.to_datetime(df['start_date'], errors='coerce')\n df['churn_date'] = pd.to_datetime(df['churn_date'], errors='coerce')\n\n def total_mrr_for_period(df, start, end):\n active = df[(df['start_date'] <= end) & (df['churn_date'].isna() | (df['churn_date'] >= start))]\n return active.groupby('plan')['mrr'].sum()\n\n q3_2024_start = pd.Timestamp('2024-07-01')\n q3_2024_end = pd.Timestamp('2024-09-30')\n q3_2025_start = pd.Timestamp('2025-07-01')\n q3_2025_end = pd.Timestamp('2025-09-30')\n\n mrr_2024 = total_mrr_for_period(df, q3_2024_start, q3_2024_end)\n mrr_2025 = total_mrr_for_period(df, q3_2025_start, q3_2025_end)\n\n plans = set(mrr_2024.index) | set(mrr_2025.index)\n pct_change = {}\n for plan in plans:\n old = mrr_2024.get(plan, 0)\n new = mrr_2025.get(plan, 0)\n if old > 0:\n pct_change[plan] = (new - old) / old * 100\n\n if not pct_change:\n return None\n\n best_plan = max(pct_change, key=pct_change.get)\n return best_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "support01_l1_089", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n return df['resolution_hours'].sum(skipna=True)", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l1_090", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n return df['resolution_hours'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l1_091", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n return tables['tickets']['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_092", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n result = df.groupby('category')['resolution_hours'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_093", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['tickets']\n eligible = df.dropna(subset=['resolution_hours'])\n result = eligible.groupby('category')['resolution_hours'].sum().sort_values(ascending=False)\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_094", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n df_2025 = df[df['created_date'].dt.year == 2025]\n\n result = (\n df_2025.dropna(subset=['resolution_hours'])\n .groupby('category')['resolution_hours']\n .sum()\n .sort_values(ascending=False)\n )\n\n if result.empty:\n return None\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_095", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n\n eligible = df[\n (df['created_date'].dt.year == 2025) &\n (df['resolution_hours'].notna())\n ]\n\n if eligible.empty:\n return None\n\n totals = eligible.groupby('category')['resolution_hours'].sum().sort_values(ascending=False)\n\n return totals.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_096", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n df = df[df['created_date'].dt.year == 2025]\n df = df.dropna(subset=['resolution_hours'])\n grouped = df.groupby('category')['resolution_hours'].sum().sort_values()\n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l2_097", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n \n eligible = df[\n (df['created_date'].dt.year == 2025) &\n (df['resolution_hours'].notna())\n ]\n \n result = (\n eligible.groupby('category')['resolution_hours']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n \n return list(result.index)", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "support01_l3_098", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n df = df[df['created_date'].dt.year == 2025]\n df = df.dropna(subset=['resolution_hours'])\n \n grouped = df.groupby('category')['resolution_hours'].agg(['mean', 'count'])\n grouped = grouped[grouped['count'] >= 30]\n \n if grouped.empty:\n return None\n \n grouped = grouped.sort_values('mean', ascending=False)\n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l4_099", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n df = df.dropna(subset=['resolution_hours', 'created_date'])\n\n def q2_mask(d, year):\n return (d['created_date'].dt.year == year) & (d['created_date'].dt.month.isin([4, 5, 6]))\n\n q2_2025 = df[q2_mask(df, 2025)].groupby('category')['resolution_hours'].sum()\n q2_2024 = df[q2_mask(df, 2024)].groupby('category')['resolution_hours'].sum()\n\n categories = df['category'].unique()\n pct_changes = {}\n for cat in categories:\n prev = q2_2024.get(cat, 0)\n curr = q2_2025.get(cat, 0)\n if prev > 0:\n pct_changes[cat] = (curr - prev) / prev * 100\n\n if not pct_changes:\n return None\n\n best_cat = max(pct_changes, key=pct_changes.get)\n return best_cat", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "support01_l4_100", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n df = tables['tickets'].copy()\n df['created_date'] = pd.to_datetime(df['created_date'], errors='coerce')\n \n def q3_mask(year):\n return (df['created_date'].dt.year == year) & (df['created_date'].dt.month.isin([7,8,9]))\n \n q3_2025 = df[q3_mask(2025)]\n q3_2024 = df[q3_mask(2024)]\n \n sum_2025 = q3_2025.groupby('category')['resolution_hours'].sum(min_count=1)\n sum_2024 = q3_2024.groupby('category')['resolution_hours'].sum(min_count=1)\n \n categories = df['category'].unique()\n \n best_cat = None\n best_pct = -math.inf\n \n for cat in categories:\n val_2025 = sum_2025.get(cat, np.nan)\n val_2024 = sum_2024.get(cat, np.nan)\n if pd.isna(val_2025) or pd.isna(val_2024) or val_2024 == 0:\n continue\n pct = (val_2025 - val_2024) / val_2024 * 100\n if pct > best_pct:\n best_pct = pct\n best_cat = cat\n \n return best_cat", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l1_012", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n return tables['sessions']['page_views'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l1_013", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n return tables['sessions']['page_views'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l1_014", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_015", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n result = sessions.groupby('category')['page_views'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_016", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n eligible = sessions.dropna(subset=['category', 'page_views'])\n result = eligible.groupby('category')['page_views'].sum()\n return result.idxmax()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_017", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n\n max_date = sessions['event_date'].max()\n cutoff = max_date - pd.Timedelta(days=90)\n\n current_period = sessions[sessions['event_date'] > cutoff]\n\n result = current_period.groupby('category')['page_views'].sum().sort_values(ascending=False)\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_018", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n sessions['event_date'] = pd.to_datetime(sessions['event_date'], errors='coerce')\n sessions = sessions.dropna(subset=['event_date', 'category', 'page_views'])\n\n max_date = sessions['event_date'].max()\n period_start = max_date - pd.Timedelta(days=90)\n\n eligible = sessions[(sessions['event_date'] >= period_start) & (sessions['event_date'] <= max_date)]\n\n if eligible.empty:\n return None\n\n result = eligible.groupby('category')['page_views'].sum().sort_values(ascending=False)\n\n return result.index[0]", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_019", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions']\n\n # Eligible records: assuming no additional filter specified, use all sessions with valid category and page_views\n df = sessions.dropna(subset=['category', 'page_views'])\n\n grouped = df.groupby('category')['page_views'].sum().sort_values()\n\n if grouped.empty:\n return None\n\n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l2_020", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions']\n conversions = tables['conversions']\n\n eligible = sessions[sessions['session_id'].isin(conversions['session_id'])]\n\n result = (\n eligible.groupby('category')['page_views']\n .sum()\n .sort_values(ascending=False)\n .head(3)\n )\n\n return result.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l3_021", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions']\n conversions = tables['conversions']\n\n new_sessions = sessions[sessions['customer_type'] == 'new']\n\n merged = new_sessions.merge(\n conversions[['session_id']], on='session_id', how='left', indicator=True\n )\n merged['converted'] = (merged['_merge'] == 'both').astype(int)\n\n rates = merged.groupby('category')['converted'].mean().sort_values(ascending=False)\n\n if rates.empty:\n return None\n\n return rates.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l3_022", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\nimport math\nimport statistics\nimport datetime\nimport collections\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n\n sessions['event_date'] = pd.to_datetime(sessions['event_date'], errors='coerce')\n conversions['event_date'] = pd.to_datetime(conversions['event_date'], errors='coerce')\n\n # Filter new users in 2025\n new_sessions = sessions[(sessions['customer_type'] == 'new') & (sessions['event_date'].dt.year == 2025)]\n\n if new_sessions.empty:\n return None\n\n converted_session_ids = set(conversions['session_id'].unique())\n\n new_sessions = new_sessions.copy()\n new_sessions['converted'] = new_sessions['session_id'].isin(converted_session_ids)\n\n grouped = new_sessions.groupby('category')['converted'].agg(['sum', 'count'])\n grouped['conversion_rate'] = grouped['sum'] / grouped['count']\n\n grouped = grouped.sort_values('conversion_rate', ascending=False)\n\n if grouped.empty:\n return None\n\n return grouped.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l3_023", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n\n # Exclude test traffic\n sessions = sessions[sessions['traffic_source'] != 'test']\n\n # Filter for 2025\n sessions_2025 = sessions[sessions['event_date'].dt.year == 2025]\n\n # Get session ids that converted\n converted_session_ids = set(conversions['session_id'])\n\n sessions_2025 = sessions_2025.copy()\n sessions_2025['converted'] = sessions_2025['session_id'].isin(converted_session_ids)\n\n grouped = sessions_2025.groupby('category')['converted'].mean()\n\n if grouped.empty:\n return None\n\n grouped_sorted = grouped.sort_values(ascending=False)\n return grouped_sorted.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l3_024", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n\n # Filter sessions for new users, mobile device, and year 2025\n filtered = sessions[\n (sessions['customer_type'] == 'new') &\n (sessions['device'] == 'mobile') &\n (sessions['event_date'].dt.year == 2025)\n ]\n\n if filtered.empty:\n return None\n\n # Mark which sessions converted\n converted_session_ids = set(conversions['session_id'])\n filtered = filtered.copy()\n filtered['converted'] = filtered['session_id'].isin(converted_session_ids)\n\n # Group by category and compute conversion rate\n grouped = filtered.groupby('category')['converted'].mean().reset_index()\n grouped = grouped.sort_values('converted', ascending=False)\n\n if grouped.empty:\n return None\n\n return grouped.iloc[0]['category']", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l4_025", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n\n q2_2025 = sessions[(sessions['event_date'] >= '2025-04-01') & (sessions['event_date'] <= '2025-06-30')]\n q2_2024 = sessions[(sessions['event_date'] >= '2024-04-01') & (sessions['event_date'] <= '2024-06-30')]\n\n pv_2025 = q2_2025.groupby('category')['page_views'].sum()\n pv_2024 = q2_2024.groupby('category')['page_views'].sum()\n\n categories = pv_2025.index.union(pv_2024.index)\n pv_2025 = pv_2025.reindex(categories, fill_value=0)\n pv_2024 = pv_2024.reindex(categories, fill_value=0)\n\n pct_change = pd.Series(index=categories, dtype=float)\n for cat in categories:\n prev = pv_2024[cat]\n curr = pv_2025[cat]\n if prev == 0:\n pct_change[cat] = float('inf') if curr > 0 else 0.0\n else:\n pct_change[cat] = (curr - prev) / prev * 100\n\n pct_change_sorted = pct_change.sort_values(ascending=False)\n return pct_change_sorted.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l4_026", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n\n def in_q3(df, year):\n return df[(df['event_date'] >= f'{year}-07-01') & (df['event_date'] <= f'{year}-09-30')]\n\n q3_2025 = in_q3(sessions, 2025).groupby('category')['page_views'].sum()\n q3_2024 = in_q3(sessions, 2024).groupby('category')['page_views'].sum()\n\n categories = q3_2025.index.union(q3_2024.index)\n pct_change = {}\n for cat in categories:\n v2025 = q3_2025.get(cat, 0)\n v2024 = q3_2024.get(cat, 0)\n if v2024 == 0:\n continue\n pct_change[cat] = (v2025 - v2024) / v2024 * 100\n\n if not pct_change:\n return None\n\n best_cat = max(pct_change, key=pct_change.get)\n return best_cat", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-sonnet-4-6", "task_id": "web01_l5_027", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n\n # Filter: new customers, excluding test traffic\n sessions = sessions[(sessions['customer_type'] == 'new') & (sessions['traffic_source'] != 'test')].copy()\n\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n\n converted_ids = set(conversions['session_id'].unique())\n sessions['converted'] = sessions['session_id'].isin(converted_ids)\n\n def get_period(df, year):\n mask = (df['event_date'].dt.year == year) & (df['event_date'].dt.month.isin([4, 5, 6]))\n return df[mask]\n\n q2_2025 = get_period(sessions, 2025)\n q2_2024 = get_period(sessions, 2024)\n\n stats_2025 = q2_2025.groupby('category').agg(\n sessions_count=('session_id', 'count'),\n conversions_count=('converted', 'sum')\n )\n stats_2024 = q2_2024.groupby('category').agg(\n sessions_count=('session_id', 'count'),\n conversions_count=('converted', 'sum')\n )\n\n stats_2025['conv_rate'] = stats_2025['conversions_count'] / stats_2025['sessions_count']\n stats_2024['conv_rate'] = stats_2024['conversions_count'] / stats_2024['sessions_count']\n\n merged = stats_2025.join(stats_2024, lsuffix='_2025', rsuffix='_2024', how='inner')\n\n # Eligible: at least 30 sessions in both periods\n merged = merged[(merged['sessions_count_2025'] >= 30) & (merged['sessions_count_2024'] >= 30)]\n\n if merged.empty:\n return None\n\n merged = merged[merged['conv_rate_2024'] != 0]\n\n merged['pct_change'] = (merged['conv_rate_2025'] - merged['conv_rate_2024']) / merged['conv_rate_2024'] * 100\n\n merged = merged.sort_values(by='pct_change', key=lambda x: x.abs(), ascending=False)\n\n if merged.empty:\n return None\n\n return merged.index[0]", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-sonnet-4-6", "task_id": "web01_l5_028", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n\n # Filter: new customers, exclude test traffic\n df = sessions[(sessions['customer_type'] == 'new') & (sessions['traffic_source'] != 'test')].copy()\n\n # Mark conversions\n converted_ids = set(conversions['session_id'])\n df['converted'] = df['session_id'].isin(converted_ids)\n\n df['year'] = df['event_date'].dt.year\n df['quarter'] = df['event_date'].dt.quarter\n\n q3 = df[df['quarter'] == 3]\n\n results = {}\n for cat, grp in q3.groupby('category'):\n g2024 = grp[grp['year'] == 2024]\n g2025 = grp[grp['year'] == 2025]\n\n if len(g2024) < 30 or len(g2025) < 30:\n continue\n\n cr2024 = g2024['converted'].mean()\n cr2025 = g2025['converted'].mean()\n\n if cr2024 == 0:\n continue\n\n pct_change = (cr2025 - cr2024) / cr2024 * 100\n results[cat] = pct_change\n\n if not results:\n return None\n\n best_category = max(results.items(), key=lambda x: abs(x[1]))[0]\n return best_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "market01_l1_029", "scenario_id": "market01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l1_030", "scenario_id": "market01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['order_value'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l1_031", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['seller_orders']\n return df['seller_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l2_032", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['seller_orders']\n \n # Group by category and sum order_value\n category_order_value = df.groupby('category')['order_value'].sum()\n \n # Find the category with highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l2_033", "scenario_id": "market01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # \"Eligible records\" typically means records that are valid/completed\n # Based on order_status, we should exclude 'returned' and possibly 'cancelled'\n # Common interpretation: eligible = completed/delivered orders (not returned/cancelled)\n # Looking at the data, order_status has 4 unique values\n # Typically eligible means orders that count towards GMV (completed, not returned/cancelled)\n \n # Filter for eligible records - assuming eligible means not returned and not cancelled\n # Let's check what statuses exist and filter appropriately\n # Common eligible statuses would be 'completed', 'delivered', 'shipped'\n \n # Since we don't know exact values, let's assume eligible = not 'returned' and not 'cancelled'\n eligible_df = df[~df['order_status'].isin(['returned', 'cancelled'])]\n \n # If no records remain, fall back to all records\n if len(eligible_df) == 0:\n eligible_df = df\n \n # Group by category and sum order_value\n category_order_value = eligible_df.groupby('category')['order_value'].sum()\n \n # Find the category with highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-opus-4-5", "task_id": "market01_l2_034", "scenario_id": "market01", "generated_program": "import pandas as pd\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Determine the current period - assuming it's the most recent complete month or the current month\n # Based on the data, let's find the maximum date and consider \"current period\" as the most recent month\n max_date = df['order_date'].max()\n \n # Current period = the month of the max date\n current_year = max_date.year\n current_month = max_date.month\n \n # Filter for current period\n current_period_df = df[(df['order_date'].dt.year == current_year) & \n (df['order_date'].dt.month == current_month)]\n \n # Calculate total order_value by category in current period\n order_value_by_category = current_period_df.groupby('category')['order_value'].sum()\n \n # Find the category with highest total order_value\n highest_order_value_category = order_value_by_category.idxmax()\n \n return highest_order_value_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l2_035", "scenario_id": "market01", "generated_program": "import pandas as pd\nimport numpy as np\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Determine \"current period\" - assuming it means the most recent period\n # Common interpretation: current month/year or most recent complete period\n # Let's find the max date and use that as reference for current period\n max_date = df['order_date'].max()\n \n # Current period could be the current month of the max date\n current_year = max_date.year\n current_month = max_date.month\n \n # Filter for current period (current month and year)\n current_period_mask = (df['order_date'].dt.year == current_year) & (df['order_date'].dt.month == current_month)\n \n # \"Eligible records\" typically means non-cancelled/non-returned orders\n # Common interpretation: completed or shipped orders (not cancelled, not returned)\n eligible_statuses = ['completed', 'shipped', 'delivered', 'pending']\n # Let's check what statuses exist and exclude problematic ones\n # Typically 'returned' and 'cancelled' are not eligible\n eligible_mask = ~df['order_status'].isin(['returned', 'cancelled'])\n \n # Combine filters\n filtered_df = df[current_period_mask & eligible_mask]\n \n # If no data in current month, try broader interpretation (current year)\n if filtered_df.empty:\n current_period_mask = (df['order_date'].dt.year == current_year)\n filtered_df = df[current_period_mask & eligible_mask]\n \n # If still empty, just use eligible records across all time\n if filtered_df.empty:\n filtered_df = df[eligible_mask]\n \n # Group by category and sum order_value\n category_order_value = filtered_df.groupby('category')['order_value'].sum()\n \n # Find category with highest total order_value\n highest_category = category_order_value.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l2_036", "scenario_id": "market01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Group by category and sum order_value for eligible records\n # Assuming \"eligible records\" means records without null values in key fields\n # Based on the schema, seller_id has nulls, so we filter those out\n eligible_df = df.dropna(subset=['seller_id'])\n \n # Calculate total order_value by category\n category_order_value = eligible_df.groupby('category')['order_value'].sum()\n \n # Find the category with the lowest total order_value\n lowest_category = category_order_value.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "market01_l2_037", "scenario_id": "market01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders']\n \n # Group by category and sum order_value\n category_order_value = df.groupby('category')['order_value'].sum().sort_values(ascending=False)\n \n # Get top 3 categories\n top_3_categories = category_order_value.head(3).index.tolist()\n \n return top_3_categories", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "market01_l3_038", "scenario_id": "market01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['seller_orders']\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Filter for 2025 orders\n df_2025 = df[df['order_date'].dt.year == 2025]\n \n # Filter for eligible orders (assuming eligible means not cancelled/returned - typically completed/delivered)\n # Based on common order statuses, eligible orders are usually 'delivered' or 'completed'\n # Let's check what statuses exist and assume non-cancelled/returned are eligible\n # Common interpretation: eligible = delivered or shipped (not cancelled, not returned)\n eligible_statuses = df_2025['order_status'].unique()\n # Assuming eligible means orders that count towards GMV (delivered, shipped, completed - not cancelled/returned)\n # Let's filter out 'cancelled' and 'returned' as non-eligible\n df_eligible = df_2025[~df_2025['order_status'].isin(['cancelled', 'returned'])]\n \n # Calculate average GMV per category\n avg_order_value_by_category = df_eligible.groupby('category')['order_value'].mean()\n \n # Find the category with highest average GMV\n highest_avg_category = avg_order_value_by_category.idxmax()\n \n return highest_avg_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "market01_l4_039", "scenario_id": "market01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders'].copy()\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Extract year and quarter\n df['year'] = df['order_date'].dt.year\n df['quarter'] = df['order_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_data = df[df['quarter'] == 2]\n \n # Group by year and category, sum GMV\n order_value_by_year_cat = q2_data.groupby(['year', 'category'])['order_value'].sum().reset_index()\n \n # Pivot to have years as columns\n pivot = order_value_by_year_cat.pivot(index='category', columns='year', values='order_value')\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # Percentage increase = (2025 - 2024) / 2024 * 100\n if 2024 in pivot.columns and 2025 in pivot.columns:\n pivot['yoy_pct_increase'] = (pivot[2025] - pivot[2024]) / pivot[2024] * 100\n \n # Find the category with the largest YoY percentage increase\n category_with_largest_increase = pivot['yoy_pct_increase'].idxmax()\n return category_with_largest_increase\n else:\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "market01_l4_040", "scenario_id": "market01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['seller_orders'].copy()\n \n # Convert order_date to datetime\n df['order_date'] = pd.to_datetime(df['order_date'])\n \n # Extract year and quarter\n df['year'] = df['order_date'].dt.year\n df['quarter'] = df['order_date'].dt.quarter\n \n # Filter for Q3 (quarters 3) for both 2024 and 2025\n q3_data = df[df['quarter'] == 3]\n \n # Group by year and category to get total order_value\n grouped = q3_data.groupby(['year', 'category'])['order_value'].sum().reset_index()\n \n # Pivot to have years as columns\n pivoted = grouped.pivot(index='category', columns='year', values='order_value')\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # YoY % increase = ((2025 - 2024) / 2024) * 100\n pivoted['yoy_pct_increase'] = ((pivoted[2025] - pivoted[2024]) / pivoted[2024]) * 100\n \n # Find the category with the largest YoY percentage increase\n result = pivoted['yoy_pct_increase'].idxmax()\n \n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l1_053", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n return campaigns['spend'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l1_054", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n return campaigns['spend'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l1_055", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n return campaigns['campaign_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_056", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n total_spend_by_channel = campaigns.groupby('channel')['spend'].sum()\n highest_spend_channel = total_spend_by_channel.idxmax()\n return highest_spend_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_057", "scenario_id": "mktg01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n campaigns = tables['campaigns']\n \n # Group by channel and sum the spend\n channel_spend = campaigns.groupby('channel')['spend'].sum()\n \n # Find the channel with the highest total spend\n highest_spend_channel = channel_spend.idxmax()\n \n return highest_spend_channel", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_058", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n \n # Convert event_date to datetime\n campaigns['event_date'] = pd.to_datetime(campaigns['event_date'])\n \n # Filter for 2025\n campaigns_2025 = campaigns[campaigns['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n channel_spend = campaigns_2025.groupby('channel')['spend'].sum()\n \n # Find channel with highest total spend\n highest_spend_channel = channel_spend.idxmax()\n \n return highest_spend_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_059", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n \n # Convert event_date to datetime\n campaigns['event_date'] = pd.to_datetime(campaigns['event_date'])\n \n # Filter for records in 2025\n campaigns_2025 = campaigns[campaigns['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n channel_spend = campaigns_2025.groupby('channel')['spend'].sum()\n \n # Find the channel with highest total spend\n highest_channel = channel_spend.idxmax()\n \n return highest_channel", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_060", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n \n # Convert event_date to datetime\n campaigns['event_date'] = pd.to_datetime(campaigns['event_date'])\n \n # Filter for records in 2025\n campaigns_2025 = campaigns[campaigns['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n spend_by_channel = campaigns_2025.groupby('channel')['spend'].sum()\n \n # Find the channel with lowest total spend\n lowest_spend_channel = spend_by_channel.idxmin()\n \n return lowest_spend_channel", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "mktg01_l2_061", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['campaigns']\n \n # Convert event_date to datetime\n df['event_date'] = pd.to_datetime(df['event_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['event_date'].dt.year == 2025]\n \n # Group by channel and sum spend\n channel_spend = df_2025.groupby('channel')['spend'].sum()\n \n # Sort descending and get top 3\n top_3_channels = channel_spend.sort_values(ascending=False).head(3).index.tolist()\n \n return top_3_channels", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "mktg01_l3_062", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n \n # Convert event_date to datetime\n campaigns['event_date'] = pd.to_datetime(campaigns['event_date'])\n \n # Filter for records in 2025\n campaigns_2025 = campaigns[campaigns['event_date'].dt.year == 2025]\n \n # Group by channel and calculate count and average spend\n channel_stats = campaigns_2025.groupby('channel').agg(\n count=('spend', 'count'),\n avg_spend=('spend', 'mean')\n ).reset_index()\n \n # Filter for channels with at least 30 records\n eligible_channels = channel_stats[channel_stats['count'] >= 30]\n \n # Find the channel with highest average spend\n if len(eligible_channels) == 0:\n return None\n \n highest_avg_channel = eligible_channels.loc[eligible_channels['avg_spend'].idxmax(), 'channel']\n \n return highest_avg_channel", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "mktg01_l4_063", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['campaigns'].copy()\n \n # Convert event_date to datetime\n df['event_date'] = pd.to_datetime(df['event_date'])\n \n # Extract year and quarter\n df['year'] = df['event_date'].dt.year\n df['quarter'] = df['event_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_2024 = df[(df['year'] == 2024) & (df['quarter'] == 2)]\n q2_2025 = df[(df['year'] == 2025) & (df['quarter'] == 2)]\n \n # Calculate total spend by channel for each year's Q2\n spend_2024 = q2_2024.groupby('channel')['spend'].sum()\n spend_2025 = q2_2025.groupby('channel')['spend'].sum()\n \n # Calculate year-over-year percentage increase\n # Percentage increase = ((new - old) / old) * 100\n channels = spend_2024.index.intersection(spend_2025.index)\n \n pct_increase = {}\n for channel in channels:\n old_spend = spend_2024[channel]\n new_spend = spend_2025[channel]\n if old_spend > 0:\n pct_increase[channel] = ((new_spend - old_spend) / old_spend) * 100\n \n # Find the channel with the largest percentage increase\n if pct_increase:\n max_channel = max(pct_increase, key=pct_increase.get)\n return max_channel\n else:\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "mktg01_l4_064", "scenario_id": "mktg01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n campaigns = tables['campaigns']\n \n # Convert event_date to datetime\n campaigns['event_date'] = pd.to_datetime(campaigns['event_date'])\n \n # Extract year and quarter\n campaigns['year'] = campaigns['event_date'].dt.year\n campaigns['quarter'] = campaigns['event_date'].dt.quarter\n \n # Filter for Q3 data (quarter 3) for both 2024 and 2025\n q3_data = campaigns[campaigns['quarter'] == 3]\n \n # Group by channel and year, sum the spend\n spend_by_channel_year = q3_data.groupby(['channel', 'year'])['spend'].sum().reset_index()\n \n # Pivot to have years as columns\n pivot = spend_by_channel_year.pivot(index='channel', columns='year', values='spend')\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # We need both 2024 and 2025 data\n if 2024 in pivot.columns and 2025 in pivot.columns:\n pivot['yoy_pct_increase'] = ((pivot[2025] - pivot[2024]) / pivot[2024]) * 100\n \n # Find the channel with the largest YoY percentage increase\n # Filter out channels that don't have data for both years\n valid_pivot = pivot.dropna(subset=['yoy_pct_increase'])\n \n if len(valid_pivot) > 0:\n max_channel = valid_pivot['yoy_pct_increase'].idxmax()\n return max_channel\n \n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l1_077", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n return shipments['cost'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l1_078", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n return shipments['cost'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l1_079", "scenario_id": "ops01", "generated_program": "def analyze(tables: dict) -> object:\n shipments = tables['shipments']\n return shipments['order_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_080", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n total_cost_by_category = shipments.groupby('category')['cost'].sum()\n category_with_highest_cost = total_cost_by_category.idxmax()\n return category_with_highest_cost", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_081", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # The question asks about \"eligible records\" - without specific criteria mentioned,\n # we'll consider all records as eligible (or records with non-null values in relevant columns)\n # Since cost and category have no nulls, all records are eligible\n \n # Group by category and sum the cost\n category_costs = df.groupby('category')['cost'].sum()\n \n # Find the category with the highest total cost\n highest_cost_category = category_costs.idxmax()\n \n return highest_cost_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_082", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n \n # Convert ship_date to datetime\n shipments['ship_date'] = pd.to_datetime(shipments['ship_date'])\n \n # Filter for 2025\n shipments_2025 = shipments[shipments['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = shipments_2025.groupby('category')['cost'].sum()\n \n # Find the category with highest total cost\n highest_cost_category = category_costs.idxmax()\n \n return highest_cost_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_083", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n \n # Convert ship_date to datetime\n shipments['ship_date'] = pd.to_datetime(shipments['ship_date'])\n \n # Filter for records in 2025\n shipments_2025 = shipments[shipments['ship_date'].dt.year == 2025]\n \n # Group by category and calculate total cost\n category_costs = shipments_2025.groupby('category')['cost'].sum()\n \n # Find the category with the highest total cost\n highest_cost_category = category_costs.idxmax()\n \n return highest_cost_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_084", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n shipments = tables['shipments']\n \n # Convert ship_date to datetime\n shipments['ship_date'] = pd.to_datetime(shipments['ship_date'])\n \n # Filter for records in 2025\n shipments_2025 = shipments[shipments['ship_date'].dt.year == 2025]\n \n # Group by category and calculate total cost\n total_cost_by_category = shipments_2025.groupby('category')['cost'].sum()\n \n # Find the category with the lowest total cost\n lowest_cost_category = total_cost_by_category.idxmin()\n \n return lowest_cost_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l2_085", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for records in 2025\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and sum the cost\n category_costs = df_2025.groupby('category')['cost'].sum()\n \n # Sort by total cost descending and get top 3\n top_3_categories = category_costs.sort_values(ascending=False).head(3).index.tolist()\n \n return top_3_categories", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l3_086", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Filter for records in 2025\n df_2025 = df[df['ship_date'].dt.year == 2025]\n \n # Group by category and calculate average cost and count\n category_stats = df_2025.groupby('category').agg(\n avg_cost=('cost', 'mean'),\n count=('cost', 'count')\n ).reset_index()\n \n # Filter for categories with at least 30 records\n eligible = category_stats[category_stats['count'] >= 30]\n \n # Find the category with highest average cost\n if len(eligible) == 0:\n return None\n \n result = eligible.loc[eligible['avg_cost'].idxmax(), 'category']\n \n return result", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l4_087", "scenario_id": "ops01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments']\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Extract year and quarter\n df['year'] = df['ship_date'].dt.year\n df['quarter'] = df['ship_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_2024 = df[(df['year'] == 2024) & (df['quarter'] == 2)]\n q2_2025 = df[(df['year'] == 2025) & (df['quarter'] == 2)]\n \n # Calculate total cost by category for each year's Q2\n cost_2024 = q2_2024.groupby('category')['cost'].sum()\n cost_2025 = q2_2025.groupby('category')['cost'].sum()\n \n # Calculate year-over-year percentage increase\n # Percentage increase = ((new - old) / old) * 100\n categories = cost_2024.index.intersection(cost_2025.index)\n \n yoy_increase = {}\n for cat in categories:\n old_cost = cost_2024[cat]\n new_cost = cost_2025[cat]\n if old_cost > 0:\n pct_increase = ((new_cost - old_cost) / old_cost) * 100\n yoy_increase[cat] = pct_increase\n \n # Find category with largest increase\n if yoy_increase:\n max_category = max(yoy_increase, key=yoy_increase.get)\n return max_category\n else:\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "ops01_l4_088", "scenario_id": "ops01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['shipments'].copy()\n \n # Convert ship_date to datetime\n df['ship_date'] = pd.to_datetime(df['ship_date'])\n \n # Extract year and quarter\n df['year'] = df['ship_date'].dt.year\n df['quarter'] = df['ship_date'].dt.quarter\n \n # Filter for Q3 data (Q3 2024 and Q3 2025)\n q3_data = df[df['quarter'] == 3]\n \n # Group by category and year, sum the cost\n grouped = q3_data.groupby(['category', 'year'])['cost'].sum().reset_index()\n \n # Pivot to have years as columns\n pivot = grouped.pivot(index='category', columns='year', values='cost')\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # Percentage increase = (2025 - 2024) / 2024 * 100\n if 2024 in pivot.columns and 2025 in pivot.columns:\n pivot['yoy_pct_increase'] = (pivot[2025] - pivot[2024]) / pivot[2024] * 100\n \n # Find the category with the largest percentage increase\n max_category = pivot['yoy_pct_increase'].idxmax()\n return max_category\n else:\n return None", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "payments01_l1_065", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['transactions']\n return df['amount'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l1_066", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n transactions = tables['transactions']\n mean_amount = transactions['amount'].mean()\n return mean_amount", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l1_067", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n transactions = tables['transactions']\n return transactions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_068", "scenario_id": "payments01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n transactions = tables['transactions']\n total_by_method = transactions.groupby('payment_method')['amount'].sum()\n return total_by_method.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_069", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n transactions = tables['transactions']\n \n # Group by payment_method and sum the amounts\n total_by_method = transactions.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with the highest total amount\n highest_method = total_by_method.idxmax()\n \n return highest_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_070", "scenario_id": "payments01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum amounts\n total_by_method = df_2025.groupby('payment_method')['amount'].sum()\n \n # Find the payment method with highest total amount\n highest_method = total_by_method.idxmax()\n \n return highest_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_071", "scenario_id": "payments01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum the amount\n total_by_payment = df_2025.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with highest total amount\n highest_payment_method = total_by_payment.idxmax()\n \n return highest_payment_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_072", "scenario_id": "payments01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum amounts\n total_by_method = df_2025.groupby('payment_method')['amount'].sum()\n \n # Find the payment_method with lowest total amount\n lowest_method = total_by_method.idxmin()\n \n return lowest_method", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "payments01_l2_073", "scenario_id": "payments01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Filter for 2025 records\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and sum the amount\n payment_totals = df_2025.groupby('payment_method')['amount'].sum()\n \n # Sort by total amount descending and get top 3\n top_3 = payment_totals.sort_values(ascending=False).head(3)\n \n # Return the top 3 payment methods as a list\n return top_3.index.tolist()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l3_074", "scenario_id": "payments01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime and filter for 2025\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n df_2025 = df[df['txn_date'].dt.year == 2025]\n \n # Group by payment_method and calculate average amount and count\n grouped = df_2025.groupby('payment_method').agg(\n avg_amount=('amount', 'mean'),\n count=('amount', 'count')\n )\n \n # Filter for at least 30 records\n eligible = grouped[grouped['count'] >= 30]\n \n # Find the payment_method with highest average amount\n result = eligible['avg_amount'].idxmax()\n \n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-opus-4-5", "task_id": "payments01_l4_075", "scenario_id": "payments01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions']\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Extract year and quarter\n df['year'] = df['txn_date'].dt.year\n df['quarter'] = df['txn_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_2024 = df[(df['year'] == 2024) & (df['quarter'] == 2)]\n q2_2025 = df[(df['year'] == 2025) & (df['quarter'] == 2)]\n \n # Calculate total amount by payment_method for each year's Q2\n total_2024 = q2_2024.groupby('payment_method')['amount'].sum()\n total_2025 = q2_2025.groupby('payment_method')['amount'].sum()\n \n # Calculate year-over-year percentage increase\n # Only consider payment methods that exist in both years\n common_methods = total_2024.index.intersection(total_2025.index)\n \n yoy_increase = {}\n for method in common_methods:\n if total_2024[method] > 0: # Avoid division by zero\n pct_increase = ((total_2025[method] - total_2024[method]) / total_2024[method]) * 100\n yoy_increase[method] = pct_increase\n \n # Find the payment method with the largest percentage increase\n if yoy_increase:\n max_method = max(yoy_increase, key=yoy_increase.get)\n return max_method\n else:\n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "payments01_l4_076", "scenario_id": "payments01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['transactions'].copy()\n \n # Convert txn_date to datetime\n df['txn_date'] = pd.to_datetime(df['txn_date'])\n \n # Extract year and quarter\n df['year'] = df['txn_date'].dt.year\n df['quarter'] = df['txn_date'].dt.quarter\n \n # Filter for Q3 data (2024 and 2025)\n q3_data = df[(df['quarter'] == 3) & (df['year'].isin([2024, 2025]))]\n \n # Group by payment_method and year, sum the amounts\n grouped = q3_data.groupby(['payment_method', 'year'])['amount'].sum().reset_index()\n \n # Pivot to get years as columns\n pivot = grouped.pivot(index='payment_method', columns='year', values='amount')\n \n # Calculate year-over-year percentage increase\n # (Q3 2025 - Q3 2024) / Q3 2024 * 100\n pivot['yoy_pct_increase'] = ((pivot[2025] - pivot[2024]) / pivot[2024]) * 100\n \n # Find the payment_method with the largest YoY percentage increase\n # Filter out any rows where we can't calculate (missing 2024 or 2025 data)\n valid = pivot.dropna(subset=['yoy_pct_increase'])\n \n if valid.empty:\n return None\n \n result = valid['yoy_pct_increase'].idxmax()\n \n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l1_000", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n return orders['revenue'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l1_001", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n return orders['revenue'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l1_002", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n orders = tables['orders']\n return orders['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_003", "scenario_id": "retail01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n revenue_by_category = orders.groupby('category')['revenue'].sum()\n return revenue_by_category.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_004", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n orders = tables['orders']\n \n # Group by category and sum revenue\n category_revenue = orders.groupby('category')['revenue'].sum()\n \n # Find the category with highest total revenue\n highest_revenue_category = category_revenue.idxmax()\n \n return highest_revenue_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_005", "scenario_id": "retail01", "generated_program": "import pandas as pd\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Determine current period - assuming it's the most recent complete period in the data\n # Let's consider \"current period\" as the most recent month or the current year\n # Based on the sample data showing dates in 2024-2025, let's use the most recent year/month\n \n max_date = orders['order_date'].max()\n \n # Current period could be interpreted as the current year or current month\n # Let's use the year of the max date as the current period\n current_year = max_date.year\n \n # Filter for current period (current year)\n current_period_orders = orders[orders['order_date'].dt.year == current_year]\n \n # Calculate total revenue by category\n revenue_by_category = current_period_orders.groupby('category')['revenue'].sum()\n \n # Find the category with highest total revenue\n highest_revenue_category = revenue_by_category.idxmax()\n \n return highest_revenue_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_006", "scenario_id": "retail01", "generated_program": "import pandas as pd\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Determine the current period - assuming it's the most recent month/year in the data\n # or we could interpret \"current period\" as the latest year\n max_date = orders['order_date'].max()\n \n # Define current period as the same year and month as the max date\n current_year = max_date.year\n current_month = max_date.month\n \n # Filter for current period (same year and month as the latest date)\n current_period_mask = (orders['order_date'].dt.year == current_year) & (orders['order_date'].dt.month == current_month)\n current_period_orders = orders[current_period_mask]\n \n # \"Eligible records\" - typically means non-refunded/cancelled orders\n # Common interpretation: exclude 'refunded' and 'cancelled' statuses\n eligible_mask = ~current_period_orders['order_status'].isin(['refunded', 'cancelled'])\n eligible_orders = current_period_orders[eligible_mask]\n \n # Calculate total revenue by category\n revenue_by_category = eligible_orders.groupby('category')['revenue'].sum()\n \n # Find the category with highest total revenue\n highest_revenue_category = revenue_by_category.idxmax()\n \n return highest_revenue_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_007", "scenario_id": "retail01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Group by category and sum the revenue\n category_revenue = orders.groupby('category')['revenue'].sum()\n \n # Find the category with the lowest total revenue\n lowest_revenue_category = category_revenue.idxmin()\n \n return lowest_revenue_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "retail01_l2_008", "scenario_id": "retail01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n orders = tables['orders']\n \n # Group by category and sum revenue\n category_revenue = orders.groupby('category')['revenue'].sum()\n \n # Sort descending and get top 3\n top_3_categories = category_revenue.sort_values(ascending=False).head(3)\n \n # Return the category names as a list\n return top_3_categories.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "retail01_l3_009", "scenario_id": "retail01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Filter for orders in 2025\n orders_2025 = orders[orders['order_date'].dt.year == 2025]\n \n # Calculate average revenue per category\n avg_revenue_by_category = orders_2025.groupby('category')['revenue'].mean()\n \n # Find the category with the highest average revenue\n category_highest_avg = avg_revenue_by_category.idxmax()\n \n return category_highest_avg", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l4_010", "scenario_id": "retail01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders'].copy()\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Extract year and quarter\n orders['year'] = orders['order_date'].dt.year\n orders['quarter'] = orders['order_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_2024 = orders[(orders['year'] == 2024) & (orders['quarter'] == 2)]\n q2_2025 = orders[(orders['year'] == 2025) & (orders['quarter'] == 2)]\n \n # Calculate total revenue by category for each year's Q2\n revenue_2024 = q2_2024.groupby('category')['revenue'].sum()\n revenue_2025 = q2_2025.groupby('category')['revenue'].sum()\n \n # Calculate year-over-year percentage increase\n # Only consider categories that exist in both years\n common_categories = revenue_2024.index.intersection(revenue_2025.index)\n \n yoy_increase = {}\n for cat in common_categories:\n if revenue_2024[cat] > 0: # Avoid division by zero\n pct_increase = ((revenue_2025[cat] - revenue_2024[cat]) / revenue_2024[cat]) * 100\n yoy_increase[cat] = pct_increase\n \n # Find the category with the largest percentage increase\n if yoy_increase:\n max_category = max(yoy_increase, key=yoy_increase.get)\n return max_category\n else:\n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "retail01_l4_011", "scenario_id": "retail01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n orders = tables['orders']\n \n # Convert order_date to datetime\n orders['order_date'] = pd.to_datetime(orders['order_date'])\n \n # Extract year and quarter\n orders['year'] = orders['order_date'].dt.year\n orders['quarter'] = orders['order_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) in 2024 and 2025\n q3_2024 = orders[(orders['year'] == 2024) & (orders['quarter'] == 3)]\n q3_2025 = orders[(orders['year'] == 2025) & (orders['quarter'] == 3)]\n \n # Calculate total revenue by category for Q3 2024\n revenue_q3_2024 = q3_2024.groupby('category')['revenue'].sum()\n \n # Calculate total revenue by category for Q3 2025\n revenue_q3_2025 = q3_2025.groupby('category')['revenue'].sum()\n \n # Calculate year-over-year percentage increase\n # Percentage increase = ((new - old) / old) * 100\n yoy_increase = ((revenue_q3_2025 - revenue_q3_2024) / revenue_q3_2024) * 100\n \n # Find the category with the largest percentage increase\n # Filter out categories that didn't exist in Q3 2024 (would be inf) or don't exist in Q3 2025\n yoy_increase = yoy_increase.dropna()\n yoy_increase = yoy_increase[yoy_increase != float('inf')]\n \n largest_increase_category = yoy_increase.idxmax()\n \n return largest_increase_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "saas01_l1_041", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n return subscriptions['mrr'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l1_042", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n return subscriptions['mrr'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l1_043", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n return subscriptions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_044", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n total_mrr_by_plan = subscriptions.groupby('plan')['mrr'].sum()\n highest_mrr_plan = total_mrr_by_plan.idxmax()\n return highest_mrr_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_045", "scenario_id": "saas01", "generated_program": "def analyze(tables: dict) -> object:\n df = tables['subscriptions']\n # Group by plan and sum mrr, then find the plan with highest total mrr\n plan_mrr = df.groupby('plan')['mrr'].sum()\n return plan_mrr.idxmax()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_046", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n subscriptions = tables['subscriptions']\n \n # Convert start_date to datetime\n subscriptions['start_date'] = pd.to_datetime(subscriptions['start_date'])\n \n # Filter for subscriptions that started in 2025\n subs_2025 = subscriptions[subscriptions['start_date'].dt.year == 2025]\n \n # Group by plan and sum mrr\n plan_mrr = subs_2025.groupby('plan')['mrr'].sum()\n \n # Find the plan with highest total mrr\n highest_plan = plan_mrr.idxmax()\n \n return highest_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_047", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for eligible records in 2025\n # Eligible records in 2025 means the start_date is in 2025\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum mrr\n plan_mrr = df_2025.groupby('plan')['mrr'].sum()\n \n # Find the plan with highest total mrr\n highest_plan = plan_mrr.idxmax()\n \n return highest_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_048", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime to filter for 2025\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for eligible records in 2025\n # Assuming \"eligible records in 2025\" means records with start_date in 2025\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum mrr\n plan_mrr = df_2025.groupby('plan')['mrr'].sum()\n \n # Find the plan with the lowest total mrr\n lowest_plan = plan_mrr.idxmin()\n \n return lowest_plan", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l2_049", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for records eligible in 2025 (start_date in 2025)\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and sum mrr\n plan_mrr = df_2025.groupby('plan')['mrr'].sum()\n \n # Get top 3 plans by total mrr\n top_3_plans = plan_mrr.sort_values(ascending=False).head(3).index.tolist()\n \n return top_3_plans", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "saas01_l3_050", "scenario_id": "saas01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions']\n \n # Convert start_date to datetime to filter for 2025\n df['start_date'] = pd.to_datetime(df['start_date'])\n \n # Filter for records in 2025\n df_2025 = df[df['start_date'].dt.year == 2025]\n \n # Group by plan and calculate count and average mrr\n plan_stats = df_2025.groupby('plan').agg(\n count=('mrr', 'count'),\n avg_mrr=('mrr', 'mean')\n )\n \n # Filter for plans with at least 30 records\n eligible_plans = plan_stats[plan_stats['count'] >= 30]\n \n # Find the plan with the highest average mrr\n highest_avg_mrr_plan = eligible_plans['avg_mrr'].idxmax()\n \n return highest_avg_mrr_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l4_051", "scenario_id": "saas01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions'].copy()\n \n # Convert dates to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n df['churn_date'] = pd.to_datetime(df['churn_date'])\n \n # Define Q2 periods (April 1 - June 30)\n q2_2024_start = pd.Timestamp('2024-04-01')\n q2_2024_end = pd.Timestamp('2024-06-30')\n q2_2025_start = pd.Timestamp('2025-04-01')\n q2_2025_end = pd.Timestamp('2025-06-30')\n \n # Function to check if subscription was active during a given period\n def was_active_during(row, period_start, period_end):\n # Subscription is active during period if:\n # - start_date <= period_end (started before or during period)\n # - AND (churn_date is null OR churn_date >= period_start) (hasn't churned before period)\n started_before_end = row['start_date'] <= period_end\n not_churned_before_start = pd.isna(row['churn_date']) or row['churn_date'] >= period_start\n return started_before_end and not_churned_before_start\n \n # Calculate total MRR by plan for Q2 2024\n df['active_q2_2024'] = df.apply(lambda row: was_active_during(row, q2_2024_start, q2_2024_end), axis=1)\n q2_2024_mrr = df[df['active_q2_2024']].groupby('plan')['mrr'].sum()\n \n # Calculate total MRR by plan for Q2 2025\n df['active_q2_2025'] = df.apply(lambda row: was_active_during(row, q2_2025_start, q2_2025_end), axis=1)\n q2_2025_mrr = df[df['active_q2_2025']].groupby('plan')['mrr'].sum()\n \n # Calculate year-over-year percentage increase\n mrr_comparison = pd.DataFrame({\n 'q2_2024': q2_2024_mrr,\n 'q2_2025': q2_2025_mrr\n }).fillna(0)\n \n # Calculate percentage increase: (new - old) / old * 100\n # Only for plans that had non-zero MRR in Q2 2024\n mrr_comparison['pct_increase'] = np.where(\n mrr_comparison['q2_2024'] > 0,\n (mrr_comparison['q2_2025'] - mrr_comparison['q2_2024']) / mrr_comparison['q2_2024'] * 100,\n np.nan\n )\n \n # Find plan with largest percentage increase\n valid_plans = mrr_comparison.dropna(subset=['pct_increase'])\n if valid_plans.empty:\n return None\n \n largest_increase_plan = valid_plans['pct_increase'].idxmax()\n \n return largest_increase_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "saas01_l4_052", "scenario_id": "saas01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n df = tables['subscriptions'].copy()\n \n # Convert dates to datetime\n df['start_date'] = pd.to_datetime(df['start_date'])\n df['churn_date'] = pd.to_datetime(df['churn_date'])\n \n # Define Q3 2024 and Q3 2025 date ranges\n q3_2024_start = pd.Timestamp('2024-07-01')\n q3_2024_end = pd.Timestamp('2024-09-30')\n q3_2025_start = pd.Timestamp('2025-07-01')\n q3_2025_end = pd.Timestamp('2025-09-30')\n \n # Function to check if subscription was active during a period\n def is_active_during(row, period_start, period_end):\n # Subscription is active if it started before or during the period\n # and either hasn't churned or churned after the period started\n started_before_period_end = row['start_date'] <= period_end\n # If churn_date is NaT, subscription is still active\n if pd.isna(row['churn_date']):\n not_churned_before_period = True\n else:\n not_churned_before_period = row['churn_date'] >= period_start\n \n return started_before_period_end and not_churned_before_period\n \n # Calculate total MRR by plan for Q3 2024\n df['active_q3_2024'] = df.apply(lambda row: is_active_during(row, q3_2024_start, q3_2024_end), axis=1)\n q3_2024_mrr = df[df['active_q3_2024']].groupby('plan')['mrr'].sum()\n \n # Calculate total MRR by plan for Q3 2025\n df['active_q3_2025'] = df.apply(lambda row: is_active_during(row, q3_2025_start, q3_2025_end), axis=1)\n q3_2025_mrr = df[df['active_q3_2025']].groupby('plan')['mrr'].sum()\n \n # Combine into a dataframe for comparison\n mrr_comparison = pd.DataFrame({\n 'q3_2024': q3_2024_mrr,\n 'q3_2025': q3_2025_mrr\n }).fillna(0)\n \n # Calculate year-over-year percentage increase\n # Only calculate for plans that had MRR in Q3 2024 (to avoid division by zero)\n mrr_comparison['yoy_pct_increase'] = np.where(\n mrr_comparison['q3_2024'] > 0,\n ((mrr_comparison['q3_2025'] - mrr_comparison['q3_2024']) / mrr_comparison['q3_2024']) * 100,\n np.nan\n )\n \n # Find the plan with the largest percentage increase\n max_increase_plan = mrr_comparison['yoy_pct_increase'].idxmax()\n \n return max_increase_plan", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "support01_l1_089", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n tickets = tables['tickets']\n return tickets['resolution_hours'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l1_090", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n tickets = tables['tickets']\n mean_resolution_hours = tickets['resolution_hours'].mean()\n \n return mean_resolution_hours", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l1_091", "scenario_id": "support01", "generated_program": "def analyze(tables: dict) -> object:\n tickets = tables['tickets']\n return tickets['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l2_092", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Group by category and sum resolution_hours, skipping nulls\n category_totals = tickets.groupby('category')['resolution_hours'].sum()\n \n # Find the category with the highest total resolution_hours\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l2_093", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Filter eligible records (those with non-null resolution_hours)\n eligible = tickets.dropna(subset=['resolution_hours'])\n \n # Group by category and sum resolution_hours\n category_totals = eligible.groupby('category')['resolution_hours'].sum()\n \n # Find the category with the highest total resolution_hours\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-opus-4-5", "task_id": "support01_l2_094", "scenario_id": "support01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Filter for 2025\n tickets_2025 = tickets[tickets['created_date'].dt.year == 2025]\n \n # Group by category and sum resolution_hours, skipping nulls\n category_totals = tickets_2025.groupby('category')['resolution_hours'].sum()\n \n # Find category with highest total\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l2_095", "scenario_id": "support01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Filter for records in 2025\n tickets_2025 = tickets[tickets['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n eligible = tickets_2025[tickets_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = eligible.groupby('category')['resolution_hours'].sum()\n \n # Find the category with highest total\n highest_category = category_totals.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "support01_l2_096", "scenario_id": "support01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Filter for records in 2025\n tickets_2025 = tickets[tickets['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n eligible = tickets_2025[tickets_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = eligible.groupby('category')['resolution_hours'].sum()\n \n # Find the category with the lowest total\n lowest_category = category_totals.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l2_097", "scenario_id": "support01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Filter for records in 2025\n tickets_2025 = tickets[tickets['created_date'].dt.year == 2025]\n \n # Filter for eligible records (non-null resolution_hours)\n eligible = tickets_2025[tickets_2025['resolution_hours'].notna()]\n \n # Group by category and sum resolution_hours\n category_totals = eligible.groupby('category')['resolution_hours'].sum()\n \n # Sort descending and get top 3\n top_3 = category_totals.sort_values(ascending=False).head(3)\n \n # Return the category names as a list\n return top_3.index.tolist()", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "support01_l3_098", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets']\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Filter for 2025 records\n tickets_2025 = tickets[tickets['created_date'].dt.year == 2025]\n \n # Filter out null resolution_hours\n tickets_2025 = tickets_2025[tickets_2025['resolution_hours'].notna()]\n \n # Group by category and calculate average resolution_hours and count\n grouped = tickets_2025.groupby('category').agg(\n avg_resolution_hours=('resolution_hours', 'mean'),\n count=('resolution_hours', 'count')\n ).reset_index()\n \n # Filter for categories with at least 30 records\n eligible = grouped[grouped['count'] >= 30]\n \n # Find the category with highest average resolution_hours\n result = eligible.loc[eligible['avg_resolution_hours'].idxmax(), 'category']\n \n return result", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l4_099", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets'].copy()\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Extract year and quarter\n tickets['year'] = tickets['created_date'].dt.year\n tickets['quarter'] = tickets['created_date'].dt.quarter\n \n # Filter for Q2 (quarter 2) in 2024 and 2025\n q2_2024 = tickets[(tickets['year'] == 2024) & (tickets['quarter'] == 2)]\n q2_2025 = tickets[(tickets['year'] == 2025) & (tickets['quarter'] == 2)]\n \n # Calculate total resolution_hours by category for each year's Q2\n totals_2024 = q2_2024.groupby('category')['resolution_hours'].sum()\n totals_2025 = q2_2025.groupby('category')['resolution_hours'].sum()\n \n # Calculate year-over-year percentage increase\n # Percentage increase = ((new - old) / old) * 100\n categories = totals_2024.index.union(totals_2025.index)\n \n percentage_increases = {}\n for cat in categories:\n old_val = totals_2024.get(cat, 0)\n new_val = totals_2025.get(cat, 0)\n \n if old_val > 0:\n pct_increase = ((new_val - old_val) / old_val) * 100\n percentage_increases[cat] = pct_increase\n \n # Find the category with the largest percentage increase\n if percentage_increases:\n max_category = max(percentage_increases, key=percentage_increases.get)\n return max_category\n else:\n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "support01_l4_100", "scenario_id": "support01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n tickets = tables['tickets'].copy()\n \n # Convert created_date to datetime\n tickets['created_date'] = pd.to_datetime(tickets['created_date'])\n \n # Extract year and quarter\n tickets['year'] = tickets['created_date'].dt.year\n tickets['quarter'] = tickets['created_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) for both 2024 and 2025\n q3_data = tickets[(tickets['quarter'] == 3) & (tickets['year'].isin([2024, 2025]))]\n \n # Calculate total resolution_hours by category and year for Q3\n grouped = q3_data.groupby(['category', 'year'])['resolution_hours'].sum().reset_index()\n \n # Pivot to get years as columns\n pivoted = grouped.pivot(index='category', columns='year', values='resolution_hours')\n \n # Calculate year-over-year percentage increase\n # (Q3 2025 - Q3 2024) / Q3 2024 * 100\n pivoted['yoy_pct_increase'] = ((pivoted[2025] - pivoted[2024]) / pivoted[2024]) * 100\n \n # Find the category with the largest percentage increase\n # Handle potential NaN values (categories that might not exist in both years)\n pivoted_valid = pivoted.dropna(subset=['yoy_pct_increase'])\n \n if len(pivoted_valid) == 0:\n return None\n \n largest_increase_category = pivoted_valid['yoy_pct_increase'].idxmax()\n \n return largest_increase_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l1_012", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['page_views'].sum()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l1_013", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['page_views'].mean()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l1_014", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n sessions = tables['sessions']\n return sessions['customer_id'].nunique()", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l2_015", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Group by category and sum page_views\n category_page_views = sessions.groupby('category')['page_views'].sum()\n \n # Find the category with highest total page_views\n highest_category = category_page_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l2_016", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n sessions = tables['sessions']\n \n # Group by category and sum page_views\n category_page_views = sessions.groupby('category')['page_views'].sum()\n \n # Find the category with the highest total page_views\n highest_category = category_page_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "web01_l2_017", "scenario_id": "web01", "generated_program": "import pandas as pd\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Determine current period - assuming \"current\" means the most recent year or period in the data\n # Based on the sample dates, the data spans 2024-2025\n # \"Current period\" likely means the most recent year\n max_date = sessions['event_date'].max()\n current_year = max_date.year\n \n # Filter for current period (current year)\n current_period_sessions = sessions[sessions['event_date'].dt.year == current_year]\n \n # Calculate total page_views by category\n category_page_views = current_period_sessions.groupby('category')['page_views'].sum()\n \n # Find the category with highest total page_views\n highest_category = category_page_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": true, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l2_018", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\nfrom datetime import datetime\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Determine the current period - assuming it's the most recent year or similar\n # Based on the data, we need to identify what \"current period\" means\n # Looking at the dates, they range from 2024 to 2025\n # Current period likely means the most recent period (e.g., 2025 or last 12 months)\n \n max_date = sessions['event_date'].max()\n \n # Define current period as the last 12 months from the max date\n # Or alternatively, the current year\n current_year = max_date.year\n \n # Filter for current period (current year)\n current_period = sessions[sessions['event_date'].dt.year == current_year]\n \n # \"Eligible records\" - without more specific criteria, assume all non-null records\n # Since page_views has 0 nulls and category has 0 nulls, all records are eligible\n eligible = current_period.dropna(subset=['category', 'page_views'])\n \n # Group by category and sum page_views\n category_views = eligible.groupby('category')['page_views'].sum()\n \n # Find category with highest total page_views\n highest_category = category_views.idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l2_019", "scenario_id": "web01", "generated_program": "def analyze(tables: dict) -> object:\n import pandas as pd\n \n sessions = tables['sessions']\n \n # Group by category and sum page_views\n category_views = sessions.groupby('category')['page_views'].sum()\n \n # Find the category with the lowest total page_views\n lowest_category = category_views.idxmin()\n \n return lowest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l2_020", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n \n # Group by category and sum page_views\n category_views = sessions.groupby('category')['page_views'].sum()\n \n # Sort descending and get top 3\n top_3_categories = category_views.sort_values(ascending=False).head(3).index.tolist()\n \n return top_3_categories", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "web01_l3_021", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Filter for new users only\n new_user_sessions = sessions[sessions['customer_type'] == 'new']\n \n # Merge sessions with conversions to identify which sessions converted\n # A session that exists in conversions table means it converted\n new_user_sessions = new_user_sessions.copy()\n new_user_sessions['converted'] = new_user_sessions['session_id'].isin(conversions['session_id']).astype(int)\n \n # Calculate conversion rate by category\n conversion_rates = new_user_sessions.groupby('category').agg(\n total_sessions=('session_id', 'count'),\n conversions=('converted', 'sum')\n )\n conversion_rates['conversion_rate'] = conversion_rates['conversions'] / conversion_rates['total_sessions']\n \n # Find the category with the highest conversion rate\n highest_conversion_category = conversion_rates['conversion_rate'].idxmax()\n \n return highest_conversion_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "web01_l3_022", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Filter sessions for new users in 2025\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n new_user_sessions_2025 = sessions[\n (sessions['customer_type'] == 'new') & \n (sessions['event_date'].dt.year == 2025)\n ]\n \n # Count total sessions per category for new users in 2025\n sessions_per_category = new_user_sessions_2025.groupby('category')['session_id'].count()\n \n # Find which of these sessions converted\n converted_sessions = new_user_sessions_2025[\n new_user_sessions_2025['session_id'].isin(conversions['session_id'])\n ]\n \n # Count conversions per category\n conversions_per_category = converted_sessions.groupby('category')['session_id'].count()\n \n # Calculate conversion rate\n conversion_rate = conversions_per_category / sessions_per_category\n \n # Find category with highest conversion rate\n highest_conversion_category = conversion_rate.idxmax()\n \n return highest_conversion_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "web01_l3_023", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Filter sessions for 2025 and exclude test traffic\n sessions_2025 = sessions[\n (sessions['event_date'].str.startswith('2025')) & \n (sessions['traffic_source'] != 'test')\n ]\n \n # Get session_ids that converted\n converted_session_ids = set(conversions['session_id'])\n \n # Add conversion flag to sessions\n sessions_2025 = sessions_2025.copy()\n sessions_2025['converted'] = sessions_2025['session_id'].isin(converted_session_ids)\n \n # Calculate conversion rate by category\n conversion_rates = sessions_2025.groupby('category').agg(\n total_sessions=('session_id', 'count'),\n conversions=('converted', 'sum')\n )\n conversion_rates['conversion_rate'] = conversion_rates['conversions'] / conversion_rates['total_sessions']\n \n # Find category with highest conversion rate\n best_category = conversion_rates['conversion_rate'].idxmax()\n \n return best_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": false}
{"model": "claude-opus-4-5", "task_id": "web01_l3_024", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions']\n conversions = tables['conversions']\n \n # Filter sessions for mobile device and new users in 2025\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n sessions_2025 = sessions[(sessions['event_date'].dt.year == 2025) & \n (sessions['device'] == 'mobile') & \n (sessions['customer_type'] == 'new')]\n \n # Get conversion session ids\n converted_session_ids = set(conversions['session_id'])\n \n # Mark sessions as converted\n sessions_2025 = sessions_2025.copy()\n sessions_2025['converted'] = sessions_2025['session_id'].isin(converted_session_ids)\n \n # Calculate conversion rate by category\n conversion_rates = sessions_2025.groupby('category').agg(\n total_sessions=('session_id', 'count'),\n conversions=('converted', 'sum')\n )\n \n conversion_rates['conversion_rate'] = conversion_rates['conversions'] / conversion_rates['total_sessions']\n \n # Find category with highest conversion rate\n highest_category = conversion_rates['conversion_rate'].idxmax()\n \n return highest_category", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l4_025", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n # Filter for Q2 only (quarters 2)\n q2_sessions = sessions[sessions['quarter'] == 2]\n \n # Group by category and year, sum page_views\n q2_grouped = q2_sessions.groupby(['category', 'year'])['page_views'].sum().reset_index()\n \n # Pivot to have years as columns\n q2_pivot = q2_grouped.pivot(index='category', columns='year', values='page_views')\n \n # Calculate year-over-year percentage increase from 2024 to 2025\n # YoY % increase = ((2025 - 2024) / 2024) * 100\n if 2024 in q2_pivot.columns and 2025 in q2_pivot.columns:\n q2_pivot['yoy_pct_increase'] = ((q2_pivot[2025] - q2_pivot[2024]) / q2_pivot[2024]) * 100\n \n # Find the category with the largest YoY percentage increase\n result = q2_pivot['yoy_pct_increase'].idxmax()\n return result\n else:\n return None", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": true, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l4_026", "scenario_id": "web01", "generated_program": "import pandas as pd\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n \n # Extract year and quarter\n sessions['year'] = sessions['event_date'].dt.year\n sessions['quarter'] = sessions['event_date'].dt.quarter\n \n # Filter for Q3 (quarter 3) in 2024 and 2025\n q3_data = sessions[(sessions['quarter'] == 3) & (sessions['year'].isin([2024, 2025]))]\n \n # Group by category and year, sum page_views\n grouped = q3_data.groupby(['category', 'year'])['page_views'].sum().reset_index()\n \n # Pivot to get years as columns\n pivoted = grouped.pivot(index='category', columns='year', values='page_views')\n \n # Calculate year-over-year percentage increase\n # (2025 - 2024) / 2024 * 100\n pivoted['yoy_pct_increase'] = (pivoted[2025] - pivoted[2024]) / pivoted[2024] * 100\n \n # Find category with largest YoY percentage increase\n result = pivoted['yoy_pct_increase'].idxmax()\n \n return result", "executed_on_seed42": true, "correct_seed42": false, "correct_seed7": false, "correct_seed123": true}
{"model": "claude-opus-4-5", "task_id": "web01_l5_027", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for new customers (excluding test traffic)\n # Assuming 'test' traffic source should be excluded\n sessions_filtered = sessions[\n (sessions['customer_type'] == 'new') & \n (sessions['traffic_source'] != 'test')\n ].copy()\n \n # Mark sessions that converted\n converted_sessions = set(conversions['session_id'])\n sessions_filtered['converted'] = sessions_filtered['session_id'].isin(converted_sessions)\n \n # Extract year and quarter\n sessions_filtered['year'] = sessions_filtered['event_date'].dt.year\n sessions_filtered['quarter'] = sessions_filtered['event_date'].dt.quarter\n \n # Filter for Q2 (quarter == 2) in 2024 and 2025\n q2_sessions = sessions_filtered[\n (sessions_filtered['quarter'] == 2) & \n (sessions_filtered['year'].isin([2024, 2025]))\n ].copy()\n \n # Group by category and year to calculate conversion rates\n grouped = q2_sessions.groupby(['category', 'year']).agg(\n total_sessions=('session_id', 'count'),\n conversions=('converted', 'sum')\n ).reset_index()\n \n # Filter for categories with at least 30 eligible sessions\n grouped = grouped[grouped['total_sessions'] >= 30]\n \n # Calculate conversion rate\n grouped['conversion_rate'] = grouped['conversions'] / grouped['total_sessions']\n \n # Pivot to get 2024 and 2025 conversion rates side by side\n pivot = grouped.pivot(index='category', columns='year', values='conversion_rate').reset_index()\n pivot.columns = ['category', 'cr_2024', 'cr_2025']\n \n # Drop categories that don't have data for both years\n pivot = pivot.dropna(subset=['cr_2024', 'cr_2025'])\n \n # Calculate year-over-year percentage change\n # YoY % change = ((2025 - 2024) / 2024) * 100\n pivot['yoy_pct_change'] = ((pivot['cr_2025'] - pivot['cr_2024']) / pivot['cr_2024']) * 100\n \n # Find the category with the largest YoY percentage change (absolute value for \"largest\")\n # But typically \"largest\" could mean highest positive or highest absolute\n # Given the question asks for \"largest\", we'll assume largest absolute change\n pivot['abs_yoy_change'] = pivot['yoy_pct_change'].abs()\n \n result = pivot.loc[pivot['abs_yoy_change'].idxmax(), 'category']\n \n return result", "executed_on_seed42": false, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}
{"model": "claude-opus-4-5", "task_id": "web01_l5_028", "scenario_id": "web01", "generated_program": "import pandas as pd\nimport numpy as np\n\ndef analyze(tables: dict) -> object:\n sessions = tables['sessions'].copy()\n conversions = tables['conversions'].copy()\n \n # Convert event_date to datetime\n sessions['event_date'] = pd.to_datetime(sessions['event_date'])\n conversions['event_date'] = pd.to_datetime(conversions['event_date'])\n \n # Filter for new customers (excluding test traffic)\n # Assuming 'new' customer_type and excluding 'test' traffic_source\n new_customers = sessions[\n (sessions['customer_type'] == 'new') & \n (sessions['traffic_source'] != 'test')\n ].copy()\n \n # Mark sessions that converted\n converted_sessions = set(conversions['session_id'])\n new_customers['converted'] = new_customers['session_id'].isin(converted_sessions)\n \n # Extract year and quarter\n new_customers['year'] = new_customers['event_date'].dt.year\n new_customers['quarter'] = new_customers['event_date'].dt.quarter\n \n # Filter for Q3 (2024 and 2025)\n q3_sessions = new_customers[\n (new_customers['quarter'] == 3) & \n (new_customers['year'].isin([2024, 2025]))\n ].copy()\n \n # Group by year and category, calculate eligible sessions and conversions\n # First check which categories have at least 30 eligible sessions\n category_year_stats = q3_sessions.groupby(['year', 'category']).agg(\n eligible_sessions=('session_id', 'count'),\n conversions=('converted', 'sum')\n ).reset_index()\n \n # Calculate conversion rate\n category_year_stats['conversion_rate'] = (\n category_year_stats['conversions'] / category_year_stats['eligible_sessions']\n )\n \n # Pivot to get 2024 and 2025 side by side\n pivot = category_year_stats.pivot(\n index='category', \n columns='year', \n values=['eligible_sessions', 'conversion_rate']\n )\n \n # Flatten column names\n pivot.columns = [f'{col[0]}_{col[1]}' for col in pivot.columns]\n pivot = pivot.reset_index()\n \n # Filter for categories with at least 30 eligible sessions in both years\n valid_categories = pivot[\n (pivot['eligible_sessions_2024'] >= 30) & \n (pivot['eligible_sessions_2025'] >= 30)\n ].copy()\n \n # If no categories meet the threshold for both years, check if we need at least 30 total\n if len(valid_categories) == 0:\n # Try with at least 30 eligible sessions total (either year)\n valid_categories = pivot[\n (pivot['eligible_sessions_2024'] >= 30) | \n (pivot['eligible_sessions_2025'] >= 30)\n ].copy()\n \n # If still no valid categories, relax to just having data in both years\n if len(valid_categories) == 0:\n valid_categories = pivot.dropna(subset=['conversion_rate_2024', 'conversion_rate_2025']).copy()\n \n # Calculate year-over-year percentage change in conversion rate\n # YoY change = ((CR_2025 - CR_2024) / CR_2024) * 100\n valid_categories['yoy_pct_change'] = (\n (valid_categories['conversion_rate_2025'] - valid_categories['conversion_rate_2024']) \n / valid_categories['conversion_rate_2024'] * 100\n )\n \n # Handle cases where 2024 conversion rate is 0\n valid_categories['yoy_pct_change'] = valid_categories['yoy_pct_change'].replace([np.inf, -np.inf], np.nan)\n \n # Find the category with the largest absolute YoY percentage change\n valid_categories['abs_yoy_change'] = valid_categories['yoy_pct_change'].abs()\n \n # Get the category with the largest absolute change\n result = valid_categories.loc[valid_categories['abs_yoy_change'].idxmax(), 'category']\n \n return result", "executed_on_seed42": false, "correct_seed42": false, "correct_seed7": null, "correct_seed123": null}