{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How Debuggers Work\n",
    "\n",
    "Interactive _debuggers_ are tools that allow you to selectively observe the program state during an execution.  In this chapter, you will learn how such debuggers work – by building your own debugger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.604088Z",
     "iopub.status.busy": "2023-11-12T12:39:53.603970Z",
     "iopub.status.idle": "2023-11-12T12:39:53.644367Z",
     "shell.execute_reply": "2023-11-12T12:39:53.644065Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"640\"\n",
       "            height=\"360\"\n",
       "            src=\"https://www.youtube-nocookie.com/embed/4aZ0t7CWSjA\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "            \n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x107cf7490>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from bookutils import YouTubeVideo\n",
    "YouTubeVideo(\"4aZ0t7CWSjA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Prerequisites**\n",
    "\n",
    "* You should have read the [Chapter on Tracing Executions](Tracer.ipynb).\n",
    "* Again, knowing a bit of _Python_ is helpful for understanding the code examples in the book."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.666440Z",
     "iopub.status.busy": "2023-11-12T12:39:53.666228Z",
     "iopub.status.idle": "2023-11-12T12:39:53.668767Z",
     "shell.execute_reply": "2023-11-12T12:39:53.668455Z"
    },
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import bookutils.setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.670425Z",
     "iopub.status.busy": "2023-11-12T12:39:53.670203Z",
     "iopub.status.idle": "2023-11-12T12:39:53.672072Z",
     "shell.execute_reply": "2023-11-12T12:39:53.671774Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.673714Z",
     "iopub.status.busy": "2023-11-12T12:39:53.673582Z",
     "iopub.status.idle": "2023-11-12T12:39:53.771395Z",
     "shell.execute_reply": "2023-11-12T12:39:53.771022Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from Tracer import Tracer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Synopsis\n",
    "<!-- Automatically generated. Do not edit. -->\n",
    "\n",
    "To [use the code provided in this chapter](Importing.ipynb), write\n",
    "\n",
    "```python\n",
    ">>> from debuggingbook.Debugger import <identifier>\n",
    "```\n",
    "\n",
    "and then make use of the following features.\n",
    "\n",
    "\n",
    "This chapter provides an interactive debugger for Python functions. The debugger is invoked as\n",
    "\n",
    "```python\n",
    "with Debugger():\n",
    "    function_to_be_observed()\n",
    "    ...\n",
    "```\n",
    "While running, you can enter _debugger commands_ at the `(debugger)` prompt. Here's an example session:\n",
    "\n",
    "```python\n",
    ">>> with Debugger():\n",
    ">>>     ret = remove_html_markup('abc')\n",
    "Calling remove_html_markup(s = 'abc')\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>help</b></samp>\n",
    "```\n",
    "break      -- Set a breakoint in given line. If no line is given, list all breakpoints\n",
    "continue   -- Resume execution\n",
    "delete     -- Delete breakoint in line given by `arg`.\n",
    "           Without given line, clear all breakpoints\n",
    "help       -- Give help on given `command`. If no command is given, give help on all\n",
    "list       -- Show current function. If `arg` is given, show its source code.\n",
    "print      -- Print an expression. If no expression is given, print all variables\n",
    "quit       -- Finish execution\n",
    "step       -- Execute up to the next line\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>break 14</b></samp>\n",
    "```\n",
    "Breakpoints: {14}\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>list</b></samp>\n",
    "```\n",
    "   1> def remove_html_markup(s):  # type: ignore\n",
    "   2      tag = False\n",
    "   3      quote = False\n",
    "   4      out = \"\"\n",
    "   5  \n",
    "   6      for c in s:\n",
    "   7          if c == '<' and not quote:\n",
    "   8              tag = True\n",
    "   9          elif c == '>' and not quote:\n",
    "  10              tag = False\n",
    "  11          elif c == '\"' or c == \"'\" and tag:\n",
    "  12              quote = not quote\n",
    "  13          elif not tag:\n",
    "  14#             out = out + c\n",
    "  15  \n",
    "  16      return out\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>continue</b></samp>\n",
    "```\n",
    "                                         # tag = False, quote = False, out = '', c = 'a'\n",
    "14             out = out + c\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>step</b></samp>\n",
    "```\n",
    "                                         # out = 'a'\n",
    "6     for c in s:\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>print out</b></samp>\n",
    "```\n",
    "out = 'a'\n",
    "\n",
    "```\n",
    "<samp>(debugger) <b>quit</b></samp>\n",
    "\n",
    "The `Debugger` class can be easily extended in subclasses. A new method `NAME_command(self, arg)` will be invoked whenever a command named `NAME` is entered, with `arg` holding given command arguments (empty string if none).\n",
    "\n",
    "![](PICS/Debugger-synopsis-1.svg)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Debuggers\n",
    "\n",
    "_Interactive Debuggers_ (or short *debuggers*) are tools that allow you to observe program executions. A debugger typically offers the following features:\n",
    "\n",
    "* _Run_ the program\n",
    "* Define _conditions_ under which the execution should _stop_ and hand over control to the debugger. Conditions include\n",
    "    * a particular location is reached\n",
    "    * a particular variable takes a particular value\n",
    "    * a particular variable is accessed\n",
    "    * or some other condition of choice.\n",
    "* When the program stops, you can _observe_ the current state, including\n",
    "    * the current location\n",
    "    * variables and their values\n",
    "    * the current function and its callers\n",
    "* When the program stops, you can _step_ through program execution, having it stop at the next instruction again.\n",
    "* Finally, you can also _resume_ execution to the next stop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This functionality often comes as a _command-line interface_, typing commands at a prompt; or as a _graphical user interface_, selecting commands from the screen. Debuggers can come as standalone tools, or be integrated into a programming environment of choice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Debugger interaction typically follows a _loop_ pattern. First, you identify the location(s) you want to inspect, and tell the debugger to stop execution once one of these _breakpoints_ is reached. Here's a command that could instruct a command-line debugger to stop at Line 239:\n",
    "\n",
    "```\n",
    "(debugger) break 239\n",
    "(debugger) _\n",
    "```\n",
    "\n",
    "Then you have the debugger resume or start execution. The debugger will stop at the given location.\n",
    "\n",
    "```\n",
    "(debugger) continue\n",
    "Line 239: s = x\n",
    "(debugger) _\n",
    "```\n",
    "\n",
    "When it stops at the given location, you use debugger commands to inspect the state (and check whether things are as expected).\n",
    "\n",
    "```\n",
    "(debugger) print s\n",
    "s = 'abc'\n",
    "(debugger) _\n",
    "```\n",
    "\n",
    "You can then step through the program, executing more lines.\n",
    "\n",
    "```\n",
    "(debugger) step\n",
    "Line 240: c = s[0]\n",
    "(debugger) print c\n",
    "c = 'a'\n",
    "(debugger) _\n",
    "```\n",
    "\n",
    "You can also define new stop conditions, investigating other locations, variables, and conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Debugger Interaction\n",
    "\n",
    "Let us now show how to build such a debugger.  The key idea of an _interactive_ debugger is to set up the _tracing function_ such that it actually _asks_ what to do next, prompting you to enter a _command_. For the sake of simplicity, we collect such a command interactively from a command line, using the Python `input()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Our debugger holds a number of variables to indicate its current status:\n",
    "* `stepping` is True whenever the user wants to step into the next line.\n",
    "* `breakpoints` is a set of breakpoints (line numbers)\n",
    "* `interact` is True while the user stays at one position.\n",
    "\n",
    "We also store the current tracing information in three attributes `frame`, `event`, and `arg`. The variable `local_vars` holds local variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.773504Z",
     "iopub.status.busy": "2023-11-12T12:39:53.773364Z",
     "iopub.status.idle": "2023-11-12T12:39:53.774969Z",
     "shell.execute_reply": "2023-11-12T12:39:53.774709Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from types import FrameType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.776356Z",
     "iopub.status.busy": "2023-11-12T12:39:53.776271Z",
     "iopub.status.idle": "2023-11-12T12:39:53.778077Z",
     "shell.execute_reply": "2023-11-12T12:39:53.777788Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "from typing import Any, Optional, Callable, Dict, List, Tuple, Set, TextIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.779743Z",
     "iopub.status.busy": "2023-11-12T12:39:53.779654Z",
     "iopub.status.idle": "2023-11-12T12:39:53.782067Z",
     "shell.execute_reply": "2023-11-12T12:39:53.781797Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Tracer):\n",
    "    \"\"\"Interactive Debugger\"\"\"\n",
    "\n",
    "    def __init__(self, *, file: TextIO = sys.stdout) -> None:\n",
    "        \"\"\"Create a new interactive debugger.\"\"\"\n",
    "        self.stepping: bool = True\n",
    "        self.breakpoints: Set[int] = set()\n",
    "        self.interact: bool = True\n",
    "\n",
    "        self.frame: FrameType\n",
    "        self.event: Optional[str] = None\n",
    "        self.arg: Any = None\n",
    "\n",
    "        self.local_vars: Dict[str, Any] = {}\n",
    "\n",
    "        super().__init__(file=file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `traceit()` method is the main entry point for our debugger. If we should stop, we go into user interaction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.783639Z",
     "iopub.status.busy": "2023-11-12T12:39:53.783526Z",
     "iopub.status.idle": "2023-11-12T12:39:53.785661Z",
     "shell.execute_reply": "2023-11-12T12:39:53.785414Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def traceit(self, frame: FrameType, event: str, arg: Any) -> None:\n",
    "        \"\"\"Tracing function; called at every line. To be overloaded in subclasses.\"\"\"\n",
    "        self.frame = frame\n",
    "        self.local_vars = frame.f_locals  # Dereference exactly once\n",
    "        self.event = event\n",
    "        self.arg = arg\n",
    "\n",
    "        if self.stop_here():\n",
    "            self.interaction_loop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We stop whenever we are stepping through the program or reach a breakpoint:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.787099Z",
     "iopub.status.busy": "2023-11-12T12:39:53.786997Z",
     "iopub.status.idle": "2023-11-12T12:39:53.788723Z",
     "shell.execute_reply": "2023-11-12T12:39:53.788416Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def stop_here(self) -> bool:\n",
    "        \"\"\"Return True if we should stop\"\"\"\n",
    "        return self.stepping or self.frame.f_lineno in self.breakpoints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our interaction loop shows the current status, reads in commands, and executes them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.790334Z",
     "iopub.status.busy": "2023-11-12T12:39:53.790207Z",
     "iopub.status.idle": "2023-11-12T12:39:53.792402Z",
     "shell.execute_reply": "2023-11-12T12:39:53.792137Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def interaction_loop(self) -> None:\n",
    "        \"\"\"Interact with the user\"\"\"\n",
    "        self.print_debugger_status(self.frame, self.event, self.arg)  # type: ignore\n",
    "\n",
    "        self.interact = True\n",
    "        while self.interact:\n",
    "            command = input(\"(debugger) \")\n",
    "            self.execute(command)  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For a moment, let us implement two commands, `step` and `continue`. `step` steps through the program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.794196Z",
     "iopub.status.busy": "2023-11-12T12:39:53.793922Z",
     "iopub.status.idle": "2023-11-12T12:39:53.796245Z",
     "shell.execute_reply": "2023-11-12T12:39:53.795947Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def step_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Execute up to the next line\"\"\"\n",
    "\n",
    "        self.stepping = True\n",
    "        self.interact = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.797798Z",
     "iopub.status.busy": "2023-11-12T12:39:53.797671Z",
     "iopub.status.idle": "2023-11-12T12:39:53.799807Z",
     "shell.execute_reply": "2023-11-12T12:39:53.799451Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def continue_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Resume execution\"\"\"\n",
    "\n",
    "        self.stepping = False\n",
    "        self.interact = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `execute()` method dispatches between these two."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.801427Z",
     "iopub.status.busy": "2023-11-12T12:39:53.801293Z",
     "iopub.status.idle": "2023-11-12T12:39:53.803308Z",
     "shell.execute_reply": "2023-11-12T12:39:53.803050Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def execute(self, command: str) -> None:\n",
    "        if command.startswith('s'):\n",
    "            self.step_command()\n",
    "        elif command.startswith('c'):\n",
    "            self.continue_command()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our debugger is now ready to run! Let us invoke it on the buggy `remove_html_markup()` variant from the [Introduction to Debugging](Intro_Debugging.ipynb):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.804837Z",
     "iopub.status.busy": "2023-11-12T12:39:53.804726Z",
     "iopub.status.idle": "2023-11-12T12:39:53.807177Z",
     "shell.execute_reply": "2023-11-12T12:39:53.806919Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def remove_html_markup(s):  # type: ignore\n",
    "    tag = False\n",
    "    quote = False\n",
    "    out = \"\"\n",
    "\n",
    "    for c in s:\n",
    "        if c == '<' and not quote:\n",
    "            tag = True\n",
    "        elif c == '>' and not quote:\n",
    "            tag = False\n",
    "        elif c == '\"' or c == \"'\" and tag:\n",
    "            quote = not quote\n",
    "        elif not tag:\n",
    "            out = out + c\n",
    "\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We invoke the debugger just like `Tracer`, using a `with` clause. The code\n",
    "\n",
    "```python\n",
    "with Debugger():\n",
    "    remove_html_markup('abc')\n",
    "```\n",
    "gives us a debugger prompt\n",
    "```\n",
    "(debugger) _\n",
    "```\n",
    "where we can enter one of our two commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us do two steps through the program and then resume execution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.808788Z",
     "iopub.status.busy": "2023-11-12T12:39:53.808682Z",
     "iopub.status.idle": "2023-11-12T12:39:53.810392Z",
     "shell.execute_reply": "2023-11-12T12:39:53.810121Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import input, next_inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.811920Z",
     "iopub.status.busy": "2023-11-12T12:39:53.811807Z",
     "iopub.status.idle": "2023-11-12T12:39:53.814157Z",
     "shell.execute_reply": "2023-11-12T12:39:53.813845Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['step', 'step', 'continue']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "next_inputs([\"step\", \"step\", \"continue\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.816490Z",
     "iopub.status.busy": "2023-11-12T12:39:53.816247Z",
     "iopub.status.idle": "2023-11-12T12:39:53.865273Z",
     "shell.execute_reply": "2023-11-12T12:39:53.864997Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2     tag = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False\n",
      "3     quote = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.866808Z",
     "iopub.status.busy": "2023-11-12T12:39:53.866694Z",
     "iopub.status.idle": "2023-11-12T12:39:53.868271Z",
     "shell.execute_reply": "2023-11-12T12:39:53.868027Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Try this out for yourself by running the above invocation in the interactive notebook! If you are reading the Web version, the top menu entry `Resources` -> `Edit as Notebook` will do the trick. Navigate to the above invocation and press `Shift`+`Enter`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A Command Dispatcher"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our `execute()` function is still a bit rudimentary. A true command-line tool should provide means to tell which commands are available (`help`), automatically split arguments, and not stand in line of extensibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We therefore implement a better `execute()` method which does all that. Our revised `execute()` method _inspects_ its class for methods that end in `_command()`, and automatically registers their names as commands. Hence, with the above, we already get `step` and `continue` as possible commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Implementing execute()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us detail how we implement `execute()`. The `commands()` method returns a list of all commands (as strings) from the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.869914Z",
     "iopub.status.busy": "2023-11-12T12:39:53.869803Z",
     "iopub.status.idle": "2023-11-12T12:39:53.871871Z",
     "shell.execute_reply": "2023-11-12T12:39:53.871604Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def commands(self) -> List[str]:\n",
    "        \"\"\"Return a list of commands\"\"\"\n",
    "\n",
    "        cmds = [method.replace('_command', '')\n",
    "                for method in dir(self.__class__)\n",
    "                if method.endswith('_command')]\n",
    "        cmds.sort()\n",
    "        return cmds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.873454Z",
     "iopub.status.busy": "2023-11-12T12:39:53.873308Z",
     "iopub.status.idle": "2023-11-12T12:39:53.875674Z",
     "shell.execute_reply": "2023-11-12T12:39:53.875359Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['continue', 'step']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Debugger()\n",
    "d.commands()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `command_method()` method converts a given command (or its abbrevation) into a method to be called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.877494Z",
     "iopub.status.busy": "2023-11-12T12:39:53.877362Z",
     "iopub.status.idle": "2023-11-12T12:39:53.880224Z",
     "shell.execute_reply": "2023-11-12T12:39:53.879967Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def help_command(self, command: str) -> None:\n",
    "        ...\n",
    "\n",
    "    def command_method(self, command: str) -> Optional[Callable[[str], None]]:\n",
    "        \"\"\"Convert `command` into the method to be called.\n",
    "           If the method is not found, return `None` instead.\"\"\"\n",
    "\n",
    "        if command.startswith('#'):\n",
    "            return None  # Comment\n",
    "\n",
    "        possible_cmds = [possible_cmd for possible_cmd in self.commands()\n",
    "                         if possible_cmd.startswith(command)]\n",
    "        if len(possible_cmds) != 1:\n",
    "            self.help_command(command)\n",
    "            return None\n",
    "\n",
    "        cmd = possible_cmds[0]\n",
    "        return getattr(self, cmd + '_command')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.881753Z",
     "iopub.status.busy": "2023-11-12T12:39:53.881629Z",
     "iopub.status.idle": "2023-11-12T12:39:53.883938Z",
     "shell.execute_reply": "2023-11-12T12:39:53.883667Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Debugger.step_command of <__main__.Debugger object at 0x108315510>>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Debugger()\n",
    "d.command_method(\"step\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.885360Z",
     "iopub.status.busy": "2023-11-12T12:39:53.885256Z",
     "iopub.status.idle": "2023-11-12T12:39:53.887584Z",
     "shell.execute_reply": "2023-11-12T12:39:53.887285Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Debugger.step_command of <__main__.Debugger object at 0x1083169e0>>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Debugger()\n",
    "d.command_method(\"s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The revised `execute()` method now determines this method and executes it with the given argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.889048Z",
     "iopub.status.busy": "2023-11-12T12:39:53.888939Z",
     "iopub.status.idle": "2023-11-12T12:39:53.891196Z",
     "shell.execute_reply": "2023-11-12T12:39:53.890940Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def execute(self, command: str) -> None:\n",
    "        \"\"\"Execute `command`\"\"\"\n",
    "\n",
    "        sep = command.find(' ')\n",
    "        if sep > 0:\n",
    "            cmd = command[:sep].strip()\n",
    "            arg = command[sep + 1:].strip()\n",
    "        else:\n",
    "            cmd = command.strip()\n",
    "            arg = \"\"\n",
    "\n",
    "        method = self.command_method(cmd)\n",
    "        if method:\n",
    "            method(arg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If `command_method()` cannot find the command, or finds more than one matching the prefix, it invokes the `help` command providing additional assistance. `help` draws extra info on each command from its documentation string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.892670Z",
     "iopub.status.busy": "2023-11-12T12:39:53.892566Z",
     "iopub.status.idle": "2023-11-12T12:39:53.895128Z",
     "shell.execute_reply": "2023-11-12T12:39:53.894852Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def help_command(self, command: str = \"\") -> None:\n",
    "        \"\"\"Give help on given `command`. If no command is given, give help on all\"\"\"\n",
    "\n",
    "        if command:\n",
    "            possible_cmds = [possible_cmd for possible_cmd in self.commands()\n",
    "                             if possible_cmd.startswith(command)]\n",
    "\n",
    "            if len(possible_cmds) == 0:\n",
    "                self.log(f\"Unknown command {repr(command)}. Possible commands are:\")\n",
    "                possible_cmds = self.commands()\n",
    "            elif len(possible_cmds) > 1:\n",
    "                self.log(f\"Ambiguous command {repr(command)}. Possible expansions are:\")\n",
    "        else:\n",
    "            possible_cmds = self.commands()\n",
    "\n",
    "        for cmd in possible_cmds:\n",
    "            method = self.command_method(cmd)\n",
    "            self.log(f\"{cmd:10} -- {method.__doc__}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.896532Z",
     "iopub.status.busy": "2023-11-12T12:39:53.896427Z",
     "iopub.status.idle": "2023-11-12T12:39:53.898767Z",
     "shell.execute_reply": "2023-11-12T12:39:53.898484Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "continue   -- Resume execution\n",
      "help       -- Give help on given `command`. If no command is given, give help on all\n",
      "step       -- Execute up to the next line\n"
     ]
    }
   ],
   "source": [
    "d = Debugger()\n",
    "d.execute(\"help\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.900507Z",
     "iopub.status.busy": "2023-11-12T12:39:53.900403Z",
     "iopub.status.idle": "2023-11-12T12:39:53.902867Z",
     "shell.execute_reply": "2023-11-12T12:39:53.902625Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unknown command 'foo'. Possible commands are:\n",
      "continue   -- Resume execution\n",
      "help       -- Give help on given `command`. If no command is given, give help on all\n",
      "step       -- Execute up to the next line\n"
     ]
    }
   ],
   "source": [
    "d = Debugger()\n",
    "d.execute(\"foo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Printing Values\n",
    "\n",
    "With `execute()`, we can now easily extend our class – all it takes is for a new command `NAME` is a new `NAME_command()` method. Let us start by providing a `print` command to print all variables. We use similar code as for the `Tracer` class in the [chapter on tracing](Tracer.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.904775Z",
     "iopub.status.busy": "2023-11-12T12:39:53.904670Z",
     "iopub.status.idle": "2023-11-12T12:39:53.906652Z",
     "shell.execute_reply": "2023-11-12T12:39:53.906424Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def print_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Print an expression. If no expression is given, print all variables\"\"\"\n",
    "\n",
    "        vars = self.local_vars\n",
    "        self.log(\"\\n\".join([f\"{var} = {repr(value)}\" for var, value in vars.items()]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.908006Z",
     "iopub.status.busy": "2023-11-12T12:39:53.907901Z",
     "iopub.status.idle": "2023-11-12T12:39:53.909610Z",
     "shell.execute_reply": "2023-11-12T12:39:53.909349Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"step\", \"step\", \"step\", \"print\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.911307Z",
     "iopub.status.busy": "2023-11-12T12:39:53.911189Z",
     "iopub.status.idle": "2023-11-12T12:39:53.923342Z",
     "shell.execute_reply": "2023-11-12T12:39:53.923073Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2     tag = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False\n",
      "3     quote = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # quote = False\n",
      "4     out = \"\"\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n",
      "tag = False\n",
      "quote = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.925103Z",
     "iopub.status.busy": "2023-11-12T12:39:53.924927Z",
     "iopub.status.idle": "2023-11-12T12:39:53.926627Z",
     "shell.execute_reply": "2023-11-12T12:39:53.926397Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us extend `print` such that if an argument is given, it only evaluates and prints out this argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.928543Z",
     "iopub.status.busy": "2023-11-12T12:39:53.928371Z",
     "iopub.status.idle": "2023-11-12T12:39:53.931196Z",
     "shell.execute_reply": "2023-11-12T12:39:53.930916Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def print_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Print an expression. If no expression is given, print all variables\"\"\"\n",
    "\n",
    "        vars = self.local_vars\n",
    "\n",
    "        if not arg:\n",
    "            self.log(\"\\n\".join([f\"{var} = {repr(value)}\" for var, value in vars.items()]))\n",
    "        else:\n",
    "            try:\n",
    "                self.log(f\"{arg} = {repr(eval(arg, globals(), vars))}\")\n",
    "            except Exception as err:\n",
    "                self.log(f\"{err.__class__.__name__}: {err}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.932852Z",
     "iopub.status.busy": "2023-11-12T12:39:53.932641Z",
     "iopub.status.idle": "2023-11-12T12:39:53.934396Z",
     "shell.execute_reply": "2023-11-12T12:39:53.934117Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"p s\", \"c\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.936005Z",
     "iopub.status.busy": "2023-11-12T12:39:53.935823Z",
     "iopub.status.idle": "2023-11-12T12:39:53.939364Z",
     "shell.execute_reply": "2023-11-12T12:39:53.938980Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>p s</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>c</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.940995Z",
     "iopub.status.busy": "2023-11-12T12:39:53.940898Z",
     "iopub.status.idle": "2023-11-12T12:39:53.942507Z",
     "shell.execute_reply": "2023-11-12T12:39:53.942245Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note how we would abbreviate commands to speed things up. The argument to `print` can be any Python expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.944011Z",
     "iopub.status.busy": "2023-11-12T12:39:53.943904Z",
     "iopub.status.idle": "2023-11-12T12:39:53.945621Z",
     "shell.execute_reply": "2023-11-12T12:39:53.945314Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"print (s[0], 2 + 2)\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.947083Z",
     "iopub.status.busy": "2023-11-12T12:39:53.946993Z",
     "iopub.status.idle": "2023-11-12T12:39:53.950374Z",
     "shell.execute_reply": "2023-11-12T12:39:53.950031Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print (s[0], 2 + 2)</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(s[0], 2 + 2) = ('a', 4)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our `help` command also properly lists `print` as a possible command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.952004Z",
     "iopub.status.busy": "2023-11-12T12:39:53.951858Z",
     "iopub.status.idle": "2023-11-12T12:39:53.953471Z",
     "shell.execute_reply": "2023-11-12T12:39:53.953221Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"help print\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.954844Z",
     "iopub.status.busy": "2023-11-12T12:39:53.954754Z",
     "iopub.status.idle": "2023-11-12T12:39:53.958160Z",
     "shell.execute_reply": "2023-11-12T12:39:53.957893Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>help print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print      -- Print an expression. If no expression is given, print all variables\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.959523Z",
     "iopub.status.busy": "2023-11-12T12:39:53.959439Z",
     "iopub.status.idle": "2023-11-12T12:39:53.961146Z",
     "shell.execute_reply": "2023-11-12T12:39:53.960895Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listing Source Code\n",
    "\n",
    "We implement a `list` command that shows the source code of the current function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.962662Z",
     "iopub.status.busy": "2023-11-12T12:39:53.962556Z",
     "iopub.status.idle": "2023-11-12T12:39:53.964103Z",
     "shell.execute_reply": "2023-11-12T12:39:53.963853Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import inspect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.965645Z",
     "iopub.status.busy": "2023-11-12T12:39:53.965540Z",
     "iopub.status.idle": "2023-11-12T12:39:53.967211Z",
     "shell.execute_reply": "2023-11-12T12:39:53.966936Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import getsourcelines  # like inspect.getsourcelines(), but in color"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.968846Z",
     "iopub.status.busy": "2023-11-12T12:39:53.968647Z",
     "iopub.status.idle": "2023-11-12T12:39:53.970817Z",
     "shell.execute_reply": "2023-11-12T12:39:53.970562Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def list_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Show current function.\"\"\"\n",
    "\n",
    "        source_lines, line_number = getsourcelines(self.frame.f_code)\n",
    "\n",
    "        for line in source_lines:\n",
    "            self.log(f'{line_number:4} {line}', end='')\n",
    "            line_number += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.972287Z",
     "iopub.status.busy": "2023-11-12T12:39:53.972181Z",
     "iopub.status.idle": "2023-11-12T12:39:53.973713Z",
     "shell.execute_reply": "2023-11-12T12:39:53.973480Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"list\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:53.975092Z",
     "iopub.status.busy": "2023-11-12T12:39:53.975002Z",
     "iopub.status.idle": "2023-11-12T12:39:54.047923Z",
     "shell.execute_reply": "2023-11-12T12:39:54.047524Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>list</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1 \u001b[34mdef\u001b[39;49;00m \u001b[32mremove_html_markup\u001b[39;49;00m(s):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   2     tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   3     quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   4     out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   5 \u001b[37m\u001b[39;49;00m\n",
      "   6     \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "   7         \u001b[34mif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m<\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "   8             tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   9         \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "  10             tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "  11         \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mor\u001b[39;49;00m c == \u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  12             quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "  13         \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  14             out = out + c\u001b[37m\u001b[39;49;00m\n",
      "  15 \u001b[37m\u001b[39;49;00m\n",
      "  16     \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.053087Z",
     "iopub.status.busy": "2023-11-12T12:39:54.052929Z",
     "iopub.status.idle": "2023-11-12T12:39:54.054815Z",
     "shell.execute_reply": "2023-11-12T12:39:54.054460Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Setting Breakpoints\n",
    "\n",
    "Stepping through the program line by line is a bit cumbersome. We therefore implement _breakpoints_ – a set of lines that cause the program to be interrupted as soon as this line is met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.056670Z",
     "iopub.status.busy": "2023-11-12T12:39:54.056545Z",
     "iopub.status.idle": "2023-11-12T12:39:54.058855Z",
     "shell.execute_reply": "2023-11-12T12:39:54.058548Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def break_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Set a breakoint in given line. If no line is given, list all breakpoints\"\"\"\n",
    "\n",
    "        if arg:\n",
    "            self.breakpoints.add(int(arg))\n",
    "        self.log(\"Breakpoints:\", self.breakpoints)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's an example, setting a breakpoint at the end of the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.060536Z",
     "iopub.status.busy": "2023-11-12T12:39:54.060417Z",
     "iopub.status.idle": "2023-11-12T12:39:54.062974Z",
     "shell.execute_reply": "2023-11-12T12:39:54.062668Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "_, remove_html_markup_starting_line_number = \\\n",
    "    inspect.getsourcelines(remove_html_markup)\n",
    "next_inputs([f\"break {remove_html_markup_starting_line_number + 13}\",\n",
    "             \"continue\", \"print\", \"continue\", \"continue\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.064622Z",
     "iopub.status.busy": "2023-11-12T12:39:54.064506Z",
     "iopub.status.idle": "2023-11-12T12:39:54.080874Z",
     "shell.execute_reply": "2023-11-12T12:39:54.080460Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>break 14</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: {14}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False, quote = False, out = '', c = 'a'\n",
      "14             out = out + c\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n",
      "tag = False\n",
      "quote = False\n",
      "out = ''\n",
      "c = 'a'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # out = 'a', c = 'b'\n",
      "14             out = out + c\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # out = 'ab', c = 'c'\n",
      "14             out = out + c\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.082703Z",
     "iopub.status.busy": "2023-11-12T12:39:54.082550Z",
     "iopub.status.idle": "2023-11-12T12:39:54.084132Z",
     "shell.execute_reply": "2023-11-12T12:39:54.083909Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.085590Z",
     "iopub.status.busy": "2023-11-12T12:39:54.085507Z",
     "iopub.status.idle": "2023-11-12T12:39:54.086980Z",
     "shell.execute_reply": "2023-11-12T12:39:54.086724Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import quiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.088771Z",
     "iopub.status.busy": "2023-11-12T12:39:54.088636Z",
     "iopub.status.idle": "2023-11-12T12:39:54.093485Z",
     "shell.execute_reply": "2023-11-12T12:39:54.093196Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    \n",
       "    <script>\n",
       "    var bad_answers = new Map();\n",
       "\n",
       "    function answer(quiz_id) {\n",
       "        ans = 0;\n",
       "        for (i = 1;; i++) {\n",
       "            checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "            if (!checkbox)\n",
       "                break;\n",
       "            if (checkbox.checked)\n",
       "                ans |= (1 << i);\n",
       "        }\n",
       "        return ans;\n",
       "    }\n",
       "    function check_selection(quiz_id, correct_answer, multiple_choice, hint) {\n",
       "        given_answer = answer(quiz_id);\n",
       "        if (given_answer == correct_answer)\n",
       "        {\n",
       "            document.getElementById(quiz_id + \"-submit\").value = \"Correct!\";\n",
       "            document.getElementById(quiz_id + \"-hint\").innerHTML = \"\";\n",
       "\n",
       "            for (i = 1;; i++) {\n",
       "                checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "                label = document.getElementById(quiz_id + \"-\" + i.toString() + \"-label\")\n",
       "                if (!checkbox)\n",
       "                    break;\n",
       "    \n",
       "                if (checkbox.checked) {\n",
       "                    label.style.fontWeight = \"bold\";\n",
       "                }\n",
       "                else {\n",
       "                    label.style.textDecoration = \"line-through\";\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        else \n",
       "        {\n",
       "            document.getElementById(quiz_id + \"-submit\").value = \"Try again\";\n",
       "            \n",
       "            if (!bad_answers.has(quiz_id)) {\n",
       "                bad_answers.set(quiz_id, 1);\n",
       "            }\n",
       "            else {\n",
       "                bad_answers.set(quiz_id, bad_answers.get(quiz_id) + 1);\n",
       "            }\n",
       "\n",
       "            if (bad_answers.get(quiz_id) >= 2 && hint.length > 0) {\n",
       "                document.getElementById(quiz_id + \"-hint\").innerHTML = \n",
       "                    \"&nbsp;&nbsp;(Hint: <code>\" + hint + \"</code>)\";\n",
       "            }\n",
       "\n",
       "            if (!multiple_choice) {\n",
       "                for (i = 1;; i++) {\n",
       "                    checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "                    label = document.getElementById(quiz_id + \"-\" + i.toString() + \"-label\")\n",
       "\n",
       "                    if (!checkbox)\n",
       "                        break;\n",
       "                    if (checkbox.checked) {\n",
       "                        label.style.textDecoration = \"line-through\";\n",
       "                    }\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    function clear_selection(quiz_id) {\n",
       "        document.getElementById(quiz_id + \"-submit\").value = \"Submit\";\n",
       "        document.getElementById(quiz_id + \"-hint\").innerHTML = \"\";\n",
       "    }\n",
       "    </script>\n",
       "    \n",
       "    <div class=\"quiz\">\n",
       "    <h3 class=\"quiz_title\">Quiz</h3>\n",
       "    <p>\n",
       "    <div class=\"quiz_question\">What happens if we enter the command <code>break 2 + 3</code>?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Pick a choice.\">\n",
       "    \n",
       "        <input type=\"radio\" name=\"9456e6fa-8158-11ee-b209-6298cf1a5790\" id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-1\" onclick=\"clear_selection('9456e6fa-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-1-label\" for=\"9456e6fa-8158-11ee-b209-6298cf1a5790-1\">A breakpoint is set in Line 2.</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"9456e6fa-8158-11ee-b209-6298cf1a5790\" id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-2\" onclick=\"clear_selection('9456e6fa-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-2-label\" for=\"9456e6fa-8158-11ee-b209-6298cf1a5790-2\">A breakpoint is set in Line 5.</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"9456e6fa-8158-11ee-b209-6298cf1a5790\" id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-3\" onclick=\"clear_selection('9456e6fa-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-3-label\" for=\"9456e6fa-8158-11ee-b209-6298cf1a5790-3\">Two breakpoints are set in Lines 2 and 3.</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"9456e6fa-8158-11ee-b209-6298cf1a5790\" id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-4\" onclick=\"clear_selection('9456e6fa-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-4-label\" for=\"9456e6fa-8158-11ee-b209-6298cf1a5790-4\">The debugger raises a <code>ValueError</code> exception.</label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('9456e6fa-8158-11ee-b209-6298cf1a5790', 16, 0, '12345 % 7')\">\n",
       "    <span class=\"quiz_hint\" id=\"9456e6fa-8158-11ee-b209-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"What happens if we enter the command `break 2 + 3`?\",\n",
    "     [\n",
    "         \"A breakpoint is set in Line 2.\",\n",
    "         \"A breakpoint is set in Line 5.\",\n",
    "         \"Two breakpoints are set in Lines 2 and 3.\",\n",
    "         \"The debugger raises a `ValueError` exception.\"\n",
    "     ], '12345 % 7')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Try it out yourself by executing the above code block!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Deleting Breakpoints\n",
    "\n",
    "To delete breakpoints, we introduce a `delete` command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.095131Z",
     "iopub.status.busy": "2023-11-12T12:39:54.095009Z",
     "iopub.status.idle": "2023-11-12T12:39:54.097446Z",
     "shell.execute_reply": "2023-11-12T12:39:54.097153Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def delete_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Delete breakoint in line given by `arg`.\n",
    "           Without given line, clear all breakpoints\"\"\"\n",
    "\n",
    "        if arg:\n",
    "            try:\n",
    "                self.breakpoints.remove(int(arg))\n",
    "            except KeyError:\n",
    "                self.log(f\"No such breakpoint: {arg}\")\n",
    "        else:\n",
    "            self.breakpoints = set()\n",
    "        self.log(\"Breakpoints:\", self.breakpoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.098905Z",
     "iopub.status.busy": "2023-11-12T12:39:54.098796Z",
     "iopub.status.idle": "2023-11-12T12:39:54.100647Z",
     "shell.execute_reply": "2023-11-12T12:39:54.100354Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([f\"break {remove_html_markup_starting_line_number + 15}\",\n",
    "             \"continue\", \"print\",\n",
    "             f\"delete {remove_html_markup_starting_line_number + 15}\",\n",
    "             \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.102170Z",
     "iopub.status.busy": "2023-11-12T12:39:54.102052Z",
     "iopub.status.idle": "2023-11-12T12:39:54.110896Z",
     "shell.execute_reply": "2023-11-12T12:39:54.110538Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>break 16</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: {16}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False, quote = False, out = 'abc', c = 'c'\n",
      "16     return out\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n",
      "tag = False\n",
      "quote = False\n",
      "out = 'abc'\n",
      "c = 'c'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>delete 16</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: set()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.112696Z",
     "iopub.status.busy": "2023-11-12T12:39:54.112600Z",
     "iopub.status.idle": "2023-11-12T12:39:54.114296Z",
     "shell.execute_reply": "2023-11-12T12:39:54.114008Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.115903Z",
     "iopub.status.busy": "2023-11-12T12:39:54.115812Z",
     "iopub.status.idle": "2023-11-12T12:39:54.119224Z",
     "shell.execute_reply": "2023-11-12T12:39:54.118952Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    \n",
       "    <script>\n",
       "    var bad_answers = new Map();\n",
       "\n",
       "    function answer(quiz_id) {\n",
       "        ans = 0;\n",
       "        for (i = 1;; i++) {\n",
       "            checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "            if (!checkbox)\n",
       "                break;\n",
       "            if (checkbox.checked)\n",
       "                ans |= (1 << i);\n",
       "        }\n",
       "        return ans;\n",
       "    }\n",
       "    function check_selection(quiz_id, correct_answer, multiple_choice, hint) {\n",
       "        given_answer = answer(quiz_id);\n",
       "        if (given_answer == correct_answer)\n",
       "        {\n",
       "            document.getElementById(quiz_id + \"-submit\").value = \"Correct!\";\n",
       "            document.getElementById(quiz_id + \"-hint\").innerHTML = \"\";\n",
       "\n",
       "            for (i = 1;; i++) {\n",
       "                checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "                label = document.getElementById(quiz_id + \"-\" + i.toString() + \"-label\")\n",
       "                if (!checkbox)\n",
       "                    break;\n",
       "    \n",
       "                if (checkbox.checked) {\n",
       "                    label.style.fontWeight = \"bold\";\n",
       "                }\n",
       "                else {\n",
       "                    label.style.textDecoration = \"line-through\";\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        else \n",
       "        {\n",
       "            document.getElementById(quiz_id + \"-submit\").value = \"Try again\";\n",
       "            \n",
       "            if (!bad_answers.has(quiz_id)) {\n",
       "                bad_answers.set(quiz_id, 1);\n",
       "            }\n",
       "            else {\n",
       "                bad_answers.set(quiz_id, bad_answers.get(quiz_id) + 1);\n",
       "            }\n",
       "\n",
       "            if (bad_answers.get(quiz_id) >= 2 && hint.length > 0) {\n",
       "                document.getElementById(quiz_id + \"-hint\").innerHTML = \n",
       "                    \"&nbsp;&nbsp;(Hint: <code>\" + hint + \"</code>)\";\n",
       "            }\n",
       "\n",
       "            if (!multiple_choice) {\n",
       "                for (i = 1;; i++) {\n",
       "                    checkbox = document.getElementById(quiz_id + \"-\" + i.toString());\n",
       "                    label = document.getElementById(quiz_id + \"-\" + i.toString() + \"-label\")\n",
       "\n",
       "                    if (!checkbox)\n",
       "                        break;\n",
       "                    if (checkbox.checked) {\n",
       "                        label.style.textDecoration = \"line-through\";\n",
       "                    }\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    function clear_selection(quiz_id) {\n",
       "        document.getElementById(quiz_id + \"-submit\").value = \"Submit\";\n",
       "        document.getElementById(quiz_id + \"-hint\").innerHTML = \"\";\n",
       "    }\n",
       "    </script>\n",
       "    \n",
       "    <div class=\"quiz\">\n",
       "    <h3 class=\"quiz_title\">Quiz</h3>\n",
       "    <p>\n",
       "    <div class=\"quiz_question\">What does the command <code>delete</code> (without argument) do?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Check all that apply.\">\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"945b083e-8158-11ee-b209-6298cf1a5790\" id=\"945b083e-8158-11ee-b209-6298cf1a5790-1\" onclick=\"clear_selection('945b083e-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"945b083e-8158-11ee-b209-6298cf1a5790-1-label\" for=\"945b083e-8158-11ee-b209-6298cf1a5790-1\">It deletes all breakpoints</label><br>\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"945b083e-8158-11ee-b209-6298cf1a5790\" id=\"945b083e-8158-11ee-b209-6298cf1a5790-2\" onclick=\"clear_selection('945b083e-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"945b083e-8158-11ee-b209-6298cf1a5790-2-label\" for=\"945b083e-8158-11ee-b209-6298cf1a5790-2\">It deletes the source code</label><br>\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"945b083e-8158-11ee-b209-6298cf1a5790\" id=\"945b083e-8158-11ee-b209-6298cf1a5790-3\" onclick=\"clear_selection('945b083e-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"945b083e-8158-11ee-b209-6298cf1a5790-3-label\" for=\"945b083e-8158-11ee-b209-6298cf1a5790-3\">It lists all breakpoints</label><br>\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"945b083e-8158-11ee-b209-6298cf1a5790\" id=\"945b083e-8158-11ee-b209-6298cf1a5790-4\" onclick=\"clear_selection('945b083e-8158-11ee-b209-6298cf1a5790')\">\n",
       "        <label id=\"945b083e-8158-11ee-b209-6298cf1a5790-4-label\" for=\"945b083e-8158-11ee-b209-6298cf1a5790-4\">It stops execution</label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"945b083e-8158-11ee-b209-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('945b083e-8158-11ee-b209-6298cf1a5790', 10, 1, '[n for n in range(2 // 2, 2 * 2) if n % 2 / 2]')\">\n",
       "    <span class=\"quiz_hint\" id=\"945b083e-8158-11ee-b209-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"What does the command `delete` (without argument) do?\",\n",
    "    [\n",
    "        \"It deletes all breakpoints\",\n",
    "        \"It deletes the source code\",\n",
    "        \"It lists all breakpoints\",\n",
    "        \"It stops execution\"\n",
    "    ],\n",
    "    '[n for n in range(2 // 2, 2 * 2) if n % 2 / 2]'\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listings with Benefits\n",
    "\n",
    "Let us extend `list` a bit such that \n",
    "\n",
    "1. it can also list a given function, and \n",
    "2. it shows the current line (`>`) as well as breakpoints (`#`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.121023Z",
     "iopub.status.busy": "2023-11-12T12:39:54.120855Z",
     "iopub.status.idle": "2023-11-12T12:39:54.124298Z",
     "shell.execute_reply": "2023-11-12T12:39:54.123948Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def list_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Show current function. If `arg` is given, show its source code.\"\"\"\n",
    "\n",
    "        try:\n",
    "            if arg:\n",
    "                obj = eval(arg)\n",
    "                source_lines, line_number = inspect.getsourcelines(obj)\n",
    "                current_line = -1\n",
    "            else:\n",
    "                source_lines, line_number = \\\n",
    "                    getsourcelines(self.frame.f_code)\n",
    "                current_line = self.frame.f_lineno\n",
    "        except Exception as err:\n",
    "            self.log(f\"{err.__class__.__name__}: {err}\")\n",
    "            source_lines = []\n",
    "            line_number = 0\n",
    "\n",
    "        for line in source_lines:\n",
    "            spacer = ' '\n",
    "            if line_number == current_line:\n",
    "                spacer = '>'\n",
    "            elif line_number in self.breakpoints:\n",
    "                spacer = '#'\n",
    "            self.log(f'{line_number:4}{spacer} {line}', end='')\n",
    "            line_number += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.126430Z",
     "iopub.status.busy": "2023-11-12T12:39:54.126276Z",
     "iopub.status.idle": "2023-11-12T12:39:54.129146Z",
     "shell.execute_reply": "2023-11-12T12:39:54.128812Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "_, remove_html_markup_starting_line_number = \\\n",
    "    inspect.getsourcelines(remove_html_markup)\n",
    "next_inputs([f\"break {remove_html_markup_starting_line_number + 13}\",\n",
    "             \"list\", \"continue\", \"delete\", \"list\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.130652Z",
     "iopub.status.busy": "2023-11-12T12:39:54.130540Z",
     "iopub.status.idle": "2023-11-12T12:39:54.222381Z",
     "shell.execute_reply": "2023-11-12T12:39:54.222070Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>break 14</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: {14}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>list</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1> \u001b[34mdef\u001b[39;49;00m \u001b[32mremove_html_markup\u001b[39;49;00m(s):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   2      tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   3      quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   4      out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   5  \u001b[37m\u001b[39;49;00m\n",
      "   6      \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "   7          \u001b[34mif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m<\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "   8              tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   9          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "  10              tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "  11          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mor\u001b[39;49;00m c == \u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  12              quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "  13          \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  14#             out = out + c\u001b[37m\u001b[39;49;00m\n",
      "  15  \u001b[37m\u001b[39;49;00m\n",
      "  16      \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False, quote = False, out = '', c = 'a'\n",
      "14             out = out + c\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>delete</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: set()\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>list</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1  \u001b[34mdef\u001b[39;49;00m \u001b[32mremove_html_markup\u001b[39;49;00m(s):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   2      tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   3      quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   4      out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   5  \u001b[37m\u001b[39;49;00m\n",
      "   6      \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "   7          \u001b[34mif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m<\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "   8              tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   9          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "  10              tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "  11          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mor\u001b[39;49;00m c == \u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  12              quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "  13          \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  14>             out = out + c\u001b[37m\u001b[39;49;00m\n",
      "  15  \u001b[37m\u001b[39;49;00m\n",
      "  16      \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.227762Z",
     "iopub.status.busy": "2023-11-12T12:39:54.227438Z",
     "iopub.status.idle": "2023-11-12T12:39:54.229522Z",
     "shell.execute_reply": "2023-11-12T12:39:54.229191Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Quitting\n",
    "\n",
    "In the Python debugger interface, we can only observe, but not alter the control flow. To make sure we can always exit out of our debugging session, we introduce a `quit` command that deletes all breakpoints and resumes execution until the observed function finishes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.231764Z",
     "iopub.status.busy": "2023-11-12T12:39:54.231607Z",
     "iopub.status.idle": "2023-11-12T12:39:54.233878Z",
     "shell.execute_reply": "2023-11-12T12:39:54.233572Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def quit_command(self, arg: str = \"\") -> None:\n",
    "        \"\"\"Finish execution\"\"\"\n",
    "\n",
    "        self.breakpoints = set()\n",
    "        self.stepping = False\n",
    "        self.interact = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "With this, our command palette is pretty complete, and we can use our debugger to happily inspect Python executions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.235632Z",
     "iopub.status.busy": "2023-11-12T12:39:54.235356Z",
     "iopub.status.idle": "2023-11-12T12:39:54.237356Z",
     "shell.execute_reply": "2023-11-12T12:39:54.237034Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"help\", \"quit\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.239112Z",
     "iopub.status.busy": "2023-11-12T12:39:54.238978Z",
     "iopub.status.idle": "2023-11-12T12:39:54.244841Z",
     "shell.execute_reply": "2023-11-12T12:39:54.244549Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>help</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "break      -- Set a breakoint in given line. If no line is given, list all breakpoints\n",
      "continue   -- Resume execution\n",
      "delete     -- Delete breakoint in line given by `arg`.\n",
      "           Without given line, clear all breakpoints\n",
      "help       -- Give help on given `command`. If no command is given, give help on all\n",
      "list       -- Show current function. If `arg` is given, show its source code.\n",
      "print      -- Print an expression. If no expression is given, print all variables\n",
      "quit       -- Finish execution\n",
      "step       -- Execute up to the next line\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>quit</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.248775Z",
     "iopub.status.busy": "2023-11-12T12:39:54.248635Z",
     "iopub.status.idle": "2023-11-12T12:39:54.250552Z",
     "shell.execute_reply": "2023-11-12T12:39:54.250206Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Synopsis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This chapter provides an interactive debugger for Python functions. The debugger is invoked as\n",
    "\n",
    "```python\n",
    "with Debugger():\n",
    "    function_to_be_observed()\n",
    "    ...\n",
    "```\n",
    "While running, you can enter _debugger commands_ at the `(debugger)` prompt. Here's an example session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.252088Z",
     "iopub.status.busy": "2023-11-12T12:39:54.251968Z",
     "iopub.status.idle": "2023-11-12T12:39:54.254249Z",
     "shell.execute_reply": "2023-11-12T12:39:54.253976Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "_, remove_html_markup_starting_line_number = \\\n",
    "    inspect.getsourcelines(remove_html_markup)\n",
    "next_inputs([\"help\", f\"break {remove_html_markup_starting_line_number + 13}\",\n",
    "             \"list\", \"continue\", \"step\", \"print out\", \"quit\"])\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.255788Z",
     "iopub.status.busy": "2023-11-12T12:39:54.255680Z",
     "iopub.status.idle": "2023-11-12T12:39:54.310120Z",
     "shell.execute_reply": "2023-11-12T12:39:54.309753Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>help</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "break      -- Set a breakoint in given line. If no line is given, list all breakpoints\n",
      "continue   -- Resume execution\n",
      "delete     -- Delete breakoint in line given by `arg`.\n",
      "           Without given line, clear all breakpoints\n",
      "help       -- Give help on given `command`. If no command is given, give help on all\n",
      "list       -- Show current function. If `arg` is given, show its source code.\n",
      "print      -- Print an expression. If no expression is given, print all variables\n",
      "quit       -- Finish execution\n",
      "step       -- Execute up to the next line\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>break 14</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Breakpoints: {14}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>list</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1> \u001b[34mdef\u001b[39;49;00m \u001b[32mremove_html_markup\u001b[39;49;00m(s):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   2      tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   3      quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   4      out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   5  \u001b[37m\u001b[39;49;00m\n",
      "   6      \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "   7          \u001b[34mif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m<\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "   8              tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   9          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote:\u001b[37m\u001b[39;49;00m\n",
      "  10              tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "  11          \u001b[34melif\u001b[39;49;00m c == \u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m \u001b[35mor\u001b[39;49;00m c == \u001b[33m\"\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m \u001b[35mand\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  12              quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "  13          \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "  14#             out = out + c\u001b[37m\u001b[39;49;00m\n",
      "  15  \u001b[37m\u001b[39;49;00m\n",
      "  16      \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False, quote = False, out = '', c = 'a'\n",
      "14             out = out + c\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # out = 'a'\n",
      "6     for c in s:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print out</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out = 'a'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>quit</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    ret = remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.312115Z",
     "iopub.status.busy": "2023-11-12T12:39:54.311978Z",
     "iopub.status.idle": "2023-11-12T12:39:54.313607Z",
     "shell.execute_reply": "2023-11-12T12:39:54.313341Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `Debugger` class can be easily extended in subclasses. A new method `NAME_command(self, arg)` will be invoked whenever a command named `NAME` is entered, with `arg` holding given command arguments (empty string if none)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.315228Z",
     "iopub.status.busy": "2023-11-12T12:39:54.315119Z",
     "iopub.status.idle": "2023-11-12T12:39:54.316574Z",
     "shell.execute_reply": "2023-11-12T12:39:54.316349Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "from ClassDiagram import display_class_hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.318862Z",
     "iopub.status.busy": "2023-11-12T12:39:54.318612Z",
     "iopub.status.idle": "2023-11-12T12:39:54.818301Z",
     "shell.execute_reply": "2023-11-12T12:39:54.817890Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 9.0.0 (20230911.1827)\n",
       " -->\n",
       "<!-- Pages: 1 -->\n",
       "<svg width=\"291pt\" height=\"408pt\"\n",
       " viewBox=\"0.00 0.00 290.62 407.75\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 403.75)\">\n",
       "<g id=\"a_graph0\"><a xlink:title=\"Debugger class hierarchy\">\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-403.75 286.62,-403.75 286.62,4 -4,4\"/>\n",
       "</a>\n",
       "</g>\n",
       "<!-- Debugger -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>Debugger</title>\n",
       "<g id=\"a_node1\"><a xlink:href=\"#\" xlink:title=\"class Debugger:&#10;Interactive Debugger\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"21,-0.5 21,-202.5 145,-202.5 145,-0.5 21,-0.5\"/>\n",
       "<text text-anchor=\"start\" x=\"51.12\" y=\"-186.2\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">Debugger</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"21,-177.25 145,-177.25\"/>\n",
       "<g id=\"a_node1_0\"><a xlink:href=\"#\" xlink:title=\"Debugger\">\n",
       "<g id=\"a_node1_1\"><a xlink:href=\"#\" xlink:title=\"__init__(self, *, file: &lt;class &#39;TextIO&#39;&gt; = &lt;ipykernel.iostream.OutStream object at 0x107c5cb50&gt;) &#45;&gt; None:&#10;Create a new interactive debugger.\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-164.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__init__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_2\"><a xlink:href=\"#\" xlink:title=\"break_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Set a breakoint in given line. If no line is given, list all breakpoints\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-152.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">break_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_3\"><a xlink:href=\"#\" xlink:title=\"command_method(self, command: str) &#45;&gt; Optional[Callable[[str], NoneType]]:&#10;Convert `command` into the method to be called.&#10;If the method is not found, return `None` instead.\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-141.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">command_method()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_4\"><a xlink:href=\"#\" xlink:title=\"commands(self) &#45;&gt; List[str]:&#10;Return a list of commands\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-130\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">commands()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_5\"><a xlink:href=\"#\" xlink:title=\"continue_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Resume execution\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-118.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">continue_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_6\"><a xlink:href=\"#\" xlink:title=\"delete_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Delete breakoint in line given by `arg`.&#10;Without given line, clear all breakpoints\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-107.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">delete_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_7\"><a xlink:href=\"#\" xlink:title=\"execute(self, command: str) &#45;&gt; None:&#10;Execute `command`\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-96.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">execute()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_8\"><a xlink:href=\"#\" xlink:title=\"help_command(self, command: str = &#39;&#39;) &#45;&gt; None:&#10;Give help on given `command`. If no command is given, give help on all\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-85\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">help_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_9\"><a xlink:href=\"#\" xlink:title=\"interaction_loop(self) &#45;&gt; None:&#10;Interact with the user\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-73.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">interaction_loop()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_10\"><a xlink:href=\"#\" xlink:title=\"list_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Show current function. If `arg` is given, show its source code.\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-62.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">list_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_11\"><a xlink:href=\"#\" xlink:title=\"print_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Print an expression. If no expression is given, print all variables\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-51.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">print_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_12\"><a xlink:href=\"#\" xlink:title=\"quit_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Finish execution\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-40\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">quit_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_13\"><a xlink:href=\"#\" xlink:title=\"step_command(self, arg: str = &#39;&#39;) &#45;&gt; None:&#10;Execute up to the next line\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-28.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">step_command()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_14\"><a xlink:href=\"#\" xlink:title=\"stop_here(self) &#45;&gt; bool:&#10;Return True if we should stop\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-17.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">stop_here()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_15\"><a xlink:href=\"#\" xlink:title=\"traceit(self, frame: frame, event: str, arg: Any) &#45;&gt; None:&#10;Tracing function; called at every line. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"29\" y=\"-7.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">traceit()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Tracer -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>Tracer</title>\n",
       "<g id=\"a_node2\"><a xlink:href=\"Tracer.ipynb\" xlink:title=\"class Tracer:&#10;A class for tracing a piece of code. Use as `with Tracer(): block()`\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"42,-239.5 42,-317.75 124,-317.75 124,-239.5 42,-239.5\"/>\n",
       "<text text-anchor=\"start\" x=\"63.5\" y=\"-301.45\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">Tracer</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"42,-292.5 124,-292.5\"/>\n",
       "<g id=\"a_node2_16\"><a xlink:href=\"#\" xlink:title=\"Tracer\">\n",
       "<g id=\"a_node2_17\"><a xlink:href=\"Tracer.ipynb\" xlink:title=\"__enter__(self) &#45;&gt; Any:&#10;Called at begin of `with` block. Turn tracing on.\">\n",
       "<text text-anchor=\"start\" x=\"50\" y=\"-280\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">__enter__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node2_18\"><a xlink:href=\"Tracer.ipynb\" xlink:title=\"__exit__(self, exc_tp: Type, exc_value: BaseException, exc_traceback: traceback) &#45;&gt; Optional[bool]:&#10;Called at end of `with` block. Turn tracing off.&#10;Return `None` if ok, not `None` if internal error.\">\n",
       "<text text-anchor=\"start\" x=\"50\" y=\"-268.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">__exit__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node2_19\"><a xlink:href=\"Tracer.ipynb\" xlink:title=\"__init__(self, file: &lt;class &#39;TextIO&#39;&gt; = &lt;ipykernel.iostream.OutStream object at 0x107c5cb50&gt;) &#45;&gt; None:&#10;Create a new tracer.&#10;If `file` is given, output to `file` instead of stdout.\">\n",
       "<text text-anchor=\"start\" x=\"50\" y=\"-257.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__init__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node2_20\"><a xlink:href=\"Tracer.ipynb\" xlink:title=\"traceit(self, frame: frame, event: str, arg: Any) &#45;&gt; None:&#10;Tracing function; called at every line. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"50\" y=\"-246.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">traceit()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Debugger&#45;&gt;Tracer -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>Debugger&#45;&gt;Tracer</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M83,-202.85C83,-211.37 83,-219.74 83,-227.6\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"79.5,-227.59 83,-237.59 86.5,-227.59 79.5,-227.59\"/>\n",
       "</g>\n",
       "<!-- StackInspector -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>StackInspector</title>\n",
       "<g id=\"a_node3\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"class StackInspector:&#10;Provide functions to inspect the stack\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"0,-354.75 0,-399.25 166,-399.25 166,-354.75 0,-354.75\"/>\n",
       "<text text-anchor=\"start\" x=\"36.5\" y=\"-382.95\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">StackInspector</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"0,-374 166,-374\"/>\n",
       "<g id=\"a_node3_21\"><a xlink:href=\"#\" xlink:title=\"StackInspector\">\n",
       "<g id=\"a_node3_22\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"_generated_function_cache = {}\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-360.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">_generated_function_cache</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Tracer&#45;&gt;StackInspector -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>Tracer&#45;&gt;StackInspector</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M83,-317.99C83,-326.32 83,-335.05 83,-343.14\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"79.5,-342.89 83,-352.89 86.5,-342.89 79.5,-342.89\"/>\n",
       "</g>\n",
       "<!-- Legend -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>Legend</title>\n",
       "<text text-anchor=\"start\" x=\"163.38\" y=\"-117.5\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"10.00\" fill=\"#6a0dad\">Legend</text>\n",
       "<text text-anchor=\"start\" x=\"163.38\" y=\"-107.5\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"169.38\" y=\"-107.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"8.00\">public_method()</text>\n",
       "<text text-anchor=\"start\" x=\"163.38\" y=\"-97.5\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"169.38\" y=\"-97.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"8.00\">private_method()</text>\n",
       "<text text-anchor=\"start\" x=\"163.38\" y=\"-87.5\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"169.38\" y=\"-87.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"8.00\">overloaded_method()</text>\n",
       "<text text-anchor=\"start\" x=\"163.38\" y=\"-78.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"9.00\">Hover over names to see doc</text>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x1086b2740>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "display_class_hierarchy(Debugger, \n",
    "                        public_methods=[\n",
    "                            Tracer.__init__,\n",
    "                            Tracer.__enter__,\n",
    "                            Tracer.__exit__,\n",
    "                            Tracer.traceit,\n",
    "                            Debugger.__init__,\n",
    "                        ],\n",
    "    project='debuggingbook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lessons Learned\n",
    "\n",
    "* _Debugging hooks_ from interpreted languages allow for simple interactive debugging.\n",
    "* A command-line debugging framework can be very easily extended with additional functionality."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Next Steps\n",
    "\n",
    "In the next chapter, we will see how [assertions](Assertions.ipynb) check correctness at runtime."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Background\n",
    "\n",
    "The command-line interface in this chapter is modeled after [GDB, the GNU debugger](https://www.gnu.org/software/gdb/), whose interface in turn goes back to earlier command-line debuggers such as [dbx](https://en.wikipedia.org/wiki/Dbx_%28debugger%29). All modern debuggers build on the functionality and concepts realized in these debuggers, be it breakpoints, stepping through programs, or inspecting program state.\n",
    "\n",
    "The concept of time travel debugging (see the Exercises, below) has been invented (and reinvented) many times. One of the most impactful tools comes from King et al. \\cite{King2005}, integrating _a time-traveling virtual machine_ (TTVM) for debugging operating systems, integrated into GDB. The recent [record+replay \"rr\" debugger](https://rr-project.org) also implements time travel debugging on top of the GDB command line debugger; it is applicable for general-purpose programs and available as open source."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercises\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "### Exercise 1: Changing State\n",
    "\n",
    "Some Python implementations allow altering the state by assigning values to `frame.f_locals`. Implement a `assign VAR=VALUE` command that allows changing the value of (local) variable `VAR` to the new value `VALUE`.\n",
    "\n",
    "Note: As detailed in [this blog post](https://utcc.utoronto.ca/~cks/space/blog/python/FLocalsAndTraceFunctions), \n",
    "`frame.f_locals` is re-populated with every access, so assign to our local alias `self.local_vars` instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "solution2": "hidden"
   },
   "source": [
    "**Solution.** Here is an `assign` command that gets things right on CPython."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.820410Z",
     "iopub.status.busy": "2023-11-12T12:39:54.820251Z",
     "iopub.status.idle": "2023-11-12T12:39:54.823143Z",
     "shell.execute_reply": "2023-11-12T12:39:54.822853Z"
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "class Debugger(Debugger):\n",
    "    def assign_command(self, arg: str) -> None:\n",
    "        \"\"\"Use as 'assign VAR=VALUE'. Assign VALUE to local variable VAR.\"\"\"\n",
    "\n",
    "        sep = arg.find('=')\n",
    "        if sep > 0:\n",
    "            var = arg[:sep].strip()\n",
    "            expr = arg[sep + 1:].strip()\n",
    "        else:\n",
    "            self.help_command(\"assign\")\n",
    "            return\n",
    "\n",
    "        vars = self.local_vars\n",
    "        try:\n",
    "            vars[var] = eval(expr, self.frame.f_globals, vars)\n",
    "        except Exception as err:\n",
    "            self.log(f\"{err.__class__.__name__}: {err}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.824827Z",
     "iopub.status.busy": "2023-11-12T12:39:54.824690Z",
     "iopub.status.idle": "2023-11-12T12:39:54.826615Z",
     "shell.execute_reply": "2023-11-12T12:39:54.826340Z"
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"assign s = 'xyz'\", \"print\", \"step\", \"print\", \"step\",\n",
    "             \"assign tag = True\", \"assign s = 'abc'\", \"print\",\n",
    "             \"step\", \"print\", \"continue\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.828432Z",
     "iopub.status.busy": "2023-11-12T12:39:54.828289Z",
     "iopub.status.idle": "2023-11-12T12:39:54.847334Z",
     "shell.execute_reply": "2023-11-12T12:39:54.847058Z"
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling remove_html_markup(s = 'abc')\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>assign s = 'xyz'</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'xyz'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # s = 'xyz'\n",
      "2     tag = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'xyz'\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # tag = False\n",
      "3     quote = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>assign tag = True</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>assign s = 'abc'</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n",
      "tag = True\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>step</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         # s = 'abc', tag = True, quote = False\n",
      "4     out = \"\"\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>print</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s = 'abc'\n",
      "tag = True\n",
      "quote = False\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<samp>(debugger) <b>continue</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Debugger():\n",
    "    remove_html_markup('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.849005Z",
     "iopub.status.busy": "2023-11-12T12:39:54.848868Z",
     "iopub.status.idle": "2023-11-12T12:39:54.850814Z",
     "shell.execute_reply": "2023-11-12T12:39:54.850401Z"
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "solution2": "hidden"
   },
   "outputs": [],
   "source": [
    "# docassert\n",
    "assert not next_inputs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 2: More Commands\n",
    "\n",
    "Extending the `Debugger` class with extra features and commands is a breeze. The following commands are inspired from [the GNU command-line debugger (GDB)](https://www.gnu.org/software/gdb/):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Named breakpoints (\"break\")\n",
    "\n",
    "With `break FUNCTION` and `delete FUNCTION`, set and delete a breakpoint at `FUNCTION`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Step over functions (\"next\")\n",
    "\n",
    "When stopped at a function call, the `next` command should execute the entire call, stopping when the function returns. (In contrast, `step` stops at the first line of the function called.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Print call stack (\"where\")\n",
    "\n",
    "Implement a `where` command that shows the stack of calling functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Move up and down the call stack (\"up\" and \"down\")\n",
    "\n",
    "After entering the `up` command, explore the source and variables of the _calling_ function rather than the current function. Use `up` repeatedly to move further up the stack. `down` returns to the caller."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Execute until line (\"until\")\n",
    "\n",
    "With `until LINE`, resume execution until a line greater than `LINE` is reached. If `LINE` is not given, resume execution until a line greater than the current is reached. This is useful to avoid stepping through multiple loop iterations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Execute until return (\"finish\")\n",
    "\n",
    "With `finish`, resume execution until the current function returns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Watchpoints (\"watch\")\n",
    "\n",
    "With `watch CONDITION`, stop execution as soon as `CONDITION` changes its value. (Use the code from our `EventTracer` class in the [chapter on Tracing](Tracer.ipynb).) `delete CONDITION` removes the watchpoint. Keep in mind that some variable names may not exist at all times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 3: Time-Travel Debugging\n",
    "\n",
    "Rather than inspecting a function at the moment it executes, you can also _record_ the entire state (call stack, local variables, etc.) during execution, and then run an interactive session to step through the recorded execution. Your time travel debugger would be invoked as\n",
    "\n",
    "```python\n",
    "with TimeTravelDebugger():\n",
    "    function_to_be_tracked()\n",
    "    ...\n",
    "```\n",
    "\n",
    "The interaction then starts at the end of the `with` block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Part 1: Recording Values\n",
    "\n",
    "Start with a subclass of `Tracer` from the [chapter on tracing](Tracer.ipynb) (say, `TimeTravelTracer`) to execute a program while recording all values. Keep in mind that recording even only local variables at each step quickly consumes large amounts of memory. As an alternative, consider recording only _changes_ to variables, with the option to restore an entire state from a baseline and later changes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Part 2: Command Line Interface\n",
    "\n",
    "Create `TimeTravelDebugger` as subclass of both `TimeTravelTracer` and `Debugger` to provide a command line interface as with `Debugger`, including additional commands which get you back to earlier states:\n",
    "\n",
    "* `back` is like `step`, except that you go one line back\n",
    "* `restart` gets you to the beginning of the execution\n",
    "* `rewind` gets you to the beginning of the current function invocation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Part 3: Graphical User Interface\n",
    "\n",
    "Create `GUItimeTravelDebugger` to provide a _graphical user interface_ that allows you to explore a recorded execution, using HTML and JavaScript."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's a simple example to get you started. Assume you have recorded the following line numbers and variable values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.853293Z",
     "iopub.status.busy": "2023-11-12T12:39:54.853026Z",
     "iopub.status.idle": "2023-11-12T12:39:54.855702Z",
     "shell.execute_reply": "2023-11-12T12:39:54.855465Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "recording: List[Tuple[int, Dict[str, Any]]] = [\n",
    "    (10, {'x': 25}),\n",
    "    (11, {'x': 25}),\n",
    "    (12, {'x': 26, 'a': \"abc\"}),\n",
    "    (13, {'x': 26, 'a': \"abc\"}),\n",
    "    (10, {'x': 30}),\n",
    "    (11, {'x': 30}),\n",
    "    (12, {'x': 31, 'a': \"def\"}),\n",
    "    (13, {'x': 31, 'a': \"def\"}),\n",
    "    (10, {'x': 35}),\n",
    "    (11, {'x': 35}),\n",
    "    (12, {'x': 36, 'a': \"ghi\"}),\n",
    "    (13, {'x': 36, 'a': \"ghi\"}),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Then, the following function will provide a _slider_ that will allow you to explore these values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.857501Z",
     "iopub.status.busy": "2023-11-12T12:39:54.857320Z",
     "iopub.status.idle": "2023-11-12T12:39:54.859127Z",
     "shell.execute_reply": "2023-11-12T12:39:54.858774Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.860940Z",
     "iopub.status.busy": "2023-11-12T12:39:54.860748Z",
     "iopub.status.idle": "2023-11-12T12:39:54.863532Z",
     "shell.execute_reply": "2023-11-12T12:39:54.863275Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def slider(rec: List[Tuple[int, Dict[str, Any]]]) -> str:\n",
    "    lines_over_time = [line for (line, var) in rec]\n",
    "    vars_over_time = []\n",
    "    for (line, vars) in rec:\n",
    "        vars_over_time.append(\", \".join(f\"{var} = {repr(value)}\"\n",
    "                                        for var, value in vars.items()))\n",
    "\n",
    "    # print(lines_over_time)\n",
    "    # print(vars_over_time)\n",
    "\n",
    "    template = f'''\n",
    "    <div class=\"time_travel_debugger\">\n",
    "      <input type=\"range\" min=\"0\" max=\"{len(lines_over_time) - 1}\"\n",
    "      value=\"0\" class=\"slider\" id=\"time_slider\">\n",
    "      Line <span id=\"line\">{lines_over_time[0]}</span>:\n",
    "      <span id=\"vars\">{vars_over_time[0]}</span>\n",
    "    </div>\n",
    "    <script>\n",
    "       var lines_over_time = {lines_over_time};\n",
    "       var vars_over_time = {vars_over_time};\n",
    "\n",
    "       var time_slider = document.getElementById(\"time_slider\");\n",
    "       var line = document.getElementById(\"line\");\n",
    "       var vars = document.getElementById(\"vars\");\n",
    "\n",
    "       time_slider.oninput = function() {{\n",
    "          line.innerHTML = lines_over_time[this.value];\n",
    "          vars.innerHTML = vars_over_time[this.value];\n",
    "       }}\n",
    "    </script>\n",
    "    '''\n",
    "    # print(template)\n",
    "    return HTML(template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:39:54.865010Z",
     "iopub.status.busy": "2023-11-12T12:39:54.864899Z",
     "iopub.status.idle": "2023-11-12T12:39:54.867110Z",
     "shell.execute_reply": "2023-11-12T12:39:54.866869Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div class=\"time_travel_debugger\">\n",
       "      <input type=\"range\" min=\"0\" max=\"11\"\n",
       "      value=\"0\" class=\"slider\" id=\"time_slider\">\n",
       "      Line <span id=\"line\">10</span>:\n",
       "      <span id=\"vars\">x = 25</span>\n",
       "    </div>\n",
       "    <script>\n",
       "       var lines_over_time = [10, 11, 12, 13, 10, 11, 12, 13, 10, 11, 12, 13];\n",
       "       var vars_over_time = ['x = 25', 'x = 25', \"x = 26, a = 'abc'\", \"x = 26, a = 'abc'\", 'x = 30', 'x = 30', \"x = 31, a = 'def'\", \"x = 31, a = 'def'\", 'x = 35', 'x = 35', \"x = 36, a = 'ghi'\", \"x = 36, a = 'ghi'\"];\n",
       "\n",
       "       var time_slider = document.getElementById(\"time_slider\");\n",
       "       var line = document.getElementById(\"line\");\n",
       "       var vars = document.getElementById(\"vars\");\n",
       "\n",
       "       time_slider.oninput = function() {\n",
       "          line.innerHTML = lines_over_time[this.value];\n",
       "          vars.innerHTML = vars_over_time[this.value];\n",
       "       }\n",
       "    </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slider(recording)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Explore the HTML and JavaScript details of how `slider()` works, and then expand it to a user interface where you can\n",
    "\n",
    "* see the current source code (together with the line being executed)\n",
    "* search for specific events, such as a line being executed or a variable changing its value\n",
    "\n",
    "Just like `slider()`, your user interface should come in pure HTML and JavaScript such that it can run in a browser (or a Jupyter notebook) without interacting with a Python program."
   ]
  }
 ],
 "metadata": {
  "ipub": {
   "bibliography": "fuzzingbook.bib",
   "toc": true
  },
  "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.10.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": false,
  "toc-showtags": false,
  "vscode": {
   "interpreter": {
    "hash": "0af4f07dd039d1b4e562c7a7d0340393b1c66f50605ac6af30beb81aa23b7ef5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}