agent_coding_eval/notebooks/03_registry_level_eval.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluación Nivel Registry — Qwen2.5-Coder-7B\n",
    "\n",
    "Challenges de nivel production inspirados en funciones reales del fn_registry.\n",
    "\n",
    "**Categorías:**\n",
    "- Functional Programming: pipe, compose, memoize, partition\n",
    "- Data Processing: type coercion, frontmatter parsing, JSON extraction, text splitting\n",
    "- Algorithms: topological sort, interval scheduling, tree operations\n",
    "- Real-World Patterns: retry backoff, schema validation, rate limiting, line diff\n",
    "\n",
    "**Dificultad:** medium → hard → expert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ qwen2.5-coder-7b-abliterated-i1 listo\n"
     ]
    }
   ],
   "source": [
    "import sys, os\n",
    "sys.path.insert(0, os.path.join(os.getcwd(), '..'))\n",
    "\n",
    "import requests\n",
    "API_BASE = \"http://127.0.0.1:1234/v1\"\n",
    "MODEL = \"qwen2.5-coder-7b-abliterated-i1\"\n",
    "\n",
    "resp = requests.get(f\"{API_BASE}/models\")\n",
    "models = [m[\"id\"] for m in resp.json()[\"data\"]]\n",
    "assert MODEL in models, f\"{MODEL} no disponible! Modelos: {models}\"\n",
    "print(f\"✓ {MODEL} listo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total challenges: 15\n",
      "  Functional: 4 — {'medium': 3, 'hard': 1}\n",
      "  Data Processing: 4 — {'hard': 3, 'medium': 1}\n",
      "  Algorithms: 3 — {'hard': 2, 'expert': 1}\n",
      "  Real-World: 4 — {'hard': 1, 'expert': 3}\n"
     ]
    }
   ],
   "source": [
    "from eval_runner import evaluate\n",
    "from challenges import ALL_CHALLENGES, FUNCTIONAL, DATA_PROCESSING, ALGORITHMS, REAL_WORLD\n",
    "\n",
    "print(f\"Total challenges: {len(ALL_CHALLENGES)}\")\n",
    "for name, group in [(\"Functional\", FUNCTIONAL), (\"Data Processing\", DATA_PROCESSING),\n",
    "                     (\"Algorithms\", ALGORITHMS), (\"Real-World\", REAL_WORLD)]:\n",
    "    diffs = {}\n",
    "    for c in group:\n",
    "        diffs[c.difficulty] = diffs.get(c.difficulty, 0) + 1\n",
    "    print(f\"  {name}: {len(group)} — {diffs}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "══════════════════════════════════════════════════════════════════════\n",
      "  EVALUACIÓN NIVEL REGISTRY: qwen2.5-coder-7b-abliterated-i1\n",
      "══════════════════════════════════════════════════════════════════════\n",
      "\n",
      "  [fn_pipe] Pipe with error propagation (medium)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PASS  9630ms  147tok  15.3t/s\n",
      "  [fn_group_by_multi] Group by with transform (medium)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PASS  12179ms  204tok  16.8t/s\n",
      "  [fn_memoize] Memoize decorator with max size (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  20622ms  311tok  15.1t/s\n",
      "    |     assert \u001b[1;31mcall_count == 2\u001b[0m  # same as (1, 2) via kwargs\n",
      "    |            \u001b[1;31m^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [fn_compose_async] Partition with multiple predicates (medium)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PASS  16920ms  304tok  18.0t/s\n",
      "  [dp_coerce] Type coercion with schema (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  11097ms  210tok  18.9t/s\n",
      "    |     \u001b[1;31md, w\u001b[0m = coerce_types({\"age\": \"25\", \"score\": \"3.14\", \"active\": \"yes\"}, {\"age\": \"int\", \"score\": \"float\", \"ac\n",
      "    |     \u001b[1;31m^^^^\u001b[0m\n",
      "    | \u001b[1;35mTypeError\u001b[0m: \u001b[35mcannot unpack non-iterable NoneType object\u001b[0m\n",
      "  [dp_frontmatter] Extract YAML frontmatter (medium)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  6613ms  118tok  17.8t/s\n",
      "    |     \u001b[1;31mbody, meta\u001b[0m = extract_frontmatter(content)\n",
      "    |     \u001b[1;31m^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mTypeError\u001b[0m: \u001b[35mcannot unpack non-iterable NoneType object\u001b[0m\n",
      "  [dp_json_extract] Extract JSON from LLM response (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  7794ms  142tok  18.2t/s\n",
      "    |     assert \u001b[1;31mextract_json_from_llm('```json\\n{\"name\": \"test\"}\\n```') == {\"name\": \"test\"}\u001b[0m\n",
      "    |            \u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [dp_smart_split] Smart text splitter with token budget (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  15320ms  260tok  17.0t/s\n",
      "    |     assert \u001b[1;31mlen(chunks) == 1\u001b[0m\n",
      "    |            \u001b[1;31m^^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [alg_topo_sort] Topological sort with cycle detection (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  20569ms  296tok  14.4t/s\n",
      "    |     assert \u001b[1;31mnot cycle\u001b[0m\n",
      "    |            \u001b[1;31m^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [alg_interval_merge] Interval scheduler with priorities (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  29162ms  428tok  14.7t/s\n",
      "    |     assert \u001b[1;31mtotal == 5\u001b[0m, f\"got total={total}\"\n",
      "    |            \u001b[1;31m^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m: \u001b[35mgot total=8\u001b[0m\n",
      "  [alg_tree_ops] Tree operations suite (expert)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  25543ms  444tok  17.4t/s\n",
      "    |     assert \u001b[31mall\u001b[0m\u001b[1;31m(\"children\" not in n for n in flat)\u001b[0m\n",
      "    |            \u001b[31m~~~\u001b[0m\u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [rw_retry] Retry with exponential backoff (hard)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  22362ms  395tok  17.7t/s\n",
      "    |     assert \u001b[1;31mclassify_error\u001b[0m(200) == \"success\"\n",
      "    |            \u001b[1;31m^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mNameError\u001b[0m: \u001b[35mname 'classify_error' is not defined\u001b[0m\n",
      "  [rw_schema_validate] Schema validator for dicts (expert)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  36041ms  632tok  17.5t/s\n",
      "    |     assert \u001b[31many\u001b[0m\u001b[1;31m(\"role\" in e and \"choices\" in e.lower() for e in errors)\u001b[0m\n",
      "    |            \u001b[31m~~~\u001b[0m\u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "  [rw_rate_limiter] Token bucket rate limiter (expert)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  10589ms  180tok  17.0t/s\n",
      "    |   File \u001b[35m\"/tmp/tmpohadpdim.py\"\u001b[0m, line \u001b[35m24\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    |     bucket = TokenBucket(capacity=10, refill_rate=1.0)\n",
      "    | \u001b[1;35mTypeError\u001b[0m: \u001b[35mTokenBucket() takes no arguments\u001b[0m\n",
      "  [rw_diff] Simple line differ (expert)... "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FAIL  31928ms  596tok  18.7t/s\n",
      "    |     assert \u001b[1;31mresult == [\"  a\", \"  b\", \"  c\"]\u001b[0m\n",
      "    |            \u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "    | \u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "══════════════════════════════════════════════════════════════════════\n",
      "  TOTAL: 3/15 (20%)\n",
      "══════════════════════════════════════════════════════════════════════\n"
     ]
    }
   ],
   "source": [
    "# ── Ejecutar TODOS los challenges ─────────────────────────\n",
    "\n",
    "print(f\"{'═'*70}\")\n",
    "print(f\"  EVALUACIÓN NIVEL REGISTRY: {MODEL}\")\n",
    "print(f\"{'═'*70}\\n\")\n",
    "\n",
    "results = evaluate(MODEL, ALL_CHALLENGES)\n",
    "\n",
    "passed = sum(1 for r in results if r.passed)\n",
    "total = len(results)\n",
    "print(f\"\\n{'═'*70}\")\n",
    "print(f\"  TOTAL: {passed}/{total} ({100*passed/total:.0f}%)\")\n",
    "print(f\"{'═'*70}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "status                             challenge        category difficulty  latency_s  tokens  tok_s\n",
      "     ✓           Pipe with error propagation      functional     medium       10.6     147   13.9\n",
      "     ✓               Group by with transform      functional     medium       12.3     204   16.6\n",
      "     ✗       Memoize decorator with max size      functional       hard       22.0     311   14.1\n",
      "     ✓    Partition with multiple predicates      functional     medium       20.8     304   14.6\n",
      "     ✗             Type coercion with schema data_processing       hard       16.6     210   12.6\n",
      "     ✗              Extract YAML frontmatter data_processing     medium       10.0     118   11.8\n",
      "     ✗        Extract JSON from LLM response data_processing       hard        9.3     142   15.2\n",
      "     ✗ Smart text splitter with token budget data_processing       hard       19.1     260   13.6\n",
      "     ✗ Topological sort with cycle detection       algorithm       hard       17.8     296   16.6\n",
      "     ✗    Interval scheduler with priorities       algorithm       hard       29.0     428   14.8\n",
      "     ✗                 Tree operations suite       algorithm     expert       33.6     444   13.2\n",
      "     ✗        Retry with exponential backoff      real_world       hard       28.5     395   13.9\n",
      "     ✗            Schema validator for dicts      real_world     expert       43.9     632   14.4\n",
      "     ✗             Token bucket rate limiter      real_world     expert       11.3     180   16.0\n",
      "     ✗                    Simple line differ      real_world     expert       36.9     588   15.9\n",
      "\n",
      "────────────────────────────────────────────────────────────\n",
      "Velocidad promedio:  14.5 tok/s\n",
      "Latencia promedio:   21.4s\n",
      "Tokens promedio:     311\n"
     ]
    }
   ],
   "source": [
    "# ── Tabla detallada ───────────────────────────────────────\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame([{\n",
    "    \"challenge\": r.name,\n",
    "    \"category\": r.category,\n",
    "    \"difficulty\": r.difficulty,\n",
    "    \"passed\": r.passed,\n",
    "    \"latency_s\": round(r.latency_ms / 1000, 1),\n",
    "    \"tokens\": r.completion_tokens,\n",
    "    \"tok_s\": round(r.tokens_per_second, 1),\n",
    "} for r in results])\n",
    "\n",
    "df[\"status\"] = df[\"passed\"].map({True: \"✓\", False: \"✗\"})\n",
    "\n",
    "print(df[[\"status\", \"challenge\", \"category\", \"difficulty\", \"latency_s\", \"tokens\", \"tok_s\"]].to_string(index=False))\n",
    "\n",
    "print(f\"\\n{'─'*60}\")\n",
    "print(f\"Velocidad promedio:  {df['tok_s'].mean():.1f} tok/s\")\n",
    "print(f\"Latencia promedio:   {df['latency_s'].mean():.1f}s\")\n",
    "print(f\"Tokens promedio:     {df['tokens'].mean():.0f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Por categoría:\n",
      "  functional            3/4 passed  |  14.8 tok/s\n",
      "  data_processing       0/4 passed  |  13.3 tok/s\n",
      "  algorithm             0/3 passed  |  14.9 tok/s\n",
      "  real_world            0/4 passed  |  15.0 tok/s\n",
      "\n",
      "Por dificultad:\n",
      "  medium      3/4 passed  |  14.2 tok/s\n",
      "  hard        0/7 passed  |  14.4 tok/s\n",
      "  expert      0/4 passed  |  14.9 tok/s\n"
     ]
    }
   ],
   "source": [
    "# ── Resultados por categoría y dificultad ─────────────────\n",
    "\n",
    "print(\"\\nPor categoría:\")\n",
    "for cat in [\"functional\", \"data_processing\", \"algorithm\", \"real_world\"]:\n",
    "    subset = [r for r in results if r.category == cat]\n",
    "    p = sum(1 for r in subset if r.passed)\n",
    "    avg_tps = sum(r.tokens_per_second for r in subset) / max(len(subset), 1)\n",
    "    print(f\"  {cat:20s}  {p}/{len(subset)} passed  |  {avg_tps:.1f} tok/s\")\n",
    "\n",
    "print(\"\\nPor dificultad:\")\n",
    "for diff in [\"medium\", \"hard\", \"expert\"]:\n",
    "    subset = [r for r in results if r.difficulty == diff]\n",
    "    if not subset:\n",
    "        continue\n",
    "    p = sum(1 for r in subset if r.passed)\n",
    "    avg_tps = sum(r.tokens_per_second for r in subset) / len(subset)\n",
    "    print(f\"  {diff:10s}  {p}/{len(subset)} passed  |  {avg_tps:.1f} tok/s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data",
     "transient": {}
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✓ Gráfico guardado\n"
     ]
    }
   ],
   "source": [
    "# ── Gráficos ──────────────────────────────────────────────\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n",
    "\n",
    "# 1. Pass rate por categoría\n",
    "ax = axes[0][0]\n",
    "cats = [\"functional\", \"data_processing\", \"algorithm\", \"real_world\"]\n",
    "cat_labels = [\"Functional\", \"Data Proc.\", \"Algorithm\", \"Real-World\"]\n",
    "rates = []\n",
    "for cat in cats:\n",
    "    subset = [r for r in results if r.category == cat]\n",
    "    rates.append(100 * sum(1 for r in subset if r.passed) / max(len(subset), 1))\n",
    "colors = [\"#2ecc71\" if v == 100 else \"#e74c3c\" if v < 50 else \"#f39c12\" for v in rates]\n",
    "ax.bar(cat_labels, rates, color=colors)\n",
    "ax.set_title(\"Pass Rate por Categoría\")\n",
    "ax.set_ylabel(\"%\")\n",
    "ax.set_ylim(0, 110)\n",
    "for i, v in enumerate(rates):\n",
    "    ax.text(i, v + 2, f\"{v:.0f}%\", ha=\"center\", fontweight=\"bold\")\n",
    "\n",
    "# 2. Pass rate por dificultad\n",
    "ax = axes[0][1]\n",
    "diffs = [\"medium\", \"hard\", \"expert\"]\n",
    "rates_d = []\n",
    "for d in diffs:\n",
    "    subset = [r for r in results if r.difficulty == d]\n",
    "    rates_d.append(100 * sum(1 for r in subset if r.passed) / max(len(subset), 1))\n",
    "colors_d = [\"#2ecc71\" if v == 100 else \"#e74c3c\" if v < 50 else \"#f39c12\" for v in rates_d]\n",
    "ax.bar(diffs, rates_d, color=colors_d)\n",
    "ax.set_title(\"Pass Rate por Dificultad\")\n",
    "ax.set_ylabel(\"%\")\n",
    "ax.set_ylim(0, 110)\n",
    "for i, v in enumerate(rates_d):\n",
    "    ax.text(i, v + 2, f\"{v:.0f}%\", ha=\"center\", fontweight=\"bold\")\n",
    "\n",
    "# 3. Velocidad por challenge\n",
    "ax = axes[1][0]\n",
    "names = [r.name[:25] for r in results]\n",
    "tps = [r.tokens_per_second for r in results]\n",
    "bar_colors = [\"#2ecc71\" if r.passed else \"#e74c3c\" for r in results]\n",
    "y_pos = np.arange(len(names))\n",
    "ax.barh(y_pos, tps, color=bar_colors)\n",
    "ax.set_yticks(y_pos)\n",
    "ax.set_yticklabels(names, fontsize=8)\n",
    "ax.set_title(\"Velocidad (tok/s)\")\n",
    "ax.set_xlabel(\"tokens/segundo\")\n",
    "ax.invert_yaxis()\n",
    "\n",
    "# 4. Tokens usados por challenge\n",
    "ax = axes[1][1]\n",
    "tokens = [r.completion_tokens for r in results]\n",
    "ax.barh(y_pos, tokens, color=bar_colors)\n",
    "ax.set_yticks(y_pos)\n",
    "ax.set_yticklabels(names, fontsize=8)\n",
    "ax.set_title(\"Tokens generados\")\n",
    "ax.set_xlabel(\"tokens\")\n",
    "ax.invert_yaxis()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../data/registry_level_eval.png\", dpi=150, bbox_inches=\"tight\")\n",
    "plt.show()\n",
    "print(\"✓ Gráfico guardado\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 challenges fallidos:\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Memoize decorator with max size (functional/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (311 tokens):\n",
      "from collections import OrderedDict\n",
      "\n",
      "def memoize(max_size: int = 128):\n",
      "    \"\"\"Decorator that memoizes function results. When cache exceeds max_size,\n",
      "    evict the oldest entry (FIFO). The key is (args, tuple(sorted(kwargs.items()))).\n",
      "    Must work with both positional and keyword arguments.\"\"\"\n",
      "\n",
      "    def decorator(func):\n",
      "        cache = OrderedDict()\n",
      "\n",
      "        def wrapper(*args, **kwargs):\n",
      "            key = (args, tuple(sorted(kwargs.items())))\n",
      "            if key in cache:\n",
      "                return cache[key]\n",
      "            result = func(*args, **kwargs)\n",
      "            cache[key] = result\n",
      "            if len(cache) > max_size:\n",
      "                cache.popitem(last=False)\n",
      "            return result\n",
      "\n",
      "        return wrapper\n",
      "\n",
      "    return decorator\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp8rjeyq6u.py\"\u001b[0m, line \u001b[35m49\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mcall_count == 2\u001b[0m  # same as (1, 2) via kwargs\n",
      "           \u001b[1;31m^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Type coercion with schema (data_processing/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (210 tokens):\n",
      "def coerce_types(data: dict, schema: dict[str, str]) -> tuple[dict, list[str]]:\n",
      "    \"\"\"Coerce dict values to types specified in schema. Never mutate original.\n",
      "\n",
      "    Schema maps field names to type strings: \"int\", \"float\", \"str\", \"bool\", \"list[str]\".\n",
      "\n",
      "    Rules:\n",
      "    - str → int: parse via float first (handle \"3.0\" → 3), warn if lossy (\"3.7\" → 3)\n",
      "    - str → float: standard float()\n",
      "    - str → bool: \"true/1/yes\" → True, \"false/0/no\" → False (case-insensitive)\n",
      "    - str → list[str]: split by \",\" and strip whitespace from each item\n",
      "    - Fields not in schema: pass through unchanged\n",
      "    - Fields in schema but not in data: skip\n",
      "    - Failed coercion: keep original value, add warning string to list\n",
      "\n",
      "    Returns (new_dict, warnings_list).\"\"\"\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp6_i3ueiy.py\"\u001b[0m, line \u001b[35m19\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    \u001b[1;31md, w\u001b[0m = coerce_types({\"age\": \"25\", \"score\": \"3.14\", \"active\": \"yes\"}, {\"age\": \"int\", \"score\": \"float\", \"active\": \"bool\"})\n",
      "    \u001b[1;31m^^^^\u001b[0m\n",
      "\u001b[1;35mTypeError\u001b[0m: \u001b[35mcannot unpack non-iterable NoneType object\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Extract YAML frontmatter (data_processing/medium)\n",
      "======================================================================\n",
      "\n",
      "Código generado (118 tokens):\n",
      "def extract_frontmatter(content: str) -> tuple[str, dict | None]:\n",
      "    \"\"\"Extract YAML-like frontmatter delimited by '---' from start of markdown.\n",
      "\n",
      "    Frontmatter format:\n",
      "    ---\n",
      "    key: value\n",
      "    another: something\n",
      "    ---\n",
      "\n",
      "    Rest of content here.\n",
      "\n",
      "    Parse simple key:value pairs (no nested YAML needed). Values are always strings.\n",
      "    Do NOT use the yaml library.\n",
      "\n",
      "    Returns (content_without_frontmatter, parsed_dict_or_None).\n",
      "    If no frontmatter found, return (original_content, None).\"\"\"\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmpftdwrn65.py\"\u001b[0m, line \u001b[35m21\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    \u001b[1;31mbody, meta\u001b[0m = extract_frontmatter(content)\n",
      "    \u001b[1;31m^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mTypeError\u001b[0m: \u001b[35mcannot unpack non-iterable NoneType object\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Extract JSON from LLM response (data_processing/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (142 tokens):\n",
      "def extract_json_from_llm(content: str) -> dict:\n",
      "    \"\"\"Extract and parse JSON from messy LLM responses.\n",
      "\n",
      "    Must handle:\n",
      "    1. JSON inside ```json ... ``` code blocks\n",
      "    2. JSON inside ``` ... ``` blocks (no language tag)\n",
      "    3. Raw JSON with surrounding text\n",
      "    4. Trailing commas: {\"a\": 1,} or [1, 2,]\n",
      "    5. Python None instead of null\n",
      "    6. Single-quoted strings converted to double quotes\n",
      "\n",
      "    Returns parsed dict. Returns empty dict {} on failure.\n",
      "    Use only stdlib (json, re).\"\"\"\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp_gteve2c.py\"\u001b[0m, line \u001b[35m19\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mextract_json_from_llm('```json\\n{\"name\": \"test\"}\\n```') == {\"name\": \"test\"}\u001b[0m\n",
      "           \u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Smart text splitter with token budget (data_processing/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (260 tokens):\n",
      "def smart_split(text: str, max_chars: int = 500, overlap: int = 50) -> list[str]:\n",
      "    paragraphs = text.split('\\n\\n')\n",
      "    chunks = []\n",
      "    \n",
      "    for paragraph in paragraphs:\n",
      "        sentences = [sentence.strip() for sentence in paragraph.split('. ') if sentence]\n",
      "        \n",
      "        current_chunk = ''\n",
      "        for sentence in sentences:\n",
      "            if len(current_chunk + ' ' + sentence) <= max_chars:\n",
      "                current_chunk += ' ' + sentence\n",
      "            else:\n",
      "                chunks.append(current_chunk.strip())\n",
      "                current_chunk = sentence\n",
      "        \n",
      "        if current_chunk and not any(chunk.endswith(current_chunk[-overlap:]) for chunk in chunks):\n",
      "            chunks.append(current_chunk.strip())\n",
      "\n",
      "    return [chunk for chunk in chunks if chunk]\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmpmzy5tut_.py\"\u001b[0m, line \u001b[35m25\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mlen(chunks) == 1\u001b[0m\n",
      "           \u001b[1;31m^^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Topological sort with cycle detection (algorithm/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (296 tokens):\n",
      "from collections import deque\n",
      "\n",
      "def topo_sort(graph: dict[str, list[str]]) -> tuple[list[str], bool]:\n",
      "    in_degree = {node: 0 for node in graph}\n",
      "    for neighbors in graph.values():\n",
      "        for neighbor in neighbors:\n",
      "            in_degree[neighbor] += 1\n",
      "    \n",
      "    queue = deque([node for node, degree in in_degree.items() if degree == 0])\n",
      "    \n",
      "    sorted_list = []\n",
      "    while queue:\n",
      "        node = queue.popleft()\n",
      "        sorted_list.append(node)\n",
      "        \n",
      "        for neighbor in graph[node]:\n",
      "            in_degree[neighbor] -= 1\n",
      "            if in_degree[neighbor] == 0:\n",
      "                queue.append(neighbor)\n",
      "                \n",
      "    has_cycle = any(degree > 0 for degree in in_degree.values())\n",
      "    \n",
      "    return (sorted_list, not has_cycle)\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmpccyd2kz4.py\"\u001b[0m, line \u001b[35m28\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mnot cycle\u001b[0m\n",
      "           \u001b[1;31m^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Interval scheduler with priorities (algorithm/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (428 tokens):\n",
      "def schedule_intervals(intervals: list[dict]) -> list[dict]:\n",
      "    # Sort intervals by end time in ascending order\n",
      "    intervals.sort(key=lambda x: x[\"end\"])\n",
      "\n",
      "    n = len(intervals)\n",
      "    dp = [0] * (n + 1)  # Dynamic programming table\n",
      "\n",
      "    for i in range(1, n + 1):\n",
      "        j = i - 1\n",
      "        while j >= 0 and intervals[j][\"end\"] > intervals[i-1][\"start\"]:\n",
      "            j -= 1\n",
      "        dp[i] = max(dp[i-1], dp[j+1] + intervals[i-1][\"priority\"])\n",
      "\n",
      "    selected_intervals = []\n",
      "    i, j = n, n - 1\n",
      "\n",
      "    while i >= 0:\n",
      "        if dp[i] == dp[i-1]:\n",
      "            i -= 1\n",
      "        else:\n",
      "            selected_intervals.append(intervals[i-1])\n",
      "            j = i - 2\n",
      "            while j >= 0 and intervals[j][\"end\"] > intervals[i-1][\"start\"]:\n",
      "                j -= 1\n",
      "            i = j + 1\n",
      "\n",
      "    return sorted(selected_intervals, key=lambda x: x[\"start\"])\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp8yr1ne_a.py\"\u001b[0m, line \u001b[35m40\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mtotal == 5\u001b[0m, f\"got total={total}\"\n",
      "           \u001b[1;31m^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m: \u001b[35mgot total=8\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Tree operations suite (algorithm/expert)\n",
      "======================================================================\n",
      "\n",
      "Código generado (444 tokens):\n",
      "from copy import deepcopy\n",
      "\n",
      "def flatten_tree(tree: dict) -> list[dict]:\n",
      "    \"\"\"Flatten nested tree to list. Each node is a dict with optional 'children' key.\n",
      "    DFS pre-order. Remove 'children' key from output nodes. Deep copy nodes.\"\"\"\n",
      "\n",
      "    def dfs(node):\n",
      "        if not isinstance(node, dict):\n",
      "            return []\n",
      "        \n",
      "        result = [deepcopy(node)]\n",
      "        children = node.get('children', [])\n",
      "        for child in children:\n",
      "            result.extend(dfs(child))\n",
      "        return result\n",
      "\n",
      "    return dfs(tree)\n",
      "\n",
      "def find_path(tree: dict, target_id: str) -> list[str] | None:\n",
      "    \"\"\"Find path from root to node with given 'id' field. Returns list of ids\n",
      "    from root to target (inclusive), or None if not found.\"\"\"\n",
      "\n",
      "    def dfs(node, current_path):\n",
      "        if isinstance(node, dict):\n",
      "            current_path.append(node['id'])\n",
      "            children = node.get('children', [])\n",
      "            for child in children:\n",
      "                result = dfs(child, current_path)\n",
      "                if result is not None:\n",
      "                    return result\n",
      "            current_path.pop()\n",
      "        elif node == target_id:\n",
      "            return current_path + [target_id]\n",
      "        return None\n",
      "\n",
      "    return dfs(tree, [])\n",
      "\n",
      "def map_tree(tree: dict, fn) -> dict:\n",
      "    \"\"\"Apply fn to each node (excluding 'children' key), return new tree with\n",
      "    same structure. fn receives a dict without 'children' and returns a new dict.\n",
      "    Must not mutate original.\"\"\"\n",
      "\n",
      "    def dfs(node):\n",
      "        if isinstance(node, dict):\n",
      "            child\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmpdb6oal4s.py\"\u001b[0m, line \u001b[35m74\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[31mall\u001b[0m\u001b[1;31m(\"children\" not in n for n in flat)\u001b[0m\n",
      "           \u001b[31m~~~\u001b[0m\u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Retry with exponential backoff (real_world/hard)\n",
      "======================================================================\n",
      "\n",
      "Código generado (395 tokens):\n",
      "def compute_backoff_delays(max_retries: int, base_delay: float = 1.0,\n",
      "                           max_delay: float = 60.0, jitter: bool = False) -> list[float]:\n",
      "    \"\"\"Compute the sequence of backoff delays for retry logic.\n",
      "\n",
      "    Formula: delay = min(base_delay * 2^attempt, max_delay)\n",
      "    If jitter=True, multiply each delay by a factor between 0.5 and 1.0\n",
      "    (use deterministic half-jitter: factor = 0.75 for testability).\n",
      "\n",
      "    attempt starts at 0.\n",
      "    Returns list of `max_retries` delay values.\"\"\"\n",
      "\n",
      "    delays = []\n",
      "    for attempt in range(max_retries):\n",
      "        delay = min(base_delay * 2 ** attempt, max_delay)\n",
      "        if jitter:\n",
      "            delay *= 0.75\n",
      "        delays.append(delay)\n",
      "\n",
      "    return delays\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmpbk8a7fj3.py\"\u001b[0m, line \u001b[35m38\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mclassify_error\u001b[0m(200) == \"success\"\n",
      "           \u001b[1;31m^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mNameError\u001b[0m: \u001b[35mname 'classify_error' is not defined\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Schema validator for dicts (real_world/expert)\n",
      "======================================================================\n",
      "\n",
      "Código generado (632 tokens):\n",
      "import re\n",
      "\n",
      "def validate(data: dict, schema: dict) -> list[str]:\n",
      "    errors = []\n",
      "\n",
      "    for field_name, rule in schema.items():\n",
      "        value = data.get(field_name)\n",
      "\n",
      "        # Check if required field is missing\n",
      "        if rule.get(\"required\", False) and value is None:\n",
      "            errors.append(f\"{field_name}: required field is missing\")\n",
      "            continue\n",
      "\n",
      "        # Check type of the value\n",
      "        expected_type = rule[\"type\"]\n",
      "        actual_type = type(value).__name__\n",
      "        if expected_type != actual_type:\n",
      "            errors.append(f\"{field_name}: expected type {expected_type}, got {actual_type}\")\n",
      "            continue\n",
      "\n",
      "        # Check minimum and maximum values or lengths\n",
      "        min_value = rule.get(\"min\")\n",
      "        max_value = rule.get(\"max\")\n",
      "\n",
      "        if isinstance(value, (int, float)):\n",
      "            if min_value is not None and value < min_value:\n",
      "                errors.append(f\"{field_name}: expected at least {min_value}, got {value}\")\n",
      "            elif max_value is not None and value > max_value:\n",
      "                errors.append(f\"{field_name}: expected at most {max_value}, got {value}\")\n",
      "\n",
      "        elif isinstance(value, str):\n",
      "            if min_value is not None and len(value) < min_value:\n",
      "                errors.append(f\"{field_name}: expected at least {min_value} characters, got {len(value)}\")\n",
      "            elif max_value is not None and len(value) > max_value:\n",
      "                errors.append(f\"{field_name}: expected at most {max_value} characters, got {len(value)}\")\n",
      "\n",
      "        elif i\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp6op42bj8.py\"\u001b[0m, line \u001b[35m88\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[31many\u001b[0m\u001b[1;31m(\"role\" in e and \"choices\" in e.lower() for e in errors)\u001b[0m\n",
      "           \u001b[31m~~~\u001b[0m\u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Token bucket rate limiter (real_world/expert)\n",
      "======================================================================\n",
      "\n",
      "Código generado (180 tokens):\n",
      "class TokenBucket:\n",
      "    \"\"\"Token bucket rate limiter (non-threaded, for testing).\n",
      "\n",
      "    Args:\n",
      "        capacity: Maximum tokens in bucket.\n",
      "        refill_rate: Tokens added per second.\n",
      "\n",
      "    Methods:\n",
      "        consume(tokens: int = 1, current_time: float = None) -> bool:\n",
      "            Try to consume tokens. Returns True if allowed, False if not enough tokens.\n",
      "            current_time is injectable for testing (defaults to time.time()).\n",
      "            Before checking, refill based on elapsed time since last refill.\n",
      "\n",
      "        tokens_available(current_time: float = None) -> float:\n",
      "            Return current token count after refill.\n",
      "\n",
      "        wait_time(tokens: int = 1, current_time: float = None) -> float:\n",
      "            Return seconds to wait before `tokens` would be available.\n",
      "            Returns 0.0 if tokens are already available.\n",
      "    \"\"\"\n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp7jdz5i74.py\"\u001b[0m, line \u001b[35m24\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    bucket = TokenBucket(capacity=10, refill_rate=1.0)\n",
      "\u001b[1;35mTypeError\u001b[0m: \u001b[35mTokenBucket() takes no arguments\u001b[0m\n",
      "\n",
      "======================================================================\n",
      "FALLÓ: Simple line differ (real_world/expert)\n",
      "======================================================================\n",
      "\n",
      "Código generado (588 tokens):\n",
      "def line_diff(old: str, new: str) -> list[str]:\n",
      "    \"\"\"Compute line-by-line diff between old and new text.\n",
      "\n",
      "    Returns list of diff lines:\n",
      "    - Lines only in old: prefixed with \"- \"\n",
      "    - Lines only in new: prefixed with \"+ \"\n",
      "    - Common lines: prefixed with \"  \" (two spaces)\n",
      "\n",
      "    Use longest common subsequence (LCS) to produce minimal diff.\n",
      "    Split input on newlines. Empty string = no lines.\"\"\"\n",
      "    \n",
      "    # Split the text into lines\n",
      "    old_lines = old.split('\\n')\n",
      "    new_lines = new.split('\\n')\n",
      "\n",
      "    # Compute LCS using dynamic programming\n",
      "    m, n = len(old_lines), len(new_lines)\n",
      "    dp = [[0] * (n + 1) for _ in range(m + 1)]\n",
      "    \n",
      "    for i in range(1, m + 1):\n",
      "        for j in range(1, n + 1):\n",
      "            if old_lines[i - 1] == new_lines[j - 1]:\n",
      "                dp[i][j] = dp[i - 1][j - 1] + 1\n",
      "            else:\n",
      "                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n",
      "    \n",
      "    # Reconstruct the LCS from the DP table\n",
      "    i, j = m, n\n",
      "    lcs = []\n",
      "    while i > 0 and j > 0:\n",
      "        if old_lines[i - 1] == new_lines[j - 1]:\n",
      "            lcs.append(old_lines[i - 1])\n",
      "            i -= 1\n",
      "            j -= 1\n",
      "        elif dp[i - 1][j] >= dp[i][j - 1]:\n",
      "            i -= 1\n",
      "        else:\n",
      "            j -= 1\n",
      "    \n",
      "    # Compute the diff by comparing LCS with original lines\n",
      "    diff = []\n",
      "    lcs_index = len(lcs) - 1\n",
      "    for line in old_lines + new_lines:\n",
      "        if lcs_index >= 0 and line == lcs[lcs_index]:\n",
      "            diff.append(\"  \" + line)\n",
      "            lcs_index -= 1\n",
      "        elif line in \n",
      "\n",
      "Error:\n",
      "Traceback (most recent call last):\n",
      "  File \u001b[35m\"/tmp/tmp_dec25hv.py\"\u001b[0m, line \u001b[35m57\u001b[0m, in \u001b[35m<module>\u001b[0m\n",
      "    assert \u001b[1;31mresult == [\"  a\", \"  b\", \"  c\"]\u001b[0m\n",
      "           \u001b[1;31m^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\u001b[0m\n",
      "\u001b[1;35mAssertionError\u001b[0m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ── Inspeccionar fallos ───────────────────────────────────\n",
    "\n",
    "failed = [r for r in results if not r.passed]\n",
    "if not failed:\n",
    "    print(\"Todos los challenges pasaron!\")\n",
    "else:\n",
    "    print(f\"{len(failed)} challenges fallidos:\\n\")\n",
    "    for r in failed:\n",
    "        print(f\"{'='*70}\")\n",
    "        print(f\"FALLÓ: {r.name} ({r.category}/{r.difficulty})\")\n",
    "        print(f\"{'='*70}\")\n",
    "        print(f\"\\nCódigo generado ({r.completion_tokens} tokens):\")\n",
    "        print(r.code[:1500])\n",
    "        print(f\"\\nError:\")\n",
    "        print(r.error[:500])\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "════════════════════════════════════════════════════════════\n",
      "  RESUMEN EJECUTIVO\n",
      "  Modelo: qwen2.5-coder-7b-abliterated-i1\n",
      "════════════════════════════════════════════════════════════\n",
      "\n",
      "  Correctitud total:  3/15 (20%)\n",
      "  Velocidad:          14.5 tok/s\n",
      "  Latencia promedio:  21.4s\n",
      "  Tokens promedio:    311\n",
      "\n",
      "  Por categoría:\n",
      "    Functional       3/4\n",
      "    Data Proc.       0/4\n",
      "    Algorithm        0/3\n",
      "    Real-World       0/4\n",
      "\n",
      "  Por dificultad:\n",
      "    medium      3/4\n",
      "    hard        0/7\n",
      "    expert      0/4\n",
      "════════════════════════════════════════════════════════════\n"
     ]
    }
   ],
   "source": [
    "# ── Resumen ejecutivo ─────────────────────────────────────\n",
    "\n",
    "passed = sum(1 for r in results if r.passed)\n",
    "total = len(results)\n",
    "avg_tps = sum(r.tokens_per_second for r in results) / total\n",
    "avg_lat = sum(r.latency_ms for r in results) / total\n",
    "avg_tok = sum(r.completion_tokens for r in results) / total\n",
    "\n",
    "print(f\"\\n{'═'*60}\")\n",
    "print(f\"  RESUMEN EJECUTIVO\")\n",
    "print(f\"  Modelo: {MODEL}\")\n",
    "print(f\"{'═'*60}\")\n",
    "print(f\"\")\n",
    "print(f\"  Correctitud total:  {passed}/{total} ({100*passed/total:.0f}%)\")\n",
    "print(f\"  Velocidad:          {avg_tps:.1f} tok/s\")\n",
    "print(f\"  Latencia promedio:  {avg_lat/1000:.1f}s\")\n",
    "print(f\"  Tokens promedio:    {avg_tok:.0f}\")\n",
    "print(f\"\")\n",
    "print(f\"  Por categoría:\")\n",
    "for cat, label in [(\"functional\", \"Functional\"), (\"data_processing\", \"Data Proc.\"),\n",
    "                    (\"algorithm\", \"Algorithm\"), (\"real_world\", \"Real-World\")]:\n",
    "    s = [r for r in results if r.category == cat]\n",
    "    p = sum(1 for r in s if r.passed)\n",
    "    print(f\"    {label:15s}  {p}/{len(s)}\")\n",
    "print(f\"\")\n",
    "print(f\"  Por dificultad:\")\n",
    "for d in [\"medium\", \"hard\", \"expert\"]:\n",
    "    s = [r for r in results if r.difficulty == d]\n",
    "    if not s: continue\n",
    "    p = sum(1 for r in s if r.passed)\n",
    "    print(f\"    {d:10s}  {p}/{len(s)}\")\n",
    "print(f\"{'═'*60}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}