From 785c194c537dae38a61730e3f13eafa9de220041 Mon Sep 17 00:00:00 2001 From: Robin Olsen Date: Wed, 4 Mar 2026 19:20:51 +0100 Subject: [PATCH] add data analisys notebook --- notebooks/task-data-analysis.ipynb | 2421 ++++++++++++++++++++++++++++ 1 file changed, 2421 insertions(+) create mode 100644 notebooks/task-data-analysis.ipynb diff --git a/notebooks/task-data-analysis.ipynb b/notebooks/task-data-analysis.ipynb new file mode 100644 index 0000000..4765eac --- /dev/null +++ b/notebooks/task-data-analysis.ipynb @@ -0,0 +1,2421 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task Data Analysis Notebook\n", + "\n", + "This notebook loads task run stats from `./.pm` and gives a quick view of completion rates, validation behavior, timings, and common failure patterns." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8626d9d2", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import json\n", + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "pd.set_option(\"display.max_columns\", 200)\n", + "plt.style.use(\"ggplot\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7bc3e98d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Working directory: /home/robino/Projects/Go/LazyPM/notebooks\n", + "Using stats directory: /home/robino/Projects/Go/LazyPM/.pm\n", + "Found 1 stats file(s).\n" + ] + }, + { + "data": { + "text/plain": [ + "[PosixPath('/home/robino/Projects/Go/LazyPM/.pm/coding-task-stats.json')]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "candidate_dirs = [\n", + " Path.cwd(),\n", + " Path.cwd() / \"./.pm\",\n", + " Path.cwd().parent / \"./.pm\",\n", + "]\n", + "\n", + "stats_dir = None\n", + "stat_files = []\n", + "for d in candidate_dirs:\n", + " if d.is_dir():\n", + " files = sorted(d.glob(\"*-stats.json\"))\n", + " if files:\n", + " stats_dir = d\n", + " stat_files = files\n", + " break\n", + "\n", + "print(f\"Working directory: {Path.cwd()}\")\n", + "print(f\"Using stats directory: {stats_dir}\")\n", + "print(f\"Found {len(stat_files)} stats file(s).\")\n", + "stat_files" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c453e1ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 1 task dataset(s).\n" + ] + } + ], + "source": [ + "datasets = []\n", + "for file in stat_files:\n", + " with file.open() as f:\n", + " data = json.load(f)\n", + " data[\"_file\"] = file.name\n", + " datasets.append(data)\n", + "\n", + "print(f\"Loaded {len(datasets)} task dataset(s).\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cbb0dd6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((1, 19), (19, 18), (2263, 12))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary_rows = []\n", + "run_rows = []\n", + "log_rows = []\n", + "\n", + "for ds in datasets:\n", + " task_name = ds.get(\"task_name\")\n", + " file_name = ds.get(\"_file\")\n", + "\n", + " summary = ds.get(\"summary\", {}).copy()\n", + " summary.update({\"task_name\": task_name, \"file\": file_name})\n", + " summary_rows.append(summary)\n", + "\n", + " for run in ds.get(\"runs\", []):\n", + " row = run.copy()\n", + " row.update({\"task_name\": task_name, \"file\": file_name})\n", + " run_rows.append(row)\n", + "\n", + " for log in run.get(\"logs\", []):\n", + " lrow = log.copy()\n", + " lrow.update({\n", + " \"task_name\": task_name,\n", + " \"file\": file_name,\n", + " \"run_id\": run.get(\"run_id\"),\n", + " \"run_completed\": run.get(\"completed\"),\n", + " })\n", + " log_rows.append(lrow)\n", + "\n", + "summary_df = pd.DataFrame(summary_rows)\n", + "runs_df = pd.DataFrame(run_rows)\n", + "logs_df = pd.DataFrame(log_rows)\n", + "\n", + "for col in [\"updated_at\", \"first_run_started_at\", \"last_run_started_at\", \"last_run_ended_at\"]:\n", + " if col in summary_df.columns:\n", + " summary_df[col] = pd.to_datetime(summary_df[col], errors=\"coerce\")\n", + "\n", + "for col in [\"started_at\", \"ended_at\"]:\n", + " if col in runs_df.columns:\n", + " runs_df[col] = pd.to_datetime(runs_df[col], errors=\"coerce\")\n", + "\n", + "if \"timestamp\" in logs_df.columns:\n", + " logs_df[\"timestamp\"] = pd.to_datetime(logs_df[\"timestamp\"], errors=\"coerce\")\n", + "\n", + "summary_df.shape, runs_df.shape, logs_df.shape" + ] + }, + { + "cell_type": "markdown", + "id": "c974d4f8", + "metadata": {}, + "source": [ + "## Task-level summary" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "92aea6d2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_nametotal_runscompleted_runsincomplete_runsaverage_duration_msvalidation_attemptsvalidation_successesvalidation_failurestotal_user_actionscompletion_rate_pctavg_duration_s
0Coding Task19118710813431342595.371.08
\n", + "
" + ], + "text/plain": [ + " task_name total_runs completed_runs incomplete_runs \\\n", + "0 Coding Task 19 1 18 \n", + "\n", + " average_duration_ms validation_attempts validation_successes \\\n", + "0 71081 343 1 \n", + "\n", + " validation_failures total_user_actions completion_rate_pct \\\n", + "0 342 59 5.3 \n", + "\n", + " avg_duration_s \n", + "0 71.08 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary_cols = [\n", + " \"task_name\",\n", + " \"total_runs\",\n", + " \"completed_runs\",\n", + " \"incomplete_runs\",\n", + " \"average_duration_ms\",\n", + " \"validation_attempts\",\n", + " \"validation_successes\",\n", + " \"validation_failures\",\n", + " \"total_user_actions\",\n", + "]\n", + "\n", + "summary_view = summary_df.reindex(columns=summary_cols).copy()\n", + "\n", + "if not summary_view.empty:\n", + " total_runs_nonzero = summary_view[\"total_runs\"].replace({0: pd.NA})\n", + " summary_view[\"completion_rate_pct\"] = (summary_view[\"completed_runs\"] / total_runs_nonzero * 100).round(1)\n", + " summary_view[\"avg_duration_s\"] = (summary_view[\"average_duration_ms\"] / 1000).round(2)\n", + "\n", + "summary_view.sort_values(\"completion_rate_pct\", ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6bd0a081", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not summary_view.empty and summary_view[\"completion_rate_pct\"].notna().any():\n", + " plot_df = summary_view[[\"task_name\", \"completion_rate_pct\"]].sort_values(\"completion_rate_pct\")\n", + " ax = plot_df.plot(kind=\"barh\", x=\"task_name\", y=\"completion_rate_pct\", legend=False, figsize=(8, 4))\n", + " ax.set_xlabel(\"Completion rate (%)\")\n", + " ax.set_ylabel(\"\")\n", + " ax.set_title(\"Completion rate by task\")\n", + " plt.tight_layout()\n", + "else:\n", + " print(\"No summary data available for plotting.\")" + ] + }, + { + "cell_type": "markdown", + "id": "8d7da541", + "metadata": {}, + "source": [ + "## Run-level diagnostics" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "694e0476", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_namerun_idinterface_typecompletedduration_msvalidation_attemptsvalidation_successesvalidation_failuresquestionnaire_completedduration_s
0Coding Task1webTrue9014384183True90.14
1Coding Task2replFalse28458000False28.46
2Coding Task3replFalse10512000False10.51
3Coding Task4replFalse8732978078True87.33
4Coding Task5replFalse4171440040True41.71
5Coding Task6replFalse5493953053True54.94
6Coding Task7replFalse3962638038True39.63
7Coding Task8replFalse4816046046True48.16
8Coding Task9replFalse11927202True11.93
9Coding Task10replFalse258557202True258.56
10Coding Task11replFalse40334000False40.33
11Coding Task12replFalse21621000True21.62
12Coding Task13replFalse72097000True72.10
13Coding Task14replFalse9530000True9.53
14Coding Task15webFalse523000False0.52
15Coding Task16replFalse101759000True101.76
16Coding Task17replFalse114763000True114.76
17Coding Task18replFalse55497000True55.50
18Coding Task19replFalse263061000True263.06
\n", + "
" + ], + "text/plain": [ + " task_name run_id interface_type completed duration_ms \\\n", + "0 Coding Task 1 web True 90143 \n", + "1 Coding Task 2 repl False 28458 \n", + "2 Coding Task 3 repl False 10512 \n", + "3 Coding Task 4 repl False 87329 \n", + "4 Coding Task 5 repl False 41714 \n", + "5 Coding Task 6 repl False 54939 \n", + "6 Coding Task 7 repl False 39626 \n", + "7 Coding Task 8 repl False 48160 \n", + "8 Coding Task 9 repl False 11927 \n", + "9 Coding Task 10 repl False 258557 \n", + "10 Coding Task 11 repl False 40334 \n", + "11 Coding Task 12 repl False 21621 \n", + "12 Coding Task 13 repl False 72097 \n", + "13 Coding Task 14 repl False 9530 \n", + "14 Coding Task 15 web False 523 \n", + "15 Coding Task 16 repl False 101759 \n", + "16 Coding Task 17 repl False 114763 \n", + "17 Coding Task 18 repl False 55497 \n", + "18 Coding Task 19 repl False 263061 \n", + "\n", + " validation_attempts validation_successes validation_failures \\\n", + "0 84 1 83 \n", + "1 0 0 0 \n", + "2 0 0 0 \n", + "3 78 0 78 \n", + "4 40 0 40 \n", + "5 53 0 53 \n", + "6 38 0 38 \n", + "7 46 0 46 \n", + "8 2 0 2 \n", + "9 2 0 2 \n", + "10 0 0 0 \n", + "11 0 0 0 \n", + "12 0 0 0 \n", + "13 0 0 0 \n", + "14 0 0 0 \n", + "15 0 0 0 \n", + "16 0 0 0 \n", + "17 0 0 0 \n", + "18 0 0 0 \n", + "\n", + " questionnaire_completed duration_s \n", + "0 True 90.14 \n", + "1 False 28.46 \n", + "2 False 10.51 \n", + "3 True 87.33 \n", + "4 True 41.71 \n", + "5 True 54.94 \n", + "6 True 39.63 \n", + "7 True 48.16 \n", + "8 True 11.93 \n", + "9 True 258.56 \n", + "10 False 40.33 \n", + "11 True 21.62 \n", + "12 True 72.10 \n", + "13 True 9.53 \n", + "14 False 0.52 \n", + "15 True 101.76 \n", + "16 True 114.76 \n", + "17 True 55.50 \n", + "18 True 263.06 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_cols = [\n", + " \"task_name\",\n", + " \"run_id\",\n", + " \"interface_type\",\n", + " \"completed\",\n", + " \"duration_ms\",\n", + " \"validation_attempts\",\n", + " \"validation_successes\",\n", + " \"validation_failures\",\n", + " \"questionnaire_completed\",\n", + "]\n", + "\n", + "runs_view = runs_df.reindex(columns=run_cols).copy()\n", + "if \"duration_ms\" in runs_view.columns:\n", + " runs_view[\"duration_s\"] = (runs_view[\"duration_ms\"] / 1000).round(2)\n", + "\n", + "runs_view.sort_values([\"task_name\", \"run_id\"]).head(20)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7e0aae07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
runscompleted_runsavg_duration_smedian_duration_savg_validation_attemptscompletion_rate_pct
task_name
Coding Task19171.0848.1618.055.3
\n", + "
" + ], + "text/plain": [ + " runs completed_runs avg_duration_s median_duration_s \\\n", + "task_name \n", + "Coding Task 19 1 71.08 48.16 \n", + "\n", + " avg_validation_attempts completion_rate_pct \n", + "task_name \n", + "Coding Task 18.05 5.3 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not runs_df.empty and {\"task_name\", \"run_id\", \"completed\", \"duration_ms\", \"validation_attempts\"}.issubset(runs_df.columns):\n", + " agg = runs_df.groupby(\"task_name\", dropna=False).agg(\n", + " runs=(\"run_id\", \"count\"),\n", + " completed_runs=(\"completed\", \"sum\"),\n", + " avg_duration_s=(\"duration_ms\", lambda s: round(s.mean() / 1000, 2)),\n", + " median_duration_s=(\"duration_ms\", lambda s: round(s.median() / 1000, 2)),\n", + " avg_validation_attempts=(\"validation_attempts\", \"mean\"),\n", + " )\n", + "\n", + " agg[\"completion_rate_pct\"] = (agg[\"completed_runs\"] / agg[\"runs\"] * 100).round(1)\n", + " agg[\"avg_validation_attempts\"] = agg[\"avg_validation_attempts\"].round(2)\n", + " display(agg.sort_values(\"completion_rate_pct\", ascending=False))\n", + "else:\n", + " print(\"Not enough run data to build aggregate diagnostics.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "25d3f1a6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHaCAYAAAAdVCoXAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXnZJREFUeJzt3X1cVGX+//H3DDPcKoyIBAqCiIimgpo3X3W9S8vKvKtV07Y2k7Y0c9vdWrftztLMLf3Wam1tauXWluZmZnm3llrepKaV95IiCgoC6qCICMOc3x9+mZ8TqEhMI/B6Ph4+ZM65zjmfcwYd3lznuo7JMAxDAAAAAACg2pm9XQAAAAAAALUVoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAcM0zmUzq3bu3t8u4aunp6TKZTPrtb3/r7VIqraJr/eyzz8pkMmnt2rVeqemdd96RyWTSO++847Y8NjZWsbGxXqmpjLevTUV++9vfymQyKT093dul/KJq6v8TAGo/QjcA1EImk8ntj4+Pj0JDQ9W7d2+98847MgzD2yXWGvygf2U1OQReKvCjYjX5vQYAT7F4uwAAgOc888wzkqSSkhIdOHBAixcv1rp16/Ttt99q9uzZXq6u9mvSpIn27t2rkJAQb5fyszz88MMaOXKkmjZt6pXjDx06VF27dlVkZKRXjn853r42AIBrH6EbAGqxZ5991u31hg0b1LNnT73++uv64x//qGbNmnmnsDrCarUqMTHR22X8bGFhYQoLC/Pa8UNCQq7ZX1x4+9oAAK593F4OAHVI9+7dlZiYKMMwtG3bNtfytWvXymQylQvpZSoaO3vxbbdr1qxR7969Vb9+fQUHB+u2227T3r17r6q24uJiPf/882revLn8/PzUrFkzPfnkkzp//nyF7S93G+ulzqd3794ymUwqLi7Wc889p5YtW8rPz8815jo/P18vvfSS+vbtq6ioKPn6+qpRo0YaNGiQNm3aVOH5S9K6devcbucvO+7lxnRnZWVp/Pjxio2NdR1n2LBhbu/LT4/lrWt9qXHLX3/9tW6//XZFRUXJz89PERER6tq1qyZPnuxqYzKZ9O6770qSmjVr5rpGF38/Xel9udIt3vn5+Xr44YfVpEkT+fv7q3Xr1vr73/9ebhjF1X6f9+7dW/fdd58k6b777nN7j8u+7y43pvuLL77QgAEDFBoaKj8/PyUkJGjSpEnKz88v17bsGjgcDr3wwgtq0aKF/Pz8FB0drT//+c8qLi6usObLcTqdmjlzphITE+Xv76+oqCg9+uijOn36tKtNaWmpoqOjFRwcrIKCggr3M2HCBJlMJi1atOiyx6vMe71t2zZNnDhRSUlJCg0Nlb+/v1q0aKE//vGPOnXqVLl9FhcX6+9//7s6dOigBg0aKDAwULGxsRo8eLBWr15dqevw0ksvyWw2q3v37jp58mSltgGA6kRPNwDUUVartVr289lnn2nJkiW65ZZb9OCDD2rPnj1atmyZtm7dqj179lSqF9AwDA0fPlxLlixR8+bN9fDDD6u4uFjz5s3Tzp07q6XOi91xxx3aunWrbrnlFg0ZMkTh4eGSpL179+qvf/2revbsqdtuu00NGjTQkSNH9Omnn2r58uVaunSpBgwYIElKTk7WM888o8mTJysmJsYtWF9pjPehQ4fUo0cPHTt2TH379tVdd92ljIwMffTRR/r888/1n//8RwMHDiy33bV0rVesWKHbbrtNwcHBGjRokJo0aaKTJ09q7969ev31111DG5555hl98skn+uGHHzRx4kTZbDZJcv19sUu9L5dTXFysfv36yW63a+TIkSouLtZ//vMfTZw4Ufv379drr71W6XP6qd/+9rey2WxasmSJBg8erOTkZNe6iuq/2JtvvqmHHnpIQUFB+vWvf63w8HCtXbtW06dP19KlS7Vhw4YK9zFq1Ch9/fXXuuWWWxQcHKxly5bpb3/7m3JycvT2229fVf2PPvqovvrqKw0fPlyDBw/WypUr9corr+jrr7/W+vXr5e/vLx8fH6WkpOiZZ57RBx98oJSUFLd9nDt3Tu+9954iIiI0ePDgyx6vMu/1W2+9pcWLF6tXr17q16+fnE6ntm3bppkzZ2r58uXavHmz6tev72r/29/+Vh988IHatGmje+65RwEBATp27JjWr1+vFStWqF+/fpesx+l06ve//71mzZqlYcOG6f3335e/v/9VXUMAqBYGAKDWkWRU9F/8unXrDLPZbPj6+hrHjh1zLV+zZo0hyXjmmWcq3F9MTIwRExPjtuztt982JBk+Pj7G6tWr3dZNmjTJkGRMnz69UvW+//77hiSja9euxrlz51zLT5w4YcTFxRmSjF69erltc++99xqSjEOHDpXb36XOp1evXoYko23btkZubm657ex2e4XLMzIyjMjISCMxMbHcuopqK3Po0CFDknHvvfe6Lb/pppsMScaUKVPclm/YsMHw8fExQkNDjTNnzriWe/taP/PMM4YkY82aNa5lw4YNMyQZ33//fblj/PQaXu69Mowrvy9l5//222+7LY+JiTEkGd27dzeKiooqPJd169a5lv+c7/OfHrtMRdcmPT3d8PX1NerXr2/s3bvXrf1DDz1kSDJSUlIqvAYdOnQwTpw44VpeUFBgNG/e3DCbzUZWVlaFNfxU2fVu2LChkZ6e7lpeWlrqet+ee+451/Jjx44ZFovF6NixY7l9lZ3/E088cVXHvtR7nZ6ebjgcjnLL58yZY0gyXnzxRdcyu91umEwmo2PHjhVuk5eX5/b64u/dc+fOuc714YcfNkpLSytVPwB4AreXA0At9uyzz+rZZ5/VX//6V40YMUL9+vWTYRh6+eWXq21SqpEjR+rGG290W/bAAw9IkrZs2VKpfZT14L3wwgtuPVGhoaF66qmnqqXOiz3//PMV9gqHhIRUuDwqKkp33nmn9u3bpyNHjvysY2dmZmrVqlVq2rSpHn/8cbd13bp101133aWTJ0/q448/LrfttXitAwICyi2r6hjnS70vVzJt2jT5+fm5Xl98LlfbO1wd3nvvPRUXF+vhhx8uN6Z/6tSpql+/vv71r39VeDv/9OnTFRoa6nodFBSk0aNHy+l06ttvv72qOiZOnKiYmBjXa7PZ7LrVet68ea7lkZGRGjJkiLZt21ZueMObb74ps9lcrge8qmJiYuTj41Nu+ZgxYxQcHKyVK1e6lplMJhmGIT8/P5nN5X9kbdiwYYXHOHnypPr166fFixdr+vTpmjVrVoXbA8Avhf+BAKAWmzx5siZPnqwXXnhBCxculMPh0Ny5czVhwoRqO8YNN9xQbll0dLQkVThGsyLbt2+X2WxWjx49yq3zxOO4OnfufMl1GzZs0PDhwxUdHS0/Pz/XuNRZs2ZJko4ePfqzjv3dd99Jkn71q19VeIt/37593dpd7Fq61qNHj5YkdenSRQ8++KAWLFigzMzMSm9fkcu9L5disVjUrVu3csvLzqWi6+hp27dvl/T/38uLNWjQQO3bt1dRUZH27dtXbn11vMdlevXqVW5ZXFycoqOjlZ6eLrvd7lo+btw4SRdCdpmdO3fqm2++0c0331xtz0MvKSnR7Nmz1aNHD4WGhsrHx0cmk0lms1mnT592+/cVHBys22+/XRs3blRycrKee+45rVmzRoWFhZfc//Hjx9W9e3dt3bpV7733XrlfbAGANzCmGwBqMeP/JpI6e/asNm3apPvvv18PPvigYmJiKgwEVVHRuFSL5cLHS2lpaaX2kZ+fr9DQ0ApDaERExM+qryKX2ufixYt15513yt/fX/3791fz5s0VFBQks9mstWvXat26dZecbKyyyibRutSdBmXLLw5EZa6laz1s2DB99tlnmjFjhubNm+cKax07dtS0adPUv3//Su+rKscvExYWVmHPadm+Kpq0zNO8/R6Xue666ypcHhERocOHDys/P991vD59+qhVq1b64IMPNGPGDNWvX1///Oc/JUm/+93vruq4lzNixAgtXrxYcXFxGjx4sCIiIlx3Kbzyyivl/n0tWLBA06dP17///W/XPAH+/v6688479fLLL5c7x+zsbJ0+fVpRUVEV/mIJALyBnm4AqAOCgoLUr18/LV26VKWlpbr33nvdeovKbr10OBwVbl9ROKhOISEhOnnypEpKSsqty87OrnCby9V8pXrLZh3/qaeeekq+vr769ttv9cknn2jGjBl67rnn9Oyzz6ply5ZXOIvKKXv01aXOKysry61ddavKtb6U2267TV9++aVOnTqlL774Qo8++qh2796tgQMHas+ePVdd26Xel8vJy8urMIyWncvF1/GX+j739ntc5vjx4xUur+jaSNKDDz6ogoICvf/++64J1Jo0aVLhpH5V8e2332rx4sXq16+f9u/fr7ffflvTpk3Ts88+q6effrrCGdoDAgL07LPPKjU1VUeOHNF7772nHj166L333tOdd95Zrn1SUpLeffddHT16VD179lRaWlq11A4APwehGwDqkHbt2iklJUWZmZn63//9X9fyBg0aSJIyMjLKbXPgwAGP9xZ26NBBTqdT69evL7euokcxSZev+WrHvpY5cOCAWrdurVatWrktv1Rt0oUgdzU9kO3bt5ckrV+/vsLwt2bNGkkXroknVOVaX0lQUJD69u2rmTNn6oknnlBxcbGWL1/uWl/WE321PbWV4XA4tHHjxnLLy86l7HpLVfs+r0rtZces6Hra7XZ9//338vf3L/d9Vt3WrVtXbllaWpoyMjIUGxtbrlf93nvvVWBgoP75z39qwYIFstvtuv/++yu8k+BSLne9Dhw4IEkaNGiQq/e+zJYtW3Tu3LnL7js6OlqjR4/WypUrFR8fr/Xr1+vEiRPl2t1999368MMPdezYMfXs2VOpqamVrh8APIHQDQB1zJNPPik/Pz+9/PLLrjGiiYmJCg4O1pIlS5STk+Nqe+7cOT3yyCMer6nsWch//etfVVRU5Fp+8uRJTZkypcJtysb/vvXWW27Ld+7cqVdffbVKdcTGxurHH3/UsWPHXMsMw9Czzz57yZ7bhg0bVhjiLiUqKkr9+/dXenq6XnnlFbd1mzdv1r///W81aNBAQ4cOrdI5XElVrnVFvvrqqwp/aVDWuxoYGOhaVjbh1c+dhO5S/vKXv7jdlnzxuZSdr1S17/Oq1H733XfLarVq1qxZrqBZ5qmnntLp06d19913u03+5gmvvvqqDh8+7HrtdDr12GOPyel0ul2XMiEhIRo1apS+++47Pfnkk67HiV2Ny12vsnHhP/1lRE5OjsaPH1+ufW5uboWPsTt79qwKCgpksVjk6+tbYR133nmnFi1apLy8PPXq1Uu7d+++qvMAgOrEmG4AqGOaNGmiBx98UK+++qr+9re/adq0abJarZo4caKef/55tW/fXkOHDpXD4dB///tfNW7cWI0bN/ZoTXfddZcWLFigTz/9VG3atNHgwYNVUlKiRYsWqVOnTjp48GC5bQYPHqwWLVrogw8+UGZmprp06aIjR464nqm8cOHCq67j0Ucf1YMPPqj27dvrjjvukNVq1YYNG7Rnzx7dfvvtWrp0abltbrzxRn344Ye6/fbb1aFDB1mtVvXs2VM9e/a85HHeeOMNde/eXY899phWrVqlG264wfWcbrPZrLffftvtWcXVqSrXuiKPPPKIjh49qu7duys2Nla+vr7atm2bvvzyS8XExGjkyJGutjfeeKNeeuklpaSk6I477lD9+vVls9n08MMP/+zziYyM1Pnz59WmTRsNGjTIdS5ZWVkaN26c2/tQle/z//mf/1FgYKBeeeUVnThxwjVWfMKECZe8PTw2NlavvPKKxo8frw4dOmj48OFq1KiR1q1bp02bNikxMVHTp0//2ed+Jd27d1dycrJGjBihkJAQrVy5Uj/88IM6dux4yQnGxo0bpzlz5ujo0aO6/fbbFRUVdVXHvNx73alTJ3Xv3l0ff/yxunXrph49euj48eNavny5WrZsWe76Hz16VO3bt1fbtm3Vrl07RUdH6/Tp0/rss8+UnZ2tRx555LL/TgYNGqQlS5Zo6NCh6t27t1avXq2kpKSrOh8AqBbefWIZAMATdInndJfJzs42AgMDjcDAQCM7O9swDMNwOp3GtGnTjLi4OMNqtRrR0dHGY489Zpw9e7ZKzy/WZZ5fXZHz588bkydPNpo1a2b4+voaMTExxhNPPGEUFRVdcl9Hjhwxhg8fbjRo0MDw9/c3brjhBuM///nPFZ/TfTlvv/22kZSUZAQGBhoNGzY0hgwZYuzYsaPC5zEbhmEcP37cuOuuu4zw8HDDbDa7HfdSz+k2DMPIzMw0HnzwQaNp06aG1Wo1GjZsaAwePNjYsmVLhTV581pXdO4LFiwwRo4cacTHxxtBQUFG/fr1jeuvv9544oknjJycnHLHnDFjhpGYmGj4+voakty+n670vlzuOd0xMTGG3W43xo0bZzRu3Njw9fU1EhMTjVdffdVwOp3l9nW13+eGYRjLly83unbtagQFBbn+bZU9h/pS3xeGYRgrV640+vfvb9hsNsPX19do3ry58dhjjxmnTp0q1/Zy1+BK7/9PlT0r++DBg8bLL79stGzZ0vDz8zMaN25sTJw40cjPz7/s9snJyYYk47PPPqvU8X7qcu/1iRMnjIceesiIiYkx/Pz8jLi4OOMvf/lLhdf/1KlTxuTJk40+ffq43tuIiAijV69exr///e9y7++l/h2sWbPGqFevntGgQYMK/30BgKeZDOP/prYFAABAnXbmzBk1btxYoaGhOnToEM+3BoBqwP+kAAAAkCT94x//UEFBgcaNG0fgBoBqQk83AABAHZafn69//OMfOnr0qN566y2FhoZq//79HptXAADqGkI3AABAHZaenq5mzZrJz89PHTt21KxZszz2yDoAqIsI3QAAAAAAeAiDdQAAAAAA8BBCNwAAAAAAHkLoBgAAAADAQyzeLgDSqVOn5HA4vF0GAADVrlGjRsrNzfV2GQAAVDuLxaIGDRpcud0vUAuuwOFwqKSkxNtlAABQrUwmk6QLn3PM2woAqKu4vRwAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA+xeLsAAABQ+5SWlmrLli0qLi6Wr6+vOnfuLB8fH2+XBQDAL47QDQAAqtWyZcv03HPPKSMjw7UsOjpaTz/9tG699VYvVgYAwC+P28sBAEC1WbZsmR544AElJiZq6dKlOnPmjJYuXarExEQ98MADWrZsmbdLBADgF2UyDMPwdhF1XW5urkpKSrxdBgAAP0tpaam6d++uxMREzZs3Tz4+PoqMjFRWVpZKS0s1ZswY7d+/X+vXr+dWcwBAjWe1WtWoUaMrtqOnGwAAVIvNmzcrIyNDEyZMkNns/iOG2WzWww8/rCNHjmjz5s1eqhAAgF8eY7oBAEC1yMnJkSQlJiZWOJFaYmKiWzsAAOoCQjcAAKgW4eHhkqR58+bp/fffLzeR2ujRo93aAQBQF3B7OQAAqBZdunRRw4YN9eKLL6ply5ZuE6m1bNlSL774osLCwtSlSxdvlwoAwC+G0A0AADzCMAzXHwAA6ipCNwAAqBabN2/WiRMnNGnSJO3fv1+DBg1ScHCwBg0apNTUVE2aNEl5eXlMpAYAqFMY0w0AAKpF2QRpY8aM0bhx48pNpHbu3Dm9+OKLTKQGAKhTCN0AAKBalE2Qtm/fPnXs2FHdunVzPafbMAzt27fPrR0AAHUBt5cDAIBq0aVLF0VHR2vWrFlyOp1u65xOp2bPnq2mTZsykRoAoE4hdAMAgGrh4+Ojp59+WqtXr9aYMWP07bff6syZM/r22281ZswYrV69Wk899ZR8fHy8XSoAAL8Yk8GUol6Xm5urkpISb5cBAEC1WLZsmZ577jm353Q3bdpUTz31lG699VYvVgYAQPWxWq1q1KjRFdsRuq8BhG4AQG1TWlpabiI1ergBALUJobsGIXQDAGojk8nkNpEaAAC1SWVD9zU1e/nixYu1ZcsWHT16VL6+vkpISNDdd9+txo0bu9o8++yz2rNnj9t2/fr10wMPPOB6nZeXp7feeku7d++Wv7+/evXqpVGjRrn9hn337t2aP3++MjIy1LBhQ91xxx3q3bu3235XrFihpUuXym63KyYmRmPGjFF8fLxrfXFxsebPn6+NGzeqpKRESUlJGjt2rGw2W/VeGAAAAABAjXRNhe49e/bo5ptvVvPmzVVaWqoPPvhAU6ZM0cyZM+Xv7+9qd+ONN2rEiBGu176+vq6vnU6npk2bJpvNpilTpujUqVOaPXu2fHx8NGrUKEkXniP64osvqn///powYYJ27dqlN954QzabTcnJyZKkjRs3av78+UpJSVGLFi30+eefa+rUqXrllVcUEhIiSXr33Xe1fft2/eEPf1BgYKDmzp2rGTNm6Pnnn/8FrhYAAAAA4Fp3Tc1e/te//lW9e/dWdHS0YmNjNX78eOXl5SktLc2tnZ+fn2w2m+tPYGCga90PP/ygzMxMTZgwQbGxsWrfvr1GjBihlStXyuFwSJJWrVql8PBw3XPPPYqKitKAAQPUtWtXff755679fPbZZ7rxxhvVp08fRUVFKSUlRb6+vlqzZo0kqbCwUF9++aXuvfdetWnTRnFxcRo3bpz279+v1NTUX+BqAQAAAACudddUT/dPFRYWSpLq1avntvzrr7/W119/LZvNpo4dO+qOO+6Qn5+fJCk1NVVNmzZ1u8U7OTlZc+bMUUZGhpo1a6Yff/xRbdu2ddtnUlKS3nnnHUmSw+FQWlqahgwZ4lpvNpvVtm1bV6BOS0tTaWmp236aNGmisLAwpaamKiEhodz5lJSUuI3dNplMCggIcH0NAEBtUvbZxmccAKAuu2ZDt9Pp1DvvvKOWLVuqadOmruU9evRQWFiYQkNDdfjwYb3//vs6duyY/vSnP0mS7HZ7uTHVZbeD2+12199lyy5uc+7cORUXF6ugoEBOp7Pcfmw2m44dO+bah8ViUVBQULn9lB3npxYvXqxFixa5Xjdr1kzTp0+v1OB7AABqqoiICG+XAACA11yzoXvu3LnKyMjQc88957a8X79+rq+bNm2qBg0a6LnnnlN2dvY1/6E+dOhQDRw40PW67Df/ubm5rlvfAQCoLUwmkyIiIpSdnc3s5QCAWsdisdS82cvLzJ07V9u3b9fkyZPVsGHDy7Ytm028LHTbbDYdOHDArU1+fr4kuXqubTaba9nFbQICAuTr66vg4GCZzeZyPdYX96LbbDY5HA6dPXvWrbc7Pz//krOXW61WWa3WCtfxwwgAoLYyDIPPOQBAnXVNTaRmGIbmzp2rLVu26Omnn1Z4ePgVt0lPT5ckNWjQQJKUkJCgI0eOuIXqHTt2KCAgQFFRUZKkFi1aaOfOnW772bFjh2sctsViUVxcnHbt2uVa73Q6tWvXLlebuLg4+fj4uO3n2LFjysvLq3A8NwAAAACg7rmmQvfcuXP19ddfa+LEiQoICJDdbpfdbldxcbGkC73ZixYtUlpamnJycvTtt9/qtddeU6tWrRQTEyPpwoRoUVFRmj17ttLT0/X999/rww8/1M033+zqZb7pppuUk5Oj9957T0ePHtXKlSu1adMm3Xbbba5aBg4cqC+++EJr165VZmam5syZo/Pnz7ue5R0YGKi+fftq/vz52rVrl9LS0vT6668rISGB0A0AAAAAkCSZjGvofq/hw4dXuHzcuHHq3bu38vLyNGvWLGVkZOj8+fNq2LChOnfurGHDhrk9Niw3N1dz5szR7t275efnp169emn06NHy8fFxtdm9e7feffddZWZmqmHDhrrjjjtcgbrMihUr9Omnn8putys2Nlb33XefWrRo4VpfXFys+fPna8OGDXI4HEpKStLYsWMveXv5peTm5rrNag4AQG1gMpkUGRmprKwsbi8HANQ6Vqu1UmO6r6nQXVcRugEAtRGhGwBQm1U2dF9Tt5cDAAAAAFCbELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5i8XYBF1u8eLG2bNmio0ePytfXVwkJCbr77rvVuHFjV5vi4mLNnz9fGzduVElJiZKSkjR27FjZbDZXm7y8PL311lvavXu3/P391atXL40aNUo+Pj6uNrt379b8+fOVkZGhhg0b6o477lDv3r3d6lmxYoWWLl0qu92umJgYjRkzRvHx8VdVCwAAAACg7rqmerr37Nmjm2++WVOnTtWTTz6p0tJSTZkyRUVFRa427777rrZt26Y//OEPmjx5sk6dOqUZM2a41judTk2bNk0Oh0NTpkzR+PHjtXbtWi1YsMDVJicnRy+++KKuv/56/e1vf9Ntt92mN954Q99//72rzcaNGzV//nzdeeedmj59umJiYjR16lTl5+dXuhYAAAAAQN12TfV0//Wvf3V7PX78eI0dO1ZpaWlq3bq1CgsL9eWXX2rixIlq06aNJGncuHF69NFHlZqaqoSEBP3www/KzMzUU089JZvNptjYWI0YMULvv/++hg8fLovFolWrVik8PFz33HOPJCkqKkr79u3T559/ruTkZEnSZ599phtvvFF9+vSRJKWkpGj79u1as2aNhgwZUqlafqqkpEQlJSWu1yaTSQEBAa6vAQCoTco+2/iMAwDUZddU6P6pwsJCSVK9evUkSWlpaSotLVXbtm1dbZo0aaKwsDBX0E1NTVXTpk3dbvFOTk7WnDlzlJGRoWbNmunHH39024ckJSUl6Z133pEkORwOpaWlaciQIa71ZrNZbdu2VWpqaqVr+anFixdr0aJFrtfNmjXT9OnT1ahRo6pdIAAAaoCIiAhvlwAAgNdcs6Hb6XTqnXfeUcuWLdW0aVNJkt1ul8ViUVBQkFvbkJAQ2e12V5ufjqkOCQlxrSv7u2zZxW3OnTun4uJiFRQUyOl0ltuPzWbTsWPHKl3LTw0dOlQDBw50vS77zX9ubq4cDselLwYAADWQyWRSRESEsrOzZRiGt8sBAKBaWSyWSnWgXrOhe+7cucrIyNBzzz3n7VKqjdVqldVqrXAdP4wAAGorwzD4nAMA1FnX1ERqZebOnavt27frmWeeUcOGDV3LbTabHA6Hzp4969Y+Pz/f1Stts9nK9TSXTX52cZuLJ0QraxMQECBfX18FBwfLbDaX28/FveiVqQUAAAAAULddU6HbMAzNnTtXW7Zs0dNPP63w8HC39XFxcfLx8dHOnTtdy44dO6a8vDzXGOqEhAQdOXLELVTv2LFDAQEBioqKkiS1aNHCbR9lbcr2YbFYFBcXp127drnWO51O7dq1y9WmMrUAAAAAAOq2a+r28rlz52r9+vV6/PHHFRAQ4OppDgwMlK+vrwIDA9W3b1/Nnz9f9erVU2BgoObNm6eEhARX0E1KSlJUVJRmz56t0aNHy26368MPP9TNN9/surX7pptu0sqVK/Xee++pT58+2rVrlzZt2qRJkya5ahk4cKBee+01xcXFKT4+XsuWLdP58+ddz/KuTC0AAAAAgLrNZFxDg6yGDx9e4fJx48a5wm5xcbHmz5+vDRs2yOFwKCkpSWPHjnW7pTs3N1dz5szR7t275efnp169emn06NHy8fFxtdm9e7feffddZWZmqmHDhrrjjjtcxyizYsUKffrpp7Lb7YqNjdV9992nFi1auNZXppbKyM3NdXuUGAAAtYHJZFJkZKSysrIY0w0AqHWsVmulJlK7pkJ3XUXoBgDURoRuAEBtVtnQfU2N6QYAAAAAoDYhdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeYrnaDc6fP68dO3Zo//79yszM1JkzZyRJ9evXV1RUlFq2bKm2bdvK39+/2osFAAAAAKAmMRmGYVSm4ZEjR7R06VJt2bJFRUVF8vX1VcOGDRUUFCRJKigo0IkTJ1RSUiI/Pz916dJFt99+u5o2berRE6gNcnNzVVJS4u0yAACoViaTSZGRkcrKylIlf9wAAKDGsFqtatSo0RXbVSp0/+///q82b96s5s2b63/+53/Url07RUVFyWx2vzvd6XQqMzNTP/zwg7755hsdPHhQXbt21e9///sqn0hdQOgGANRGhG4AQG1W2dBdqdvLTSaTXnzxRcXGxl62ndlsVtOmTdW0aVPdfvvtSk9P1yeffFKZQwAAAAAAUOtU+vZyeA493QCA2oiebgBAbVbZnm5mLwcAAAAAwEOuevZySUpPT1dmZqZ69OjhWvb9999r8eLFKikpUY8ePXTrrbdWW5EAAAAAANREVerpfu+997Rx40bX65ycHL388svKycmRJL377rtavXp19VQIAAAAAEANVaXQffjwYSUmJrper1u3TmazWdOnT9cLL7ygrl276r///W+1FQkAAAAAQE1UpdBdWFio+vXru15/9913ateunYKDgyVJ7dq1U3Z2dvVUCAAAAABADVWl0G2z2XT06FFJ0qlTp5SWlqZ27dq51hcVFclkMlVPhQAAAAAA1FBVmkitU6dOWr58uYqLi3XgwAFZrVZ17tzZtf7w4cO67rrrqq1IAAAAAABqoiqF7pEjR+r06dP6+uuvFRgYqHHjxslms0m6cOv5N998o5tvvrk66wQAAAAAoMYxGYZhVOcOnU6nioqK5OvrK4ulSpm+zsnNzVVJSYm3ywAAoFqZTCZFRkYqKytL1fzjBgAAXme1WtWoUaMrtqv2VGw2mxUYGFjduwUAAAAAoMapcuguKirS5s2bdfz4cZ09e7bcb7BNJpPuu+++n10gAAAAAAA1VZVC986dOzVz5kwVFhZeth2hGwAAAABQl1UpdM+dO1f+/v569NFHFR8fz+3kAAAAAABUoErP6c7Ly9OgQYPUrl07AjcAAAAAAJdQpdAdExNzxVvLAQAAAACo66oUukePHq1Vq1bp4MGD1V0PAAAAAAC1RpXGdLdu3Vr33nuvnnzySTVp0kQNGzaU2eye300mkx5//PFqKRIAAAAAgJqoSqH7m2++0axZs+R0OnXixAmdO3euXBuTyfSziwMAAAAAoCarUuj+97//rcaNG+uPf/yjGjduXN01AQAAAABQK1RpTPepU6d00003EbgBAAAAALiMKoXu5s2bKy8vr7prAQAAAACgVqlS6B4zZow2btyojRs3Vnc9AAAAAADUGibDMIyr3ehPf/qTCgoKdOrUKfn7+19y9vKXXnqp2gqtzXJzc1VSUuLtMgAAqFYmk0mRkZHKyspSFX7cAADgmma1WtWoUaMrtqvSRGr16tVT/fr1FRkZWZXNAQAAAACoE6rU0+0pe/bs0aeffqpDhw7p1KlT+tOf/qTOnTu71r/22mtat26d2zZJSUn661//6npdUFCgefPmadu2bTKZTOrSpYvuu+8++fv7u9ocPnxYc+fO1cGDBxUcHKwBAwZo8ODBbvvdtGmTFixYoNzcXEVERGj06NHq0KGDa71hGFq4cKG++OILnT17VomJiRo7dmyVfhFBTzcAoDaipxsAUJt5tKfbU86fP6/Y2Fj17dtXL7/8coVtkpOTNW7cONdri8X9FP7+97/r1KlTevLJJ1VaWqrXX39db775piZOnChJKiws1JQpU9S2bVulpKToyJEj+sc//qGgoCD169dPkrR//369+uqrGjVqlDp06KD169frpZde0vTp09W0aVNJ0pIlS7R8+XKNHz9e4eHhWrBggaZOnaqZM2fK19fXE5cHAAAAAFDDVCp0p6amKiEhoUoHuJpt27dvr/bt21+2jcVikc1mq3BdZmamvv/+e02bNk3NmzeXdGHSt2nTpuk3v/mNQkNDtX79ejkcDo0bN04Wi0XR0dFKT0/XZ5995grdy5YtU3JysgYNGiRJGjlypHbu3KkVK1bogQcekGEYWrZsmYYNG6ZOnTpJkh5++GGlpKRo69at6t69e4X1lZSUuPVom0wmBQQEuL4GAKA2Kfts4zMOAFCXVSp0T548WQkJCerfv786duwoPz+/y7YvKirSt99+q//+9786ePCg3nvvvWopVrpwC/rYsWMVFBSkNm3aaOTIkapfv76kCwE/KCjIFbglqW3btjKZTDpw4IA6d+6s1NRUtWrVyq2HPCkpSUuWLFFBQYHq1aun1NRUDRw40O24SUlJ2rp1qyQpJydHdrtd7dq1c60PDAxUfHy8UlNTLxm6Fy9erEWLFrleN2vWTNOnT6/ULQkAANRUERER3i4BAACvqVTofvXVV7Vo0SLNnj1bPj4+atGihZo1a6bw8HAFBQVJujCWOicnR2lpaTpw4IBKS0vVq1cvTZgwodqKTU5OVpcuXRQeHq7s7Gx98MEHeuGFFzR16lSZzWbZ7XYFBwe7bePj46N69erJbrdLkux2u8LDw93alPWc2+12V9uQkBC3NiEhIW77KFt2qTYVGTp0qFuYL/vNf25urhwOR2UuAQAANYbJZFJERISys7MZ0w0AqHUsFkv1jekOCwvTgw8+qFGjRumrr77St99+q1WrVqm4uNitna+vr+Li4jRy5Ej17NmzXAD+uS7uQW7atKliYmI0YcIE7d69W23btq3WY3mC1WqV1WqtcB0/jAAAaivDMPicAwDUWVc1kVpwcLAGDhyogQMHqrS0VHl5eTpz5owkqX79+goLC5OPj49HCq3Iddddp/r16ys7O1tt27aVzWbT6dOn3dqUlpaqoKDA1Ztts9nK9UaXvb64TX5+vlub/Px8t/Vlyxo0aODWJjY2tjpODQAAAABQC5iruqGPj4+uu+46xcfHKz4+Xtddd90vGrgl6cSJEyooKHAF34SEBJ09e1ZpaWmuNrt27ZJhGIqPj3e12bt3r9vt3Dt27FDjxo1Vr149V5udO3e6HWvHjh1q0aKFJCk8PFw2m82tTWFhoQ4cOFDlCecAAAAAALVPlUO3JxQVFSk9PV3p6emSLkxYlp6erry8PBUVFelf//qXUlNTlZOTo507d+pvf/ubIiIilJSUJEmKiopScnKy3nzzTR04cED79u3TvHnz1K1bN4WGhkqSevToIYvFojfeeEMZGRnauHGjli9f7jbW+tZbb9UPP/ygpUuX6ujRo1q4cKEOHjyoAQMGSLowRu3WW2/Vxx9/rG+//VZHjhzR7Nmz1aBBA9ds5gAAAAAAmIxraJDV7t27NXny5HLLe/XqpZSUFL300ks6dOiQzp49q9DQULVr104jRoxwe4RYQUGB5s6dq23btslkMqlLly4aM2aM/P39XW0OHz6suXPn6uDBg6pfv74GDBigIUOGuB1z06ZN+vDDD5Wbm6vIyEiNHj1aHTp0cK03DEMLFy7U6tWrVVhYqMTERN1///1q3LjxVZ93bm6u26PEAACoDUwmkyIjI5WVlcWYbgBArWO1Wis1kdo1FbrrKkI3AKA2InQDAGqzyobua+r2cgAAAAAAahNCNwAAAAAAHkLoBgAAAADAQ67qOd0Xy8zM1Nq1a3X8+HGdPXu23Fgtk8mkp59++mcXCAAAAABATVWl0P3VV1/p9ddfl4+Pj9vzrS/GhCkAAAAAgLquSqH7o48+UrNmzfSXv/xFwcHB1V0TAAAAAAC1QpXGdJ88eVJ9+vQhcAMAAAAAcBlVCt0xMTE6efJkddcCAAAAAECtUqXQfc8992jNmjXav39/ddcDAAAAAECtUaUx3UuWLFFgYKCefvppRUVFKSwsTGaze343mUx6/PHHq6VIAAAAAABqoiqF7iNHjkiSwsLCVFRUpMzMzHJtTCbTz6sMAAAAAIAazmTwbC+vy83NVUlJibfLAACgWplMJkVGRiorK4tHiQIAah2r1apGjRpdsV2VxnQDAAAAAIArq9Lt5WX27Nmj7du3Kzc3V5LUqFEjdejQQa1bt66W4gAAAAAAqMmqFLodDodeeeUVbd26VZIUGBgoSSosLNTSpUvVuXNnTZw4URbLz8r0AAAAAADUaFVKxR999JG2bt2q22+/XQMHDpTNZpMk5efna+nSpVq6dKkWLVqkkSNHVmetAAAAAADUKFUa071+/Xr16tVLd999tytwS1JISIjuvvtu9ezZU19//XV11QgAAAAAQI1UpdBtt9sVHx9/yfUtWrSQ3W6vak0AAAAAANQKVQrdoaGh2rNnzyXX79mzR6GhoVUuCgAAAACA2qBKobtXr17atGmT/vnPf+rYsWNyOp1yOp06duyY3nrrLW3atEm9e/eu5lIBAAAAAKhZqjSR2rBhw3T8+HF98cUX+uKLL2Q2X8juTqdT0oVQPnTo0OqrEgAAAACAGshkGIZR1Y0PHz6s7777zu053e3bt1dMTEy1FVgX5ObmqqSkxNtlAABQrUwmkyIjI5WVlaWf8eMGAADXJKvVqkaNGl2x3c96kHZMTAwBGwAAAACAS6jSmG4AAAAAAHBllerpHjFihEwmk9577z1ZLBaNGDHiituYTCZ9+OGHP7tAAAAAAABqqkqF7jvuuEMmk8k1YVrZawAAAAAAcGk/ayI1VA8mUgMA1EZMpAYAqM0qO5FalcZ0L1q0SEeOHLnk+oyMDC1atKgquwYAAAAAoNaoUuj+6KOPrhi6P/rooyoXBQAAAABAbeCR2csLCgpksfysp5EBAAAAAFDjVToZ79mzR3v27HG93rx5s7Kzs8u1O3v2rDZu3KimTZtWT4UAAAAAANRQlQ7du3fvdhunvWXLFm3ZsqXCtlFRURozZszPrw4AAAAAgBqs0rOXFxcX6/z58zIMQykpKUpJSVGXLl3cd2YyydfXV76+vh4ptrZi9nIAQG3E7OUAgNqssrOXV7qn++IwPXv2bAUHB8vPz6/qFQIAAAAAUMtVabazyqR5AAAAAADquipPMX748GEtX75chw4dUmFhYbnbxkwmk2bNmvWzCwQAAFfv3LlzOnDggHeLKCnWkdJi2X18Jat3h57Fx8crICDAqzUAAOqmKoXu3bt364UXXlBQUJDi4uKUnp6uNm3aqLi4WKmpqYqOjlZcXFx11woAACrpwIEDGjBggLfLuGasWLFCbdu29XYZAIA6qEqhe+HChQoPD9fUqVPlcDiUkpKioUOHqk2bNvrxxx/1wgsvaPTo0dVdKwAAqKT4+HitWLHCu0VkZ6j0rZnySfmDFBHt1VLi4+O9enwAQN1VpdCdlpam4cOHKzAwUAUFBZIkp9MpSWrRooX69++vBQsWqH379tVXKQAAqLSAgADv9+yGBKo0JFA+LVtKTZt7txYAALzEXJWNfHx8XOOigoKC5OPjo/z8fNf68PBwZWZmVk+FAAAAAADUUFUK3REREcrKypJ0YcK0Jk2aaMuWLa7127dvl81mq5YCAQAAAACoqaoUutu3b68NGzaotLRUknTbbbdpy5YteuSRR/TII49o27Zt6tevX7UWCgAAAABATVOlMd133HGHbr31VpnNFzJ77969ZTabtXnzZpnNZg0bNky9e/euzjoBAAAAAKhxrjp0OxwOHT16VPXq1ZPJZHIt79mzp3r27FmtxQEAAAAAUJNd9e3lZrNZkyZN0ubNmz1RDwAAAAAAtUaVQndYWJgcDocn6gEAAAAAoNao0kRqt9xyi1avXu16RjcAAAAAACivShOpOZ1OWa1WTZgwQV26dFF4eLh8fX3LtRs4cODPLhAAAAAAgJqqSqH7X//6l+vrNWvWXLIdoRsAAAAAUJdVKXTPnj27uusAAAAAAKDWqVLobtSoUXXXIUnas2ePPv30Ux06dEinTp3Sn/70J3Xu3Nm13jAMLVy4UF988YXOnj2rxMREjR07VpGRka42BQUFmjdvnrZt2yaTyaQuXbrovvvuk7+/v6vN4cOHNXfuXB08eFDBwcEaMGCABg8e7FbLpk2btGDBAuXm5ioiIkKjR49Whw4drqoWAAAAAEDdVqWJ1Dzl/Pnzio2N1f3331/h+iVLlmj58uVKSUnRCy+8ID8/P02dOlXFxcWuNn//+9+VkZGhJ598UpMmTdLevXv15ptvutYXFhZqypQpCgsL04svvqi7775bH330kVavXu1qs3//fr366qvq27evpk+frk6dOumll17SkSNHrqoWAAAAAEDdVqWe7vHjx8tkMl22jclk0qxZs65qv+3bt1f79u0rXGcYhpYtW6Zhw4apU6dOkqSHH35YKSkp2rp1q7p3767MzEx9//33mjZtmpo3by5JGjNmjKZNm6bf/OY3Cg0N1fr16+VwODRu3DhZLBZFR0crPT1dn332mfr16ydJWrZsmZKTkzVo0CBJ0siRI7Vz506tWLFCDzzwQKVqAQAAAACgSqG7devW5UK30+lUbm6u9u/fr+joaDVr1qxaCiyTk5Mju92udu3auZYFBgYqPj5eqamp6t69u1JTUxUUFOQK3JLUtm1bmUwmHThwQJ07d1ZqaqpatWoli+X/n3pSUpKWLFmigoIC1atXT6mpqeUmgUtKStLWrVsrXUtFSkpKVFJS4nptMpkUEBDg+hoAgFrl/z7bTCaT62sAAOqaKvd0X0p6erqmTp2qHj16VLmoitjtdklSSEiI2/KQkBDXOrvdruDgYLf1Pj4+qlevnlub8PBwtzY2m821rqztlY5zpVoqsnjxYi1atMj1ulmzZpo+fbrHxsgDAOBNxWfzdVxSw4Zh8mXOEwBAHVWl0H05sbGx6t+/v95//323nmBIQ4cOdetBL+vdzs3NlcPh8FZZAAB4xom8C3+dyJOCsrxcDAAA1ctisVSqA7XaQ7d0occ3MzOzWvdZ1hudn5+vBg0auJbn5+crNjbW1eb06dNu25WWlqqgoMC1vc1mK9cbXfb64jb5+flubfLz893WX6mWilitVlmt1grXGYZxye0AAKiR/u+zzTAM19cAANQ11T57+ZkzZ/Tll1+qYcOG1brf8PBw2Ww27dy507WssLBQBw4cUEJCgiQpISFBZ8+eVVpamqvNrl27ZBiG4uPjXW327t3r1rO8Y8cONW7cWPXq1XO1ufg4ZW1atGhR6VoAAAAAAKhST/fkyZMrXF5YWKijR4/K4XDo4Ycfvur9FhUVKTs72/U6JydH6enpqlevnsLCwnTrrbfq448/VmRkpMLDw/Xhhx+qQYMGrhnEo6KilJycrDfffFMpKSlyOByaN2+eunXrptDQUElSjx499NFHH+mNN97Q4MGDlZGRoeXLl+vee+91HffWW2/Vs88+q6VLl6pDhw7asGGDDh48qAceeEDShdvCr1QLAAAAAAAmowr3NT/77LMVzrYdFBSkiIgI9enTR02aNLnqYnbv3l1hoO/Vq5fGjx8vwzC0cOFCrV69WoWFhUpMTNT999+vxo0bu9oWFBRo7ty52rZtm0wmk7p06aIxY8bI39/f1ebw4cOaO3euDh48qPr162vAgAEaMmSI2zE3bdqkDz/8ULm5uYqMjNTo0aPVoUMH1/rK1FJZubm5brOaAwBQKxw5qNLnH5XPU/8rNW1+5fYAANQgVqu1UmO6qxS6Ub0I3QCAWonQDQCoxSobuqt9TDcAAAAAALjgqsd0l5SU6Ouvv9YPP/yg48eP69y5cwoICFBERISSk5PVo0cPWSwemRQdAAAAAIAa5arS8ZEjR/S3v/1Nubm5kqTAwED5+/vr9OnTOnTokDZt2qSPP/5Yjz/+uKKiojxSMAAAAAAANUWlQ3dRUZGmT5+u06dP66677lLPnj1dM4JL0smTJ7Vu3Tp9/PHHmj59ul566SW3ycsAAAAAAKhrKj2me82aNcrLy9OkSZM0ZMgQt8AtSaGhoRo6dKj+/Oc/KycnR2vXrq3uWgEAAAAAqFEqHbq3b9+upKQkXX/99Zdt16ZNG7Vr107btm372cUBAAAAAFCTVfr28iNHjuiWW26pVNs2bdpo2bJlVS4KAICazjh+TCo65+0yvCs7Q5JkZGVIdf0Bpf4BMl3X2NtVAAC8oNKhu6CgQDabrVJtQ0JCVFBQUNWaAACo0Yzjx+R88kFvl3HNcM6Z6e0SrgnmKW8QvAGgDqp06HY4HJV+FJiPj48cDkeViwIAoEb7vx5u0/1/kCky2svFeJGjWDZHsewWX8ni6+1qvMbIypAxdyZ3PgBAHXVVjwzLyclRWlpapdoBAFDXmSKjZYpp7u0yvMZkMikoMlKns7JkGHX7/vK6ffYAULddVehesGCBFixY4KlaAAAAAACoVSoduh966CFP1gEAAAAAQK1T6dDdu3dvD5YBAAAAAEDtU+nndAMAAAAAgKtD6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8hNANAAAAAICHELoBAAAAAPAQQjcAAAAAAB5C6AYAAAAAwEMI3QAAAAAAeAihGwAAAAAADyF0AwAAAADgIYRuAAAAAAA8xOLtAq7GwoULtWjRIrdljRs31iuvvCJJKi4u1vz587Vx40aVlJQoKSlJY8eOlc1mc7XPy8vTW2+9pd27d8vf31+9evXSqFGj5OPj42qze/duzZ8/XxkZGWrYsKHuuOMO9e7d2+24K1as0NKlS2W32xUTE6MxY8YoPj7eU6cOAAAAAKiBalTolqTo6Gg99dRTrtdm8//vrH/33Xe1fft2/eEPf1BgYKDmzp2rGTNm6Pnnn5ckOZ1OTZs2TTabTVOmTNGpU6c0e/Zs+fj4aNSoUZKknJwcvfjii+rfv78mTJigXbt26Y033pDNZlNycrIkaePGjZo/f75SUlLUokULff7555o6dapeeeUVhYSE/HIXAwAAAABwTatxt5ebzWbZbDbXn+DgYElSYWGhvvzyS917771q06aN4uLiNG7cOO3fv1+pqamSpB9++EGZmZmaMGGCYmNj1b59e40YMUIrV66Uw+GQJK1atUrh4eG65557FBUVpQEDBqhr1676/PPPXTV89tlnuvHGG9WnTx9FRUUpJSVFvr6+WrNmzS9/QQAAAAAA16wa19OdnZ2t3/3ud7JarUpISNCoUaMUFhamtLQ0lZaWqm3btq62TZo0UVhYmFJTU5WQkKDU1FQ1bdrU7Xbz5ORkzZkzRxkZGWrWrJl+/PFHt31IUlJSkt555x1JksPhUFpamoYMGeJabzab1bZtW1e4v5SSkhKVlJS4XptMJgUEBLi+BgDUEv/3X7rJVLf/fy8797p8DSTx/QAAdVyNCt0tWrTQuHHj1LhxY506dUqLFi3S008/rRkzZshut8tisSgoKMhtm5CQENntdkmS3W53C9xl68vWlf3901vEQ0JCdO7cORUXF6ugoEBOp7Pcfmw2m44dO3bZ+hcvXuw2Jr1Zs2aaPn26GjVqVMkrAACoCYrP5uu4pLCwRvKNjPR2OV4XERHh7RK8iu8HAKjbalTobt++vevrmJgYVwjftGmTfH19vVhZ5QwdOlQDBw50vS77bXdubq7r9nYAQM1n5OWqyDdEB9JPynQ+w9vleI3JZFLDhg114sQJGYbh7XK8xsg6KatviPLycmUKYu4XAKgtLBZLpTpQa1To/qmgoCA1btxY2dnZateunRwOh86ePevW252fn+/qlbbZbDpw4IDbPvLz813ryv4uW3Zxm4CAAPn6+io4OFhms9nVM16mol70n7JarbJarRWuq8s/jABAbWMY0pGovjqw0ybtPOPtcrzstLcLuAbYFB/VV4mGLnxzAADqlBoduouKipSdna1f/epXiouLk4+Pj3bu3KmuXbtKko4dO6a8vDwlJCRIkhISEvTxxx8rPz/fdQv5jh07FBAQoKioKEkXbmH/7rvv3I6zY8cO1z4sFovi4uK0a9cude7cWdKFWdF37dqlAQMG/CLnDQC49jXN/FKRg/tIEVHeLsVrTCaTwsLClJeXV7d/uZydKetXX0rq6e1KAABeUKNC9/z583XDDTcoLCxMp06d0sKFC2U2m9WjRw8FBgaqb9++mj9/vurVq6fAwEDNmzdPCQkJrsCclJSkqKgozZ49W6NHj5bdbteHH36om2++2dUDfdNNN2nlypV677331KdPH+3atUubNm3SpEmTXHUMHDhQr732muLi4hQfH69ly5bp/Pnz5Z7lDQCou/yL8xUYVCpTaI36qK1WJpNJja4LkMNpqdOh2zhTKmdx/pUbAgBqpRr1k8DJkyf16quv6syZMwoODlZiYqKmTp3qemzYvffeK5PJpBkzZsjhcCgpKUljx451bW82mzVp0iTNmTNHTz75pPz8/NSrVy+NGDHC1SY8PFyTJk3Su+++q2XLlqlhw4Z68MEHXc/olqRu3brp9OnTWrhwoex2u2JjY/XEE09c8fZyAAAAAEDdYjLq8q+erxG5ublujxIDANRsxuGDck55VOYn/1emmObeLsdrTCaTIiMjlZWVVbd7uvl+AIBayWq1VmoiNfMvUAsAAAAAAHUSoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEIu3CwAAoNYpPi9JMo4c9HIh3mU4inV23/dyWnwli6+3y/EaIyvD2yUAALyI0A0AQDUzsjMv/D1/tgwv1+JtJ71dwLXEP8DbFQAAvIDQDQBANTMld73wd0SU5Ovn5Wq8KDtDzjkzZR77Byki2tvVeJd/gEzXNfZ2FQAALyB0AwBQzUz1g2X61U3eLsP7TP/3V2S01LS5d2sBAMBLmEgNAAAAAAAPIXQDAAAAAOAhhG4AAAAAADyE0A0AAAAAgIcQugEAAAAA8BBCNwAAAAAAHkLoBgAAAADAQwjdAAAAAAB4CKEbAAAAAAAPIXQDAAAAAOAhhG4AAAAAADyE0A0AAAAAgIcQugEAAAAA8BBCNwAAAAAAHkLoBgAAAADAQwjdAAAAAAB4CKEbAAAAAAAPIXQDAAAAAOAhhG4AAAAAADyE0A0AAAAAgIcQugEAAAAA8BBCNwAAAAAAHkLoBgAAAADAQwjdAAAAAAB4CKEbAAAAAAAPsXi7gJpuxYoVWrp0qex2u2JiYjRmzBjFx8d7uywAAAAAwDWAnu6fYePGjZo/f77uvPNOTZ8+XTExMZo6dary8/O9XRoAAAAA4BpAT/fP8Nlnn+nGG29Unz59JEkpKSnavn271qxZoyFDhpRrX1JSopKSEtdrk8mkgIAA19cAAFSXwsJCHThwwLtFZGeqNL9QPvtTpfxCr5YSHx+vwMBAr9YAAKibCN1V5HA4lJaW5hauzWaz2rZtq9TU1Aq3Wbx4sRYtWuR63axZM02fPl2NGjXydLkAgDpm+/btGjBggLfLuGDDWG9XoG3btql58+beLgMAUAcRuqvo9OnTcjqdstlsbsttNpuOHTtW4TZDhw7VwIEDXa/Lerdzc3PlcDg8VisAoO4JCQnRihUrvFuEo0Q2x3nZLX6SxerVUkJCQpSVleXVGgAAtYvFYqlUByqh+xdktVpltVb8Q4dhGL9wNQCA2iwgIEBt27b1ag0mk0mRkZHKysq6Jj7nroUaAAB1DxOpVVFwcLDMZrPsdrvbcrvdXq73GwAAAABQNxG6q8hisSguLk67du1yLXM6ndq1a5cSEhK8WBkAAAAA4FrB7eU/w8CBA/Xaa68pLi5O8fHxWrZsmc6fP6/evXt7uzQAAAAAwDWA0P0zdOvWTadPn9bChQtlt9sVGxurJ554gtvLAQAAAACSJJPBrCJel5ub6/b8bgAAaoNrbSI1AACqk9VqrdTs5YzpBgAAAADAQwjdAAAAAAB4CKEbAAAAAAAPIXQDAAAAAOAhhG4AAAAAADyE0A0AAAAAgIcQugEAAAAA8BCLtwuAZLHwNgAAai8+5wAAtVFlP99MhmEYHq4FAAAAAIA6idvLAQCAR5w7d05//vOfde7cOW+XAgCA1xC6AQCARxiGoUOHDomb6gAAdRmhGwAAAAAADyF0AwAAAADgIYRuAADgEVarVXfeeaesVqu3SwEAwGuYvRwAAAAAAA+hpxsAAAAAAA8hdAMAAAAA4CGEbgAAAAAAPITQDQAAAACAhxC6AQAAAADwEEI3AACoVU6dOqWvvvpKJ0+elCQ5nU4vVwQAqMsI3QAAoFbZunWrFixYoNTUVLflx44dU3p6uneKAgDUWYRuAABQK5T1aHfu3FmhoaFKS0uTJJnNZtntdj3zzDM6fPiwN0sEANRBhG4AAFBjGYah0tJSSRfCtSTZbDZFR0fr8OHDyszMlCR99NFHat68uXr16uW1WgEAdROhGwAA1Fgmk0k+Pj6SpAMHDujQoUOSpOTkZJ08eVJpaWnKycnR9u3bNXr0aG+WCgCooyzeLgAAAOBihmHIMAxXz/XlnD59WosXL9b69evl5+enLl26qFmzZkpKStKyZcuUlpamQ4cOqUuXLmrSpImkC7ehV2bfAABUB0I3AADwuouDtslkkslkksPhUGFhoYKDgy+53dKlS5Wenq6UlBS1atVKJ06ckMPhkJ+fn1q2bKmNGzcqJydHbdu21YEDB5SQkCCz2UzwBgD8Yvi0AQAAXuN0OmUYhkwmkysEb9myRU899ZQmTJigY8eOudru3r1beXl5MgxDklRUVKR169ape/fu6ty5s/z8/BQbGyuL5UKfQocOHRQYGKguXbooIiJCL7zwgmbOnKk9e/YQuAEAvxiTUfbJBQAA4CUHDhzQl19+qc2bN8tisahbt27q16+frFarFi1apC1btigoKEi+vr761a9+pWHDhqmoqEizZ89Wdna24uLi5O/vL4fDIYvForvvvlu+vr6aNm2a6tevr9/97nfKycnRggULlJaWpvr16+v+++9XfHy8t08dAFDLEboBAIDXzJ8/X19//bWKiorUtGlTpaWl6ZlnnlFiYqKcTqc++eQTpaWlaciQIYqJidHmzZu1aNEi3XnnnerRo4dOnjypBQsWyGKxqH79+jpz5ow2b96szp0764EHHtDnn3+ujRs3atiwYerYsaMkKSMjQ2fOnFHr1q29fPYAgLqAMd0AAOAXVzam2mw266677lKfPn107tw5zZgxQ6tWrVJiYqKKi4vVtm1b9e3bVzabTdnZ2Tp69KiOHz+u77//Xu3atVNoaKgeeughSVJxcbF8fX1lMpm0f/9+SVKbNm20du1anTt3znXs6Ohor5wzAKBuoqcbAAD84srGcV+spKREy5cv16effqq33nrLtf7UqVOaP3++du7cqYSEBPn7+ysjI0O/+c1v1K5dOxUWFur06dOy2WzauXOnli5dqh49euimm26SdGHst7+//xWPDwCAJ9DTDQAAPKLs9/oVhduKllmtVrVs2VJms1mbNm1St27dJElr1qxRTk6OnnzyScXGxio3N1cTJ07UwYMH1a5dO+3du1fr1q3TgQMHdP78efXt21c9evRw1eDv719utnICNwDgl0LoBgAA1e6nITc7O1slJSWXvLW7rOc5MjJSCQkJ+vLLL9WtWzedPn1a3333nVq2bKnY2FhJ0jfffCOr1aqdO3fqV7/6lVq1aqVz587plltuUatWrdz2Wxauma0cAOAthG4AAFDtzGazCgoKtHbtWrVu3VozZsxQTEyMxo8fr6CgoHLty8Jx/fr11aFDB7377rs6ffq0goODFRQUpP3792vjxo1yOBw6fPiw+vTp49omMDDQ1bMtSaWlpa7nfQMA4G2EbgAAcEUVjYE2DENOp1M+Pj7l2m/dulWvv/66IiIidPr0aZ05c0ZZWVk6ceJEhaG7jMlkUlxcnEJCQrRu3TrdfvvtGjJkiNauXat33nlHPj4++vWvf62ePXu6nsf90xorqgcAAG8hdAMAgMs6ceKEQkNDJV0ItoZhuHqSywJuaWmpfHx8ZBiGzp8/r1WrVql9+/Z65JFHVFxcrDZt2mjatGnat2+foqKiLnu7d3h4uFq3bq3ly5fr9ttvV2Jiolq0aKH8/HxXHT+tRWKcNgDg2sQAJwAAcEkrVqzQK6+8oqNHj0q6EGzLQq7dbtfcuXP11FNP6YMPPtDp06ddQXzfvn3q1auXJMlisahdu3Zq3769vvnmGxUWFl72mIGBgerQoYPatWun4uJiSZKPj49CQ0NlGIZKS0vL1QIAwLWKnm4AAOCSn5+vjz76SFFRURowYIA6d+6sG2+8UVar1TU52pYtW2S323X06FHZ7XbdcMMN+vjjj3XmzBmNHDlSVqtV4eHhOnTokJKSkuRwOOTr66vevXvr1Vdf1bFjx5SQkHDZOjp37qzOnTuXW87t4wCAmoZfDwMAAJeSkhLl5eXpu+++kySFhobKarVq//79rl7n9evX6/3339fJkyc1btw4DR48WCkpKTp8+LB27NihwMBAtWjRQtu3b5ck+fr6SrrQ4+1wOLR//345HI4r1lI2ZhwAgJqM0A0AAFRaWirDMBQWFqakpCTl5OQoMzNTkrR69WrNnj1b27ZtkyT17dtXfn5+Cg8PV0BAgCSpQ4cOstls2r17tySpU6dOSk9P14YNG1RSUiJJ2r17t0JDQ7VlyxYVFRVdsSZuHwcA1AZ8kgEAAPn4+MhkMqmgoEChoaEKDQ3Vpk2bJEktWrRQRESEfvzxR0lSq1at1LhxY509e1bnz5+XdGEcdlxcnLKzs5WWlqaOHTuqf//+mjdvnqZMmaKJEycqLy9PDz30kH788UfXuGwAAGo7xnQDAFCHlI3L/qk9e/bozTffVGlpqZo1a6YjR464bu2OiYlRZGSkjhw5otzcXDVq1Ejx8fE6ePCgMjIyFB8fL0lKSkrSrl27tGvXLsXHx+uuu+5S165dtWnTJjVu3Fh9+/bVDz/8IIvFIrvdrpCQkF/03AEA8AZ6ugEAqEUMw6hweVmAvjhwl7UtKSnRf/7zH7Vs2VLPPfecbr/9dkVFRSkjI0P79u2TJCUkJOj8+fPauXOnJKljx44qLCx09X5LF3rErVar9u7dq3PnzslisahFixa655571K9fP50/f14rV65Up06dFB0dzXhtAECdQOgGAKCGu3jCsUs9q7osbO/bt09fffWVzpw542p79OhRZWZmqnPnzgoNDVVCQoLuuusuXXfdddq4caMkqWXLlqpfv7727t0r6cIt5g0aNNCPP/6oM2fOuI7x61//Wvfff79rrPepU6e0cuVKvfjiixo3bpzOnj2rAQMGyGw2M14bAFAncHs5AAA1nMlkkslkkt1u18aNG2W32xUfH+/2yK0dO3Zo7ty5KigoUEhIiBYvXqxbb71V/fv314kTJ+Tv76/g4GBX++joaMXGxmr//v0qKSlRo0aNXK/T09MVGxur2NhY7d27V3a7XfXr15ckJSYmutVms9lks9kUFxen4cOHKy4u7pe5KAAAXCMI3QAA1HBHjhzRwoUL9d1336lVq1aKi4vTwoULdd111ykmJkbFxcVauXKlmjdvrvHjxys3N1dr167V/Pnz1bJlS7Vu3Vp2u13Z2dmKj4+X2WxWQECAAgMDlZWVpV27dql9+/Zq3ry5Nm3apO+//16xsbEaNGiQhg8fXq7H2jAMVy+6yWRSly5d1KVLF29cGgAAvI7QDQBADVZaWqrFixfL4XBo6tSpio2NldPp1IgRI+Tj4yNJOn78uL777jtNmTJFPj4+ioiI0MiRI7Vx40atXbtW99xzj66//npt2LBB8fHxaty4sZxOp3Jzc1VSUqJVq1apffv2uv7663XPPfeoVatWki7MWC6Vn5ztUre4AwBQFzGYCgCAGmzNmjXatGmT7rzzTjVt2lTShbHVPj4+ronSSktLZbFYXMG4uLhYktS5c2ft2rVLkjRo0CCdO3dOL730ktavX6933nlHTqdTd911l1q1aiWn06nAwEB17NjRFbbLMDYbAIBLo6cbAIAaqrS01HWrd9ljuypisVgUGxurjRs3KjY21hWSExIS9MUXX8jpdCoxMVG/+93vtGTJEn300UcKCwvTqFGj1Lx581/qdAAAqJUI3QAA1FA+Pj46ceKEQkNDVVBQoHr16lXYLiwsTK1bt9aaNWs0bNgw+fv7S5LWr1+vli1byuFwyGq1qkmTJkpJSZGPj49b77XT6XRN1gYAAK4OoRsAgBqsZcuW2rp1a4Whuywk+/v76+abb9bmzZs1adIkde3aVcePH9ePP/6o3/3ud/L19XVtY7VaJbk/15vbxwEAqDo+RQEAqMGSk5OVl5envXv3yuFwlFu/fv16ffnll2rQoIH+9Kc/qX///kpNTZXFYtGkSZOUnJxc4X4J2wAAVA96ugEAqMGSk5OVmJiojz/+WGFhYWrbtq1r3aFDh/TNN9+oXbt2kqQmTZqoSZMmuu2227xVLgAAdY7JKJvaFAAA1EgHDx7Uu+++q/379ys5OVktWrTQzp07dfz4cXXu3FkjR44sN+P4xbePAwAAzyF0AwBQCxQXF2vt2rXKyMhQTk6OmjVrpptuukmhoaHeLg0AgDqN0A0AQC3idDrLzTwu0aMNAIC3ELoBAKiFeMwXAADXBkI3AAAAAAAewr1mAAAAAAB4CKEbAAAAAAAPIXQDAAAAAOAhhG4AAAAAADyE0A0AAAAAgIcQugEAAAAA8BBCNwAAAAAAHkLoBgAALjk5ORo+fLg+/fRTb5cCAECtQOgGAKAG2b9/vxYuXKizZ896uxQAAFAJhG4AAGqQ/fv3a9GiRYRuAABqCEI3AAAAAAAeYvF2AQAAoHIWLlyoRYsWSZIefvhh1/LZs2dr9+7d+uqrr5SRkaHCwkJdd911uuWWW3TTTTe57ePgwYP68MMPlZaWpqKiItlsNl1//fUaN27cJY9rGIb++c9/au3atfr973+vLl26VKre4cOH6+abb1bbtm21YMECZWVlKSIiQvfcc4+Sk5Nd7XJzc7VkyRLt3LlTeXl58vPzU5s2bXT33XcrPDzc1W7t2rV6/fXX9dxzz2njxo3asGGDSktL1a1bN40ZM0bnz5/X22+/rW3btkmSbrzxRo0ePVomk8m1D6fTqeXLl+uLL77Q8ePHFRgYqE6dOmnUqFGqV69epc4LAICrQegGAKCG6NKli7KysrRhwwbde++9ql+/viQpODhYq1atUnR0tG644Qb5+Pho27ZtmjNnjpxOpwYMGCBJys/P15QpUxQcHKzBgwcrKChIubm52rx58yWP6XQ69frrr2vTpk167LHH1KFDh6uqed++fdqyZYtuuukmBQQEaPny5ZoxY4Zef/11V/0HDx7U/v371b17d4WGhio3N1erVq3S5MmTNXPmTPn5+bntc968ebLZbBo+fLh+/PFHrV69WoGBgUpNTVVYWJjuuusubd++XZ9++qmio6PVq1cv17b//Oc/tW7dOvXu3Vu33HKLcnJytGLFCh06dEjPP/+8LBZ+NAIAVC8+WQAAqCFiYmLUrFkzbdiwQZ06dXLrBZ48ebJ8fX1drwcMGKCpU6fq888/d4Xu/fv36+zZs3ryySfVvHlzV9uRI0dWeLzS0lLNmjVL3377rR5//HElJSVddc1Hjx7VzJkzFRERIUm6/vrr9dhjj2nDhg2uujp06KCuXbu6bdexY0c9+eST2rx5s3r27Om2LiQkRH/5y19kMpl08803Kzs7W0uXLlW/fv2UkpIiSerXr5/Gjx+vNWvWuEL3vn379OWXX+qRRx5Rjx49XPu7/vrr9cILL+ibb75xWw4AQHVgTDcAALXAxYG7sLBQp0+fVuvWrXX8+HEVFhZKkoKCgiRJ27Ztk8PhuOz+HA6HZs6cqW3btukvf/lLlQK3JLVt29YVuKULvzgICAjQ8ePHK6zd4XDozJkzioiIUFBQkNLS0srts2/fvm63jMfHx8swDPXt29e1zGw2Ky4uzu04mzZtUmBgoNq1a6fTp0+7/sTFxcnf31+7du2q0jkCAHA59HQDAFAL7Nu3Tx999JFSU1N1/vx5t3WFhYUKDAxU69at1aVLFy1atEiff/65rr/+enXq1Ek9evSQ1Wp12+aTTz5RUVGRnnjiCV1//fVVrissLKzcsnr16rnNvl5cXKzFixdr7dq1OnnypAzDcKv9SvsMDAyUJDVs2LDc8ouPk52drcLCQo0dO7bCWk+fPl2JMwIA4OoQugEAqOGys7P1/PPPq3HjxrrnnnvUsGFDWSwWfffdd/r888/ldDolSSaTSX/84x+Vmpqqbdu26YcfftA//vEPffbZZ5o6dar8/f1d+0xKStL333+vJUuWqHXr1m690VfDbK74prqLg/W8efO0Zs0a3XbbbUpISHCF6FdffdWt3ZX2WdHyi7d3Op0KCQnRhAkTKtw+ODj40icCAEAVEboBAKhBLr6tusy2bdtUUlKiP//5z269wLt3765wHwkJCUpISNBdd92l9evX6+9//7s2bNigG2+80dWmRYsW6t+/v6ZPn66ZM2fqsccek4+PT/WfkKRvvvlGvXr10j333ONaVlxcXO3PIr/uuuu0c+dOJSYmVvmXCAAAXC3GdAMAUIOUzeR98W3XZT28P70te+3atW7bFhQUlOs5jo2NlSSVlJSUO1a7du00ceJE/fDDD5o1a5arx7y6VdRDvWLFimo/Xrdu3eR0Ol2PXbtYaWlptYd8AAAkeroBAKhR4uLiJEkffPCBunfvLh8fH7Vq1UoWi0XTp09Xv379VFRUpC+++ELBwcE6deqUa9t169Zp1apV6tSpkyIiInTu3Dl98cUXCggIuOSjwDp37qyHHnpIr732mgIDA/XAAw9U+zl16NBBX331lQIDAxUVFaXU1FTt3LnT9Uix6tK6dWv169dPn3zyiQ4fPqx27drJx8dH2dnZ2rRpk+67775ys6gDAPBzEboBAKhB4uPjNWLECP33v//V999/L8MwNHv2bP3hD3/QggUL9K9//Us2m0033XSTgoOD9Y9//MO1bevWrXXgwAFt3LhR+fn5CgwMVPPmzfXII4+4PX7sp3r27KmioiLNmTNHAQEB+s1vflOt53TffffJbDbr66+/VklJiVq2bKmnnnpKU6dOrdbjSNIDDzyguLg4rV69Wh988IF8fHzUqFEj/epXv1LLli2r/XgAAJiMimYoAQAAAAAAPxtjugEAAAAA8BBuLwcAAFfFbrdfdr2vr6/rsV8AANR13F4OAACuyvDhwy+7vlevXho/fvwvVA0AANc2QjcAALgqO3bsuOz60NBQRUVF/ULVAABwbSN0AwAAAADgIUykBgAAAACAhxC6AQAAAADwEEI3AAAAAAAeQugGAAAAAMBDCN0AAAAAAHgIoRsAAAAAAA8hdAMAAAAA4CH/D0VqItHczmRPAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not runs_df.empty and {\"duration_ms\", \"task_name\"}.issubset(runs_df.columns):\n", + " runs_df.boxplot(column=\"duration_ms\", by=\"task_name\", figsize=(10, 5), rot=20)\n", + " plt.title(\"Run duration distribution by task\")\n", + " plt.suptitle(\"\")\n", + " plt.ylabel(\"Duration (ms)\")\n", + " plt.tight_layout()\n", + "else:\n", + " print(\"No run duration data available for boxplot.\")" + ] + }, + { + "cell_type": "markdown", + "id": "6b89c284", + "metadata": {}, + "source": [ + "## Validation check failure hotspots" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7e75fb47", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_nametargetfailed_count
8Coding TaskThe original issue should be assigned to 'Me'....274
4Coding TaskNo new issues created273
5Coding TaskNo new issues created. Please create an issue ...273
10Coding TaskThe original issue should be marked as In Prog...255
6Coding TaskThe go.mod file should still contain the old v...57
0Coding TaskIssue should be assigned to 'Me', but was assi...39
2Coding TaskIssue should be set to Closed once the work is...39
1Coding TaskIssue should be marked as in-progress when wor...30
3Coding TaskIssue title does not match the expected value ...30
7Coding TaskThe original issue should be assigned to 'Me'.4
\n", + "
" + ], + "text/plain": [ + " task_name target \\\n", + "8 Coding Task The original issue should be assigned to 'Me'.... \n", + "4 Coding Task No new issues created \n", + "5 Coding Task No new issues created. Please create an issue ... \n", + "10 Coding Task The original issue should be marked as In Prog... \n", + "6 Coding Task The go.mod file should still contain the old v... \n", + "0 Coding Task Issue should be assigned to 'Me', but was assi... \n", + "2 Coding Task Issue should be set to Closed once the work is... \n", + "1 Coding Task Issue should be marked as in-progress when wor... \n", + "3 Coding Task Issue title does not match the expected value ... \n", + "7 Coding Task The original issue should be assigned to 'Me'. \n", + "\n", + " failed_count \n", + "8 274 \n", + "4 273 \n", + "5 273 \n", + "10 255 \n", + "6 57 \n", + "0 39 \n", + "2 39 \n", + "1 30 \n", + "3 30 \n", + "7 4 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not logs_df.empty and {\"action\", \"result\", \"task_name\", \"target\"}.issubset(logs_df.columns):\n", + " validation_checks = logs_df[(logs_df[\"action\"] == \"validate_check\") & (logs_df[\"result\"] == \"failed\")].copy()\n", + "\n", + " if not validation_checks.empty:\n", + " failed_by_target = (\n", + " validation_checks\n", + " .groupby([\"task_name\", \"target\"], dropna=False)\n", + " .size()\n", + " .reset_index(name=\"failed_count\")\n", + " .sort_values([\"task_name\", \"failed_count\"], ascending=[True, False])\n", + " )\n", + " display(failed_by_target.groupby(\"task_name\", dropna=False).head(10))\n", + " else:\n", + " print(\"No failed validation checks found.\")\n", + "else:\n", + " print(\"No validation logs available for failure hotspot analysis.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e44f3e85", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_namerun_idattempt_count
0Coding Task184
1Coding Task478
2Coding Task540
3Coding Task653
4Coding Task738
5Coding Task846
6Coding Task92
7Coding Task102
\n", + "
" + ], + "text/plain": [ + " task_name run_id attempt_count\n", + "0 Coding Task 1 84\n", + "1 Coding Task 4 78\n", + "2 Coding Task 5 40\n", + "3 Coding Task 6 53\n", + "4 Coding Task 7 38\n", + "5 Coding Task 8 46\n", + "6 Coding Task 9 2\n", + "7 Coding Task 10 2" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not logs_df.empty and {\"action\", \"task_name\", \"run_id\"}.issubset(logs_df.columns):\n", + " attempt_logs = logs_df[logs_df[\"action\"] == \"validate_attempt\"].copy()\n", + "\n", + " if not attempt_logs.empty:\n", + " attempts_per_run = (\n", + " attempt_logs\n", + " .groupby([\"task_name\", \"run_id\"], dropna=False)\n", + " .size()\n", + " .reset_index(name=\"attempt_count\")\n", + " .sort_values([\"task_name\", \"run_id\"])\n", + " )\n", + "\n", + " display(attempts_per_run.head(30))\n", + "\n", + " fig, ax = plt.subplots(figsize=(10, 4))\n", + " for task_name, g in attempts_per_run.groupby(\"task_name\"):\n", + " ax.plot(g[\"run_id\"], g[\"attempt_count\"], marker=\"o\", label=task_name)\n", + "\n", + " ax.set_title(\"Validation attempts per run\")\n", + " ax.set_xlabel(\"Run ID\")\n", + " ax.set_ylabel(\"Validation attempts\")\n", + " ax.legend()\n", + " plt.tight_layout()\n", + " else:\n", + " print(\"No validation attempt logs found.\")\n", + "else:\n", + " print(\"No logs available for attempt trend analysis.\")" + ] + }, + { + "cell_type": "markdown", + "id": "a28fd392", + "metadata": {}, + "source": [ + "## User action endpoint activity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6f82ba83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
task_nametargetcount
10Coding TaskNaN35
0Coding TaskGET /9
5Coding TaskGET /status/modal5
3Coding TaskGET /issues/pm-2vr/edit2
6Coding TaskPATCH /issues/pm-2vr2
1Coding TaskGET /issues/create1
2Coding TaskGET /issues/pm-2vr/assignee1
4Coding TaskGET /issues/pm-c9p/assignee1
7Coding TaskPATCH /issues/pm-2vr/assignee1
8Coding TaskPATCH /issues/pm-c9p/assignee1
9Coding TaskPOST /issues1
\n", + "
" + ], + "text/plain": [ + " task_name target count\n", + "10 Coding Task NaN 35\n", + "0 Coding Task GET / 9\n", + "5 Coding Task GET /status/modal 5\n", + "3 Coding Task GET /issues/pm-2vr/edit 2\n", + "6 Coding Task PATCH /issues/pm-2vr 2\n", + "1 Coding Task GET /issues/create 1\n", + "2 Coding Task GET /issues/pm-2vr/assignee 1\n", + "4 Coding Task GET /issues/pm-c9p/assignee 1\n", + "7 Coding Task PATCH /issues/pm-2vr/assignee 1\n", + "8 Coding Task PATCH /issues/pm-c9p/assignee 1\n", + "9 Coding Task POST /issues 1" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if not logs_df.empty and {\"level\", \"task_name\", \"target\"}.issubset(logs_df.columns):\n", + " user_actions = logs_df[logs_df[\"level\"] == \"user_action\"].copy()\n", + "\n", + " if not user_actions.empty:\n", + " endpoint_counts = (\n", + " user_actions\n", + " .groupby([\"task_name\", \"target\"], dropna=False)\n", + " .size()\n", + " .reset_index(name=\"count\")\n", + " .sort_values([\"task_name\", \"count\"], ascending=[True, False])\n", + " )\n", + "\n", + " display(endpoint_counts.groupby(\"task_name\", dropna=False).head(15))\n", + " else:\n", + " print(\"No user_action logs found.\")\n", + "else:\n", + " print(\"No logs available for endpoint activity analysis.\")" + ] + }, + { + "cell_type": "markdown", + "id": "32a64572", + "metadata": {}, + "source": [ + "## Quick filters for ad-hoc debugging" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f8502e4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task: Coding Task, run_id: 1\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
run_idtask_nameinterface_typestarted_atended_atduration_mscompletedvalidation_attemptsvalidation_successesvalidation_failuresvalidation_checks_passedvalidation_checks_failedquestionnaire_completedquestionnaire_user_quitquestionnaire_answerslogsfileerror
01Coding Taskweb2026-03-04 15:11:56.497145550+01:002026-03-04 15:13:26.641005636+01:0090143True84183499242TrueFalse{'final_confirmation': None, 'task_completed':...[{'timestamp': '2026-03-04T15:11:56.497159847+...coding-task-stats.jsonNaN
\n", + "
" + ], + "text/plain": [ + " run_id task_name interface_type started_at \\\n", + "0 1 Coding Task web 2026-03-04 15:11:56.497145550+01:00 \n", + "\n", + " ended_at duration_ms completed \\\n", + "0 2026-03-04 15:13:26.641005636+01:00 90143 True \n", + "\n", + " validation_attempts validation_successes validation_failures \\\n", + "0 84 1 83 \n", + "\n", + " validation_checks_passed validation_checks_failed \\\n", + "0 499 242 \n", + "\n", + " questionnaire_completed questionnaire_user_quit \\\n", + "0 True False \n", + "\n", + " questionnaire_answers \\\n", + "0 {'final_confirmation': None, 'task_completed':... \n", + "\n", + " logs file \\\n", + "0 [{'timestamp': '2026-03-04T15:11:56.497159847+... coding-task-stats.json \n", + "\n", + " error \n", + "0 NaN " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timestamplevelmessagesourceactionresulttask_namefilerun_idrun_completedtargetattempt
02026-03-04 15:11:56.497159847+01:00infotask run startedsystemtask_run_startedokCoding Taskcoding-task-stats.json1TrueNaNNaN
12026-03-04 15:11:57.463612409+01:00user_action{\"source\":\"web\",\"action\":\"request\",\"target\":\"G...webrequestokCoding Taskcoding-task-stats.json1TrueGET /NaN
22026-03-04 15:11:58.318154048+01:00validationvalidation attempt 1systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN1.0
32026-03-04 15:11:58.318199703+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....1.0
42026-03-04 15:11:58.318212096+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...1.0
52026-03-04 15:11:58.318221323+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created1.0
62026-03-04 15:11:59.317079434+01:00validationvalidation attempt 2systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN2.0
72026-03-04 15:11:59.317145086+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....2.0
82026-03-04 15:11:59.317171636+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...2.0
92026-03-04 15:11:59.317194609+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created2.0
102026-03-04 15:12:00.317912946+01:00validationvalidation attempt 3systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN3.0
112026-03-04 15:12:00.317988177+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....3.0
122026-03-04 15:12:00.318006912+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...3.0
132026-03-04 15:12:00.318020798+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created3.0
142026-03-04 15:12:01.317868206+01:00validationvalidation attempt 4systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN4.0
152026-03-04 15:12:01.317945661+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....4.0
162026-03-04 15:12:01.317963825+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...4.0
172026-03-04 15:12:01.317977450+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created4.0
182026-03-04 15:12:01.570644963+01:00user_action{\"source\":\"web\",\"action\":\"request\",\"target\":\"G...webrequestokCoding Taskcoding-task-stats.json1TrueGET /issues/createNaN
192026-03-04 15:12:02.317463062+01:00validationvalidation attempt 5systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN5.0
202026-03-04 15:12:02.317511663+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....5.0
212026-03-04 15:12:02.317527422+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...5.0
222026-03-04 15:12:02.317538603+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created5.0
232026-03-04 15:12:03.317011327+01:00validationvalidation attempt 6systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN6.0
242026-03-04 15:12:03.317060369+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....6.0
252026-03-04 15:12:03.317072492+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...6.0
262026-03-04 15:12:03.317081078+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created6.0
272026-03-04 15:12:04.317413612+01:00validationvalidation attempt 7systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN7.0
282026-03-04 15:12:04.317467062+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....7.0
292026-03-04 15:12:04.317479285+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...7.0
302026-03-04 15:12:04.317488011+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created7.0
312026-03-04 15:12:05.317465258+01:00validationvalidation attempt 8systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN8.0
322026-03-04 15:12:05.317554294+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....8.0
332026-03-04 15:12:05.317579081+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...8.0
342026-03-04 15:12:05.317597465+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created8.0
352026-03-04 15:12:06.317295761+01:00validationvalidation attempt 9systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN9.0
362026-03-04 15:12:06.317375340+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....9.0
372026-03-04 15:12:06.317405787+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...9.0
382026-03-04 15:12:06.317434641+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created9.0
392026-03-04 15:12:07.317542913+01:00validationvalidation attempt 10systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN10.0
402026-03-04 15:12:07.317613084+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....10.0
412026-03-04 15:12:07.317626178+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...10.0
422026-03-04 15:12:07.317635035+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created10.0
432026-03-04 15:12:08.317693562+01:00validationvalidation attempt 11systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN11.0
442026-03-04 15:12:08.317760387+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....11.0
452026-03-04 15:12:08.317773101+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...11.0
462026-03-04 15:12:08.317782208+01:00validationvalidation check: No new issues createdsystemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created11.0
472026-03-04 15:12:09.317310231+01:00validationvalidation attempt 12systemvalidate_attemptfailedCoding Taskcoding-task-stats.json1TrueNaN12.0
482026-03-04 15:12:09.317473836+01:00validationvalidation check: The original issue should be...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueThe original issue should be assigned to 'Me'....12.0
492026-03-04 15:12:09.317512218+01:00validationvalidation check: No new issues created. Pleas...systemvalidate_checkfailedCoding Taskcoding-task-stats.json1TrueNo new issues created. Please create an issue ...12.0
\n", + "
" + ], + "text/plain": [ + " timestamp level \\\n", + "0 2026-03-04 15:11:56.497159847+01:00 info \n", + "1 2026-03-04 15:11:57.463612409+01:00 user_action \n", + "2 2026-03-04 15:11:58.318154048+01:00 validation \n", + "3 2026-03-04 15:11:58.318199703+01:00 validation \n", + "4 2026-03-04 15:11:58.318212096+01:00 validation \n", + "5 2026-03-04 15:11:58.318221323+01:00 validation \n", + "6 2026-03-04 15:11:59.317079434+01:00 validation \n", + "7 2026-03-04 15:11:59.317145086+01:00 validation \n", + "8 2026-03-04 15:11:59.317171636+01:00 validation \n", + "9 2026-03-04 15:11:59.317194609+01:00 validation \n", + "10 2026-03-04 15:12:00.317912946+01:00 validation \n", + "11 2026-03-04 15:12:00.317988177+01:00 validation \n", + "12 2026-03-04 15:12:00.318006912+01:00 validation \n", + "13 2026-03-04 15:12:00.318020798+01:00 validation \n", + "14 2026-03-04 15:12:01.317868206+01:00 validation \n", + "15 2026-03-04 15:12:01.317945661+01:00 validation \n", + "16 2026-03-04 15:12:01.317963825+01:00 validation \n", + "17 2026-03-04 15:12:01.317977450+01:00 validation \n", + "18 2026-03-04 15:12:01.570644963+01:00 user_action \n", + "19 2026-03-04 15:12:02.317463062+01:00 validation \n", + "20 2026-03-04 15:12:02.317511663+01:00 validation \n", + "21 2026-03-04 15:12:02.317527422+01:00 validation \n", + "22 2026-03-04 15:12:02.317538603+01:00 validation \n", + "23 2026-03-04 15:12:03.317011327+01:00 validation \n", + "24 2026-03-04 15:12:03.317060369+01:00 validation \n", + "25 2026-03-04 15:12:03.317072492+01:00 validation \n", + "26 2026-03-04 15:12:03.317081078+01:00 validation \n", + "27 2026-03-04 15:12:04.317413612+01:00 validation \n", + "28 2026-03-04 15:12:04.317467062+01:00 validation \n", + "29 2026-03-04 15:12:04.317479285+01:00 validation \n", + "30 2026-03-04 15:12:04.317488011+01:00 validation \n", + "31 2026-03-04 15:12:05.317465258+01:00 validation \n", + "32 2026-03-04 15:12:05.317554294+01:00 validation \n", + "33 2026-03-04 15:12:05.317579081+01:00 validation \n", + "34 2026-03-04 15:12:05.317597465+01:00 validation \n", + "35 2026-03-04 15:12:06.317295761+01:00 validation \n", + "36 2026-03-04 15:12:06.317375340+01:00 validation \n", + "37 2026-03-04 15:12:06.317405787+01:00 validation \n", + "38 2026-03-04 15:12:06.317434641+01:00 validation \n", + "39 2026-03-04 15:12:07.317542913+01:00 validation \n", + "40 2026-03-04 15:12:07.317613084+01:00 validation \n", + "41 2026-03-04 15:12:07.317626178+01:00 validation \n", + "42 2026-03-04 15:12:07.317635035+01:00 validation \n", + "43 2026-03-04 15:12:08.317693562+01:00 validation \n", + "44 2026-03-04 15:12:08.317760387+01:00 validation \n", + "45 2026-03-04 15:12:08.317773101+01:00 validation \n", + "46 2026-03-04 15:12:08.317782208+01:00 validation \n", + "47 2026-03-04 15:12:09.317310231+01:00 validation \n", + "48 2026-03-04 15:12:09.317473836+01:00 validation \n", + "49 2026-03-04 15:12:09.317512218+01:00 validation \n", + "\n", + " message source \\\n", + "0 task run started system \n", + "1 {\"source\":\"web\",\"action\":\"request\",\"target\":\"G... web \n", + "2 validation attempt 1 system \n", + "3 validation check: The original issue should be... system \n", + "4 validation check: No new issues created. Pleas... system \n", + "5 validation check: No new issues created system \n", + "6 validation attempt 2 system \n", + "7 validation check: The original issue should be... system \n", + "8 validation check: No new issues created. Pleas... system \n", + "9 validation check: No new issues created system \n", + "10 validation attempt 3 system \n", + "11 validation check: The original issue should be... system \n", + "12 validation check: No new issues created. Pleas... system \n", + "13 validation check: No new issues created system \n", + "14 validation attempt 4 system \n", + "15 validation check: The original issue should be... system \n", + "16 validation check: No new issues created. Pleas... system \n", + "17 validation check: No new issues created system \n", + "18 {\"source\":\"web\",\"action\":\"request\",\"target\":\"G... web \n", + "19 validation attempt 5 system \n", + "20 validation check: The original issue should be... system \n", + "21 validation check: No new issues created. Pleas... system \n", + "22 validation check: No new issues created system \n", + "23 validation attempt 6 system \n", + "24 validation check: The original issue should be... system \n", + "25 validation check: No new issues created. Pleas... system \n", + "26 validation check: No new issues created system \n", + "27 validation attempt 7 system \n", + "28 validation check: The original issue should be... system \n", + "29 validation check: No new issues created. Pleas... system \n", + "30 validation check: No new issues created system \n", + "31 validation attempt 8 system \n", + "32 validation check: The original issue should be... system \n", + "33 validation check: No new issues created. Pleas... system \n", + "34 validation check: No new issues created system \n", + "35 validation attempt 9 system \n", + "36 validation check: The original issue should be... system \n", + "37 validation check: No new issues created. Pleas... system \n", + "38 validation check: No new issues created system \n", + "39 validation attempt 10 system \n", + "40 validation check: The original issue should be... system \n", + "41 validation check: No new issues created. Pleas... system \n", + "42 validation check: No new issues created system \n", + "43 validation attempt 11 system \n", + "44 validation check: The original issue should be... system \n", + "45 validation check: No new issues created. Pleas... system \n", + "46 validation check: No new issues created system \n", + "47 validation attempt 12 system \n", + "48 validation check: The original issue should be... system \n", + "49 validation check: No new issues created. Pleas... system \n", + "\n", + " action result task_name file run_id \\\n", + "0 task_run_started ok Coding Task coding-task-stats.json 1 \n", + "1 request ok Coding Task coding-task-stats.json 1 \n", + "2 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "3 validate_check failed Coding Task coding-task-stats.json 1 \n", + "4 validate_check failed Coding Task coding-task-stats.json 1 \n", + "5 validate_check failed Coding Task coding-task-stats.json 1 \n", + "6 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "7 validate_check failed Coding Task coding-task-stats.json 1 \n", + "8 validate_check failed Coding Task coding-task-stats.json 1 \n", + "9 validate_check failed Coding Task coding-task-stats.json 1 \n", + "10 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "11 validate_check failed Coding Task coding-task-stats.json 1 \n", + "12 validate_check failed Coding Task coding-task-stats.json 1 \n", + "13 validate_check failed Coding Task coding-task-stats.json 1 \n", + "14 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "15 validate_check failed Coding Task coding-task-stats.json 1 \n", + "16 validate_check failed Coding Task coding-task-stats.json 1 \n", + "17 validate_check failed Coding Task coding-task-stats.json 1 \n", + "18 request ok Coding Task coding-task-stats.json 1 \n", + "19 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "20 validate_check failed Coding Task coding-task-stats.json 1 \n", + "21 validate_check failed Coding Task coding-task-stats.json 1 \n", + "22 validate_check failed Coding Task coding-task-stats.json 1 \n", + "23 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "24 validate_check failed Coding Task coding-task-stats.json 1 \n", + "25 validate_check failed Coding Task coding-task-stats.json 1 \n", + "26 validate_check failed Coding Task coding-task-stats.json 1 \n", + "27 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "28 validate_check failed Coding Task coding-task-stats.json 1 \n", + "29 validate_check failed Coding Task coding-task-stats.json 1 \n", + "30 validate_check failed Coding Task coding-task-stats.json 1 \n", + "31 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "32 validate_check failed Coding Task coding-task-stats.json 1 \n", + "33 validate_check failed Coding Task coding-task-stats.json 1 \n", + "34 validate_check failed Coding Task coding-task-stats.json 1 \n", + "35 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "36 validate_check failed Coding Task coding-task-stats.json 1 \n", + "37 validate_check failed Coding Task coding-task-stats.json 1 \n", + "38 validate_check failed Coding Task coding-task-stats.json 1 \n", + "39 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "40 validate_check failed Coding Task coding-task-stats.json 1 \n", + "41 validate_check failed Coding Task coding-task-stats.json 1 \n", + "42 validate_check failed Coding Task coding-task-stats.json 1 \n", + "43 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "44 validate_check failed Coding Task coding-task-stats.json 1 \n", + "45 validate_check failed Coding Task coding-task-stats.json 1 \n", + "46 validate_check failed Coding Task coding-task-stats.json 1 \n", + "47 validate_attempt failed Coding Task coding-task-stats.json 1 \n", + "48 validate_check failed Coding Task coding-task-stats.json 1 \n", + "49 validate_check failed Coding Task coding-task-stats.json 1 \n", + "\n", + " run_completed target attempt \n", + "0 True NaN NaN \n", + "1 True GET / NaN \n", + "2 True NaN 1.0 \n", + "3 True The original issue should be assigned to 'Me'.... 1.0 \n", + "4 True No new issues created. Please create an issue ... 1.0 \n", + "5 True No new issues created 1.0 \n", + "6 True NaN 2.0 \n", + "7 True The original issue should be assigned to 'Me'.... 2.0 \n", + "8 True No new issues created. Please create an issue ... 2.0 \n", + "9 True No new issues created 2.0 \n", + "10 True NaN 3.0 \n", + "11 True The original issue should be assigned to 'Me'.... 3.0 \n", + "12 True No new issues created. Please create an issue ... 3.0 \n", + "13 True No new issues created 3.0 \n", + "14 True NaN 4.0 \n", + "15 True The original issue should be assigned to 'Me'.... 4.0 \n", + "16 True No new issues created. Please create an issue ... 4.0 \n", + "17 True No new issues created 4.0 \n", + "18 True GET /issues/create NaN \n", + "19 True NaN 5.0 \n", + "20 True The original issue should be assigned to 'Me'.... 5.0 \n", + "21 True No new issues created. Please create an issue ... 5.0 \n", + "22 True No new issues created 5.0 \n", + "23 True NaN 6.0 \n", + "24 True The original issue should be assigned to 'Me'.... 6.0 \n", + "25 True No new issues created. Please create an issue ... 6.0 \n", + "26 True No new issues created 6.0 \n", + "27 True NaN 7.0 \n", + "28 True The original issue should be assigned to 'Me'.... 7.0 \n", + "29 True No new issues created. Please create an issue ... 7.0 \n", + "30 True No new issues created 7.0 \n", + "31 True NaN 8.0 \n", + "32 True The original issue should be assigned to 'Me'.... 8.0 \n", + "33 True No new issues created. Please create an issue ... 8.0 \n", + "34 True No new issues created 8.0 \n", + "35 True NaN 9.0 \n", + "36 True The original issue should be assigned to 'Me'.... 9.0 \n", + "37 True No new issues created. Please create an issue ... 9.0 \n", + "38 True No new issues created 9.0 \n", + "39 True NaN 10.0 \n", + "40 True The original issue should be assigned to 'Me'.... 10.0 \n", + "41 True No new issues created. Please create an issue ... 10.0 \n", + "42 True No new issues created 10.0 \n", + "43 True NaN 11.0 \n", + "44 True The original issue should be assigned to 'Me'.... 11.0 \n", + "45 True No new issues created. Please create an issue ... 11.0 \n", + "46 True No new issues created 11.0 \n", + "47 True NaN 12.0 \n", + "48 True The original issue should be assigned to 'Me'.... 12.0 \n", + "49 True No new issues created. Please create an issue ... 12.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Example: inspect one task and one run.\n", + "if not runs_df.empty and {\"task_name\", \"run_id\"}.issubset(runs_df.columns):\n", + " task = runs_df[\"task_name\"].iloc[0]\n", + " run_id = 1\n", + "\n", + " print(f\"Task: {task}, run_id: {run_id}\")\n", + " display(runs_df[(runs_df[\"task_name\"] == task) & (runs_df[\"run_id\"] == run_id)])\n", + "\n", + " if not logs_df.empty and {\"task_name\", \"run_id\"}.issubset(logs_df.columns):\n", + " display(logs_df[(logs_df[\"task_name\"] == task) & (logs_df[\"run_id\"] == run_id)].head(50))\n", + "else:\n", + " print(\"No run data available.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6a94bb5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}