File size: 256,046 Bytes
fb006bf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
{"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}