{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tracking Failure Origins\n",
    "\n",
    "The question of \"Where does this value come from?\" is fundamental for debugging. Which earlier variables could possibly have influenced the current erroneous state? And how did their values come to be?\n",
    "\n",
    "When programmers read code during debugging, they scan it for potential _origins_ of given values. This can be a tedious experience, notably, if the origins spread across multiple separate locations, possibly even in different modules. In this chapter, we thus investigate means to _determine such origins_ automatically – by collecting data and control dependencies during program execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.061193Z",
     "iopub.status.busy": "2023-11-12T12:40:19.061034Z",
     "iopub.status.idle": "2023-11-12T12:40:19.101419Z",
     "shell.execute_reply": "2023-11-12T12:40:19.101120Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"640\"\n",
       "            height=\"360\"\n",
       "            src=\"https://www.youtube-nocookie.com/embed/sjf3cOR0lcI\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "            \n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1044f7520>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from bookutils import YouTubeVideo\n",
    "YouTubeVideo(\"sjf3cOR0lcI\")"
   ]
  },
  {
   "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 [Introduction to Debugging](Intro_Debugging).\n",
    "* To understand how to compute dependencies automatically (the second half of this chapter), you will need\n",
    "    * advanced knowledge of Python semantics\n",
    "    * knowledge on how to instrument and transform code\n",
    "    * knowledge on how an interpreter works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.122806Z",
     "iopub.status.busy": "2023-11-12T12:40:19.122599Z",
     "iopub.status.idle": "2023-11-12T12:40:19.125087Z",
     "shell.execute_reply": "2023-11-12T12:40:19.124754Z"
    },
    "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:40:19.126834Z",
     "iopub.status.busy": "2023-11-12T12:40:19.126701Z",
     "iopub.status.idle": "2023-11-12T12:40:19.128522Z",
     "shell.execute_reply": "2023-11-12T12:40:19.128246Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import quiz, next_inputs, print_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.130368Z",
     "iopub.status.busy": "2023-11-12T12:40:19.130231Z",
     "iopub.status.idle": "2023-11-12T12:40:19.131867Z",
     "shell.execute_reply": "2023-11-12T12:40:19.131609Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import inspect\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.133412Z",
     "iopub.status.busy": "2023-11-12T12:40:19.133303Z",
     "iopub.status.idle": "2023-11-12T12:40:19.135028Z",
     "shell.execute_reply": "2023-11-12T12:40:19.134779Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "from typing import Set, List, Tuple, Any, Callable, Dict, Optional\n",
    "from typing import Union, Type, Generator, cast"
   ]
  },
  {
   "attachments": {},
   "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.Slicer import <identifier>\n",
    "```\n",
    "\n",
    "and then make use of the following features.\n",
    "\n",
    "\n",
    "This chapter provides a `Slicer` class to automatically determine and visualize dynamic flows and dependencies. When we say that a variable $x$ _depends_ on a variable $y$ (and that $y$ _flows_ into $x$), we distinguish two kinds of dependencies:\n",
    "\n",
    "* **Data dependency**: $x$ is assigned a value computed from $y$.\n",
    "* **Control dependency**: A statement involving $x$ is executed _only_ because a _condition_ involving $y$ was evaluated, influencing the execution path.\n",
    "\n",
    "Such dependencies are crucial for debugging, as they allow determininh the origins of individual values (and notably incorrect values).\n",
    "\n",
    "To determine dynamic dependencies in a function `func`, use\n",
    "\n",
    "```python\n",
    "with Slicer() as slicer:\n",
    "    <Some call to func()>\n",
    "```\n",
    "\n",
    "and then `slicer.graph()` or `slicer.code()` to examine dependencies.\n",
    "\n",
    "You can also explicitly specify the functions to be instrumented, as in \n",
    "\n",
    "```python\n",
    "with Slicer(func, func_1, func_2) as slicer:\n",
    "    <Some call to func()>\n",
    "```\n",
    "\n",
    "Here is an example. The `demo()` function computes some number from `x`:\n",
    "\n",
    "```python\n",
    ">>> def demo(x: int) -> int:\n",
    ">>>     z = x\n",
    ">>>     while x <= z <= 64:\n",
    ">>>         z *= 2\n",
    ">>>     return z\n",
    "```\n",
    "By using `with Slicer()`, we first instrument `demo()` and then execute it:\n",
    "\n",
    "```python\n",
    ">>> with Slicer() as slicer:\n",
    ">>>     demo(10)\n",
    "```\n",
    "After execution is complete, you can output `slicer` to visualize the dependencies and flows as graph. Data dependencies are shown as black solid edges; control dependencies are shown as grey dashed edges. The arrows indicate influence: If $y$ depends on $x$ (and thus $x$ flows into $y$), then we have an arrow $x \\rightarrow y$.\n",
    "We see how the parameter `x` flows into `z`, which is returned after some computation that is control dependent on a `<test>` involving `z`.\n",
    "\n",
    "```python\n",
    ">>> slicer\n",
    "```\n",
    "![](PICS/Slicer-synopsis-1.svg)\n",
    "\n",
    "An alternate representation is `slicer.code()`, annotating the instrumented source code with (backward) dependencies. Data dependencies are shown with `<=`, control dependencies with `<-`; locations (lines) are shown in parentheses.\n",
    "\n",
    "```python\n",
    ">>> slicer.code()\n",
    "*    1 def demo(x: int) -> int:\n",
    "*    2     z = x  # <= x (1)\n",
    "*    3     while x <= z <= 64:  # <= x (1), z (4), z (2)\n",
    "*    4         z *= 2  # <= z (4), z (2); <- <test> (3)\n",
    "*    5     return z  # <= z (4)\n",
    "\n",
    "```\n",
    "Dependencies can also be retrieved programmatically. The `dependencies()` method returns a `Dependencies` object encapsulating the dependency graph.\n",
    "\n",
    "The method `all_vars()` returns all variables in the dependency graph. Each variable is encoded as a pair (_name_, _location_) where _location_ is a pair (_codename_, _lineno_).\n",
    "\n",
    "```python\n",
    ">>> slicer.dependencies().all_vars()\n",
    "{('<demo() return value>', (<function __main__.demo(x: int) -> int>, 5)),\n",
    " ('<test>', (<function __main__.demo(x: int) -> int>, 3)),\n",
    " ('x', (<function __main__.demo(x: int) -> int>, 1)),\n",
    " ('z', (<function __main__.demo(x: int) -> int>, 2)),\n",
    " ('z', (<function __main__.demo(x: int) -> int>, 4))}\n",
    "```\n",
    "`code()` and `graph()` methods can also be applied on dependencies. The method `backward_slice(var)` returns a backward slice for the given variable (again given as a pair (_name_, _location_)). To retrieve where `z` in Line 2 came from, use:\n",
    "\n",
    "```python\n",
    ">>> _, start_demo = inspect.getsourcelines(demo)\n",
    ">>> start_demo\n",
    "1\n",
    ">>> slicer.dependencies().backward_slice(('z', (demo, start_demo + 1))).graph()  # type: ignore\n",
    "```\n",
    "![](PICS/Slicer-synopsis-2.svg)\n",
    "\n",
    "Here are the classes defined in this chapter. A `Slicer` instruments a program, using a `DependencyTracker` at run time to collect `Dependencies`.\n",
    "\n",
    "![](PICS/Slicer-synopsis-3.svg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dependencies\n",
    "\n",
    "In the [Introduction to debugging](Intro_Debugging.ipynb), we have seen how faults in a program state propagate to eventually become visible as failures. This induces a debugging strategy called _tracking origins_:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "1. We start with a single faulty state _f_ – the failure.\n",
    "2. We determine _f_'s _origins_ – the parts of earlier states that could have caused the faulty state _f_.\n",
    "3. For each of these origins _e_, we determine whether they are faulty or not.\n",
    "4. For each of the faulty origins, we in turn determine _their_ origins.\n",
    "5. If we find a part of the state that is faulty, yet has only correct origins, we have found the defect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In all generality, a \"part of the state\" can be anything that can influence the program – some configuration setting, some database content, or the state of a device. Almost always, though, it is through _individual variables_ that a part of the state manifests itself.\n",
    "\n",
    "The good news is that variables do not take arbitrary values at arbitrary times – instead, they are set and accessed at precise moments in time, as determined by the program's semantics. This allows us to determine their _origins_ by reading program code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us assume you have a piece of code that reads as follows. The `middle()` function is supposed to return the \"middle\" number of three values `x`, `y`, and `z` – that is, the one number that neither is the minimum nor the maximum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.136793Z",
     "iopub.status.busy": "2023-11-12T12:40:19.136676Z",
     "iopub.status.idle": "2023-11-12T12:40:19.138564Z",
     "shell.execute_reply": "2023-11-12T12:40:19.138309Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def middle(x, y, z):  # type: ignore\n",
    "    if y < z:\n",
    "        if x < y:\n",
    "            return y\n",
    "        elif x < z:\n",
    "            return y\n",
    "    else:\n",
    "        if x > y:\n",
    "            return y\n",
    "        elif x > z:\n",
    "            return x\n",
    "    return z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In most cases, `middle()` runs just fine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.140161Z",
     "iopub.status.busy": "2023-11-12T12:40:19.140035Z",
     "iopub.status.idle": "2023-11-12T12:40:19.142345Z",
     "shell.execute_reply": "2023-11-12T12:40:19.142046Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = middle(1, 2, 3)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In others, however, it returns the wrong value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.144147Z",
     "iopub.status.busy": "2023-11-12T12:40:19.144012Z",
     "iopub.status.idle": "2023-11-12T12:40:19.146296Z",
     "shell.execute_reply": "2023-11-12T12:40:19.145950Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = middle(2, 1, 3)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is a typical debugging situation: You see a value that is erroneous; and you want to find out where it came from. \n",
    "\n",
    "* In our case, we see that the erroneous value was returned from `middle()`, so we identify the five `return` statements in `middle()` that the value could have come from.\n",
    "* The value returned is the value of `y`, and neither `x`, `y`, nor `z` are altered during the execution of `middle()`. Hence, it must be one of the three `return y` statements that is the origin of `m`. But which one?\n",
    "\n",
    "For our small example, we can fire up an interactive debugger and simply step through the function; this reveals us the conditions evaluated and the `return` statement executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.148073Z",
     "iopub.status.busy": "2023-11-12T12:40:19.147964Z",
     "iopub.status.idle": "2023-11-12T12:40:19.261207Z",
     "shell.execute_reply": "2023-11-12T12:40:19.260834Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import Debugger  # minor dependency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.263237Z",
     "iopub.status.busy": "2023-11-12T12:40:19.263094Z",
     "iopub.status.idle": "2023-11-12T12:40:19.264845Z",
     "shell.execute_reply": "2023-11-12T12:40:19.264555Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "next_inputs([\"step\", \"step\", \"step\", \"step\", \"quit\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.266448Z",
     "iopub.status.busy": "2023-11-12T12:40:19.266315Z",
     "iopub.status.idle": "2023-11-12T12:40:19.323633Z",
     "shell.execute_reply": "2023-11-12T12:40:19.323368Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling middle(x = 2, y = 1, z = 3)\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     if y < z:\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": [
      "3         if x < y:\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": [
      "5         elif x < z:\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": [
      "6             return y\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.Debugger():\n",
    "    middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We now see that it was the second `return` statement that returned the incorrect value. But why was it executed after all? To this end, we can resort to the `middle()` source code and have a look at those conditions that caused the `return y` statement to be executed. Indeed, the conditions `y < z`, `x > y`, and finally `x < z` again are _origins_ of the returned value – and in turn have `x`, `y`, and `z` as origins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In our above reasoning about origins, we have encountered two kinds of origins:\n",
    "\n",
    "* earlier _data values_ (such as the value of `y` being returned) and\n",
    "* earlier _control conditions_ (such as the `if` conditions governing the `return y` statement).\n",
    "\n",
    "The later parts of the state that can be influenced by such origins are said to be _dependent_ on these origins. Speaking of variables, a variable $x$ _depends_ on the value of a variable $y$ (written as $x \\leftarrow y$) if a change in $y$ could affect the value of $x$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We distinguish two kinds of dependencies $x \\leftarrow y$, aligned with the two kinds of origins as outlined above:\n",
    "\n",
    "* **Data dependency**: $x$ is assigned a value computed from $y$. In our example, `m` is data dependent on the return value of `middle()`.\n",
    "* **Control dependency**: A statement involving $x$ is executed _only_ because a _condition_ involving $y$ was evaluated, influencing the execution path. In our example, the value returned by `return y` is control dependent on the several conditions along its path, which involve `x`, `y`, and `z`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us examine these dependencies in more detail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Visualizing Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note: This is an excursion, diverting away from the main flow of the chapter. Unless you know what you are doing, you are encouraged to skip this part."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To illustrate our examples, we introduce a `Dependencies` class that captures dependencies between variables at specific locations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### A Class for Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`Dependencies` holds two dependency graphs. `data` holds data dependencies, `control` holds control dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Each of the two is organized as a dictionary holding _nodes_ as keys and sets of nodes as values. Each node comes as a tuple\n",
    "\n",
    "```python\n",
    "(variable_name, location)\n",
    " ```\n",
    " \n",
    "where `variable_name` is a string and `location` is a pair\n",
    "\n",
    "\n",
    "```python\n",
    "(func, lineno)\n",
    " ```\n",
    " \n",
    "denoting a unique location in the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is also reflected in the following type definitions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.326037Z",
     "iopub.status.busy": "2023-11-12T12:40:19.325812Z",
     "iopub.status.idle": "2023-11-12T12:40:19.327981Z",
     "shell.execute_reply": "2023-11-12T12:40:19.327645Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Location = Tuple[Callable, int]\n",
    "Node = Tuple[str, Location]\n",
    "Dependency = Dict[Node, Set[Node]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In this chapter, for many purposes, we need to lookup a function's location, source code, or simply definition. The class `StackInspector` provides a number of convenience functions for this purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.329655Z",
     "iopub.status.busy": "2023-11-12T12:40:19.329543Z",
     "iopub.status.idle": "2023-11-12T12:40:19.331404Z",
     "shell.execute_reply": "2023-11-12T12:40:19.331118Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from StackInspector import StackInspector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `Dependencies` class builds on `StackInspector` to capture dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.332943Z",
     "iopub.status.busy": "2023-11-12T12:40:19.332840Z",
     "iopub.status.idle": "2023-11-12T12:40:19.335433Z",
     "shell.execute_reply": "2023-11-12T12:40:19.335149Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(StackInspector):\n",
    "    \"\"\"A dependency graph\"\"\"\n",
    "\n",
    "    def __init__(self, \n",
    "                 data: Optional[Dependency] = None,\n",
    "                 control: Optional[Dependency] = None) -> None:\n",
    "        \"\"\"\n",
    "        Create a dependency graph from `data` and `control`.\n",
    "        Both `data` and `control` are dictionaries\n",
    "        holding _nodes_ as keys and sets of nodes as values.\n",
    "        Each node comes as a tuple (variable_name, location)\n",
    "        where `variable_name` is a string \n",
    "        and `location` is a pair (function, lineno)\n",
    "        where `function` is a callable and `lineno` is a line number\n",
    "        denoting a unique location in the code.\n",
    "        \"\"\"\n",
    "\n",
    "        if data is None:\n",
    "            data = {}\n",
    "        if control is None:\n",
    "            control = {}\n",
    "\n",
    "        self.data = data\n",
    "        self.control = control\n",
    "\n",
    "        for var in self.data:\n",
    "            self.control.setdefault(var, set())\n",
    "        for var in self.control:\n",
    "            self.data.setdefault(var, set())\n",
    "\n",
    "        self.validate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `validate()` method checks for consistency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.337081Z",
     "iopub.status.busy": "2023-11-12T12:40:19.336950Z",
     "iopub.status.idle": "2023-11-12T12:40:19.339392Z",
     "shell.execute_reply": "2023-11-12T12:40:19.339107Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def validate(self) -> None:\n",
    "        \"\"\"Check dependency structure.\"\"\"\n",
    "        assert isinstance(self.data, dict)\n",
    "        assert isinstance(self.control, dict)\n",
    "\n",
    "        for node in (self.data.keys()) | set(self.control.keys()):\n",
    "            var_name, location = node\n",
    "            assert isinstance(var_name, str)\n",
    "            func, lineno = location\n",
    "            assert callable(func)\n",
    "            assert isinstance(lineno, int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `source()` method returns the source code for a given node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.341234Z",
     "iopub.status.busy": "2023-11-12T12:40:19.341096Z",
     "iopub.status.idle": "2023-11-12T12:40:19.344375Z",
     "shell.execute_reply": "2023-11-12T12:40:19.343984Z"
    },
    "ipub": {
     "ignore": true
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def _source(self, node: Node) -> str:\n",
    "        # Return source line, or ''\n",
    "        (name, location) = node\n",
    "        func, lineno = location\n",
    "        if not func:  # type: ignore\n",
    "            # No source\n",
    "            return ''\n",
    "\n",
    "        try:\n",
    "            source_lines, first_lineno = inspect.getsourcelines(func)\n",
    "        except OSError:\n",
    "            warnings.warn(f\"Couldn't find source \"\n",
    "                          f\"for {func} ({func.__name__})\")\n",
    "            return ''\n",
    "\n",
    "        try:\n",
    "            line = source_lines[lineno - first_lineno].strip()\n",
    "        except IndexError:\n",
    "            return ''\n",
    "\n",
    "        return line\n",
    "\n",
    "    def source(self, node: Node) -> str:\n",
    "        \"\"\"Return the source code for a given node.\"\"\"\n",
    "        line = self._source(node)\n",
    "        if line:\n",
    "            return line\n",
    "\n",
    "        (name, location) = node\n",
    "        func, lineno = location\n",
    "        code_name = func.__name__\n",
    "\n",
    "        if code_name.startswith('<'):\n",
    "            return code_name\n",
    "        else:\n",
    "            return f'<{code_name}()>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.346164Z",
     "iopub.status.busy": "2023-11-12T12:40:19.346058Z",
     "iopub.status.idle": "2023-11-12T12:40:19.348743Z",
     "shell.execute_reply": "2023-11-12T12:40:19.348499Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'def middle(x, y, z):  # type: ignore'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_deps = Dependencies()\n",
    "test_deps.source(('z', (middle, 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Drawing Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Both data and control form a graph between nodes, and can be visualized as such. We use the `graphviz` package for creating such visualizations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.350264Z",
     "iopub.status.busy": "2023-11-12T12:40:19.350176Z",
     "iopub.status.idle": "2023-11-12T12:40:19.351903Z",
     "shell.execute_reply": "2023-11-12T12:40:19.351644Z"
    },
    "ipub": {
     "ignore": true
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from graphviz import Digraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`make_graph()` sets the basic graph attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.353350Z",
     "iopub.status.busy": "2023-11-12T12:40:19.353264Z",
     "iopub.status.idle": "2023-11-12T12:40:19.354849Z",
     "shell.execute_reply": "2023-11-12T12:40:19.354620Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.356268Z",
     "iopub.status.busy": "2023-11-12T12:40:19.356184Z",
     "iopub.status.idle": "2023-11-12T12:40:19.358786Z",
     "shell.execute_reply": "2023-11-12T12:40:19.358431Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    NODE_COLOR = 'peachpuff'\n",
    "    FONT_NAME = 'Courier'  # 'Fira Mono' may produce warnings in 'dot'\n",
    "\n",
    "    def make_graph(self,\n",
    "                   name: str = \"dependencies\",\n",
    "                   comment: str = \"Dependencies\") -> Digraph:\n",
    "        return Digraph(name=name, comment=comment,\n",
    "            graph_attr={\n",
    "            },\n",
    "            node_attr={\n",
    "                'style': 'filled',\n",
    "                'shape': 'box',\n",
    "                'fillcolor': self.NODE_COLOR,\n",
    "                'fontname': self.FONT_NAME\n",
    "            },\n",
    "            edge_attr={\n",
    "                'fontname': self.FONT_NAME\n",
    "            })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`graph()` returns a graph visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.360718Z",
     "iopub.status.busy": "2023-11-12T12:40:19.360569Z",
     "iopub.status.idle": "2023-11-12T12:40:19.363267Z",
     "shell.execute_reply": "2023-11-12T12:40:19.362919Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def graph(self, *, mode: str = 'flow') -> Digraph:\n",
    "        \"\"\"\n",
    "        Draw dependencies. `mode` is either\n",
    "        * `'flow'`: arrows indicate information flow (from A to B); or\n",
    "        * `'depend'`: arrows indicate dependencies (B depends on A)\n",
    "        \"\"\"\n",
    "        self.validate()\n",
    "\n",
    "        g = self.make_graph()\n",
    "        self.draw_dependencies(g, mode)\n",
    "        self.add_hierarchy(g)\n",
    "        return g\n",
    "\n",
    "    def _repr_mimebundle_(self, include: Any = None, exclude: Any = None) -> Any:\n",
    "        \"\"\"If the object is output in Jupyter, render dependencies as a SVG graph\"\"\"\n",
    "        return self.graph()._repr_mimebundle_(include, exclude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The main part of graph drawing takes place in two methods, `draw_dependencies()` and `add_hierarchy()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`draw_dependencies()` processes through the graph, adding nodes and edges from the dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.365002Z",
     "iopub.status.busy": "2023-11-12T12:40:19.364883Z",
     "iopub.status.idle": "2023-11-12T12:40:19.367479Z",
     "shell.execute_reply": "2023-11-12T12:40:19.367127Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def all_vars(self) -> Set[Node]:\n",
    "        \"\"\"Return a set of all variables (as `var_name`, `location`) in the dependencies\"\"\"\n",
    "        all_vars = set()\n",
    "        for var in self.data:\n",
    "            all_vars.add(var)\n",
    "            for source in self.data[var]:\n",
    "                all_vars.add(source)\n",
    "\n",
    "        for var in self.control:\n",
    "            all_vars.add(var)\n",
    "            for source in self.control[var]:\n",
    "                all_vars.add(source)\n",
    "\n",
    "        return all_vars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.369296Z",
     "iopub.status.busy": "2023-11-12T12:40:19.369169Z",
     "iopub.status.idle": "2023-11-12T12:40:19.372649Z",
     "shell.execute_reply": "2023-11-12T12:40:19.372327Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def draw_edge(self, g: Digraph, mode: str,\n",
    "                  node_from: str, node_to: str, **kwargs: Any) -> None:\n",
    "        if mode == 'flow':\n",
    "            g.edge(node_from, node_to, **kwargs)\n",
    "        elif mode == 'depend':\n",
    "            g.edge(node_from, node_to, dir=\"back\", **kwargs)\n",
    "        else:\n",
    "            raise ValueError(\"`mode` must be 'flow' or 'depend'\")\n",
    "\n",
    "    def draw_dependencies(self, g: Digraph, mode: str) -> None:\n",
    "        for var in self.all_vars():\n",
    "            g.node(self.id(var),\n",
    "                   label=self.label(var),\n",
    "                   tooltip=self.tooltip(var))\n",
    "\n",
    "            if var in self.data:\n",
    "                for source in self.data[var]:\n",
    "                    self.draw_edge(g, mode, self.id(source), self.id(var))\n",
    "\n",
    "            if var in self.control:\n",
    "                for source in self.control[var]:\n",
    "                    self.draw_edge(g, mode, self.id(source), self.id(var),\n",
    "                                   style='dashed', color='grey')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`draw_dependencies()` makes use of a few helper functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.374537Z",
     "iopub.status.busy": "2023-11-12T12:40:19.374392Z",
     "iopub.status.idle": "2023-11-12T12:40:19.378146Z",
     "shell.execute_reply": "2023-11-12T12:40:19.377770Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def id(self, var: Node) -> str:\n",
    "        \"\"\"Return a unique ID for `var`.\"\"\"\n",
    "        id = \"\"\n",
    "        # Avoid non-identifier characters\n",
    "        for c in repr(var):\n",
    "            if c.isalnum() or c == '_':\n",
    "                id += c\n",
    "            if c == ':' or c == ',':\n",
    "                id += '_'\n",
    "        return id\n",
    "\n",
    "    def label(self, var: Node) -> str:\n",
    "        \"\"\"Render node `var` using HTML style.\"\"\"\n",
    "        (name, location) = var\n",
    "        source = self.source(var)\n",
    "\n",
    "        title = html.escape(name)\n",
    "        if name.startswith('<'):\n",
    "            title = f'<I>{title}</I>'\n",
    "\n",
    "        label = f'<B>{title}</B>'\n",
    "        if source:\n",
    "            label += (f'<FONT POINT-SIZE=\"9.0\"><BR/><BR/>'\n",
    "                      f'{html.escape(source)}'\n",
    "                      f'</FONT>')\n",
    "        label = f'<{label}>'\n",
    "        return label\n",
    "\n",
    "    def tooltip(self, var: Node) -> str:\n",
    "        \"\"\"Return a tooltip for node `var`.\"\"\"\n",
    "        (name, location) = var\n",
    "        func, lineno = location\n",
    "        return f\"{func.__name__}:{lineno}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In the second part of graph drawing, `add_hierarchy()` adds invisible edges to ensure that nodes with lower line numbers are drawn above nodes with higher line numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.380189Z",
     "iopub.status.busy": "2023-11-12T12:40:19.380022Z",
     "iopub.status.idle": "2023-11-12T12:40:19.382653Z",
     "shell.execute_reply": "2023-11-12T12:40:19.382364Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def add_hierarchy(self, g: Digraph) -> Digraph:\n",
    "        \"\"\"Add invisible edges for a proper hierarchy.\"\"\"\n",
    "        functions = self.all_functions()\n",
    "        for func in functions:\n",
    "            last_var = None\n",
    "            last_lineno = 0\n",
    "            for (lineno, var) in functions[func]:\n",
    "                if last_var is not None and lineno > last_lineno:\n",
    "                    g.edge(self.id(last_var),\n",
    "                           self.id(var),\n",
    "                           style='invis')\n",
    "\n",
    "                last_var = var\n",
    "                last_lineno = lineno\n",
    "\n",
    "        return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.384206Z",
     "iopub.status.busy": "2023-11-12T12:40:19.384089Z",
     "iopub.status.idle": "2023-11-12T12:40:19.386927Z",
     "shell.execute_reply": "2023-11-12T12:40:19.386640Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def all_functions(self) -> Dict[Callable, List[Tuple[int, Node]]]:\n",
    "        \"\"\"\n",
    "        Return mapping \n",
    "        {`function`: [(`lineno`, `var`), (`lineno`, `var`), ...], ...}\n",
    "        for all functions in the dependencies.\n",
    "        \"\"\"\n",
    "        functions: Dict[Callable, List[Tuple[int, Node]]] = {}\n",
    "        for var in self.all_vars():\n",
    "            (name, location) = var\n",
    "            func, lineno = location\n",
    "            if func not in functions:\n",
    "                functions[func] = []\n",
    "            functions[func].append((lineno, var))\n",
    "\n",
    "        for func in functions:\n",
    "            functions[func].sort()\n",
    "\n",
    "        return functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here comes the graph in all its glory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.388465Z",
     "iopub.status.busy": "2023-11-12T12:40:19.388354Z",
     "iopub.status.idle": "2023-11-12T12:40:19.392377Z",
     "shell.execute_reply": "2023-11-12T12:40:19.391922Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def middle_deps() -> Dependencies:\n",
    "    return Dependencies({('z', (middle, 1)): set(), ('y', (middle, 1)): set(), ('x', (middle, 1)): set(), ('<test>', (middle, 2)): {('y', (middle, 1)), ('z', (middle, 1))}, ('<test>', (middle, 3)): {('y', (middle, 1)), ('x', (middle, 1))}, ('<test>', (middle, 5)): {('z', (middle, 1)), ('x', (middle, 1))}, ('<middle() return value>', (middle, 6)): {('y', (middle, 1))}}, {('z', (middle, 1)): set(), ('y', (middle, 1)): set(), ('x', (middle, 1)): set(), ('<test>', (middle, 2)): set(), ('<test>', (middle, 3)): {('<test>', (middle, 2))}, ('<test>', (middle, 5)): {('<test>', (middle, 3))}, ('<middle() return value>', (middle, 6)): {('<test>', (middle, 5))}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.394139Z",
     "iopub.status.busy": "2023-11-12T12:40:19.394039Z",
     "iopub.status.idle": "2023-11-12T12:40:19.867220Z",
     "shell.execute_reply": "2023-11-12T12:40:19.866835Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"463pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 462.65 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 458.65,-348 458.65,4 -4,4\"/>\n",
       "<!-- test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_3</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-192 239.4,-192 239.4,-152 304.9,-152 304.9,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if x &lt; y:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_5</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"309.03,-116 235.28,-116 235.28,-76 309.03,-76 309.03,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"243.28\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-151.56C265.48,-144.25 265.26,-135.75 265.49,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-128.01 266.05,-117.82 261.99,-127.61 268.98,-128.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<!-- x_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>x_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"221.65,-268 16.65,-268 16.65,-228 221.65,-228 221.65,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"115.03\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"24.65\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M159.35,-227.56C180.66,-217.25 206.85,-204.58 228.63,-194.05\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.09,-197.23 237.57,-189.73 227.04,-190.93 230.09,-197.23\"/>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M138.84,-227.7C165.69,-201.37 213.94,-154.07 244.44,-124.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"246.77,-126.79 251.46,-117.29 241.87,-121.79 246.77,-126.79\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>y_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"454.65,-344 249.65,-344 249.65,-304 454.65,-304 454.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"348.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"257.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M346.17,-303.74C339.66,-284.03 328.27,-252.87 314.15,-228 308.98,-218.89 302.46,-209.61 296.11,-201.32\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"298.98,-199.31 290.03,-193.65 293.49,-203.66 298.98,-199.31\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_2</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"middle:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-268 239.4,-268 239.4,-228 304.9,-228 304.9,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if y &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M331.13,-303.56C322.04,-295.14 311.24,-285.16 301.38,-276.04\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.86,-273.56 294.14,-269.34 299.11,-278.7 303.86,-273.56\"/>\n",
       "</g>\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"375.03,-40 169.28,-40 169.28,0 375.03,0 375.03,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"177.28\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"251.15\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M353.02,-303.76C354.23,-260.86 353.1,-154.97 318.15,-76 313.82,-66.22 307.22,-56.81 300.35,-48.62\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.17,-46.52 293.9,-41.39 297.95,-51.18 303.17,-46.52\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-227.56C265.48,-220.25 265.26,-211.75 265.49,-203.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-204.01 266.05,-193.82 261.99,-203.61 268.98,-204.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-75.56C265.48,-68.25 265.26,-59.75 265.49,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-52.01 266.05,-41.82 261.99,-51.61 268.98,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>z_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"231.65,-344 26.65,-344 26.65,-304 231.65,-304 231.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"125.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"34.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M160.7,-303.56C180.87,-292.61 207.18,-279.01 229.22,-268.12\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.52,-271.37 237.97,-263.83 227.45,-265.09 230.52,-271.37\"/>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M51.33,-303.64C33.92,-295.53 17.55,-284.1 7.15,-268 -2.5,-253.07 -2.23,-243.1 7.15,-228 54.57,-151.66 161.1,-118.47 223.69,-105.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"224.26,-108.56 233.36,-103.14 222.87,-101.71 224.26,-108.56\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Dependencies at 0x1048d55d0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "middle_deps()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "By default, the arrow direction indicates _flows_ – an arrow _A_ → _B_ indicates that information from _A_ _flows_ into _B_ (and thus the state in _A_ _causes_ the state in _B_). By setting the extra keyword parameter `mode` to `depend` instead of `flow` (default), you can reverse these arrows; then an arrow _A_ → _B_ indicates _A_ _depends_ on _B_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:19.869164Z",
     "iopub.status.busy": "2023-11-12T12:40:19.868880Z",
     "iopub.status.idle": "2023-11-12T12:40:20.297356Z",
     "shell.execute_reply": "2023-11-12T12:40:20.296934Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"463pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 462.65 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 458.65,-348 458.65,4 -4,4\"/>\n",
       "<!-- test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_3</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-192 239.4,-192 239.4,-152 304.9,-152 304.9,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if x &lt; y:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_5</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"309.03,-116 235.28,-116 235.28,-76 309.03,-76 309.03,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"243.28\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M265.49,-140.19C265.26,-132.1 265.48,-123.61 266.14,-116.31\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"261.99,-140.26 266.04,-150.05 268.97,-139.86 261.99,-140.26\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<!-- x_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>x_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"221.65,-268 16.65,-268 16.65,-228 221.65,-228 221.65,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"115.03\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"24.65\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M169.54,-222.63C192.34,-211.6 218.66,-198.87 238.93,-189.07\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"168.19,-219.39 160.71,-226.9 171.24,-225.7 168.19,-219.39\"/>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M146.95,-219.75C177.48,-189.82 225.73,-142.52 252.54,-116.23\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"144.61,-217.14 139.92,-226.64 149.51,-222.14 144.61,-217.14\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>y_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"454.65,-344 249.65,-344 249.65,-304 454.65,-304 454.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"348.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"257.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M342.49,-292.92C335.76,-273.74 325.9,-248.69 314.15,-228 307.03,-215.46 297.36,-202.59 289.09,-192.46\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"339.15,-293.97 345.68,-302.3 345.77,-291.71 339.15,-293.97\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_2</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"middle:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-268 239.4,-268 239.4,-228 304.9,-228 304.9,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if y &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M322.77,-295.82C312.9,-286.69 302.11,-276.71 293.03,-268.31\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"320.3,-298.31 330.02,-302.53 325.06,-293.17 320.3,-298.31\"/>\n",
       "</g>\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"375.03,-40 169.28,-40 169.28,0 375.03,0 375.03,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"177.28\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"251.15\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M353.25,-292.29C353.83,-244.07 350.3,-148.64 318.15,-76 312.26,-62.68 302.14,-50.05 292.9,-40.26\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"349.75,-292.18 353.05,-302.24 356.75,-292.31 349.75,-292.18\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M265.49,-216.19C265.26,-208.1 265.48,-199.61 266.14,-192.31\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"261.99,-216.26 266.04,-226.05 268.97,-215.86 261.99,-216.26\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M265.49,-64.19C265.26,-56.1 265.48,-47.61 266.14,-40.31\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"261.99,-64.26 266.04,-74.05 268.97,-63.86 261.99,-64.26\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>z_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"231.65,-344 26.65,-344 26.65,-304 231.65,-304 231.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"125.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"34.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M170.7,-298.18C192.55,-286.53 218.9,-273.06 239.33,-263.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"169.18,-295.02 162.03,-302.84 172.5,-301.19 169.18,-295.02\"/>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M41.29,-298.5C27.76,-290.89 15.52,-280.96 7.15,-268 -2.5,-253.07 -2.23,-243.1 7.15,-228 57.52,-146.91 174.59,-114.5 234.85,-102.84\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"39.49,-301.51 49.98,-302.95 42.68,-295.28 39.49,-301.51\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x1048d6980>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "middle_deps().graph(mode='depend')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Slices\n",
    "\n",
    "The method `backward_slice(*critera, mode='cd')` returns a subset of dependencies, following dependencies backward from the given *slicing criteria* `criteria`. These criteria can be\n",
    "\n",
    "* variable names (such as `<test>`); or\n",
    "* `(function, lineno)` pairs (such as `(middle, 3)`); or\n",
    "* `(var_name, (function, lineno))` (such as `(`x`, (middle, 1))`) locations.\n",
    "\n",
    "The extra parameter `mode` controls which dependencies are to be followed:\n",
    "\n",
    "* **`d`** = data dependencies\n",
    "* **`c`** = control dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:20.299348Z",
     "iopub.status.busy": "2023-11-12T12:40:20.299099Z",
     "iopub.status.idle": "2023-11-12T12:40:20.301355Z",
     "shell.execute_reply": "2023-11-12T12:40:20.301082Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "Criterion = Union[str, Location, Node]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:20.302868Z",
     "iopub.status.busy": "2023-11-12T12:40:20.302745Z",
     "iopub.status.idle": "2023-11-12T12:40:20.308321Z",
     "shell.execute_reply": "2023-11-12T12:40:20.307978Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def expand_criteria(self, criteria: List[Criterion]) -> List[Node]:\n",
    "        \"\"\"Return list of vars matched by `criteria`.\"\"\"\n",
    "        all_vars = []\n",
    "        for criterion in criteria:\n",
    "            criterion_var = None\n",
    "            criterion_func = None\n",
    "            criterion_lineno = None\n",
    "\n",
    "            if isinstance(criterion, str):\n",
    "                criterion_var = criterion\n",
    "            elif len(criterion) == 2 and callable(criterion[0]):\n",
    "                criterion_func, criterion_lineno = criterion\n",
    "            elif len(criterion) == 2 and isinstance(criterion[0], str):\n",
    "                criterion_var = criterion[0]\n",
    "                criterion_func, criterion_lineno = criterion[1]\n",
    "            else:\n",
    "                raise ValueError(\"Invalid argument\")\n",
    "\n",
    "            for var in self.all_vars():\n",
    "                (var_name, location) = var\n",
    "                func, lineno = location\n",
    "\n",
    "                name_matches = (criterion_func is None or\n",
    "                                criterion_func == func or\n",
    "                                criterion_func.__name__ == func.__name__)\n",
    "\n",
    "                location_matches = (criterion_lineno is None or\n",
    "                                    criterion_lineno == lineno)\n",
    "\n",
    "                var_matches = (criterion_var is None or\n",
    "                               criterion_var == var_name)\n",
    "\n",
    "                if name_matches and location_matches and var_matches:\n",
    "                    all_vars.append(var)\n",
    "\n",
    "        return all_vars\n",
    "\n",
    "    def backward_slice(self, *criteria: Criterion, \n",
    "                       mode: str = 'cd', depth: int = -1) -> Dependencies:\n",
    "        \"\"\"\n",
    "        Create a backward slice from nodes `criteria`.\n",
    "        `mode` can contain 'c' (draw control dependencies)\n",
    "        and 'd' (draw data dependencies) (default: 'cd')\n",
    "        \"\"\"\n",
    "        data = {}\n",
    "        control = {}\n",
    "        queue = self.expand_criteria(criteria)  # type: ignore\n",
    "        seen = set()\n",
    "\n",
    "        while len(queue) > 0 and depth != 0:\n",
    "            var = queue[0]\n",
    "            queue = queue[1:]\n",
    "            seen.add(var)\n",
    "\n",
    "            if 'd' in mode:\n",
    "                # Follow data dependencies\n",
    "                data[var] = self.data[var]\n",
    "                for next_var in data[var]:\n",
    "                    if next_var not in seen:\n",
    "                        queue.append(next_var)\n",
    "            else:\n",
    "                data[var] = set()\n",
    "\n",
    "            if 'c' in mode:\n",
    "                # Follow control dependencies\n",
    "                control[var] = self.control[var]\n",
    "                for next_var in control[var]:\n",
    "                    if next_var not in seen:\n",
    "                        queue.append(next_var)\n",
    "            else:\n",
    "                control[var] = set()\n",
    "\n",
    "            depth -= 1\n",
    "\n",
    "        return Dependencies(data, control)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Data Dependencies\n",
    "\n",
    "Here is an example of a data dependency in our `middle()` program. The value `y` returned by `middle()` comes from the value `y` as originally passed as argument. We use arrows $x \\leftarrow y$ to indicate that a variable $x$ depends on an earlier variable $y$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:20.310400Z",
     "iopub.status.busy": "2023-11-12T12:40:20.310248Z",
     "iopub.status.idle": "2023-11-12T12:40:20.721073Z",
     "shell.execute_reply": "2023-11-12T12:40:20.720692Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"214pt\" height=\"124pt\"\n",
       " viewBox=\"0.00 0.00 213.75 124.00\" 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 120)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-120 209.75,-120 209.75,4 -4,4\"/>\n",
       "<!-- y_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>y_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"205.38,-116 0.38,-116 0.38,-76 205.38,-76 205.38,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"98.75\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"8.38\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"205.75,-40 0,-40 0,0 205.75,0 205.75,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"81.88\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M96.85,-75.56C96.2,-68.25 95.99,-59.75 96.21,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"99.7,-52.01 96.78,-41.82 92.71,-51.61 99.7,-52.01\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Dependencies at 0x1044f74c0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "middle_deps().backward_slice('<middle() return value>', mode='d')  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here, we can see that the value `y` in the return statement is data dependent on the value of `y` as passed to `middle()`. An alternate interpretation of this graph is a *data flow*: The value of `y` in the upper node _flows_ into the value of `y` in the lower node."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Since we consider the values of variables at specific locations in the program, such data dependencies can also be interpreted as dependencies between _statements_ – the above `return` statement thus is data dependent on the initialization of `y` in the upper node."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Control Dependencies\n",
    "\n",
    "Here is an example of a control dependency. The execution of the above `return` statement is controlled by the earlier test `x < z`. We use gray dashed lines to indicate control dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:20.723079Z",
     "iopub.status.busy": "2023-11-12T12:40:20.722948Z",
     "iopub.status.idle": "2023-11-12T12:40:21.160748Z",
     "shell.execute_reply": "2023-11-12T12:40:21.160327Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"214pt\" height=\"124pt\"\n",
       " viewBox=\"0.00 0.00 213.75 124.00\" 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 120)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-120 209.75,-120 209.75,4 -4,4\"/>\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"205.75,-40 0,-40 0,0 205.75,0 205.75,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"81.88\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_5</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"139.75,-116 66,-116 66,-76 139.75,-76 139.75,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"78.12\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"74\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M96.85,-75.56C96.2,-68.25 95.99,-59.75 96.21,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"99.7,-52.01 96.78,-41.82 92.71,-51.61 99.7,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Dependencies at 0x104ba0df0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "middle_deps().backward_slice('<middle() return value>', mode='c', depth=1)  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This test in turn is controlled by earlier tests, so the full chain of control dependencies looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:21.162745Z",
     "iopub.status.busy": "2023-11-12T12:40:21.162617Z",
     "iopub.status.idle": "2023-11-12T12:40:21.597107Z",
     "shell.execute_reply": "2023-11-12T12:40:21.596756Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"214pt\" height=\"276pt\"\n",
       " viewBox=\"0.00 0.00 213.75 276.00\" 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 272)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-272 209.75,-272 209.75,4 -4,4\"/>\n",
       "<!-- test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_3</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"135.62,-192 70.12,-192 70.12,-152 135.62,-152 135.62,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"78.12\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"79.25\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if x &lt; y:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_5</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"139.75,-116 66,-116 66,-76 139.75,-76 139.75,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"78.12\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"74\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M96.85,-151.56C96.2,-144.25 95.99,-135.75 96.21,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"99.7,-128.01 96.78,-117.82 92.71,-127.61 99.7,-128.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<!-- test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_2</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"135.62,-268 70.12,-268 70.12,-228 135.62,-228 135.62,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"78.12\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"79.25\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if y &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M96.85,-227.56C96.2,-220.25 95.99,-211.75 96.21,-203.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"99.7,-204.01 96.78,-193.82 92.71,-203.61 99.7,-204.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"205.75,-40 0,-40 0,0 205.75,0 205.75,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"81.88\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M96.85,-75.56C96.2,-68.25 95.99,-59.75 96.21,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"99.7,-52.01 96.78,-41.82 92.71,-51.61 99.7,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Dependencies at 0x104ba1900>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "middle_deps().backward_slice('<middle() return value>', mode='c')  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dependency Graphs\n",
    "\n",
    "The above `<test>` values (and their statements) are in turn also dependent on earlier data, namely the `x`, `y`, and `z` values as originally passed. We can draw all data and control dependencies in a single graph, called a _program dependency graph_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:21.598792Z",
     "iopub.status.busy": "2023-11-12T12:40:21.598673Z",
     "iopub.status.idle": "2023-11-12T12:40:22.003201Z",
     "shell.execute_reply": "2023-11-12T12:40:22.002818Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"463pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 462.65 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 458.65,-348 458.65,4 -4,4\"/>\n",
       "<!-- test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_3</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-192 239.4,-192 239.4,-152 304.9,-152 304.9,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if x &lt; y:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_5</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"309.03,-116 235.28,-116 235.28,-76 309.03,-76 309.03,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"243.28\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-151.56C265.48,-144.25 265.26,-135.75 265.49,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-128.01 266.05,-117.82 261.99,-127.61 268.98,-128.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_3&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<!-- x_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>x_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"221.65,-268 16.65,-268 16.65,-228 221.65,-228 221.65,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"115.03\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"24.65\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M159.35,-227.56C180.66,-217.25 206.85,-204.58 228.63,-194.05\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.09,-197.23 237.57,-189.73 227.04,-190.93 230.09,-197.23\"/>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M138.84,-227.7C165.69,-201.37 213.94,-154.07 244.44,-124.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"246.77,-126.79 251.46,-117.29 241.87,-121.79 246.77,-126.79\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>y_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"454.65,-344 249.65,-344 249.65,-304 454.65,-304 454.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"348.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"257.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M346.17,-303.74C339.66,-284.03 328.27,-252.87 314.15,-228 308.98,-218.89 302.46,-209.61 296.11,-201.32\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"298.98,-199.31 290.03,-193.65 293.49,-203.66 298.98,-199.31\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionmiddleat0x1048dec20_2</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"middle:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"304.9,-268 239.4,-268 239.4,-228 304.9,-228 304.9,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"247.4\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.53\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if y &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M331.13,-303.56C322.04,-295.14 311.24,-285.16 301.38,-276.04\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.86,-273.56 294.14,-269.34 299.11,-278.7 303.86,-273.56\"/>\n",
       "</g>\n",
       "<!-- middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"375.03,-40 169.28,-40 169.28,0 375.03,0 375.03,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"177.28\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"251.15\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x1048dec20_1&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M353.02,-303.76C354.23,-260.86 353.1,-154.97 318.15,-76 313.82,-66.22 307.22,-56.81 300.35,-48.62\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.17,-46.52 293.9,-41.39 297.95,-51.18 303.17,-46.52\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-227.56C265.48,-220.25 265.26,-211.75 265.49,-203.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-204.01 266.05,-193.82 261.99,-203.61 268.98,-204.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_2&#45;&gt;test_functionmiddleat0x1048dec20_3 -->\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M266.13,-75.56C265.48,-68.25 265.26,-59.75 265.49,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"268.98,-52.01 266.05,-41.82 261.99,-51.61 268.98,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x1048dec20_5&#45;&gt;middlereturnvalue_functionmiddleat0x1048dec20_6 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>z_functionmiddleat0x1048dec20_1</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"231.65,-344 26.65,-344 26.65,-304 231.65,-304 231.65,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"125.03\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"34.65\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M160.7,-303.56C180.87,-292.61 207.18,-279.01 229.22,-268.12\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.52,-271.37 237.97,-263.83 227.45,-265.09 230.52,-271.37\"/>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_2 -->\n",
       "<!-- z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x1048dec20_1&#45;&gt;test_functionmiddleat0x1048dec20_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M51.33,-303.64C33.92,-295.53 17.55,-284.1 7.15,-268 -2.5,-253.07 -2.23,-243.1 7.15,-228 54.57,-151.66 161.1,-118.47 223.69,-105.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"224.26,-108.56 233.36,-103.14 222.87,-101.71 224.26,-108.56\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Dependencies at 0x1044f45e0>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "middle_deps()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This graph now gives us an idea on how to proceed to track the origins of the `middle()` return value at the bottom. Its value can come from any of the origins – namely the initialization of `y` at the function call, or from the `<test>` that controls it. This test in turn depends on `x` and `z` and their associated statements, which we now can check one after the other."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note that all these dependencies in the graph are _dynamic_ dependencies – that is, they refer to statements actually evaluated in the run at hand, as well as the decisions made in that very run. There also are _static_ dependency graphs coming from static analysis of the code; but for debugging, _dynamic_ dependencies specific to the failing run are more useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Showing Dependencies with Code\n",
    "\n",
    "While a graph gives us a representation about which possible data and control flows to track, integrating dependencies with actual program code results in a compact representation that is easy to reason about."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Excursion: Listing Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To show dependencies as text, we introduce a method `format_var()` that shows a single node (a variable) as text. By default, a node is referenced as\n",
    "\n",
    "```python\n",
    "NAME (FUNCTION:LINENO)\n",
    "```\n",
    "\n",
    "However, within a given function, it makes no sense to re-state the function name again and again, so we have a shorthand\n",
    "\n",
    "```python\n",
    "NAME (LINENO)\n",
    "```\n",
    "\n",
    "to state a dependency to variable `NAME` in line `LINENO`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.005385Z",
     "iopub.status.busy": "2023-11-12T12:40:22.005247Z",
     "iopub.status.idle": "2023-11-12T12:40:22.008167Z",
     "shell.execute_reply": "2023-11-12T12:40:22.007775Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def format_var(self, var: Node, current_func: Optional[Callable] = None) -> str:\n",
    "        \"\"\"Return string for `var` in `current_func`.\"\"\"\n",
    "        name, location = var\n",
    "        func, lineno = location\n",
    "        if current_func and (func == current_func or func.__name__ == current_func.__name__):\n",
    "            return f\"{name} ({lineno})\"\n",
    "        else:\n",
    "            return f\"{name} ({func.__name__}:{lineno})\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`format_var()` is used extensively in the `__str__()` string representation of dependencies, listing all nodes and their data (`<=`) and control (`<-`) dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.010329Z",
     "iopub.status.busy": "2023-11-12T12:40:22.009967Z",
     "iopub.status.idle": "2023-11-12T12:40:22.014222Z",
     "shell.execute_reply": "2023-11-12T12:40:22.013868Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def __str__(self) -> str:\n",
    "        \"\"\"Return string representation of dependencies\"\"\"\n",
    "        self.validate()\n",
    "\n",
    "        out = \"\"\n",
    "        for func in self.all_functions():\n",
    "            code_name = func.__name__\n",
    "\n",
    "            if out != \"\":\n",
    "                out += \"\\n\"\n",
    "            out += f\"{code_name}():\\n\"\n",
    "\n",
    "            all_vars = list(set(self.data.keys()) | set(self.control.keys()))\n",
    "            all_vars.sort(key=lambda var: var[1][1])\n",
    "\n",
    "            for var in all_vars:\n",
    "                (name, location) = var\n",
    "                var_func, var_lineno = location\n",
    "                var_code_name = var_func.__name__\n",
    "\n",
    "                if var_code_name != code_name:\n",
    "                    continue\n",
    "\n",
    "                all_deps = \"\"\n",
    "                for (source, arrow) in [(self.data, \"<=\"), (self.control, \"<-\")]:\n",
    "                    deps = \"\"\n",
    "                    for data_dep in source[var]:\n",
    "                        if deps == \"\":\n",
    "                            deps = f\" {arrow} \"\n",
    "                        else:\n",
    "                            deps += \", \"\n",
    "                        deps += self.format_var(data_dep, func)\n",
    "\n",
    "                    if deps != \"\":\n",
    "                        if all_deps != \"\":\n",
    "                            all_deps += \";\"\n",
    "                        all_deps += deps\n",
    "\n",
    "                if all_deps == \"\":\n",
    "                    continue\n",
    "\n",
    "                out += (\"    \" + \n",
    "                        self.format_var(var, func) +\n",
    "                        all_deps + \"\\n\")\n",
    "\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here is a compact string representation of dependencies. We see how the (last) `middle() return value` has a data dependency to `y` in Line 1, and to the `<test>` in Line 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.016156Z",
     "iopub.status.busy": "2023-11-12T12:40:22.016004Z",
     "iopub.status.idle": "2023-11-12T12:40:22.018479Z",
     "shell.execute_reply": "2023-11-12T12:40:22.018098Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle():\n",
      "    <test> (2) <= z (1), y (1)\n",
      "    <test> (3) <= x (1), y (1); <- <test> (2)\n",
      "    <test> (5) <= x (1), z (1); <- <test> (3)\n",
      "    <middle() return value> (6) <= y (1); <- <test> (5)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(middle_deps())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `__repr__()` method shows a raw form of dependencies, useful for creating dependencies from scratch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.020239Z",
     "iopub.status.busy": "2023-11-12T12:40:22.020103Z",
     "iopub.status.idle": "2023-11-12T12:40:22.023339Z",
     "shell.execute_reply": "2023-11-12T12:40:22.023050Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def repr_var(self, var: Node) -> str:\n",
    "        name, location = var\n",
    "        func, lineno = location\n",
    "        return f\"({repr(name)}, ({func.__name__}, {lineno}))\"\n",
    "\n",
    "    def repr_deps(self, var_set: Set[Node]) -> str:\n",
    "        if len(var_set) == 0:\n",
    "            return \"set()\"\n",
    "\n",
    "        return (\"{\" +\n",
    "                \", \".join(f\"{self.repr_var(var)}\"\n",
    "                          for var in var_set) +\n",
    "                \"}\")\n",
    "\n",
    "    def repr_dependencies(self, vars: Dependency) -> str:\n",
    "        return (\"{\\n        \" +\n",
    "                \",\\n        \".join(\n",
    "                    f\"{self.repr_var(var)}: {self.repr_deps(vars[var])}\"\n",
    "                    for var in vars) +\n",
    "                \"}\")\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        \"\"\"Represent dependencies as a Python expression\"\"\"\n",
    "        # Useful for saving and restoring values\n",
    "        return (f\"Dependencies(\\n\" +\n",
    "                f\"    data={self.repr_dependencies(self.data)},\\n\" +\n",
    "                f\" control={self.repr_dependencies(self.control)})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.025017Z",
     "iopub.status.busy": "2023-11-12T12:40:22.024856Z",
     "iopub.status.idle": "2023-11-12T12:40:22.027138Z",
     "shell.execute_reply": "2023-11-12T12:40:22.026752Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dependencies(\n",
      "    data={\n",
      "        ('z', (middle, 1)): set(),\n",
      "        ('y', (middle, 1)): set(),\n",
      "        ('x', (middle, 1)): set(),\n",
      "        ('<test>', (middle, 2)): {('z', (middle, 1)), ('y', (middle, 1))},\n",
      "        ('<test>', (middle, 3)): {('x', (middle, 1)), ('y', (middle, 1))},\n",
      "        ('<test>', (middle, 5)): {('x', (middle, 1)), ('z', (middle, 1))},\n",
      "        ('<middle() return value>', (middle, 6)): {('y', (middle, 1))}},\n",
      " control={\n",
      "        ('z', (middle, 1)): set(),\n",
      "        ('y', (middle, 1)): set(),\n",
      "        ('x', (middle, 1)): set(),\n",
      "        ('<test>', (middle, 2)): set(),\n",
      "        ('<test>', (middle, 3)): {('<test>', (middle, 2))},\n",
      "        ('<test>', (middle, 5)): {('<test>', (middle, 3))},\n",
      "        ('<middle() return value>', (middle, 6)): {('<test>', (middle, 5))}})\n"
     ]
    }
   ],
   "source": [
    "print(repr(middle_deps()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "An even more useful representation comes when integrating these dependencies as comments into the code. The method `code(item_1, item_2, ...)` lists the given (function) items, including their dependencies; `code()` lists _all_ functions contained in the dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.028798Z",
     "iopub.status.busy": "2023-11-12T12:40:22.028655Z",
     "iopub.status.idle": "2023-11-12T12:40:22.033830Z",
     "shell.execute_reply": "2023-11-12T12:40:22.033510Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def code(self, *items: Callable, mode: str = 'cd') -> None:\n",
    "        \"\"\"\n",
    "        List `items` on standard output, including dependencies as comments. \n",
    "        If `items` is empty, all included functions are listed.\n",
    "        `mode` can contain 'c' (draw control dependencies) and 'd' (draw data dependencies)\n",
    "        (default: 'cd').\n",
    "        \"\"\"\n",
    "\n",
    "        if len(items) == 0:\n",
    "            items = cast(Tuple[Callable], self.all_functions().keys())\n",
    "\n",
    "        for i, item in enumerate(items):\n",
    "            if i > 0:\n",
    "                print()\n",
    "            self._code(item, mode)\n",
    "\n",
    "    def _code(self, item: Callable, mode: str) -> None:\n",
    "        # The functions in dependencies may be (instrumented) copies\n",
    "        # of the original function. Find the function with the same name.\n",
    "        func = item\n",
    "        for fn in self.all_functions():\n",
    "            if fn == item or fn.__name__ == item.__name__:\n",
    "                func = fn\n",
    "                break\n",
    "\n",
    "        all_vars = self.all_vars()\n",
    "        slice_locations = set(location for (name, location) in all_vars)\n",
    "\n",
    "        source_lines, first_lineno = inspect.getsourcelines(func)\n",
    "\n",
    "        n = first_lineno\n",
    "        for line in source_lines:\n",
    "            line_location = (func, n)\n",
    "            if line_location in slice_locations:\n",
    "                prefix = \"* \"\n",
    "            else:\n",
    "                prefix = \"  \"\n",
    "\n",
    "            print(f\"{prefix}{n:4} \", end=\"\")\n",
    "\n",
    "            comment = \"\"\n",
    "            for (mode_control, source, arrow) in [\n",
    "                ('d', self.data, '<='),\n",
    "                ('c', self.control, '<-')\n",
    "            ]:\n",
    "                if mode_control not in mode:\n",
    "                    continue\n",
    "\n",
    "                deps = \"\"\n",
    "                for var in source:\n",
    "                    name, location = var\n",
    "                    if location == line_location:\n",
    "                        for dep_var in source[var]:\n",
    "                            if deps == \"\":\n",
    "                                deps = arrow + \" \"\n",
    "                            else:\n",
    "                                deps += \", \"\n",
    "                            deps += self.format_var(dep_var, item)\n",
    "\n",
    "                if deps != \"\":\n",
    "                    if comment != \"\":\n",
    "                        comment += \"; \"\n",
    "                    comment += deps\n",
    "\n",
    "            if comment != \"\":\n",
    "                line = line.rstrip() + \"  # \" + comment\n",
    "\n",
    "            print_content(line.rstrip(), '.py')\n",
    "            print()\n",
    "            n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The following listing shows such an integration. For each executed line (`*`), we see its data (`<=`) and control (`<-`) dependencies, listing the associated variables and line numbers. The comment\n",
    "\n",
    "```python\n",
    "# <= y (1); <- <test> (5)\n",
    "```\n",
    "\n",
    "for Line 6, for instance, states that the return value is data dependent on the value of `y` in Line 1, and control dependent on the test in Line 5.\n",
    "\n",
    "Again, one can easily follow these dependencies back to track where a value came from (data dependencies) and why a statement was executed (control dependency)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.035448Z",
     "iopub.status.busy": "2023-11-12T12:40:22.035330Z",
     "iopub.status.idle": "2023-11-12T12:40:22.438804Z",
     "shell.execute_reply": "2023-11-12T12:40:22.438523Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*    1 \u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    2     \u001b[34mif\u001b[39;49;00m y < z:  \u001b[37m# <= z (1), y (1)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    3         \u001b[34mif\u001b[39;49;00m x < y:  \u001b[37m# <= x (1), y (1); <- <test> (2)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "     4             \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      "*    5         \u001b[34melif\u001b[39;49;00m x < z:  \u001b[37m# <= x (1), z (1); <- <test> (3)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    6             \u001b[34mreturn\u001b[39;49;00m y  \u001b[37m# <= y (1); <- <test> (5)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "     7     \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "     8         \u001b[34mif\u001b[39;49;00m x > y:\u001b[37m\u001b[39;49;00m\n",
      "     9             \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      "    10         \u001b[34melif\u001b[39;49;00m x > z:\u001b[37m\u001b[39;49;00m\n",
      "    11             \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m\n",
      "    12     \u001b[34mreturn\u001b[39;49;00m z\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "# ignore\n",
    "middle_deps().code()  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "One important aspect of dependencies is that they not only point to specific sources and causes of failures – but that they also _rule out_ parts of program and state as failures.\n",
    "\n",
    "* In the above code, Lines 8 and later have no influence on the output, simply because they were not executed.\n",
    "* Furthermore, we see that we can start our investigation with Line 6, because that is the last one executed.\n",
    "* The data dependencies tell us that no statement has interfered with the value of `y` between the function call and its return.\n",
    "* Hence, the error must be in the conditions or the final `return` statement.\n",
    "\n",
    "With this in mind, recall that our original invocation was `middle(2, 1, 3)`. Why and how is the above code wrong?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.440543Z",
     "iopub.status.busy": "2023-11-12T12:40:22.440415Z",
     "iopub.status.idle": "2023-11-12T12:40:22.445711Z",
     "shell.execute_reply": "2023-11-12T12:40:22.445418Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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\">Which of the following <code>middle()</code> code lines should be fixed?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Pick a choice.\">\n",
       "    \n",
       "        <input type=\"radio\" name=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790\" id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-1\" onclick=\"clear_selection('a53d0d8c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-1-label\" for=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-1\">Line 2: <code>if y &lt; z:</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790\" id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-2\" onclick=\"clear_selection('a53d0d8c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-2-label\" for=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-2\">Line 3: <code>if x &lt; y:</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790\" id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-3\" onclick=\"clear_selection('a53d0d8c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-3-label\" for=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-3\">Line 5: <code>elif x &lt; z:</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790\" id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-4\" onclick=\"clear_selection('a53d0d8c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-4-label\" for=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-4\">Line 6: <code>return z</code></label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('a53d0d8c-8158-11ee-a31f-6298cf1a5790', 16, 0, '(1 ** 0 + 1 ** 1) ** (1 ** 2 + 1 ** 3)')\">\n",
       "    <span class=\"quiz_hint\" id=\"a53d0d8c-8158-11ee-a31f-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"Which of the following `middle()` code lines should be fixed?\",\n",
    "    [\n",
    "        \"Line 2: `if y < z:`\",\n",
    "        \"Line 3: `if x < y:`\",\n",
    "        \"Line 5: `elif x < z:`\",\n",
    "        \"Line 6: `return z`\",\n",
    "    ], '(1 ** 0 + 1 ** 1) ** (1 ** 2 + 1 ** 3)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Indeed, from the controlling conditions, we see that `y < z`, `x >= y`, and `x < z` all hold. Hence, `y <= x < z` holds, and it is `x`, not `y`, that should be returned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slices\n",
    "\n",
    "Given a dependency graph for a particular variable, we can identify the subset of the program that could have influenced it – the so-called _slice_. In the above code listing, these code locations are highlighted with `*` characters. Only these locations are part of the slice."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Slices are central to debugging for two reasons:\n",
    "\n",
    "* First, they _rule out_ those locations of the program that could _not_ have an effect on the failure. Hence, these locations need not be investigated as it comes to searching for the defect. Nor do they need to be considered for a fix, as any change outside the program slice by construction cannot affect the failure.\n",
    "* Second, they bring together possible origins that may be scattered across the code. Many dependencies in program code are _non-local_, with references to functions, classes, and modules defined in other locations, files, or libraries. A slice brings together all those locations in a single whole."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here is an example of a slice – this time for our well-known `remove_html_markup()` function from [the introduction to debugging](Intro_Debugging.ipynb):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.448812Z",
     "iopub.status.busy": "2023-11-12T12:40:22.448649Z",
     "iopub.status.idle": "2023-11-12T12:40:22.452207Z",
     "shell.execute_reply": "2023-11-12T12:40:22.451843Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from Intro_Debugging import remove_html_markup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.454035Z",
     "iopub.status.busy": "2023-11-12T12:40:22.453919Z",
     "iopub.status.idle": "2023-11-12T12:40:22.487259Z",
     "shell.execute_reply": "2023-11-12T12:40:22.486914Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\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",
      "    tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34massert\u001b[39;49;00m tag \u001b[35mor\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "        \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",
      "            tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "        \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",
      "            tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "        \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",
      "            quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "            out = out + c\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "print_content(inspect.getsource(remove_html_markup), '.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When we invoke `remove_html_markup()` as follows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.489026Z",
     "iopub.status.busy": "2023-11-12T12:40:22.488888Z",
     "iopub.status.idle": "2023-11-12T12:40:22.491187Z",
     "shell.execute_reply": "2023-11-12T12:40:22.490907Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bar'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "remove_html_markup('<foo>bar</foo>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "... we obtain the following dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.493098Z",
     "iopub.status.busy": "2023-11-12T12:40:22.492957Z",
     "iopub.status.idle": "2023-11-12T12:40:22.498144Z",
     "shell.execute_reply": "2023-11-12T12:40:22.497846Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "def remove_html_markup_deps() -> Dependencies:\n",
    "    return Dependencies({('s', (remove_html_markup, 136)): set(), ('tag', (remove_html_markup, 137)): set(), ('quote', (remove_html_markup, 138)): set(), ('out', (remove_html_markup, 139)): set(), ('c', (remove_html_markup, 141)): {('s', (remove_html_markup, 136))}, ('<test>', (remove_html_markup, 144)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('tag', (remove_html_markup, 145)): set(), ('<test>', (remove_html_markup, 146)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('<test>', (remove_html_markup, 148)): {('c', (remove_html_markup, 141))}, ('<test>', (remove_html_markup, 150)): {('tag', (remove_html_markup, 147)), ('tag', (remove_html_markup, 145))}, ('tag', (remove_html_markup, 147)): set(), ('out', (remove_html_markup, 151)): {('out', (remove_html_markup, 151)), ('c', (remove_html_markup, 141)), ('out', (remove_html_markup, 139))}, ('<remove_html_markup() return value>', (remove_html_markup, 153)): {('<test>', (remove_html_markup, 146)), ('out', (remove_html_markup, 151))}}, {('s', (remove_html_markup, 136)): set(), ('tag', (remove_html_markup, 137)): set(), ('quote', (remove_html_markup, 138)): set(), ('out', (remove_html_markup, 139)): set(), ('c', (remove_html_markup, 141)): set(), ('<test>', (remove_html_markup, 144)): set(), ('tag', (remove_html_markup, 145)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 146)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 148)): {('<test>', (remove_html_markup, 146))}, ('<test>', (remove_html_markup, 150)): {('<test>', (remove_html_markup, 148))}, ('tag', (remove_html_markup, 147)): {('<test>', (remove_html_markup, 146))}, ('out', (remove_html_markup, 151)): {('<test>', (remove_html_markup, 150))}, ('<remove_html_markup() return value>', (remove_html_markup, 153)): set()})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.499739Z",
     "iopub.status.busy": "2023-11-12T12:40:22.499639Z",
     "iopub.status.idle": "2023-11-12T12:40:22.922816Z",
     "shell.execute_reply": "2023-11-12T12:40:22.922389Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"405pt\" height=\"960pt\"\n",
       " viewBox=\"0.00 0.00 404.75 960.00\" 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 956)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-956 400.75,-956 400.75,4 -4,4\"/>\n",
       "<!-- test_functionremove_html_markupat0x104965090_146 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x104965090_146</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"remove_html_markup:146\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"253.75,-420 122.25,-420 122.25,-380 253.75,-380 253.75,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"163.25\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"130.25\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_148 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x104965090_148</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"remove_html_markup:148\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"311.75,-268 180.25,-268 180.25,-228 311.75,-228 311.75,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"221.25\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"188.25\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_146&#45;&gt;test_functionremove_html_markupat0x104965090_148 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_146&#45;&gt;test_functionremove_html_markupat0x104965090_148</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M216.33,-379.55C227.44,-370.22 238.96,-358.02 245,-344 253.7,-323.8 253.61,-298.88 251.53,-279.62\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"255.03,-279.41 250.23,-269.96 248.09,-280.34 255.03,-279.41\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x104965090_147 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_147</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"remove_html_markup:147\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"235.75,-344 104.25,-344 104.25,-304 235.75,-304 235.75,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"157.62\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"112.25\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_146&#45;&gt;tag_functionremove_html_markupat0x104965090_147 -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_146&#45;&gt;tag_functionremove_html_markupat0x104965090_147</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M177.25,-379.56C174.79,-372.16 172.48,-363.55 170.74,-355.39\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"174.23,-355 168.96,-345.8 167.34,-356.27 174.23,-355\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_146&#45;&gt;tag_functionremove_html_markupat0x104965090_147 -->\n",
       "<!-- remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153</title>\n",
       "<g id=\"a_node13\"><a xlink:title=\"remove_html_markup:153\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"322.38,-40 17.62,-40 17.62,0 322.38,0 322.38,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"25.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;remove_html_markup() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"112.25\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_146&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153 -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_146&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M138.58,-379.66C122.42,-371.04 105.85,-359.3 95,-344 70.08,-308.88 76,-292.06 76,-249 76,-249 76,-249 76,-171 76,-127.94 71.85,-112.3 95,-76 102.26,-64.62 112.77,-54.81 123.64,-46.75\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"125.33,-49.84 131.55,-41.27 121.34,-44.09 125.33,-49.84\"/>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>quote_functionremove_html_markupat0x104965090_138</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"remove_html_markup:138\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"311.75,-800 180.25,-800 180.25,-760 311.75,-760 311.75,-800\"/>\n",
       "<text text-anchor=\"start\" x=\"225.38\" y=\"-783.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">quote</text>\n",
       "<text text-anchor=\"start\" x=\"188.25\" y=\"-765.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_146 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_146</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M280.68,-759.55C319.79,-734.77 378,-687.97 378,-629 378,-629 378,-629 378,-551 378,-488.26 313.38,-447.68 259.51,-424.75\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"260.88,-421.53 250.3,-420.98 258.23,-428.01 260.88,-421.53\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x104965090_144</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"remove_html_markup:144\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"235.75,-572 104.25,-572 104.25,-532 235.75,-532 235.75,-572\"/>\n",
       "<text text-anchor=\"start\" x=\"145.25\" y=\"-555.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"112.25\" y=\"-537.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_144</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M238.7,-759.57C229.19,-734.08 212.24,-687.9 199,-648 191.85,-626.45 184.38,-601.94 178.82,-583.21\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"182.23,-582.42 176.05,-573.82 175.52,-584.41 182.23,-582.42\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x104965090_139 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>out_functionremove_html_markupat0x104965090_139</title>\n",
       "<g id=\"a_node10\"><a xlink:title=\"remove_html_markup:139\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"151.75,-724 20.25,-724 20.25,-684 151.75,-684 151.75,-724\"/>\n",
       "<text text-anchor=\"start\" x=\"73.62\" y=\"-707.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">out</text>\n",
       "<text text-anchor=\"start\" x=\"28.25\" y=\"-689.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138&#45;&gt;out_functionremove_html_markupat0x104965090_139 -->\n",
       "<!-- c_functionremove_html_markupat0x104965090_141 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"remove_html_markup:141\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"339.75,-648 208.25,-648 208.25,-608 339.75,-608 339.75,-648\"/>\n",
       "<text text-anchor=\"start\" x=\"269.88\" y=\"-631.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">c</text>\n",
       "<text text-anchor=\"start\" x=\"216.25\" y=\"-613.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_146 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_146</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M268.85,-607.86C263.49,-588.52 254.55,-557.89 245,-532 231.93,-496.57 214.25,-456.95 202.06,-430.65\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"205.24,-429.2 197.84,-421.62 198.9,-432.16 205.24,-429.2\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"edge18\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M240.65,-607.56C227.57,-598.8 212.72,-588.35 199.98,-578.94\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"202.44,-576.41 192.34,-573.22 198.25,-582.02 202.44,-576.41\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_148 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_148</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M279.94,-607.8C288.16,-579.47 302,-524.68 302,-477 302,-477 302,-477 302,-399 302,-354.69 280.28,-307.39 263.9,-278.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"266.93,-276.27 258.91,-269.35 260.87,-279.77 266.93,-276.27\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x104965090_151 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>out_functionremove_html_markupat0x104965090_151</title>\n",
       "<g id=\"a_node9\"><a xlink:title=\"remove_html_markup:151\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"235.75,-116 104.25,-116 104.25,-76 235.75,-76 235.75,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"157.62\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">out</text>\n",
       "<text text-anchor=\"start\" x=\"112.25\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;out_functionremove_html_markupat0x104965090_151 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141&#45;&gt;out_functionremove_html_markupat0x104965090_151</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M288.65,-607.81C308.09,-580.38 340,-527.64 340,-477 340,-477 340,-477 340,-247 340,-186.92 279.56,-145.16 230.76,-121.23\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"232.45,-118.16 221.91,-117.04 229.45,-124.48 232.45,-118.16\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144&#45;&gt;test_functionremove_html_markupat0x104965090_146 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_144&#45;&gt;test_functionremove_html_markupat0x104965090_146</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M178.05,-531.52C181.89,-521.16 186.07,-508.1 188,-496 191.39,-474.76 191.32,-450.5 190.45,-431.81\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"193.95,-431.72 189.87,-421.94 186.96,-432.13 193.95,-431.72\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_145</title>\n",
       "<g id=\"a_node8\"><a xlink:title=\"remove_html_markup:145\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"178.75,-496 47.25,-496 47.25,-456 178.75,-456 178.75,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"100.62\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"55.25\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<g id=\"edge19\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M149,-531.56C142.21,-523.65 134.86,-514.36 128.51,-505.71\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"131.37,-503.69 122.74,-497.55 125.66,-507.73 131.37,-503.69\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<!-- test_functionremove_html_markupat0x104965090_150 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x104965090_150</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"remove_html_markup:150\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"235.75,-192 104.25,-192 104.25,-152 235.75,-152 235.75,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"145.25\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"112.25\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_148&#45;&gt;test_functionremove_html_markupat0x104965090_150 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_148&#45;&gt;test_functionremove_html_markupat0x104965090_150</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M220.01,-227.56C210.81,-219.31 200.61,-209.56 191.79,-200.59\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"194.33,-198.19 184.87,-193.4 189.28,-203.04 194.33,-198.19\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_148&#45;&gt;test_functionremove_html_markupat0x104965090_150 -->\n",
       "<!-- test_functionremove_html_markupat0x104965090_150&#45;&gt;out_functionremove_html_markupat0x104965090_151 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_150&#45;&gt;out_functionremove_html_markupat0x104965090_151</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M163.98,-151.56C163.32,-144.25 163.11,-135.75 163.34,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"166.82,-128.01 163.9,-117.82 159.84,-127.61 166.82,-128.01\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_150&#45;&gt;out_functionremove_html_markupat0x104965090_151 -->\n",
       "<!-- tag_functionremove_html_markupat0x104965090_147&#45;&gt;test_functionremove_html_markupat0x104965090_148 -->\n",
       "<!-- tag_functionremove_html_markupat0x104965090_147&#45;&gt;test_functionremove_html_markupat0x104965090_150 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_147&#45;&gt;test_functionremove_html_markupat0x104965090_150</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M170,-303.7C170,-278.38 170,-233.68 170,-203.69\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"173.5,-203.74 170,-193.74 166.5,-203.74 173.5,-203.74\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x104965090_145&#45;&gt;test_functionremove_html_markupat0x104965090_146 -->\n",
       "<!-- tag_functionremove_html_markupat0x104965090_145&#45;&gt;test_functionremove_html_markupat0x104965090_150 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_145&#45;&gt;test_functionremove_html_markupat0x104965090_150</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M106.5,-455.67C96.7,-423.61 80.73,-357.66 95,-304 105.21,-265.6 129.64,-226.73 147.86,-201.42\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"150.48,-203.76 153.6,-193.63 144.85,-199.61 150.48,-203.76\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x104965090_151&#45;&gt;out_functionremove_html_markupat0x104965090_151 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x104965090_151&#45;&gt;out_functionremove_html_markupat0x104965090_151</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M236,-109.12C246.54,-107.2 253.75,-102.83 253.75,-96 253.75,-91.95 251.21,-88.76 246.94,-86.43\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"248.04,-83.11 237.44,-83.35 245.87,-89.77 248.04,-83.11\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x104965090_151&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153 -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x104965090_151&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163.98,-75.56C163.32,-68.25 163.11,-59.75 163.34,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.82,-52.01 163.9,-41.82 159.84,-51.61 166.82,-52.01\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x104965090_151&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x104965090_153 -->\n",
       "<!-- out_functionremove_html_markupat0x104965090_139&#45;&gt;c_functionremove_html_markupat0x104965090_141 -->\n",
       "<!-- out_functionremove_html_markupat0x104965090_139&#45;&gt;out_functionremove_html_markupat0x104965090_151 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x104965090_139&#45;&gt;out_functionremove_html_markupat0x104965090_151</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M66.05,-683.69C40.65,-656.92 0,-605.83 0,-553 0,-553 0,-553 0,-247 0,-186.92 60.44,-145.16 109.24,-121.23\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"110.55,-124.48 118.09,-117.04 107.55,-118.16 110.55,-124.48\"/>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x104965090_136 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>s_functionremove_html_markupat0x104965090_136</title>\n",
       "<g id=\"a_node11\"><a xlink:title=\"remove_html_markup:136\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"396.75,-952 265.25,-952 265.25,-912 396.75,-912 396.75,-952\"/>\n",
       "<text text-anchor=\"start\" x=\"326.88\" y=\"-935.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">s</text>\n",
       "<text text-anchor=\"start\" x=\"273.25\" y=\"-917.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x104965090_136&#45;&gt;c_functionremove_html_markupat0x104965090_141 -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>s_functionremove_html_markupat0x104965090_136&#45;&gt;c_functionremove_html_markupat0x104965090_141</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M343.77,-911.51C349.66,-901.37 356,-888.5 359,-876 363.15,-858.71 362.44,-853.44 359,-836 345.88,-769.49 311.15,-697.47 290.37,-658.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"293.58,-656.93 285.75,-649.79 287.42,-660.25 293.58,-656.93\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x104965090_137 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_137</title>\n",
       "<g id=\"a_node12\"><a xlink:title=\"remove_html_markup:137\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"349.75,-876 218.25,-876 218.25,-836 349.75,-836 349.75,-876\"/>\n",
       "<text text-anchor=\"start\" x=\"271.62\" y=\"-859.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"226.25\" y=\"-841.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x104965090_136&#45;&gt;tag_functionremove_html_markupat0x104965090_137 -->\n",
       "<!-- tag_functionremove_html_markupat0x104965090_137&#45;&gt;quote_functionremove_html_markupat0x104965090_138 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x104cd74f0>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "remove_html_markup_deps().graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Again, we can read such a graph _forward_ (starting from, say, `s`) or _backward_ (starting from the return value). Starting forward, we see how the passed string `s` flows into the `for` loop, breaking `s` into individual characters `c` that are then checked on various occasions, before flowing into the `out` return value. We also see how the various `if` conditions are all influenced by `c`, `tag`, and `quote`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.925132Z",
     "iopub.status.busy": "2023-11-12T12:40:22.924911Z",
     "iopub.status.idle": "2023-11-12T12:40:22.930761Z",
     "shell.execute_reply": "2023-11-12T12:40:22.930361Z"
    },
    "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\">Why does the first line <code>tag = False</code> not influence anything?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Pick a choice.\">\n",
       "    \n",
       "        <input type=\"radio\" name=\"a58705fe-8158-11ee-a31f-6298cf1a5790\" id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-1\" onclick=\"clear_selection('a58705fe-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-1-label\" for=\"a58705fe-8158-11ee-a31f-6298cf1a5790-1\">Because the input contains only tags</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a58705fe-8158-11ee-a31f-6298cf1a5790\" id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-2\" onclick=\"clear_selection('a58705fe-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-2-label\" for=\"a58705fe-8158-11ee-a31f-6298cf1a5790-2\">Because <code>tag</code> is set to True with the first character</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a58705fe-8158-11ee-a31f-6298cf1a5790\" id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-3\" onclick=\"clear_selection('a58705fe-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-3-label\" for=\"a58705fe-8158-11ee-a31f-6298cf1a5790-3\">Because <code>tag</code> is not read by any variable</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"a58705fe-8158-11ee-a31f-6298cf1a5790\" id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-4\" onclick=\"clear_selection('a58705fe-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-4-label\" for=\"a58705fe-8158-11ee-a31f-6298cf1a5790-4\">Because the input contains no tags</label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('a58705fe-8158-11ee-a31f-6298cf1a5790', 4, 0, '(1 &lt;&lt; 1 + 1 &gt;&gt; 1)')\">\n",
       "    <span class=\"quiz_hint\" id=\"a58705fe-8158-11ee-a31f-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"Why does the first line `tag = False` not influence anything?\",\n",
    "    [\n",
    "        \"Because the input contains only tags\",\n",
    "        \"Because `tag` is set to True with the first character\",\n",
    "        \"Because `tag` is not read by any variable\",\n",
    "        \"Because the input contains no tags\",\n",
    "    ], '(1 << 1 + 1 >> 1)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Which are the locations that set `tag` to True? To this end, we compute the slice of `tag` at `tag = True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:22.932686Z",
     "iopub.status.busy": "2023-11-12T12:40:22.932559Z",
     "iopub.status.idle": "2023-11-12T12:40:23.346295Z",
     "shell.execute_reply": "2023-11-12T12:40:23.345862Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"234pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 233.50 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 229.5,-348 229.5,4 -4,4\"/>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"remove_html_markup:141\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"131.5,-192 0,-192 0,-152 131.5,-152 131.5,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"61.62\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">c</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x104965090_144</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"remove_html_markup:144\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"131.5,-116 0,-116 0,-76 131.5,-76 131.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"41\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M59.73,-151.56C59.07,-144.25 58.86,-135.75 59.09,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"62.57,-128.01 59.65,-117.82 55.59,-127.61 62.57,-128.01\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x104965090_141&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<!-- s_functionremove_html_markupat0x104965090_136 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>s_functionremove_html_markupat0x104965090_136</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"remove_html_markup:136\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"178.5,-344 47,-344 47,-304 178.5,-304 178.5,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"108.62\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">s</text>\n",
       "<text text-anchor=\"start\" x=\"55\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x104965090_136&#45;&gt;c_functionremove_html_markupat0x104965090_141 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>s_functionremove_html_markupat0x104965090_136&#45;&gt;c_functionremove_html_markupat0x104965090_141</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M101.29,-303.72C95.6,-293.42 89.04,-280.35 84.75,-268 77.48,-247.05 72.65,-222.47 69.69,-203.57\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"73.17,-203.22 68.26,-193.83 66.25,-204.23 73.17,-203.22\"/>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>quote_functionremove_html_markupat0x104965090_138</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"remove_html_markup:138\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"225.5,-268 94,-268 94,-228 225.5,-228 225.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"139.12\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">quote</text>\n",
       "<text text-anchor=\"start\" x=\"102\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x104965090_136&#45;&gt;quote_functionremove_html_markupat0x104965090_138 -->\n",
       "<!-- tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x104965090_145</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"remove_html_markup:145\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"131.5,-40 0,-40 0,0 131.5,0 131.5,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"53.38\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;remove_html_markup()&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M59.73,-75.56C59.07,-68.25 58.86,-59.75 59.09,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"62.57,-52.01 59.65,-41.82 55.59,-51.61 62.57,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x104965090_144&#45;&gt;tag_functionremove_html_markupat0x104965090_145 -->\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138&#45;&gt;c_functionremove_html_markupat0x104965090_141 -->\n",
       "<!-- quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_144 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x104965090_138&#45;&gt;test_functionremove_html_markupat0x104965090_144</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M159.89,-227.65C159.16,-207.31 155.49,-175.12 140.75,-152 133.49,-140.62 122.98,-130.81 112.11,-122.75\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"114.41,-120.09 104.2,-117.27 110.42,-125.84 114.41,-120.09\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        ('tag', (remove_html_markup, 145)): set(),\n",
       "        ('<test>', (remove_html_markup, 144)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))},\n",
       "        ('quote', (remove_html_markup, 138)): set(),\n",
       "        ('c', (remove_html_markup, 141)): {('s', (remove_html_markup, 136))},\n",
       "        ('s', (remove_html_markup, 136)): set()},\n",
       " control={\n",
       "        ('tag', (remove_html_markup, 145)): {('<test>', (remove_html_markup, 144))},\n",
       "        ('<test>', (remove_html_markup, 144)): set(),\n",
       "        ('quote', (remove_html_markup, 138)): set(),\n",
       "        ('c', (remove_html_markup, 141)): set(),\n",
       "        ('s', (remove_html_markup, 136)): set()})"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "tag_deps = Dependencies({('tag', (remove_html_markup, 145)): set(), ('<test>', (remove_html_markup, 144)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('quote', (remove_html_markup, 138)): set(), ('c', (remove_html_markup, 141)): {('s', (remove_html_markup, 136))}, ('s', (remove_html_markup, 136)): set()}, {('tag', (remove_html_markup, 145)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 144)): set(), ('quote', (remove_html_markup, 138)): set(), ('c', (remove_html_markup, 141)): set(), ('s', (remove_html_markup, 136)): set()})\n",
    "tag_deps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We see where the value of `tag` comes from: from the characters `c` in `s` as well as `quote`, which all cause it to be set. Again, we can combine these dependencies and the listing in a single, compact view. Note, again, that there are no other locations in the code that could possibly have affected `tag` in our run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.348156Z",
     "iopub.status.busy": "2023-11-12T12:40:23.348024Z",
     "iopub.status.idle": "2023-11-12T12:40:23.870783Z",
     "shell.execute_reply": "2023-11-12T12:40:23.870483Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   238 \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",
      "   239     tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   240     quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   241     out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   242 \u001b[37m\u001b[39;49;00m\n",
      "   243     \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:\u001b[37m\u001b[39;49;00m\n",
      "   244         \u001b[34massert\u001b[39;49;00m tag \u001b[35mor\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "   245 \u001b[37m\u001b[39;49;00m\n",
      "   246         \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",
      "   247             tag = \u001b[34mTrue\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   248         \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",
      "   249             tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   250         \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",
      "   251             quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "   252         \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:\u001b[37m\u001b[39;49;00m\n",
      "   253             out = out + c\u001b[37m\u001b[39;49;00m\n",
      "   254 \u001b[37m\u001b[39;49;00m\n",
      "   255     \u001b[34mreturn\u001b[39;49;00m out\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "# ignore\n",
    "tag_deps.code()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.872647Z",
     "iopub.status.busy": "2023-11-12T12:40:23.872522Z",
     "iopub.status.idle": "2023-11-12T12:40:23.877248Z",
     "shell.execute_reply": "2023-11-12T12:40:23.876924Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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\">How does the slice of <code>tag = True</code> change for a different value of <code>s</code>?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Check all that apply.\">\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"a61790d8-8158-11ee-a31f-6298cf1a5790\" id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-1\" onclick=\"clear_selection('a61790d8-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-1-label\" for=\"a61790d8-8158-11ee-a31f-6298cf1a5790-1\">Not at all</label><br>\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"a61790d8-8158-11ee-a31f-6298cf1a5790\" id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-2\" onclick=\"clear_selection('a61790d8-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-2-label\" for=\"a61790d8-8158-11ee-a31f-6298cf1a5790-2\">If <code>s</code> contains a quote, the <code>quote</code> slice is included, too</label><br>\n",
       "    \n",
       "        <input type=\"checkbox\" name=\"a61790d8-8158-11ee-a31f-6298cf1a5790\" id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-3\" onclick=\"clear_selection('a61790d8-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-3-label\" for=\"a61790d8-8158-11ee-a31f-6298cf1a5790-3\">If <code>s</code> contains no HTML tag, the slice will be empty</label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('a61790d8-8158-11ee-a31f-6298cf1a5790', 12, 1, '[1, 2, 3][1:]')\">\n",
       "    <span class=\"quiz_hint\" id=\"a61790d8-8158-11ee-a31f-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"How does the slice of `tag = True` change \"\n",
    "     \"for a different value of `s`?\",\n",
    "    [\n",
    "        \"Not at all\",\n",
    "        \"If `s` contains a quote, the `quote` slice is included, too\",\n",
    "        \"If `s` contains no HTML tag, the slice will be empty\"\n",
    "    ], '[1, 2, 3][1:]')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Indeed, our dynamic slices reflect dependencies as they occurred within a single execution. As the execution changes, so do the dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracking Techniques\n",
    "\n",
    "For the remainder of this chapter, let us investigate means to _determine such dependencies_ automatically – by _collecting_ them during program execution. The idea is that with a single Python call, we can collect the dependencies for some computation, and present them to programmers – as graphs or as code annotations, as shown above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To track dependencies, for every variable, we need to keep track of its _origins_ – where it obtained its value, and which tests controlled its assignments. There are two ways to do so:\n",
    "\n",
    "* Wrapping Data Objects\n",
    "* Wrapping Data Accesses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Wrapping Data Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "One way to track origins is to _wrap_ each value in a class that stores both a value and the origin of the value. If a variable `x` is initialized to zero in Line 3, for instance, we could store it as\n",
    "```\n",
    "x = (value=0, origin=<Line 3>)\n",
    "```\n",
    "and if it is copied in, say, Line 5 to another variable `y`, we could store this as\n",
    "```\n",
    "y = (value=0, origin=<Line 3, Line 5>)\n",
    "```\n",
    "Such a scheme would allow us to track origins and dependencies right within the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In a language like Python, it is actually possibly to subclass from basic types. Here's how we create a `MyInt` subclass of `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.879125Z",
     "iopub.status.busy": "2023-11-12T12:40:23.879005Z",
     "iopub.status.idle": "2023-11-12T12:40:23.881089Z",
     "shell.execute_reply": "2023-11-12T12:40:23.880781Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyInt(int):\n",
    "    def __new__(cls: Type, value: Any, *args: Any, **kwargs: Any) -> Any:\n",
    "        return super(cls, cls).__new__(cls, value)\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        return f\"{int(self)}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.882628Z",
     "iopub.status.busy": "2023-11-12T12:40:23.882519Z",
     "iopub.status.idle": "2023-11-12T12:40:23.884144Z",
     "shell.execute_reply": "2023-11-12T12:40:23.883904Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n: MyInt = MyInt(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can access `n` just like any integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.885830Z",
     "iopub.status.busy": "2023-11-12T12:40:23.885714Z",
     "iopub.status.idle": "2023-11-12T12:40:23.887848Z",
     "shell.execute_reply": "2023-11-12T12:40:23.887591Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n, n + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "However, we can also add extra attributes to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.889629Z",
     "iopub.status.busy": "2023-11-12T12:40:23.889504Z",
     "iopub.status.idle": "2023-11-12T12:40:23.891207Z",
     "shell.execute_reply": "2023-11-12T12:40:23.890929Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n.origin = \"Line 5\"  # type: ignore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.892748Z",
     "iopub.status.busy": "2023-11-12T12:40:23.892643Z",
     "iopub.status.idle": "2023-11-12T12:40:23.894669Z",
     "shell.execute_reply": "2023-11-12T12:40:23.894421Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Line 5'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.origin  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Such a \"wrapping\" scheme has the advantage of _leaving program code untouched_ – simply pass \"wrapped\" objects instead of the original values. However, it also has a number of drawbacks.\n",
    "\n",
    "* First, we must make sure that the \"wrapper\" objects are still compatible with the original values – notably by converting them back whenever needed. (What happens if an internal Python function expects an `int` and gets a `MyInt` instead?)\n",
    "* Second, we have to make sure that origins do not get lost during computations – which involves overloading operators such as `+`, `-`, `*`, and so on. (Right now, `MyInt(1) + 1` gives us an `int` object, not a `MyInt`.)\n",
    "* Third, we have to do this for _all_ data types of a language, which is pretty tedious.\n",
    "* Fourth and last, however, we want to track whenever a value is assigned to another variable. Python has no support for this, and thus our dependencies will necessarily be incomplete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Wrapping Data Accesses"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "An alternate way of tracking origins is to _instrument_ the source code such that all _data read and write operations are tracked_. That is, the original data stays unchanged, but we change the code instead.\n",
    "\n",
    "In essence, for every occurrence of a variable `x` being _read_, we replace it with\n",
    "\n",
    "```python\n",
    "_data.get('x', x)  # returns x\n",
    "```\n",
    "\n",
    "and for every occurrence of a value being _written_ to `x`, we replace the value with\n",
    "\n",
    "```python\n",
    "_data.set('x', value)  # returns value\n",
    "```\n",
    "\n",
    "and let the `_data` object track these reads and writes.\n",
    "\n",
    "Hence, an assignment such as\n",
    "\n",
    "```python\n",
    "a = b + c\n",
    "```\n",
    "\n",
    "would get rewritten to\n",
    "\n",
    "```python\n",
    "a = _data.set('a', _data.get('b', b) + _data.get('c', c))\n",
    "```\n",
    "\n",
    "and with every access to `_data`, we would track \n",
    "\n",
    "1. the current _location_ in the code, and \n",
    "2. whether the respective variable was read or written.\n",
    "\n",
    "For the above statement, we could deduce that `b` and `c` were read, and `a` was written – which makes `a` data dependent on `b` and `c`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The advantage of such instrumentation is that it works with _arbitrary objects_ (in Python, that is) – we do not care whether `a`, `b`, and `c` would be integers, floats, strings, lists or any other type for which `+` would be defined. Also, the code semantics remain entirely unchanged.\n",
    "\n",
    "The disadvantage, however, is that it takes a bit of effort to exactly separate reads and writes into individual groups, and that a number of language features have to be handled separately. This is what we do in the remainder of this chapter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Data Tracker\n",
    "\n",
    "To implement `_data` accesses as shown above, we introduce the `DataTracker` class. As its name suggests, it keeps track of variables being read and written, and provides methods to determine the code location where this took place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.896347Z",
     "iopub.status.busy": "2023-11-12T12:40:23.896240Z",
     "iopub.status.idle": "2023-11-12T12:40:23.898100Z",
     "shell.execute_reply": "2023-11-12T12:40:23.897851Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(StackInspector):\n",
    "    \"\"\"Track data accesses during execution\"\"\"\n",
    "\n",
    "    def __init__(self, log: bool = False) -> None:\n",
    "        \"\"\"Constructor. If `log` is set, turn on logging.\"\"\"\n",
    "        self.log = log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`set()` is invoked when a variable is set, as in\n",
    "\n",
    "```python\n",
    "pi = _data.set('pi', 3.1415)\n",
    "```\n",
    "\n",
    "By default, we simply log the access using name and value. (`loads` will be used later.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.899684Z",
     "iopub.status.busy": "2023-11-12T12:40:23.899575Z",
     "iopub.status.idle": "2023-11-12T12:40:23.901724Z",
     "shell.execute_reply": "2023-11-12T12:40:23.901485Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def set(self, name: str, value: Any, loads: Optional[Set[str]] = None) -> Any:\n",
    "        \"\"\"Track setting `name` to `value`.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: setting {name}\")\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`get()` is invoked when a variable is retrieved, as in\n",
    "\n",
    "```python\n",
    "print(_data.get('pi', pi))\n",
    "```\n",
    "By default, we simply log the access."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.903257Z",
     "iopub.status.busy": "2023-11-12T12:40:23.903134Z",
     "iopub.status.idle": "2023-11-12T12:40:23.905169Z",
     "shell.execute_reply": "2023-11-12T12:40:23.904932Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def get(self, name: str, value: Any) -> Any:\n",
    "        \"\"\"Track getting `value` from `name`.\"\"\"\n",
    "\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: getting {name}\")\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's an example of a logging `DataTracker`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.906824Z",
     "iopub.status.busy": "2023-11-12T12:40:23.906708Z",
     "iopub.status.idle": "2023-11-12T12:40:23.908588Z",
     "shell.execute_reply": "2023-11-12T12:40:23.908336Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<cell line: 2>:2: setting x\n"
     ]
    }
   ],
   "source": [
    "_test_data = DataTracker(log=True)\n",
    "x = _test_data.set('x', 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.910080Z",
     "iopub.status.busy": "2023-11-12T12:40:23.909978Z",
     "iopub.status.idle": "2023-11-12T12:40:23.911987Z",
     "shell.execute_reply": "2023-11-12T12:40:23.911750Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<cell line: 1>:1: getting x\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.get('x', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instrumenting Source Code\n",
    "\n",
    "How do we transform source code such that read and write accesses to variables would be automatically rewritten?  To this end, we inspect the internal representation of source code, namely the _abstract syntax trees_ (ASTs). An AST represents the code as a tree, with specific node types for each syntactical element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.913572Z",
     "iopub.status.busy": "2023-11-12T12:40:23.913469Z",
     "iopub.status.idle": "2023-11-12T12:40:23.914941Z",
     "shell.execute_reply": "2023-11-12T12:40:23.914722Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import ast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.916325Z",
     "iopub.status.busy": "2023-11-12T12:40:23.916244Z",
     "iopub.status.idle": "2023-11-12T12:40:23.917806Z",
     "shell.execute_reply": "2023-11-12T12:40:23.917580Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import show_ast"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is the tree representation for our `middle()` function. It starts with a `FunctionDef` node at the top (with the name `\"middle\"` and the three arguments `x`, `y`, `z` as children), followed by a subtree for each of the `If` statements, each of which contains a branch for when their condition evaluates to `True` and a branch for when their condition evaluates to `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:23.919215Z",
     "iopub.status.busy": "2023-11-12T12:40:23.919133Z",
     "iopub.status.idle": "2023-11-12T12:40:24.328725Z",
     "shell.execute_reply": "2023-11-12T12:40:24.328361Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"1862pt\" height=\"476pt\" viewBox=\"0.00 0.00 1862.00 476.00\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 472)\">\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-472 1858,-472 1858,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<text text-anchor=\"start\" x=\"197.62\" y=\"-445.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">FunctionDef</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<text text-anchor=\"middle\" x=\"67\" y=\"-372.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;middle&quot;</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0--1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M247,-431C247,-431 174.24,-413.42 117,-396 114.02,-395.09 110.95,-394.13 107.86,-393.13\"/>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<text text-anchor=\"start\" x=\"133.88\" y=\"-373.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">arguments</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>0--2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M247,-431C247,-431 217.68,-410.94 195.47,-395.74\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<text text-anchor=\"start\" x=\"464.75\" y=\"-373.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">If</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>0--9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M247,-431C247,-431 386.32,-398.94 446.19,-385.17\"/>\n",
       "</g>\n",
       "<!-- 70 -->\n",
       "<g id=\"node71\" class=\"node\">\n",
       "<title>70</title>\n",
       "<text text-anchor=\"start\" x=\"1129.25\" y=\"-373.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Return</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;70 -->\n",
       "<g id=\"edge70\" class=\"edge\">\n",
       "<title>0--70</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M247,-431C247,-431 959.36,-390.16 1121.45,-380.87\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<text text-anchor=\"start\" x=\"14.62\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">arg</text>\n",
       "</g>\n",
       "<!-- 2&#45;&#45;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>2--3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M158,-359C158,-359 104.5,-341.4 63,-324 59.94,-322.72 56.76,-321.32 53.62,-319.89\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<text text-anchor=\"start\" x=\"86.62\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">arg</text>\n",
       "</g>\n",
       "<!-- 2&#45;&#45;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>2--5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M158,-359C158,-359 135.24,-338.94 117.99,-323.74\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<text text-anchor=\"start\" x=\"158.62\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">arg</text>\n",
       "</g>\n",
       "<!-- 2&#45;&#45;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>2--7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M158,-359C158,-359 163.01,-338.94 166.82,-323.74\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<text text-anchor=\"middle\" x=\"27\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 3&#45;&#45;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3--4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M27,-288.05C27,-277.05 27,-262.76 27,-251.79\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<text text-anchor=\"middle\" x=\"99\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 5&#45;&#45;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5--6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M99,-288.05C99,-277.05 99,-262.76 99,-251.79\"/>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<text text-anchor=\"middle\" x=\"171\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;z&quot;</text>\n",
       "</g>\n",
       "<!-- 7&#45;&#45;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>7--8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M171,-288.05C171,-277.05 171,-262.76 171,-251.79\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<text text-anchor=\"start\" x=\"322.12\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Compare</text>\n",
       "</g>\n",
       "<!-- 9&#45;&#45;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>9--10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M490,-359C490,-359 428.7,-336.07 387.52,-320.66\"/>\n",
       "</g>\n",
       "<!-- 18 -->\n",
       "<g id=\"node19\" class=\"node\">\n",
       "<title>18</title>\n",
       "<text text-anchor=\"start\" x=\"594.75\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">If</text>\n",
       "</g>\n",
       "<!-- 9&#45;&#45;18 -->\n",
       "<g id=\"edge18\" class=\"edge\">\n",
       "<title>9--18</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M490,-359C490,-359 542.8,-334.7 576.22,-319.32\"/>\n",
       "</g>\n",
       "<!-- 44 -->\n",
       "<g id=\"node45\" class=\"node\">\n",
       "<title>44</title>\n",
       "<text text-anchor=\"start\" x=\"1314.75\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">If</text>\n",
       "</g>\n",
       "<!-- 9&#45;&#45;44 -->\n",
       "<g id=\"edge44\" class=\"edge\">\n",
       "<title>9--44</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M490,-359C490,-359 1153.65,-317.57 1296.23,-308.67\"/>\n",
       "</g>\n",
       "<!-- 11 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>11</title>\n",
       "<text text-anchor=\"start\" x=\"226.5\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 10&#45;&#45;11 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>10--11</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M345,-287C345,-287 300.02,-264.07 269.8,-248.66\"/>\n",
       "</g>\n",
       "<!-- 14 -->\n",
       "<g id=\"node15\" class=\"node\">\n",
       "<title>14</title>\n",
       "<text text-anchor=\"middle\" x=\"315\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Lt</text>\n",
       "</g>\n",
       "<!-- 10&#45;&#45;14 -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>10--14</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M345,-287C345,-287 333.43,-266.94 324.66,-251.74\"/>\n",
       "</g>\n",
       "<!-- 15 -->\n",
       "<g id=\"node16\" class=\"node\">\n",
       "<title>15</title>\n",
       "<text text-anchor=\"start\" x=\"370.5\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 10&#45;&#45;15 -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>10--15</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M345,-287C345,-287 361.2,-266.94 373.48,-251.74\"/>\n",
       "</g>\n",
       "<!-- 12 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>12</title>\n",
       "<text text-anchor=\"middle\" x=\"171\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 11&#45;&#45;12 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>11--12</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M236,-215C236,-215 210.93,-194.94 191.92,-179.74\"/>\n",
       "</g>\n",
       "<!-- 13 -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>13</title>\n",
       "<text text-anchor=\"middle\" x=\"243\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 11&#45;&#45;13 -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>11--13</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M236,-215C236,-215 238.7,-194.94 240.75,-179.74\"/>\n",
       "</g>\n",
       "<!-- 16 -->\n",
       "<g id=\"node17\" class=\"node\">\n",
       "<title>16</title>\n",
       "<text text-anchor=\"middle\" x=\"315\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;z&quot;</text>\n",
       "</g>\n",
       "<!-- 15&#45;&#45;16 -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>15--16</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M380,-215C380,-215 354.93,-194.94 335.92,-179.74\"/>\n",
       "</g>\n",
       "<!-- 17 -->\n",
       "<g id=\"node18\" class=\"node\">\n",
       "<title>17</title>\n",
       "<text text-anchor=\"middle\" x=\"387\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 15&#45;&#45;17 -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>15--17</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M380,-215C380,-215 382.7,-194.94 384.75,-179.74\"/>\n",
       "</g>\n",
       "<!-- 19 -->\n",
       "<g id=\"node20\" class=\"node\">\n",
       "<title>19</title>\n",
       "<text text-anchor=\"start\" x=\"516.12\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Compare</text>\n",
       "</g>\n",
       "<!-- 18&#45;&#45;19 -->\n",
       "<g id=\"edge19\" class=\"edge\">\n",
       "<title>18--19</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M613,-287C613,-287 586.77,-266.94 566.89,-251.74\"/>\n",
       "</g>\n",
       "<!-- 27 -->\n",
       "<g id=\"node28\" class=\"node\">\n",
       "<title>27</title>\n",
       "<text text-anchor=\"start\" x=\"636.25\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Return</text>\n",
       "</g>\n",
       "<!-- 18&#45;&#45;27 -->\n",
       "<g id=\"edge27\" class=\"edge\">\n",
       "<title>18--27</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M613,-287C613,-287 631.52,-266.94 645.55,-251.74\"/>\n",
       "</g>\n",
       "<!-- 31 -->\n",
       "<g id=\"node32\" class=\"node\">\n",
       "<title>31</title>\n",
       "<text text-anchor=\"start\" x=\"882.75\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">If</text>\n",
       "</g>\n",
       "<!-- 18&#45;&#45;31 -->\n",
       "<g id=\"edge31\" class=\"edge\">\n",
       "<title>18--31</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M613,-287C613,-287 794.32,-253.08 864.09,-240.03\"/>\n",
       "</g>\n",
       "<!-- 20 -->\n",
       "<g id=\"node21\" class=\"node\">\n",
       "<title>20</title>\n",
       "<text text-anchor=\"start\" x=\"442.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 19&#45;&#45;20 -->\n",
       "<g id=\"edge20\" class=\"edge\">\n",
       "<title>19--20</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M543,-215C543,-215 510.19,-194.69 485.58,-179.45\"/>\n",
       "</g>\n",
       "<!-- 23 -->\n",
       "<g id=\"node24\" class=\"node\">\n",
       "<title>23</title>\n",
       "<text text-anchor=\"middle\" x=\"531\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Lt</text>\n",
       "</g>\n",
       "<!-- 19&#45;&#45;23 -->\n",
       "<g id=\"edge23\" class=\"edge\">\n",
       "<title>19--23</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M543,-215C543,-215 538.37,-194.94 534.86,-179.74\"/>\n",
       "</g>\n",
       "<!-- 24 -->\n",
       "<g id=\"node25\" class=\"node\">\n",
       "<title>24</title>\n",
       "<text text-anchor=\"start\" x=\"586.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 19&#45;&#45;24 -->\n",
       "<g id=\"edge24\" class=\"edge\">\n",
       "<title>19--24</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M543,-215C543,-215 566.15,-194.94 583.69,-179.74\"/>\n",
       "</g>\n",
       "<!-- 21 -->\n",
       "<g id=\"node22\" class=\"node\">\n",
       "<title>21</title>\n",
       "<text text-anchor=\"middle\" x=\"387\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 20&#45;&#45;21 -->\n",
       "<g id=\"edge21\" class=\"edge\">\n",
       "<title>20--21</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M452,-143C452,-143 426.93,-122.94 407.92,-107.74\"/>\n",
       "</g>\n",
       "<!-- 22 -->\n",
       "<g id=\"node23\" class=\"node\">\n",
       "<title>22</title>\n",
       "<text text-anchor=\"middle\" x=\"459\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 20&#45;&#45;22 -->\n",
       "<g id=\"edge22\" class=\"edge\">\n",
       "<title>20--22</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M452,-143C452,-143 454.7,-122.94 456.75,-107.74\"/>\n",
       "</g>\n",
       "<!-- 25 -->\n",
       "<g id=\"node26\" class=\"node\">\n",
       "<title>25</title>\n",
       "<text text-anchor=\"middle\" x=\"531\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 24&#45;&#45;25 -->\n",
       "<g id=\"edge25\" class=\"edge\">\n",
       "<title>24--25</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M596,-143C596,-143 570.93,-122.94 551.92,-107.74\"/>\n",
       "</g>\n",
       "<!-- 26 -->\n",
       "<g id=\"node27\" class=\"node\">\n",
       "<title>26</title>\n",
       "<text text-anchor=\"middle\" x=\"603\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 24&#45;&#45;26 -->\n",
       "<g id=\"edge26\" class=\"edge\">\n",
       "<title>24--26</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M596,-143C596,-143 598.7,-122.94 600.75,-107.74\"/>\n",
       "</g>\n",
       "<!-- 28 -->\n",
       "<g id=\"node29\" class=\"node\">\n",
       "<title>28</title>\n",
       "<text text-anchor=\"start\" x=\"658.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 27&#45;&#45;28 -->\n",
       "<g id=\"edge28\" class=\"edge\">\n",
       "<title>27--28</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M664.39,-216.05C666.59,-205.05 669.45,-190.76 671.64,-179.79\"/>\n",
       "</g>\n",
       "<!-- 29 -->\n",
       "<g id=\"node30\" class=\"node\">\n",
       "<title>29</title>\n",
       "<text text-anchor=\"middle\" x=\"675\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 28&#45;&#45;29 -->\n",
       "<g id=\"edge29\" class=\"edge\">\n",
       "<title>28--29</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M682,-143C682,-143 679.3,-122.94 677.25,-107.74\"/>\n",
       "</g>\n",
       "<!-- 30 -->\n",
       "<g id=\"node31\" class=\"node\">\n",
       "<title>30</title>\n",
       "<text text-anchor=\"middle\" x=\"747\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 28&#45;&#45;30 -->\n",
       "<g id=\"edge30\" class=\"edge\">\n",
       "<title>28--30</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M682,-143C682,-143 707.07,-122.94 726.08,-107.74\"/>\n",
       "</g>\n",
       "<!-- 32 -->\n",
       "<g id=\"node33\" class=\"node\">\n",
       "<title>32</title>\n",
       "<text text-anchor=\"start\" x=\"862.12\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Compare</text>\n",
       "</g>\n",
       "<!-- 31&#45;&#45;32 -->\n",
       "<g id=\"edge32\" class=\"edge\">\n",
       "<title>31--32</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M901,-215C901,-215 897.14,-194.94 894.22,-179.74\"/>\n",
       "</g>\n",
       "<!-- 40 -->\n",
       "<g id=\"node41\" class=\"node\">\n",
       "<title>40</title>\n",
       "<text text-anchor=\"start\" x=\"982.25\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Return</text>\n",
       "</g>\n",
       "<!-- 31&#45;&#45;40 -->\n",
       "<g id=\"edge40\" class=\"edge\">\n",
       "<title>31--40</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M901,-215C901,-215 943.19,-194.3 974.33,-179.03\"/>\n",
       "</g>\n",
       "<!-- 33 -->\n",
       "<g id=\"node34\" class=\"node\">\n",
       "<title>33</title>\n",
       "<text text-anchor=\"start\" x=\"802.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 32&#45;&#45;33 -->\n",
       "<g id=\"edge33\" class=\"edge\">\n",
       "<title>32--33</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M891,-143C891,-143 863.23,-122.94 842.18,-107.74\"/>\n",
       "</g>\n",
       "<!-- 36 -->\n",
       "<g id=\"node37\" class=\"node\">\n",
       "<title>36</title>\n",
       "<text text-anchor=\"middle\" x=\"891\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Lt</text>\n",
       "</g>\n",
       "<!-- 32&#45;&#45;36 -->\n",
       "<g id=\"edge36\" class=\"edge\">\n",
       "<title>32--36</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M891,-143C891,-143 891,-122.94 891,-107.74\"/>\n",
       "</g>\n",
       "<!-- 37 -->\n",
       "<g id=\"node38\" class=\"node\">\n",
       "<title>37</title>\n",
       "<text text-anchor=\"start\" x=\"946.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 32&#45;&#45;37 -->\n",
       "<g id=\"edge37\" class=\"edge\">\n",
       "<title>32--37</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M891,-143C891,-143 918.77,-122.94 939.82,-107.74\"/>\n",
       "</g>\n",
       "<!-- 34 -->\n",
       "<g id=\"node35\" class=\"node\">\n",
       "<title>34</title>\n",
       "<text text-anchor=\"middle\" x=\"747\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 33&#45;&#45;34 -->\n",
       "<g id=\"edge34\" class=\"edge\">\n",
       "<title>33--34</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M812,-71C812,-71 786.93,-50.94 767.92,-35.74\"/>\n",
       "</g>\n",
       "<!-- 35 -->\n",
       "<g id=\"node36\" class=\"node\">\n",
       "<title>35</title>\n",
       "<text text-anchor=\"middle\" x=\"819\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 33&#45;&#45;35 -->\n",
       "<g id=\"edge35\" class=\"edge\">\n",
       "<title>33--35</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M812,-71C812,-71 814.7,-50.94 816.75,-35.74\"/>\n",
       "</g>\n",
       "<!-- 38 -->\n",
       "<g id=\"node39\" class=\"node\">\n",
       "<title>38</title>\n",
       "<text text-anchor=\"middle\" x=\"891\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;z&quot;</text>\n",
       "</g>\n",
       "<!-- 37&#45;&#45;38 -->\n",
       "<g id=\"edge38\" class=\"edge\">\n",
       "<title>37--38</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M956,-71C956,-71 930.93,-50.94 911.92,-35.74\"/>\n",
       "</g>\n",
       "<!-- 39 -->\n",
       "<g id=\"node40\" class=\"node\">\n",
       "<title>39</title>\n",
       "<text text-anchor=\"middle\" x=\"963\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 37&#45;&#45;39 -->\n",
       "<g id=\"edge39\" class=\"edge\">\n",
       "<title>37--39</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M956,-71C956,-71 958.7,-50.94 960.75,-35.74\"/>\n",
       "</g>\n",
       "<!-- 41 -->\n",
       "<g id=\"node42\" class=\"node\">\n",
       "<title>41</title>\n",
       "<text text-anchor=\"start\" x=\"1018.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 40&#45;&#45;41 -->\n",
       "<g id=\"edge41\" class=\"edge\">\n",
       "<title>40--41</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1013.78,-144.05C1018.18,-133.05 1023.89,-118.76 1028.28,-107.79\"/>\n",
       "</g>\n",
       "<!-- 42 -->\n",
       "<g id=\"node43\" class=\"node\">\n",
       "<title>42</title>\n",
       "<text text-anchor=\"middle\" x=\"1035\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 41&#45;&#45;42 -->\n",
       "<g id=\"edge42\" class=\"edge\">\n",
       "<title>41--42</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1042,-71C1042,-71 1039.3,-50.94 1037.25,-35.74\"/>\n",
       "</g>\n",
       "<!-- 43 -->\n",
       "<g id=\"node44\" class=\"node\">\n",
       "<title>43</title>\n",
       "<text text-anchor=\"middle\" x=\"1107\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 41&#45;&#45;43 -->\n",
       "<g id=\"edge43\" class=\"edge\">\n",
       "<title>41--43</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1042,-71C1042,-71 1067.07,-50.94 1086.08,-35.74\"/>\n",
       "</g>\n",
       "<!-- 45 -->\n",
       "<g id=\"node46\" class=\"node\">\n",
       "<title>45</title>\n",
       "<text text-anchor=\"start\" x=\"1236.12\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Compare</text>\n",
       "</g>\n",
       "<!-- 44&#45;&#45;45 -->\n",
       "<g id=\"edge45\" class=\"edge\">\n",
       "<title>44--45</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1332,-287C1332,-287 1306.15,-266.94 1286.57,-251.74\"/>\n",
       "</g>\n",
       "<!-- 53 -->\n",
       "<g id=\"node54\" class=\"node\">\n",
       "<title>53</title>\n",
       "<text text-anchor=\"start\" x=\"1356.25\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Return</text>\n",
       "</g>\n",
       "<!-- 44&#45;&#45;53 -->\n",
       "<g id=\"edge53\" class=\"edge\">\n",
       "<title>44--53</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1332,-287C1332,-287 1350.9,-266.94 1365.23,-251.74\"/>\n",
       "</g>\n",
       "<!-- 57 -->\n",
       "<g id=\"node58\" class=\"node\">\n",
       "<title>57</title>\n",
       "<text text-anchor=\"start\" x=\"1533.75\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">If</text>\n",
       "</g>\n",
       "<!-- 44&#45;&#45;57 -->\n",
       "<g id=\"edge57\" class=\"edge\">\n",
       "<title>44--57</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1332,-287C1332,-287 1458.9,-255.58 1515.4,-241.59\"/>\n",
       "</g>\n",
       "<!-- 46 -->\n",
       "<g id=\"node47\" class=\"node\">\n",
       "<title>46</title>\n",
       "<text text-anchor=\"start\" x=\"1162.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 45&#45;&#45;46 -->\n",
       "<g id=\"edge46\" class=\"edge\">\n",
       "<title>45--46</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1263,-215C1263,-215 1230.19,-194.69 1205.58,-179.45\"/>\n",
       "</g>\n",
       "<!-- 49 -->\n",
       "<g id=\"node50\" class=\"node\">\n",
       "<title>49</title>\n",
       "<text text-anchor=\"middle\" x=\"1251\" y=\"-156.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Gt</text>\n",
       "</g>\n",
       "<!-- 45&#45;&#45;49 -->\n",
       "<g id=\"edge49\" class=\"edge\">\n",
       "<title>45--49</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1263,-215C1263,-215 1258.37,-194.94 1254.86,-179.74\"/>\n",
       "</g>\n",
       "<!-- 50 -->\n",
       "<g id=\"node51\" class=\"node\">\n",
       "<title>50</title>\n",
       "<text text-anchor=\"start\" x=\"1306.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 45&#45;&#45;50 -->\n",
       "<g id=\"edge50\" class=\"edge\">\n",
       "<title>45--50</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1263,-215C1263,-215 1286.15,-194.94 1303.69,-179.74\"/>\n",
       "</g>\n",
       "<!-- 47 -->\n",
       "<g id=\"node48\" class=\"node\">\n",
       "<title>47</title>\n",
       "<text text-anchor=\"middle\" x=\"1107\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 46&#45;&#45;47 -->\n",
       "<g id=\"edge47\" class=\"edge\">\n",
       "<title>46--47</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1172,-143C1172,-143 1146.93,-122.94 1127.92,-107.74\"/>\n",
       "</g>\n",
       "<!-- 48 -->\n",
       "<g id=\"node49\" class=\"node\">\n",
       "<title>48</title>\n",
       "<text text-anchor=\"middle\" x=\"1179\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 46&#45;&#45;48 -->\n",
       "<g id=\"edge48\" class=\"edge\">\n",
       "<title>46--48</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1172,-143C1172,-143 1174.7,-122.94 1176.75,-107.74\"/>\n",
       "</g>\n",
       "<!-- 51 -->\n",
       "<g id=\"node52\" class=\"node\">\n",
       "<title>51</title>\n",
       "<text text-anchor=\"middle\" x=\"1251\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 50&#45;&#45;51 -->\n",
       "<g id=\"edge51\" class=\"edge\">\n",
       "<title>50--51</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1316,-143C1316,-143 1290.93,-122.94 1271.92,-107.74\"/>\n",
       "</g>\n",
       "<!-- 52 -->\n",
       "<g id=\"node53\" class=\"node\">\n",
       "<title>52</title>\n",
       "<text text-anchor=\"middle\" x=\"1323\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 50&#45;&#45;52 -->\n",
       "<g id=\"edge52\" class=\"edge\">\n",
       "<title>50--52</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1316,-143C1316,-143 1318.7,-122.94 1320.75,-107.74\"/>\n",
       "</g>\n",
       "<!-- 54 -->\n",
       "<g id=\"node55\" class=\"node\">\n",
       "<title>54</title>\n",
       "<text text-anchor=\"start\" x=\"1378.5\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 53&#45;&#45;54 -->\n",
       "<g id=\"edge54\" class=\"edge\">\n",
       "<title>53--54</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1384.39,-216.05C1386.59,-205.05 1389.45,-190.76 1391.64,-179.79\"/>\n",
       "</g>\n",
       "<!-- 55 -->\n",
       "<g id=\"node56\" class=\"node\">\n",
       "<title>55</title>\n",
       "<text text-anchor=\"middle\" x=\"1395\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;y&quot;</text>\n",
       "</g>\n",
       "<!-- 54&#45;&#45;55 -->\n",
       "<g id=\"edge55\" class=\"edge\">\n",
       "<title>54--55</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1402,-143C1402,-143 1399.3,-122.94 1397.25,-107.74\"/>\n",
       "</g>\n",
       "<!-- 56 -->\n",
       "<g id=\"node57\" class=\"node\">\n",
       "<title>56</title>\n",
       "<text text-anchor=\"middle\" x=\"1467\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 54&#45;&#45;56 -->\n",
       "<g id=\"edge56\" class=\"edge\">\n",
       "<title>54--56</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1402,-143C1402,-143 1427.07,-122.94 1446.08,-107.74\"/>\n",
       "</g>\n",
       "<!-- 58 -->\n",
       "<g id=\"node59\" class=\"node\">\n",
       "<title>58</title>\n",
       "<text text-anchor=\"start\" x=\"1548.12\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Compare</text>\n",
       "</g>\n",
       "<!-- 57&#45;&#45;58 -->\n",
       "<g id=\"edge58\" class=\"edge\">\n",
       "<title>57--58</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1561,-215C1561,-215 1567.17,-194.94 1571.85,-179.74\"/>\n",
       "</g>\n",
       "<!-- 66 -->\n",
       "<g id=\"node67\" class=\"node\">\n",
       "<title>66</title>\n",
       "<text text-anchor=\"start\" x=\"1685.25\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Return</text>\n",
       "</g>\n",
       "<!-- 57&#45;&#45;66 -->\n",
       "<g id=\"edge66\" class=\"edge\">\n",
       "<title>57--66</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1561,-215C1561,-215 1633.44,-189.72 1677.3,-174.41\"/>\n",
       "</g>\n",
       "<!-- 59 -->\n",
       "<g id=\"node60\" class=\"node\">\n",
       "<title>59</title>\n",
       "<text text-anchor=\"start\" x=\"1522.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 58&#45;&#45;59 -->\n",
       "<g id=\"edge59\" class=\"edge\">\n",
       "<title>58--59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1583,-143C1583,-143 1566.03,-122.94 1553.16,-107.74\"/>\n",
       "</g>\n",
       "<!-- 62 -->\n",
       "<g id=\"node63\" class=\"node\">\n",
       "<title>62</title>\n",
       "<text text-anchor=\"middle\" x=\"1611\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Gt</text>\n",
       "</g>\n",
       "<!-- 58&#45;&#45;62 -->\n",
       "<g id=\"edge62\" class=\"edge\">\n",
       "<title>58--62</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1583,-143C1583,-143 1593.8,-122.94 1601.99,-107.74\"/>\n",
       "</g>\n",
       "<!-- 63 -->\n",
       "<g id=\"node64\" class=\"node\">\n",
       "<title>63</title>\n",
       "<text text-anchor=\"start\" x=\"1666.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 58&#45;&#45;63 -->\n",
       "<g id=\"edge63\" class=\"edge\">\n",
       "<title>58--63</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1583,-143C1583,-143 1626.58,-120.34 1656.2,-104.94\"/>\n",
       "</g>\n",
       "<!-- 60 -->\n",
       "<g id=\"node61\" class=\"node\">\n",
       "<title>60</title>\n",
       "<text text-anchor=\"middle\" x=\"1467\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 59&#45;&#45;60 -->\n",
       "<g id=\"edge60\" class=\"edge\">\n",
       "<title>59--60</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1532,-71C1532,-71 1506.93,-50.94 1487.92,-35.74\"/>\n",
       "</g>\n",
       "<!-- 61 -->\n",
       "<g id=\"node62\" class=\"node\">\n",
       "<title>61</title>\n",
       "<text text-anchor=\"middle\" x=\"1539\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 59&#45;&#45;61 -->\n",
       "<g id=\"edge61\" class=\"edge\">\n",
       "<title>59--61</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1532,-71C1532,-71 1534.7,-50.94 1536.75,-35.74\"/>\n",
       "</g>\n",
       "<!-- 64 -->\n",
       "<g id=\"node65\" class=\"node\">\n",
       "<title>64</title>\n",
       "<text text-anchor=\"middle\" x=\"1611\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;z&quot;</text>\n",
       "</g>\n",
       "<!-- 63&#45;&#45;64 -->\n",
       "<g id=\"edge64\" class=\"edge\">\n",
       "<title>63--64</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1676,-71C1676,-71 1650.93,-50.94 1631.92,-35.74\"/>\n",
       "</g>\n",
       "<!-- 65 -->\n",
       "<g id=\"node66\" class=\"node\">\n",
       "<title>65</title>\n",
       "<text text-anchor=\"middle\" x=\"1683\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 63&#45;&#45;65 -->\n",
       "<g id=\"edge65\" class=\"edge\">\n",
       "<title>63--65</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1676,-71C1676,-71 1678.7,-50.94 1680.75,-35.74\"/>\n",
       "</g>\n",
       "<!-- 67 -->\n",
       "<g id=\"node68\" class=\"node\">\n",
       "<title>67</title>\n",
       "<text text-anchor=\"start\" x=\"1738.5\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 66&#45;&#45;67 -->\n",
       "<g id=\"edge67\" class=\"edge\">\n",
       "<title>66--67</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1720.89,-144.05C1727.97,-133.05 1737.15,-118.76 1744.21,-107.79\"/>\n",
       "</g>\n",
       "<!-- 68 -->\n",
       "<g id=\"node69\" class=\"node\">\n",
       "<title>68</title>\n",
       "<text text-anchor=\"middle\" x=\"1755\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 67&#45;&#45;68 -->\n",
       "<g id=\"edge68\" class=\"edge\">\n",
       "<title>67--68</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1762,-71C1762,-71 1759.3,-50.94 1757.25,-35.74\"/>\n",
       "</g>\n",
       "<!-- 69 -->\n",
       "<g id=\"node70\" class=\"node\">\n",
       "<title>69</title>\n",
       "<text text-anchor=\"middle\" x=\"1827\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 67&#45;&#45;69 -->\n",
       "<g id=\"edge69\" class=\"edge\">\n",
       "<title>67--69</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1762,-71C1762,-71 1787.07,-50.94 1806.08,-35.74\"/>\n",
       "</g>\n",
       "<!-- 71 -->\n",
       "<g id=\"node72\" class=\"node\">\n",
       "<title>71</title>\n",
       "<text text-anchor=\"start\" x=\"1597.5\" y=\"-301.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 70&#45;&#45;71 -->\n",
       "<g id=\"edge71\" class=\"edge\">\n",
       "<title>70--71</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1186.71,-372.02C1273.33,-358.84 1507.44,-323.22 1587.06,-311.1\"/>\n",
       "</g>\n",
       "<!-- 72 -->\n",
       "<g id=\"node73\" class=\"node\">\n",
       "<title>72</title>\n",
       "<text text-anchor=\"middle\" x=\"1614\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;z&quot;</text>\n",
       "</g>\n",
       "<!-- 71&#45;&#45;72 -->\n",
       "<g id=\"edge72\" class=\"edge\">\n",
       "<title>71--72</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1621,-287C1621,-287 1618.3,-266.94 1616.25,-251.74\"/>\n",
       "</g>\n",
       "<!-- 73 -->\n",
       "<g id=\"node74\" class=\"node\">\n",
       "<title>73</title>\n",
       "<text text-anchor=\"middle\" x=\"1686\" y=\"-228.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 71&#45;&#45;73 -->\n",
       "<g id=\"edge73\" class=\"edge\">\n",
       "<title>71--73</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M1621,-287C1621,-287 1646.07,-266.94 1665.08,-251.74\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "middle_tree = ast.parse(inspect.getsource(middle))\n",
    "show_ast(middle_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "At the very bottom of the tree, you can see a number of `Name` nodes, referring individual variables. These are the ones we want to transform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tracking Variable Accesses\n",
    "\n",
    "Our goal is to _traverse_ the tree, identify all `Name` nodes, and convert them to respective `_data` accesses.\n",
    "To this end, we manipulate the AST through the `ast` Python module `ast`. The [official Python `ast` reference](http://docs.python.org/3/library/ast) is complete, but a bit brief; the documentation [\"Green Tree Snakes - the missing Python AST docs\"](https://greentreesnakes.readthedocs.io/en/latest/) provides an excellent introduction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The Python `ast` module provides a class `NodeTransformer` that allows such transformations. By subclassing from it, we provide a method `visit_Name()` that will be invoked for all `Name` nodes – and replace it by a new subtree from `make_get_data()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.330538Z",
     "iopub.status.busy": "2023-11-12T12:40:24.330411Z",
     "iopub.status.idle": "2023-11-12T12:40:24.332275Z",
     "shell.execute_reply": "2023-11-12T12:40:24.332005Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from ast import NodeTransformer, NodeVisitor, Name, AST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.333724Z",
     "iopub.status.busy": "2023-11-12T12:40:24.333617Z",
     "iopub.status.idle": "2023-11-12T12:40:24.335378Z",
     "shell.execute_reply": "2023-11-12T12:40:24.335016Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.336942Z",
     "iopub.status.busy": "2023-11-12T12:40:24.336816Z",
     "iopub.status.idle": "2023-11-12T12:40:24.338445Z",
     "shell.execute_reply": "2023-11-12T12:40:24.338175Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "DATA_TRACKER = '_data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.339765Z",
     "iopub.status.busy": "2023-11-12T12:40:24.339662Z",
     "iopub.status.idle": "2023-11-12T12:40:24.341504Z",
     "shell.execute_reply": "2023-11-12T12:40:24.341261Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def is_internal(id: str) -> bool:\n",
    "    \"\"\"Return True if `id` is a built-in function or type\"\"\"\n",
    "    return (id in dir(__builtins__) or id in dir(typing))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.342887Z",
     "iopub.status.busy": "2023-11-12T12:40:24.342788Z",
     "iopub.status.idle": "2023-11-12T12:40:24.344663Z",
     "shell.execute_reply": "2023-11-12T12:40:24.344394Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "assert is_internal('int')\n",
    "assert is_internal('None')\n",
    "assert is_internal('Tuple')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.346199Z",
     "iopub.status.busy": "2023-11-12T12:40:24.346078Z",
     "iopub.status.idle": "2023-11-12T12:40:24.348546Z",
     "shell.execute_reply": "2023-11-12T12:40:24.348271Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackGetTransformer(NodeTransformer):\n",
    "    def visit_Name(self, node: Name) -> AST:\n",
    "        self.generic_visit(node)\n",
    "\n",
    "        if is_internal(node.id):\n",
    "            # Do not change built-in names and types\n",
    "            return node\n",
    "\n",
    "        if node.id == DATA_TRACKER:\n",
    "            # Do not change own accesses\n",
    "            return node\n",
    "\n",
    "        if not isinstance(node.ctx, Load):\n",
    "            # Only change loads (not stores, not deletions)\n",
    "            return node\n",
    "\n",
    "        new_node = make_get_data(node.id)\n",
    "        ast.copy_location(new_node, node)\n",
    "        return new_node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Our function `make_get_data(id, method)` returns a new subtree equivalent to the Python code `_data.method('id', id)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.350058Z",
     "iopub.status.busy": "2023-11-12T12:40:24.349964Z",
     "iopub.status.idle": "2023-11-12T12:40:24.351864Z",
     "shell.execute_reply": "2023-11-12T12:40:24.351575Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from ast import Module, Load, Store, \\\n",
    "    Attribute, With, withitem, keyword, Call, Expr, \\\n",
    "    Assign, AugAssign, AnnAssign, Assert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.353399Z",
     "iopub.status.busy": "2023-11-12T12:40:24.353272Z",
     "iopub.status.idle": "2023-11-12T12:40:24.354888Z",
     "shell.execute_reply": "2023-11-12T12:40:24.354641Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Starting with Python 3.8, these will become Constant.\n",
    "# from ast import Num, Str, NameConstant\n",
    "# Use `ast.Num`, `ast.Str`, and `ast.NameConstant` for compatibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.356262Z",
     "iopub.status.busy": "2023-11-12T12:40:24.356156Z",
     "iopub.status.idle": "2023-11-12T12:40:24.358340Z",
     "shell.execute_reply": "2023-11-12T12:40:24.358095Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def make_get_data(id: str, method: str = 'get') -> Call:\n",
    "    return Call(func=Attribute(value=Name(id=DATA_TRACKER, ctx=Load()), \n",
    "                               attr=method, ctx=Load()),\n",
    "                args=[ast.Str(s=id), Name(id=id, ctx=Load())],\n",
    "                keywords=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This is the tree that `make_get_data()` produces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.359715Z",
     "iopub.status.busy": "2023-11-12T12:40:24.359621Z",
     "iopub.status.idle": "2023-11-12T12:40:24.788252Z",
     "shell.execute_reply": "2023-11-12T12:40:24.787867Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"484pt\" height=\"260pt\" viewBox=\"0.00 0.00 483.88 260.00\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 256)\">\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-256 479.88,-256 479.88,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<text text-anchor=\"start\" x=\"277.38\" y=\"-229.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Call</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<text text-anchor=\"start\" x=\"138.75\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Attribute</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0--1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M292.88,-215C292.88,-215 248.02,-195.07 213.86,-179.88\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<text text-anchor=\"start\" x=\"260.88\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Constant</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>0--7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M292.88,-215C292.88,-215 293.26,-194.94 293.55,-179.74\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<text text-anchor=\"start\" x=\"363.38\" y=\"-157.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 0&#45;&#45;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>0--9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M292.88,-215C292.88,-215 327.71,-194.18 353.3,-178.88\"/>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<text text-anchor=\"start\" x=\"61.38\" y=\"-85.95\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#004080\">Name</text>\n",
       "</g>\n",
       "<!-- 1&#45;&#45;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1--2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M171.88,-143C171.88,-143 132.59,-121.27 104.81,-105.9\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<text text-anchor=\"middle\" x=\"151.88\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;get&quot;</text>\n",
       "</g>\n",
       "<!-- 1&#45;&#45;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>1--5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M171.88,-143C171.88,-143 164.16,-122.94 158.31,-107.74\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<text text-anchor=\"middle\" x=\"225.88\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 1&#45;&#45;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>1--6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M171.88,-143C171.88,-143 192.71,-122.94 208.49,-107.74\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<text text-anchor=\"middle\" x=\"36.88\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;_data&quot;</text>\n",
       "</g>\n",
       "<!-- 2&#45;&#45;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>2--3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M77.88,-71C77.88,-71 62.06,-50.94 50.07,-35.74\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<text text-anchor=\"middle\" x=\"118.88\" y=\"-12.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 2&#45;&#45;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>2--4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M77.88,-71C77.88,-71 93.69,-50.94 105.68,-35.74\"/>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<text text-anchor=\"middle\" x=\"297.88\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 7&#45;&#45;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>7--8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M294.84,-144.05C295.47,-133.05 296.29,-118.76 296.92,-107.79\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<text text-anchor=\"middle\" x=\"376.88\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">&quot;x&quot;</text>\n",
       "</g>\n",
       "<!-- 9&#45;&#45;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>9--10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M386.88,-143C386.88,-143 383.02,-122.94 380.09,-107.74\"/>\n",
       "</g>\n",
       "<!-- 11 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>11</title>\n",
       "<text text-anchor=\"middle\" x=\"448.88\" y=\"-84.95\" font-family=\"Courier,monospace\" font-size=\"14.00\" fill=\"#008040\">Load</text>\n",
       "</g>\n",
       "<!-- 9&#45;&#45;11 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>9--11</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M386.88,-143C386.88,-143 410.79,-122.94 428.92,-107.74\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_ast(Module(body=[make_get_data(\"x\")]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How do we know that this is a correct subtree? We can carefully read the [official Python `ast` reference](http://docs.python.org/3/library/ast) and then proceed by trial and error (and apply [delta debugging](DeltaDebugger.ipynb) to determine error causes). Or – pro tip! – we can simply take a piece of Python code, parse it and use `ast.dump()` to print out how to construct the resulting AST:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.790278Z",
     "iopub.status.busy": "2023-11-12T12:40:24.790128Z",
     "iopub.status.idle": "2023-11-12T12:40:24.792608Z",
     "shell.execute_reply": "2023-11-12T12:40:24.792108Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Module(body=[Expr(value=Call(func=Attribute(value=Name(id='_data', ctx=Load()), attr='get', ctx=Load()), args=[Constant(value='x'), Name(id='x', ctx=Load())], keywords=[]))], type_ignores=[])\n"
     ]
    }
   ],
   "source": [
    "print(ast.dump(ast.parse(\"_data.get('x', x)\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you compare the above output with the code of `make_get_data()`, above, you will find out where the source of `make_get_data()` comes from."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us put `TrackGetTransformer` to action. Its `visit()` method calls `visit_Name()`, which then in turn transforms the `Name` nodes as we want it. This happens in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.794603Z",
     "iopub.status.busy": "2023-11-12T12:40:24.794474Z",
     "iopub.status.idle": "2023-11-12T12:40:24.796871Z",
     "shell.execute_reply": "2023-11-12T12:40:24.796577Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "TrackGetTransformer().visit(middle_tree);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To see the effect of our transformations, we introduce a method `dump_tree()` which outputs the tree – and also compiles it to check for any inconsistencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.798775Z",
     "iopub.status.busy": "2023-11-12T12:40:24.798648Z",
     "iopub.status.idle": "2023-11-12T12:40:24.800763Z",
     "shell.execute_reply": "2023-11-12T12:40:24.800387Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def dump_tree(tree: AST) -> None:\n",
    "    print_content(ast.unparse(tree), '.py')\n",
    "    ast.fix_missing_locations(tree)  # Must run this before compiling\n",
    "    _ = compile(cast(ast.Module, tree), '<dump_tree>', 'exec')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We see that our transformer has properly replaced all variable accesses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.802517Z",
     "iopub.status.busy": "2023-11-12T12:40:24.802396Z",
     "iopub.status.idle": "2023-11-12T12:40:24.837692Z",
     "shell.execute_reply": "2023-11-12T12:40:24.837400Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y):\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mreturn\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mreturn\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "dump_tree(middle_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us now execute this code together with the `DataTracker()` class we previously introduced. The class `DataTrackerTester()` takes a (transformed) tree and a function. Using it as\n",
    "\n",
    "```python\n",
    "with DataTrackerTester(tree, func):\n",
    "    func(...)\n",
    "```\n",
    "\n",
    "first executes the code in _tree_ (possibly instrumenting `func`) and then the `with` body. At the end, `func` is restored to its previous (non-instrumented) version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.839647Z",
     "iopub.status.busy": "2023-11-12T12:40:24.839513Z",
     "iopub.status.idle": "2023-11-12T12:40:24.841127Z",
     "shell.execute_reply": "2023-11-12T12:40:24.840860Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from types import TracebackType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.842665Z",
     "iopub.status.busy": "2023-11-12T12:40:24.842538Z",
     "iopub.status.idle": "2023-11-12T12:40:24.846141Z",
     "shell.execute_reply": "2023-11-12T12:40:24.845793Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTrackerTester:\n",
    "    def __init__(self, tree: AST, func: Callable, log: bool = True) -> None:\n",
    "        \"\"\"Constructor. Execute the code in `tree` while instrumenting `func`.\"\"\"\n",
    "        # We pass the source file of `func` such that we can retrieve it\n",
    "        # when accessing the location of the new compiled code\n",
    "        source = cast(str, inspect.getsourcefile(func))\n",
    "        self.code = compile(cast(ast.Module, tree), source, 'exec')\n",
    "        self.func = func\n",
    "        self.log = log\n",
    "\n",
    "    def make_data_tracker(self) -> Any:\n",
    "        return DataTracker(log=self.log)\n",
    "\n",
    "    def __enter__(self) -> Any:\n",
    "        \"\"\"Rewrite function\"\"\"\n",
    "        tracker = self.make_data_tracker()\n",
    "        globals()[DATA_TRACKER] = tracker\n",
    "        exec(self.code, globals())\n",
    "        return tracker\n",
    "\n",
    "    def __exit__(self, exc_type: Type, exc_value: BaseException,\n",
    "                 traceback: TracebackType) -> Optional[bool]:\n",
    "        \"\"\"Restore function\"\"\"\n",
    "        globals()[self.func.__name__] = self.func\n",
    "        del globals()[DATA_TRACKER]\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here is our `middle()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.847820Z",
     "iopub.status.busy": "2023-11-12T12:40:24.847698Z",
     "iopub.status.idle": "2023-11-12T12:40:24.884115Z",
     "shell.execute_reply": "2023-11-12T12:40:24.882559Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 1  \u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      " 2      \u001b[34mif\u001b[39;49;00m y < z:\u001b[37m\u001b[39;49;00m\n",
      " 3          \u001b[34mif\u001b[39;49;00m x < y:\u001b[37m\u001b[39;49;00m\n",
      " 4              \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      " 5          \u001b[34melif\u001b[39;49;00m x < z:\u001b[37m\u001b[39;49;00m\n",
      " 6              \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      " 7      \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      " 8          \u001b[34mif\u001b[39;49;00m x > y:\u001b[37m\u001b[39;49;00m\n",
      " 9              \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      "10          \u001b[34melif\u001b[39;49;00m x > z:\u001b[37m\u001b[39;49;00m\n",
      "11              \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m\n",
      "12      \u001b[34mreturn\u001b[39;49;00m z\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "print_content(inspect.getsource(middle), '.py', start_line_number=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "And here is our instrumented `middle_tree` executed with a `DataTracker` object. We see how the `middle()` tests access one argument after another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.897915Z",
     "iopub.status.busy": "2023-11-12T12:40:24.897734Z",
     "iopub.status.idle": "2023-11-12T12:40:24.901220Z",
     "shell.execute_reply": "2023-11-12T12:40:24.900105Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle:2: getting y\n",
      "middle:2: getting z\n",
      "middle:3: getting x\n",
      "middle:3: getting y\n",
      "middle:5: getting x\n",
      "middle:5: getting z\n",
      "middle:6: getting y\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(middle_tree, middle):\n",
    "    middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "After `DataTrackerTester` is done, `middle` is reverted to its non-instrumented version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.904700Z",
     "iopub.status.busy": "2023-11-12T12:40:24.904537Z",
     "iopub.status.idle": "2023-11-12T12:40:24.907138Z",
     "shell.execute_reply": "2023-11-12T12:40:24.906704Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For a complete picture of what happens during executions, we implement a number of additional code transformers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For each assignment statement `x = y`, we change it to `x = _data.set('x', y)`. This allows __tracking assignments__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Tracking Assignments and Assertions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For the remaining transformers, we follow the same steps as for `TrackGetTransformer`, except that our `visit_...()` methods focus on different nodes, and return different subtrees. Here, we focus on assignment nodes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We want to transform assignments `x = value` into `_data.set('x', value)` to track assignments to `x`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If the left-hand side of the assignment is more complex, as in `x[y] = value`, we want to ensure the read access to `x` and `y` is also tracked. By transforming `x[y] = value` into `_data.set('x', value, loads=(x, y))`, we ensure that `x` and `y` are marked as read (as the otherwise ignored `loads` argument would be changed to `_data.get()` calls for `x` and `y`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Using `ast.dump()`, we reveal what the corresponding syntax tree has to look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.909595Z",
     "iopub.status.busy": "2023-11-12T12:40:24.909364Z",
     "iopub.status.idle": "2023-11-12T12:40:24.912020Z",
     "shell.execute_reply": "2023-11-12T12:40:24.911623Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Module(body=[Expr(value=Call(func=Attribute(value=Name(id='_data', ctx=Load()), attr='set', ctx=Load()), args=[Constant(value='x'), Name(id='value', ctx=Load())], keywords=[keyword(arg='loads', value=Tuple(elts=[Name(id='a', ctx=Load()), Name(id='b', ctx=Load())], ctx=Load()))]))], type_ignores=[])\n"
     ]
    }
   ],
   "source": [
    "print(ast.dump(ast.parse(\"_data.set('x', value, loads=(a, b))\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Using this structure, we can write a function `make_set_data()` which constructs such a subtree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.913670Z",
     "iopub.status.busy": "2023-11-12T12:40:24.913534Z",
     "iopub.status.idle": "2023-11-12T12:40:24.916665Z",
     "shell.execute_reply": "2023-11-12T12:40:24.916220Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def make_set_data(id: str, value: Any, \n",
    "                  loads: Optional[Set[str]] = None, method: str = 'set') -> Call:\n",
    "    \"\"\"\n",
    "    Construct a subtree _data.`method`('`id`', `value`). \n",
    "    If `loads` is set to [X1, X2, ...], make it\n",
    "    _data.`method`('`id`', `value`, loads=(X1, X2, ...))\n",
    "    \"\"\"\n",
    "\n",
    "    keywords=[]\n",
    "\n",
    "    if loads:\n",
    "        keywords = [\n",
    "            keyword(arg='loads',\n",
    "                    value=ast.Tuple(\n",
    "                        elts=[Name(id=load, ctx=Load()) for load in loads],\n",
    "                        ctx=Load()\n",
    "                    ))\n",
    "        ]\n",
    "\n",
    "    new_node = Call(func=Attribute(value=Name(id=DATA_TRACKER, ctx=Load()),\n",
    "                                   attr=method, ctx=Load()),\n",
    "                    args=[ast.Str(s=id), value],\n",
    "                    keywords=keywords)\n",
    "\n",
    "    ast.copy_location(new_node, value)\n",
    "\n",
    "    return new_node"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The problem is, however: How do we get the name of the variable being assigned to? The left-hand side of an assignment can be a complex expression such as `x[i]`. We use the leftmost name of the left-hand side as name to be assigned to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.918308Z",
     "iopub.status.busy": "2023-11-12T12:40:24.918187Z",
     "iopub.status.idle": "2023-11-12T12:40:24.920598Z",
     "shell.execute_reply": "2023-11-12T12:40:24.920299Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class LeftmostNameVisitor(NodeVisitor):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        self.leftmost_name: Optional[str] = None\n",
    "\n",
    "    def visit_Name(self, node: Name) -> None:\n",
    "        if self.leftmost_name is None:\n",
    "            self.leftmost_name = node.id\n",
    "        self.generic_visit(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.921948Z",
     "iopub.status.busy": "2023-11-12T12:40:24.921861Z",
     "iopub.status.idle": "2023-11-12T12:40:24.923880Z",
     "shell.execute_reply": "2023-11-12T12:40:24.923491Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def leftmost_name(tree: AST) -> Optional[str]:\n",
    "    visitor = LeftmostNameVisitor()\n",
    "    visitor.visit(tree)\n",
    "    return visitor.leftmost_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.925548Z",
     "iopub.status.busy": "2023-11-12T12:40:24.925391Z",
     "iopub.status.idle": "2023-11-12T12:40:24.927829Z",
     "shell.execute_reply": "2023-11-12T12:40:24.927452Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "leftmost_name(ast.parse('a[x] = 25'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Python also allows _tuple assignments_, as in `(a, b, c) = (1, 2, 3)`. We extract all variables being stored (that is, expressions whose `ctx` attribute is `Store()`) and extract their (leftmost) names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.929437Z",
     "iopub.status.busy": "2023-11-12T12:40:24.929333Z",
     "iopub.status.idle": "2023-11-12T12:40:24.931918Z",
     "shell.execute_reply": "2023-11-12T12:40:24.931627Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class StoreVisitor(NodeVisitor):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        self.names: Set[str] = set()\n",
    "\n",
    "    def visit(self, node: AST) -> None:\n",
    "        if hasattr(node, 'ctx') and isinstance(node.ctx, Store):  # type: ignore\n",
    "            name = leftmost_name(node)\n",
    "            if name:\n",
    "                self.names.add(name)\n",
    "\n",
    "        self.generic_visit(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.933368Z",
     "iopub.status.busy": "2023-11-12T12:40:24.933280Z",
     "iopub.status.idle": "2023-11-12T12:40:24.935085Z",
     "shell.execute_reply": "2023-11-12T12:40:24.934834Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def store_names(tree: AST) -> Set[str]:\n",
    "    visitor = StoreVisitor()\n",
    "    visitor.visit(tree)\n",
    "    return visitor.names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.936362Z",
     "iopub.status.busy": "2023-11-12T12:40:24.936280Z",
     "iopub.status.idle": "2023-11-12T12:40:24.938726Z",
     "shell.execute_reply": "2023-11-12T12:40:24.938414Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c'}"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "store_names(ast.parse('a[x], b[y], c = 1, 2, 3'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For complex assignments, we also want to access the names read in the left hand side of an expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.940594Z",
     "iopub.status.busy": "2023-11-12T12:40:24.940277Z",
     "iopub.status.idle": "2023-11-12T12:40:24.943132Z",
     "shell.execute_reply": "2023-11-12T12:40:24.942742Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class LoadVisitor(NodeVisitor):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        self.names: Set[str] = set()\n",
    "\n",
    "    def visit(self, node: AST) -> None:\n",
    "        if hasattr(node, 'ctx') and isinstance(node.ctx, Load):  # type: ignore\n",
    "            name = leftmost_name(node)\n",
    "            if name is not None:\n",
    "                self.names.add(name)\n",
    "\n",
    "        self.generic_visit(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.944813Z",
     "iopub.status.busy": "2023-11-12T12:40:24.944685Z",
     "iopub.status.idle": "2023-11-12T12:40:24.946535Z",
     "shell.execute_reply": "2023-11-12T12:40:24.946275Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def load_names(tree: AST) -> Set[str]:\n",
    "    visitor = LoadVisitor()\n",
    "    visitor.visit(tree)\n",
    "    return visitor.names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.948077Z",
     "iopub.status.busy": "2023-11-12T12:40:24.947963Z",
     "iopub.status.idle": "2023-11-12T12:40:24.950302Z",
     "shell.execute_reply": "2023-11-12T12:40:24.949908Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'x', 'y'}"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_names(ast.parse('a[x], b[y], c = 1, 2, 3'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "With this, we can now define `TrackSetTransformer` as a transformer for regular assignments. Note that in Python, an assignment can have multiple targets, as in `a = b = c`; we assign the data dependencies of `c` to them all."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.951797Z",
     "iopub.status.busy": "2023-11-12T12:40:24.951674Z",
     "iopub.status.idle": "2023-11-12T12:40:24.954146Z",
     "shell.execute_reply": "2023-11-12T12:40:24.953839Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackSetTransformer(NodeTransformer):\n",
    "    def visit_Assign(self, node: Assign) -> Assign:\n",
    "        value = ast.unparse(node.value)\n",
    "        if value.startswith(DATA_TRACKER + '.set'):\n",
    "            return node  # Do not apply twice\n",
    "\n",
    "        for target in node.targets:\n",
    "            loads = load_names(target)\n",
    "            for store_name in store_names(target):\n",
    "                node.value = make_set_data(store_name, node.value, \n",
    "                                           loads=loads)\n",
    "                loads = set()\n",
    "\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The special form of \"augmented assign\" needs special treatment. We change statements of the form `x += y` to `x += _data.augment('x', y)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.955782Z",
     "iopub.status.busy": "2023-11-12T12:40:24.955663Z",
     "iopub.status.idle": "2023-11-12T12:40:24.957790Z",
     "shell.execute_reply": "2023-11-12T12:40:24.957433Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class TrackSetTransformer(TrackSetTransformer):\n",
    "    def visit_AugAssign(self, node: AugAssign) -> AugAssign:\n",
    "        value = ast.unparse(node.value)\n",
    "        if value.startswith(DATA_TRACKER):\n",
    "            return node  # Do not apply twice\n",
    "\n",
    "        id = cast(str, leftmost_name(node.target))\n",
    "        node.value = make_set_data(id, node.value, method='augment')\n",
    "\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The corresponding `augment()` method uses a combination of `set()` and `get()` to reflect the semantics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.959535Z",
     "iopub.status.busy": "2023-11-12T12:40:24.959420Z",
     "iopub.status.idle": "2023-11-12T12:40:24.961316Z",
     "shell.execute_reply": "2023-11-12T12:40:24.961034Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def augment(self, name: str, value: Any) -> Any:\n",
    "        \"\"\"\n",
    "        Track augmenting `name` with `value`.\n",
    "        To be overloaded in subclasses.\n",
    "        \"\"\"\n",
    "        self.set(name, self.get(name, value))\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\"Annotated\" assignments come with a type, as in `x: int = 3`. We treat them like regular assignments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.962826Z",
     "iopub.status.busy": "2023-11-12T12:40:24.962711Z",
     "iopub.status.idle": "2023-11-12T12:40:24.965038Z",
     "shell.execute_reply": "2023-11-12T12:40:24.964818Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackSetTransformer(TrackSetTransformer):\n",
    "    def visit_AnnAssign(self, node: AnnAssign) -> AnnAssign:\n",
    "        if node.value is None:\n",
    "            return node  # just <var>: <type> without value\n",
    "\n",
    "        value = ast.unparse(node.value)\n",
    "        if value.startswith(DATA_TRACKER + '.set'):\n",
    "            return node  # Do not apply twice\n",
    "\n",
    "        loads = load_names(node.target)\n",
    "        for store_name in store_names(node.target):\n",
    "            node.value = make_set_data(store_name, node.value, \n",
    "                                       loads=loads)\n",
    "            loads = set()\n",
    "\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Finally, we treat _assertions_ just as if they were assignments to special variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.966923Z",
     "iopub.status.busy": "2023-11-12T12:40:24.966742Z",
     "iopub.status.idle": "2023-11-12T12:40:24.969059Z",
     "shell.execute_reply": "2023-11-12T12:40:24.968813Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class TrackSetTransformer(TrackSetTransformer):\n",
    "    def visit_Assert(self, node: Assert) -> Assert:\n",
    "        value = ast.unparse(node.test)\n",
    "        if value.startswith(DATA_TRACKER + '.set'):\n",
    "            return node  # Do not apply twice\n",
    "\n",
    "        loads = load_names(node.test)\n",
    "        node.test = make_set_data(\"<assertion>\", node.test, loads=loads)\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's all of these transformers in action. Our original function has a number of assignments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.970568Z",
     "iopub.status.busy": "2023-11-12T12:40:24.970463Z",
     "iopub.status.idle": "2023-11-12T12:40:24.972443Z",
     "shell.execute_reply": "2023-11-12T12:40:24.972201Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def assign_test(x: int) -> Tuple[int, str]:  # type: ignore\n",
    "    forty_two: int = 42\n",
    "    forty_two = forty_two = 42\n",
    "    a, b = 1, 2\n",
    "    c = d = [a, b]\n",
    "    c[d[a]].attr = 47  # type: ignore\n",
    "    a *= b + 1\n",
    "    assert a > 0\n",
    "    return forty_two, \"Forty-Two\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.973836Z",
     "iopub.status.busy": "2023-11-12T12:40:24.973721Z",
     "iopub.status.idle": "2023-11-12T12:40:24.976186Z",
     "shell.execute_reply": "2023-11-12T12:40:24.975872Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "assign_tree = ast.parse(inspect.getsource(assign_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:24.978390Z",
     "iopub.status.busy": "2023-11-12T12:40:24.978120Z",
     "iopub.status.idle": "2023-11-12T12:40:25.012933Z",
     "shell.execute_reply": "2023-11-12T12:40:25.012613Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32massign_test\u001b[39;49;00m(x: \u001b[36mint\u001b[39;49;00m) -> Tuple[\u001b[36mint\u001b[39;49;00m, \u001b[36mstr\u001b[39;49;00m]:\u001b[37m\u001b[39;49;00m\n",
      "    forty_two: \u001b[36mint\u001b[39;49;00m = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m42\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    forty_two = forty_two = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m42\u001b[39;49;00m))\u001b[37m\u001b[39;49;00m\n",
      "    (a, b) = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, (\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m)))\u001b[37m\u001b[39;49;00m\n",
      "    c = d = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, [a, b]))\u001b[37m\u001b[39;49;00m\n",
      "    c[d[a]].attr = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m47\u001b[39;49;00m, loads=(d, a, c))\u001b[37m\u001b[39;49;00m\n",
      "    a *= _data.augment(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, b + \u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<assertion>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a > \u001b[34m0\u001b[39;49;00m, loads=(a,))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m (forty_two, \u001b[33m'\u001b[39;49;00m\u001b[33mForty-Two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "TrackSetTransformer().visit(assign_tree)\n",
    "dump_tree(assign_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If we later apply our transformer for data accesses, we can see that we track all variable reads and writes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.014655Z",
     "iopub.status.busy": "2023-11-12T12:40:25.014533Z",
     "iopub.status.idle": "2023-11-12T12:40:25.049529Z",
     "shell.execute_reply": "2023-11-12T12:40:25.049151Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32massign_test\u001b[39;49;00m(x: \u001b[36mint\u001b[39;49;00m) -> Tuple[\u001b[36mint\u001b[39;49;00m, \u001b[36mstr\u001b[39;49;00m]:\u001b[37m\u001b[39;49;00m\n",
      "    forty_two: \u001b[36mint\u001b[39;49;00m = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m42\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    forty_two = forty_two = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m42\u001b[39;49;00m))\u001b[37m\u001b[39;49;00m\n",
      "    (a, b) = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, (\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m)))\u001b[37m\u001b[39;49;00m\n",
      "    c = d = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, [_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a), _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, b)]))\u001b[37m\u001b[39;49;00m\n",
      "    _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, c)[_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, d)[_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a)]].attr = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m47\u001b[39;49;00m, loads=(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, d), _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a), _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, c)))\u001b[37m\u001b[39;49;00m\n",
      "    a *= _data.augment(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, b) + \u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<assertion>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a) > \u001b[34m0\u001b[39;49;00m, loads=(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a),))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m (_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mforty_two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, forty_two), \u001b[33m'\u001b[39;49;00m\u001b[33mForty-Two\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "TrackGetTransformer().visit(assign_tree)\n",
    "dump_tree(assign_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Each return statement `return x` is transformed to `return _data.set('<return_value>', x)`. This allows __tracking return values__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Tracking Return Values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our `TrackReturnTransformer` also makes use of `make_set_data()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.051494Z",
     "iopub.status.busy": "2023-11-12T12:40:25.051361Z",
     "iopub.status.idle": "2023-11-12T12:40:25.055645Z",
     "shell.execute_reply": "2023-11-12T12:40:25.055361Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackReturnTransformer(NodeTransformer):\n",
    "    def __init__(self) -> None:\n",
    "        self.function_name: Optional[str] = None\n",
    "        super().__init__()\n",
    "\n",
    "    def visit_FunctionDef(self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]) -> AST:\n",
    "        outer_name = self.function_name\n",
    "        self.function_name = node.name  # Save current name\n",
    "        self.generic_visit(node)\n",
    "        self.function_name = outer_name\n",
    "        return node\n",
    "\n",
    "    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> AST:\n",
    "        return self.visit_FunctionDef(node)\n",
    "\n",
    "    def return_value(self, tp: str = \"return\") -> str:\n",
    "        if self.function_name is None:\n",
    "            return f\"<{tp} value>\"\n",
    "        else:\n",
    "            return f\"<{self.function_name}() {tp} value>\"\n",
    "\n",
    "    def visit_return_or_yield(self, node: Union[ast.Return, ast.Yield, ast.YieldFrom],\n",
    "                              tp: str = \"return\") -> AST:\n",
    "\n",
    "        if node.value is not None:\n",
    "            value = ast.unparse(node.value)\n",
    "            if not value.startswith(DATA_TRACKER + '.set'):\n",
    "                node.value = make_set_data(self.return_value(tp), node.value)\n",
    "\n",
    "        return node\n",
    "\n",
    "    def visit_Return(self, node: ast.Return) -> AST:\n",
    "        return self.visit_return_or_yield(node, tp=\"return\")\n",
    "\n",
    "    def visit_Yield(self, node: ast.Yield) -> AST:\n",
    "        return self.visit_return_or_yield(node, tp=\"yield\")\n",
    "\n",
    "    def visit_YieldFrom(self, node: ast.YieldFrom) -> AST:\n",
    "        return self.visit_return_or_yield(node, tp=\"yield\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is the effect of `TrackReturnTransformer`. We see that all return values are saved, and thus all locations of the corresponding return statements are tracked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.057448Z",
     "iopub.status.busy": "2023-11-12T12:40:25.057261Z",
     "iopub.status.idle": "2023-11-12T12:40:25.091018Z",
     "shell.execute_reply": "2023-11-12T12:40:25.090720Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y):\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "TrackReturnTransformer().visit(middle_tree)\n",
    "dump_tree(middle_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.092956Z",
     "iopub.status.busy": "2023-11-12T12:40:25.092830Z",
     "iopub.status.idle": "2023-11-12T12:40:25.094968Z",
     "shell.execute_reply": "2023-11-12T12:40:25.094742Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle:2: getting y\n",
      "middle:2: getting z\n",
      "middle:3: getting x\n",
      "middle:3: getting y\n",
      "middle:5: getting x\n",
      "middle:5: getting z\n",
      "middle:6: getting y\n",
      "middle:6: setting <middle() return value>\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(middle_tree, middle):\n",
    "    middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To track __control dependencies__, for every block controlled by an `if`, `while`, or `for`:\n",
    "\n",
    "1. We wrap their tests in a `_data.test()` wrapper. This allows us to assign pseudo-variables like `<test>` which hold the conditions.\n",
    "2. We wrap their controlled blocks in a `with` statement. This allows us to track the variables read right before the `with` (= the controlling variables), and to restore the current controlling variables when the block is left.\n",
    "\n",
    "A statement\n",
    "\n",
    "```python\n",
    "if cond:\n",
    "    body\n",
    "```\n",
    "\n",
    "thus becomes\n",
    "\n",
    "```python\n",
    "if _data.test(cond):\n",
    "    with _data:\n",
    "        body\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Tracking Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To modify control statements, we traverse the tree, looking for `If` nodes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.096508Z",
     "iopub.status.busy": "2023-11-12T12:40:25.096404Z",
     "iopub.status.idle": "2023-11-12T12:40:25.098437Z",
     "shell.execute_reply": "2023-11-12T12:40:25.098181Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class TrackControlTransformer(NodeTransformer):\n",
    "    def visit_If(self, node: ast.If) -> ast.If:\n",
    "        self.generic_visit(node)\n",
    "        node.test = self.make_test(node.test)\n",
    "        node.body = self.make_with(node.body)\n",
    "        node.orelse = self.make_with(node.orelse)\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The subtrees come from helper functions `make_with()` and `make_test()`. Again, all these subtrees are obtained via `ast.dump()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.099876Z",
     "iopub.status.busy": "2023-11-12T12:40:25.099769Z",
     "iopub.status.idle": "2023-11-12T12:40:25.102743Z",
     "shell.execute_reply": "2023-11-12T12:40:25.102408Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackControlTransformer(TrackControlTransformer):\n",
    "    def make_with(self, block: List[ast.stmt]) -> List[ast.stmt]:\n",
    "        \"\"\"Create a subtree 'with _data: `block`'\"\"\"\n",
    "        if len(block) == 0:\n",
    "            return []\n",
    "\n",
    "        block_as_text = ast.unparse(block[0])\n",
    "        if block_as_text.startswith('with ' + DATA_TRACKER):\n",
    "            return block  # Do not apply twice\n",
    "\n",
    "        new_node = With(\n",
    "            items=[\n",
    "                withitem(\n",
    "                    context_expr=Name(id=DATA_TRACKER, ctx=Load()),\n",
    "                    optional_vars=None)\n",
    "            ],\n",
    "            body=block\n",
    "        )\n",
    "        ast.copy_location(new_node, block[0])\n",
    "        return [new_node]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.104502Z",
     "iopub.status.busy": "2023-11-12T12:40:25.104354Z",
     "iopub.status.idle": "2023-11-12T12:40:25.106860Z",
     "shell.execute_reply": "2023-11-12T12:40:25.106594Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackControlTransformer(TrackControlTransformer):\n",
    "    def make_test(self, test: ast.expr) -> ast.expr:\n",
    "        test_as_text = ast.unparse(test)\n",
    "        if test_as_text.startswith(DATA_TRACKER + '.test'):\n",
    "            return test  # Do not apply twice\n",
    "\n",
    "        new_test = Call(func=Attribute(value=Name(id=DATA_TRACKER, ctx=Load()),\n",
    "                                       attr='test',\n",
    "                                       ctx=Load()),\n",
    "                         args=[test],\n",
    "                         keywords=[])\n",
    "        ast.copy_location(new_test, test)\n",
    "        return new_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`while` loops are handled just like `if` constructs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.108587Z",
     "iopub.status.busy": "2023-11-12T12:40:25.108286Z",
     "iopub.status.idle": "2023-11-12T12:40:25.110650Z",
     "shell.execute_reply": "2023-11-12T12:40:25.110352Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackControlTransformer(TrackControlTransformer):\n",
    "    def visit_While(self, node: ast.While) -> ast.While:\n",
    "        self.generic_visit(node)\n",
    "        node.test = self.make_test(node.test)\n",
    "        node.body = self.make_with(node.body)\n",
    "        node.orelse = self.make_with(node.orelse)\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`for` loops gets a different treatment, as there is no condition that would control the body. Still, we ensure that setting the iterator variable is properly tracked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.112394Z",
     "iopub.status.busy": "2023-11-12T12:40:25.112247Z",
     "iopub.status.idle": "2023-11-12T12:40:25.115279Z",
     "shell.execute_reply": "2023-11-12T12:40:25.114948Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackControlTransformer(TrackControlTransformer):\n",
    "    # regular `for` loop\n",
    "    def visit_For(self, node: Union[ast.For, ast.AsyncFor]) -> AST:\n",
    "        self.generic_visit(node)\n",
    "        id = ast.unparse(node.target).strip()\n",
    "        node.iter = make_set_data(id, node.iter)\n",
    "\n",
    "        # Uncomment if you want iterators to control their bodies\n",
    "        # node.body = self.make_with(node.body)\n",
    "        # node.orelse = self.make_with(node.orelse)\n",
    "        return node\n",
    "\n",
    "    # `for` loops in async functions\n",
    "    def visit_AsyncFor(self, node: ast.AsyncFor) -> AST:\n",
    "        return self.visit_For(node)\n",
    "\n",
    "    # `for` clause in comprehensions\n",
    "    def visit_comprehension(self, node: ast.comprehension) -> AST:\n",
    "        self.generic_visit(node)\n",
    "        id = ast.unparse(node.target).strip()\n",
    "        node.iter = make_set_data(id, node.iter)\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here is the effect of `TrackControlTransformer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.117586Z",
     "iopub.status.busy": "2023-11-12T12:40:25.117466Z",
     "iopub.status.idle": "2023-11-12T12:40:25.182049Z",
     "shell.execute_reply": "2023-11-12T12:40:25.181682Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "TrackControlTransformer().visit(middle_tree)\n",
    "dump_tree(middle_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We extend `DataTracker` to also log these events:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.184062Z",
     "iopub.status.busy": "2023-11-12T12:40:25.183928Z",
     "iopub.status.idle": "2023-11-12T12:40:25.186183Z",
     "shell.execute_reply": "2023-11-12T12:40:25.185911Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def test(self, cond: AST) -> AST:\n",
    "        \"\"\"Test condition `cond`. To be overloaded in subclasses.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: testing condition\")\n",
    "\n",
    "        return cond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.188146Z",
     "iopub.status.busy": "2023-11-12T12:40:25.187892Z",
     "iopub.status.idle": "2023-11-12T12:40:25.190567Z",
     "shell.execute_reply": "2023-11-12T12:40:25.190226Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def __enter__(self) -> Any:\n",
    "        \"\"\"Enter `with` block. To be overloaded in subclasses.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: entering block\")\n",
    "        return self\n",
    "\n",
    "    def __exit__(self, exc_type: Type, exc_value: BaseException, \n",
    "                 traceback: TracebackType) -> Optional[bool]:\n",
    "        \"\"\"Exit `with` block. To be overloaded in subclasses.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: exiting block\")\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.192233Z",
     "iopub.status.busy": "2023-11-12T12:40:25.192099Z",
     "iopub.status.idle": "2023-11-12T12:40:25.194579Z",
     "shell.execute_reply": "2023-11-12T12:40:25.194193Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle:2: getting y\n",
      "middle:2: getting z\n",
      "middle:2: testing condition\n",
      "middle:3: entering block\n",
      "middle:3: getting x\n",
      "middle:3: getting y\n",
      "middle:3: testing condition\n",
      "middle:5: entering block\n",
      "middle:5: getting x\n",
      "middle:5: getting z\n",
      "middle:5: testing condition\n",
      "middle:6: entering block\n",
      "middle:6: getting y\n",
      "middle:6: setting <middle() return value>\n",
      "middle:6: exiting block\n",
      "middle:5: exiting block\n",
      "middle:3: exiting block\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(middle_tree, middle):\n",
    "    middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We also want to be able to __track calls__ across multiple functions. To this end, we wrap each call\n",
    "\n",
    "```python\n",
    "func(arg1, arg2, ...)\n",
    "```\n",
    "\n",
    "into\n",
    "\n",
    "```python\n",
    "_data.ret(_data.call(func)(_data.arg(arg1), _data.arg(arg2), ...))\n",
    "```\n",
    "\n",
    "each of which simply pass through their given argument, but which allow tracking the beginning of calls (`call()`), the computation of arguments (`arg()`), and the return of the call (`ret()`), respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Tracking Calls and Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our `TrackCallTransformer` visits all `Call` nodes, applying the transformations as shown above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.196405Z",
     "iopub.status.busy": "2023-11-12T12:40:25.196240Z",
     "iopub.status.idle": "2023-11-12T12:40:25.200542Z",
     "shell.execute_reply": "2023-11-12T12:40:25.200255Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackCallTransformer(NodeTransformer):\n",
    "    def make_call(self, node: AST, func: str, \n",
    "                  pos: Optional[int] = None, kw: Optional[str] = None) -> Call:\n",
    "        \"\"\"Return _data.call(`func`)(`node`)\"\"\"\n",
    "        keywords = []\n",
    "\n",
    "        # `Num()` and `Str()` are deprecated in favor of `Constant()`\n",
    "        if pos:\n",
    "            keywords.append(keyword(arg='pos', value=ast.Num(pos)))\n",
    "        if kw:\n",
    "            keywords.append(keyword(arg='kw', value=ast.Str(kw)))\n",
    "\n",
    "        return Call(func=Attribute(value=Name(id=DATA_TRACKER,\n",
    "                                              ctx=Load()),\n",
    "                                   attr=func,\n",
    "                                   ctx=Load()),\n",
    "                     args=[node],\n",
    "                     keywords=keywords)\n",
    "\n",
    "    def visit_Call(self, node: Call) -> Call:\n",
    "        self.generic_visit(node)\n",
    "\n",
    "        call_as_text = ast.unparse(node)\n",
    "        if call_as_text.startswith(DATA_TRACKER + '.ret'):\n",
    "            return node  # Already applied\n",
    "\n",
    "        func_as_text = ast.unparse(node)\n",
    "        if func_as_text.startswith(DATA_TRACKER + '.'):\n",
    "            return node  # Own function\n",
    "\n",
    "        new_args = []\n",
    "        for n, arg in enumerate(node.args):\n",
    "            new_args.append(self.make_call(arg, 'arg', pos=n + 1))\n",
    "        node.args = cast(List[ast.expr], new_args)\n",
    "\n",
    "        for kw in node.keywords:\n",
    "            id = kw.arg if hasattr(kw, 'arg') else None\n",
    "            kw.value = self.make_call(kw.value, 'arg', kw=id)\n",
    "\n",
    "        node.func = self.make_call(node.func, 'call')\n",
    "        return self.make_call(node, 'ret')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Our example function `middle()` does not contain any calls, but here is a function that invokes `middle()` twice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.202341Z",
     "iopub.status.busy": "2023-11-12T12:40:25.202219Z",
     "iopub.status.idle": "2023-11-12T12:40:25.204201Z",
     "shell.execute_reply": "2023-11-12T12:40:25.203885Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test_call() -> int:\n",
    "    x = middle(1, 2, z=middle(1, 2, 3))\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.205961Z",
     "iopub.status.busy": "2023-11-12T12:40:25.205687Z",
     "iopub.status.idle": "2023-11-12T12:40:25.242077Z",
     "shell.execute_reply": "2023-11-12T12:40:25.241690Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mtest_call\u001b[39;49;00m() -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    x = middle(\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m, z=middle(\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m, \u001b[34m3\u001b[39;49;00m))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "call_tree = ast.parse(inspect.getsource(test_call))\n",
    "dump_tree(call_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If we invoke `TrackCallTransformer` on this testing function, we get the following transformed code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.244299Z",
     "iopub.status.busy": "2023-11-12T12:40:25.244159Z",
     "iopub.status.idle": "2023-11-12T12:40:25.246364Z",
     "shell.execute_reply": "2023-11-12T12:40:25.246022Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "TrackCallTransformer().visit(call_tree);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.248928Z",
     "iopub.status.busy": "2023-11-12T12:40:25.248608Z",
     "iopub.status.idle": "2023-11-12T12:40:25.283770Z",
     "shell.execute_reply": "2023-11-12T12:40:25.283390Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mtest_call\u001b[39;49;00m() -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    x = _data.ret(_data.call(middle)(_data.arg(\u001b[34m1\u001b[39;49;00m, pos=\u001b[34m1\u001b[39;49;00m), _data.arg(\u001b[34m2\u001b[39;49;00m, pos=\u001b[34m2\u001b[39;49;00m), z=_data.arg(_data.ret(_data.call(middle)(_data.arg(\u001b[34m1\u001b[39;49;00m, pos=\u001b[34m1\u001b[39;49;00m), _data.arg(\u001b[34m2\u001b[39;49;00m, pos=\u001b[34m2\u001b[39;49;00m), _data.arg(\u001b[34m3\u001b[39;49;00m, pos=\u001b[34m3\u001b[39;49;00m))), kw=\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m)))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "dump_tree(call_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.285847Z",
     "iopub.status.busy": "2023-11-12T12:40:25.285706Z",
     "iopub.status.idle": "2023-11-12T12:40:25.287969Z",
     "shell.execute_reply": "2023-11-12T12:40:25.287548Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def f() -> bool:\n",
    "    return math.isclose(1, 1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.290126Z",
     "iopub.status.busy": "2023-11-12T12:40:25.289878Z",
     "iopub.status.idle": "2023-11-12T12:40:25.324893Z",
     "shell.execute_reply": "2023-11-12T12:40:25.324499Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mf\u001b[39;49;00m() -> \u001b[36mbool\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m math.isclose(\u001b[34m1\u001b[39;49;00m, \u001b[34m1.0\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "f_tree = ast.parse(inspect.getsource(f))\n",
    "dump_tree(f_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.328035Z",
     "iopub.status.busy": "2023-11-12T12:40:25.327812Z",
     "iopub.status.idle": "2023-11-12T12:40:25.330612Z",
     "shell.execute_reply": "2023-11-12T12:40:25.329928Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "TrackCallTransformer().visit(f_tree);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.334255Z",
     "iopub.status.busy": "2023-11-12T12:40:25.333937Z",
     "iopub.status.idle": "2023-11-12T12:40:25.371134Z",
     "shell.execute_reply": "2023-11-12T12:40:25.370804Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mf\u001b[39;49;00m() -> \u001b[36mbool\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.ret(_data.call(math.isclose)(_data.arg(\u001b[34m1\u001b[39;49;00m, pos=\u001b[34m1\u001b[39;49;00m), _data.arg(\u001b[34m1.0\u001b[39;49;00m, pos=\u001b[34m2\u001b[39;49;00m)))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "dump_tree(f_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "As before, our default `arg()`, `ret()`, and `call()` methods simply log the event and pass through the given value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.372948Z",
     "iopub.status.busy": "2023-11-12T12:40:25.372821Z",
     "iopub.status.idle": "2023-11-12T12:40:25.375438Z",
     "shell.execute_reply": "2023-11-12T12:40:25.375167Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def arg(self, value: Any, pos: Optional[int] = None, kw: Optional[str] = None) -> Any:\n",
    "        \"\"\"\n",
    "        Track `value` being passed as argument.\n",
    "        `pos` (if given) is the argument position (starting with 1).\n",
    "        `kw` (if given) is the argument keyword.\n",
    "        \"\"\"\n",
    "\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            info = \"\"\n",
    "            if pos:\n",
    "                info += f\" #{pos}\"\n",
    "            if kw:\n",
    "                info += f\" {repr(kw)}\"\n",
    "\n",
    "            print(f\"{caller_func.__name__}:{lineno}: pushing arg{info}\")\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.376933Z",
     "iopub.status.busy": "2023-11-12T12:40:25.376762Z",
     "iopub.status.idle": "2023-11-12T12:40:25.379130Z",
     "shell.execute_reply": "2023-11-12T12:40:25.378710Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def ret(self, value: Any) -> Any:\n",
    "        \"\"\"Track `value` being used as return value.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: returned from call\")\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.380829Z",
     "iopub.status.busy": "2023-11-12T12:40:25.380708Z",
     "iopub.status.idle": "2023-11-12T12:40:25.383049Z",
     "shell.execute_reply": "2023-11-12T12:40:25.382767Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def instrument_call(self, func: Callable) -> Callable:\n",
    "        \"\"\"Instrument a call to `func`. To be implemented in subclasses.\"\"\"\n",
    "        return func\n",
    "\n",
    "    def call(self, func: Callable) -> Callable:\n",
    "        \"\"\"Track a call to `func`.\"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: calling {func}\")\n",
    "\n",
    "        return self.instrument_call(func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.384719Z",
     "iopub.status.busy": "2023-11-12T12:40:25.384605Z",
     "iopub.status.idle": "2023-11-12T12:40:25.418565Z",
     "shell.execute_reply": "2023-11-12T12:40:25.418147Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mtest_call\u001b[39;49;00m() -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    x = _data.ret(_data.call(middle)(_data.arg(\u001b[34m1\u001b[39;49;00m, pos=\u001b[34m1\u001b[39;49;00m), _data.arg(\u001b[34m2\u001b[39;49;00m, pos=\u001b[34m2\u001b[39;49;00m), z=_data.arg(_data.ret(_data.call(middle)(_data.arg(\u001b[34m1\u001b[39;49;00m, pos=\u001b[34m1\u001b[39;49;00m), _data.arg(\u001b[34m2\u001b[39;49;00m, pos=\u001b[34m2\u001b[39;49;00m), _data.arg(\u001b[34m3\u001b[39;49;00m, pos=\u001b[34m3\u001b[39;49;00m))), kw=\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m)))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "dump_tree(call_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.420609Z",
     "iopub.status.busy": "2023-11-12T12:40:25.420443Z",
     "iopub.status.idle": "2023-11-12T12:40:25.422712Z",
     "shell.execute_reply": "2023-11-12T12:40:25.422434Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test_call:2: calling <function middle at 0x1048dec20>\n",
      "test_call:2: pushing arg #1\n",
      "test_call:2: pushing arg #2\n",
      "test_call:2: calling <function middle at 0x1048dec20>\n",
      "test_call:2: pushing arg #1\n",
      "test_call:2: pushing arg #2\n",
      "test_call:2: pushing arg #3\n",
      "test_call:2: returned from call\n",
      "test_call:2: pushing arg 'z'\n",
      "test_call:2: returned from call\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(call_tree, test_call):\n",
    "    test_call()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.425116Z",
     "iopub.status.busy": "2023-11-12T12:40:25.424909Z",
     "iopub.status.idle": "2023-11-12T12:40:25.427683Z",
     "shell.execute_reply": "2023-11-12T12:40:25.427357Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_call()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "On the receiving end, for each function argument `x`, we insert a call `_data.param('x', x, [position info])` to initialize `x`. This is useful for __tracking parameters across function calls.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Tracking Parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Again, we use `ast.dump()` to determine the correct syntax tree:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.429796Z",
     "iopub.status.busy": "2023-11-12T12:40:25.429601Z",
     "iopub.status.idle": "2023-11-12T12:40:25.432304Z",
     "shell.execute_reply": "2023-11-12T12:40:25.431691Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Module(body=[Expr(value=Call(func=Attribute(value=Name(id='_data', ctx=Load()), attr='param', ctx=Load()), args=[Constant(value='x'), Name(id='x', ctx=Load())], keywords=[keyword(arg='pos', value=Constant(value=1)), keyword(arg='last', value=Constant(value=True))]))], type_ignores=[])\n"
     ]
    }
   ],
   "source": [
    "print(ast.dump(ast.parse(\"_data.param('x', x, pos=1, last=True)\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.434680Z",
     "iopub.status.busy": "2023-11-12T12:40:25.434514Z",
     "iopub.status.idle": "2023-11-12T12:40:25.438998Z",
     "shell.execute_reply": "2023-11-12T12:40:25.438553Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class TrackParamsTransformer(NodeTransformer):\n",
    "    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:\n",
    "        self.generic_visit(node)\n",
    "\n",
    "        named_args = []\n",
    "        for child in ast.iter_child_nodes(node.args):\n",
    "            if isinstance(child, ast.arg):\n",
    "                named_args.append(child)\n",
    "\n",
    "        create_stmts = []\n",
    "        for n, child in enumerate(named_args):\n",
    "            keywords=[keyword(arg='pos', value=ast.Num(n=n + 1))]\n",
    "            if child is node.args.vararg:\n",
    "                keywords.append(keyword(arg='vararg', value=ast.Str(s='*')))\n",
    "            if child is node.args.kwarg:\n",
    "                keywords.append(keyword(arg='vararg', value=ast.Str(s='**')))\n",
    "            if n == len(named_args) - 1:\n",
    "                keywords.append(keyword(arg='last',\n",
    "                                        value=ast.NameConstant(value=True)))\n",
    "\n",
    "            create_stmt = Expr(\n",
    "                value=Call(\n",
    "                    func=Attribute(value=Name(id=DATA_TRACKER, ctx=Load()),\n",
    "                                   attr='param', ctx=Load()),\n",
    "                    args=[ast.Str(s=child.arg),\n",
    "                          Name(id=child.arg, ctx=Load())\n",
    "                         ],\n",
    "                    keywords=keywords\n",
    "                )\n",
    "            )\n",
    "            ast.copy_location(create_stmt, node)\n",
    "            create_stmts.append(create_stmt)\n",
    "\n",
    "        node.body = cast(List[ast.stmt], create_stmts) + node.body\n",
    "        return node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is the effect of `TrackParamsTransformer()`. You see how the first three parameters are all initialized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.441251Z",
     "iopub.status.busy": "2023-11-12T12:40:25.441049Z",
     "iopub.status.idle": "2023-11-12T12:40:25.479437Z",
     "shell.execute_reply": "2023-11-12T12:40:25.479031Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y, pos=\u001b[34m2\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z, pos=\u001b[34m3\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "TrackParamsTransformer().visit(middle_tree)\n",
    "dump_tree(middle_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "By default, the `DataTracker` `param()` method simply calls `set()` to set variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.481457Z",
     "iopub.status.busy": "2023-11-12T12:40:25.481308Z",
     "iopub.status.idle": "2023-11-12T12:40:25.484106Z",
     "shell.execute_reply": "2023-11-12T12:40:25.483811Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DataTracker(DataTracker):\n",
    "    def param(self, name: str, value: Any, \n",
    "              pos: Optional[int] = None, vararg: str = '', last: bool = False) -> Any:\n",
    "        \"\"\"\n",
    "        At the beginning of a function, track parameter `name` being set to `value`.\n",
    "        `pos` is the position of the argument (starting with 1).\n",
    "        `vararg` is \"*\" if `name` is a vararg parameter (as in *args),\n",
    "        and \"**\" is `name` is a kwargs parameter (as in *kwargs).\n",
    "        `last` is True if `name` is the last parameter.\n",
    "        \"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            info = \"\"\n",
    "            if pos is not None:\n",
    "                info += f\" #{pos}\"\n",
    "\n",
    "            print(f\"{caller_func.__name__}:{lineno}: initializing {vararg}{name}{info}\")\n",
    "\n",
    "        return self.set(name, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.485688Z",
     "iopub.status.busy": "2023-11-12T12:40:25.485566Z",
     "iopub.status.idle": "2023-11-12T12:40:25.488057Z",
     "shell.execute_reply": "2023-11-12T12:40:25.487765Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle:1: initializing x #1\n",
      "middle:1: setting x\n",
      "middle:1: initializing y #2\n",
      "middle:1: setting y\n",
      "middle:1: initializing z #3\n",
      "middle:1: setting z\n",
      "middle:2: getting y\n",
      "middle:2: getting z\n",
      "middle:2: testing condition\n",
      "middle:3: entering block\n",
      "middle:3: getting x\n",
      "middle:3: getting y\n",
      "middle:3: testing condition\n",
      "middle:5: entering block\n",
      "middle:5: getting x\n",
      "middle:5: getting z\n",
      "middle:5: testing condition\n",
      "middle:6: entering block\n",
      "middle:6: getting y\n",
      "middle:6: setting <middle() return value>\n",
      "middle:6: exiting block\n",
      "middle:5: exiting block\n",
      "middle:3: exiting block\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(middle_tree, middle):\n",
    "    middle(2, 1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.489701Z",
     "iopub.status.busy": "2023-11-12T12:40:25.489542Z",
     "iopub.status.idle": "2023-11-12T12:40:25.491371Z",
     "shell.execute_reply": "2023-11-12T12:40:25.491102Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def args_test(x, *args, **kwargs):  # type: ignore\n",
    "    print(x, *args, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.493928Z",
     "iopub.status.busy": "2023-11-12T12:40:25.493686Z",
     "iopub.status.idle": "2023-11-12T12:40:25.528219Z",
     "shell.execute_reply": "2023-11-12T12:40:25.527747Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32margs_test\u001b[39;49;00m(x, *args, **kwargs):\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33margs\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, args, pos=\u001b[34m2\u001b[39;49;00m, vararg=\u001b[33m'\u001b[39;49;00m\u001b[33m*\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mkwargs\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, kwargs, pos=\u001b[34m3\u001b[39;49;00m, vararg=\u001b[33m'\u001b[39;49;00m\u001b[33m**\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[36mprint\u001b[39;49;00m(x, *args, **kwargs)\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "args_tree = ast.parse(inspect.getsource(args_test))\n",
    "TrackParamsTransformer().visit(args_tree)\n",
    "dump_tree(args_tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.530525Z",
     "iopub.status.busy": "2023-11-12T12:40:25.530354Z",
     "iopub.status.idle": "2023-11-12T12:40:25.532682Z",
     "shell.execute_reply": "2023-11-12T12:40:25.532312Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args_test:1: initializing x #1\n",
      "args_test:1: setting x\n",
      "args_test:1: initializing *args #2\n",
      "args_test:1: setting args\n",
      "args_test:1: initializing **kwargs #3\n",
      "args_test:1: setting kwargs\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "with DataTrackerTester(args_tree, args_test):\n",
    "    args_test(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What do we obtain after we have applied all these transformers on `middle()`? We see that the code now contains quite a load of instrumentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.535062Z",
     "iopub.status.busy": "2023-11-12T12:40:25.534914Z",
     "iopub.status.idle": "2023-11-12T12:40:25.570973Z",
     "shell.execute_reply": "2023-11-12T12:40:25.570592Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y, pos=\u001b[34m2\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z, pos=\u001b[34m3\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) < _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y)):\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y))\u001b[37m\u001b[39;49;00m\n",
      "            \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "                \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                    \u001b[34mif\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) > _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z)):\u001b[37m\u001b[39;49;00m\n",
      "                        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "                            \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<middle() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mz\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, z))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "dump_tree(middle_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "And when we execute this code, we see that we can track quite a number of events, while the code semantics stay unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.572723Z",
     "iopub.status.busy": "2023-11-12T12:40:25.572601Z",
     "iopub.status.idle": "2023-11-12T12:40:25.576239Z",
     "shell.execute_reply": "2023-11-12T12:40:25.575899Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle:1: initializing x #1\n",
      "middle:1: setting x\n",
      "middle:1: initializing y #2\n",
      "middle:1: setting y\n",
      "middle:1: initializing z #3\n",
      "middle:1: setting z\n",
      "middle:2: getting y\n",
      "middle:2: getting z\n",
      "middle:2: testing condition\n",
      "middle:3: entering block\n",
      "middle:3: getting x\n",
      "middle:3: getting y\n",
      "middle:3: testing condition\n",
      "middle:5: entering block\n",
      "middle:5: getting x\n",
      "middle:5: getting z\n",
      "middle:5: testing condition\n",
      "middle:6: entering block\n",
      "middle:6: getting y\n",
      "middle:6: setting <middle() return value>\n",
      "middle:6: exiting block\n",
      "middle:5: exiting block\n",
      "middle:3: exiting block\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with DataTrackerTester(middle_tree, middle):\n",
    "    m = middle(2, 1, 3)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Transformer Stress Test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We stress test our transformers by instrumenting, transforming, and compiling a number of modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.578775Z",
     "iopub.status.busy": "2023-11-12T12:40:25.578661Z",
     "iopub.status.idle": "2023-11-12T12:40:25.606137Z",
     "shell.execute_reply": "2023-11-12T12:40:25.605796Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import Assertions  # minor dependency\n",
    "import Debugger  # minor dependency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:25.608244Z",
     "iopub.status.busy": "2023-11-12T12:40:25.608093Z",
     "iopub.status.idle": "2023-11-12T12:40:26.660239Z",
     "shell.execute_reply": "2023-11-12T12:40:26.659838Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Assertions' instrumented successfully.\n",
      "'Debugger' instrumented successfully.\n",
      "'inspect' instrumented successfully.\n",
      "'ast' instrumented successfully.\n"
     ]
    }
   ],
   "source": [
    "for module in [Assertions, Debugger, inspect, ast]:\n",
    "    module_tree = ast.parse(inspect.getsource(module))\n",
    "    assert isinstance(module_tree, ast.Module)\n",
    "\n",
    "    TrackCallTransformer().visit(module_tree)\n",
    "    TrackSetTransformer().visit(module_tree)\n",
    "    TrackGetTransformer().visit(module_tree)\n",
    "    TrackControlTransformer().visit(module_tree)\n",
    "    TrackReturnTransformer().visit(module_tree)\n",
    "    TrackParamsTransformer().visit(module_tree)\n",
    "    # dump_tree(module_tree)\n",
    "    ast.fix_missing_locations(module_tree)  # Must run this before compiling\n",
    "\n",
    "    module_code = compile(module_tree, '<stress_test>', 'exec')\n",
    "    print(f\"{repr(module.__name__)} instrumented successfully.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our next step will now be not only to _log_ these events, but to actually construct _dependencies_ from them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tracking Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To construct dependencies from variable accesses, we subclass `DataTracker` into `DependencyTracker` – a class that actually keeps track of all these dependencies.  Its constructor initializes a number of variables we will discuss below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.662143Z",
     "iopub.status.busy": "2023-11-12T12:40:26.662018Z",
     "iopub.status.idle": "2023-11-12T12:40:26.665073Z",
     "shell.execute_reply": "2023-11-12T12:40:26.664693Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DataTracker):\n",
    "    \"\"\"Track dependencies during execution\"\"\"\n",
    "\n",
    "    def __init__(self, *args: Any, **kwargs: Any) -> None:\n",
    "        \"\"\"Constructor. Arguments are passed to DataTracker.__init__()\"\"\"\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "        self.origins: Dict[str, Location] = {}  # Where current variables were last set\n",
    "        self.data_dependencies: Dependency = {}  # As with Dependencies, above\n",
    "        self.control_dependencies: Dependency = {}\n",
    "\n",
    "        self.last_read: List[str] = []  # List of last read variables\n",
    "        self.last_checked_location = (StackInspector.unknown, 1)\n",
    "        self._ignore_location_change = False\n",
    "\n",
    "        self.data: List[List[str]] = [[]]  # Data stack\n",
    "        self.control: List[List[str]] = [[]]  # Control stack\n",
    "\n",
    "        self.frames: List[Dict[Union[int, str], Any]] = [{}]  # Argument stack\n",
    "        self.args: Dict[Union[int, str], Any] = {}  # Current args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Data Dependencies\n",
    "\n",
    "The first job of our `DependencyTracker` is to construct dependencies between _read_ and _written_ variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Reading Variables\n",
    "\n",
    "As in `DataTracker`, the key method of `DependencyTracker` again is `get()`, invoked as `_data.get('x', x)` whenever a variable `x` is read. First and foremost, it appends the name of the read variable to the list `last_read`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.666702Z",
     "iopub.status.busy": "2023-11-12T12:40:26.666602Z",
     "iopub.status.idle": "2023-11-12T12:40:26.668826Z",
     "shell.execute_reply": "2023-11-12T12:40:26.668551Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def get(self, name: str, value: Any) -> Any:\n",
    "        \"\"\"Track a read access for variable `name` with value `value`\"\"\"\n",
    "        self.check_location()\n",
    "        self.last_read.append(name)\n",
    "        return super().get(name, value)\n",
    "\n",
    "    def check_location(self) -> None:\n",
    "        pass  # More on that below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.670269Z",
     "iopub.status.busy": "2023-11-12T12:40:26.670182Z",
     "iopub.status.idle": "2023-11-12T12:40:26.671708Z",
     "shell.execute_reply": "2023-11-12T12:40:26.671466Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.673093Z",
     "iopub.status.busy": "2023-11-12T12:40:26.673005Z",
     "iopub.status.idle": "2023-11-12T12:40:26.675656Z",
     "shell.execute_reply": "2023-11-12T12:40:26.675259Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<cell line: 2>:2: getting x\n",
      "<cell line: 2>:2: getting y\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data = DependencyTracker(log=True)\n",
    "_test_data.get('x', x) + _test_data.get('y', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.677496Z",
     "iopub.status.busy": "2023-11-12T12:40:26.677391Z",
     "iopub.status.idle": "2023-11-12T12:40:26.679680Z",
     "shell.execute_reply": "2023-11-12T12:40:26.679402Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y']"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.last_read"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Checking Locations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "However, before appending the read variable to `last_read`, `_data.get()` does one more thing. By invoking `check_location()`, it clears the `last_read` list if we have reached a new line in the execution. This avoids situations such as\n",
    "\n",
    "```python\n",
    "x\n",
    "y\n",
    "z = a + b\n",
    "```\n",
    "where `x` and `y` are, well, read, but do not affect the last line. Therefore, with every new line, the list of last read lines is cleared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.681170Z",
     "iopub.status.busy": "2023-11-12T12:40:26.681082Z",
     "iopub.status.idle": "2023-11-12T12:40:26.684104Z",
     "shell.execute_reply": "2023-11-12T12:40:26.683850Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def clear_read(self) -> None:\n",
    "        \"\"\"Clear set of read variables\"\"\"\n",
    "        if self.log:\n",
    "            direct_caller = inspect.currentframe().f_back.f_code.co_name  # type: ignore\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"clearing read variables {self.last_read} \"\n",
    "                  f\"(from {direct_caller})\")\n",
    "\n",
    "        self.last_read = []\n",
    "\n",
    "    def check_location(self) -> None:\n",
    "        \"\"\"If we are in a new location, clear set of read variables\"\"\"\n",
    "        location = self.caller_location()\n",
    "        func, lineno = location\n",
    "        last_func, last_lineno = self.last_checked_location\n",
    "\n",
    "        if self.last_checked_location != location:\n",
    "            if self._ignore_location_change:\n",
    "                self._ignore_location_change = False\n",
    "            elif func.__name__.startswith('<'):\n",
    "                # Entering list comprehension, eval(), exec(), ...\n",
    "                pass\n",
    "            elif last_func.__name__.startswith('<'):\n",
    "                # Exiting list comprehension, eval(), exec(), ...\n",
    "                pass\n",
    "            else:\n",
    "                # Standard case\n",
    "                self.clear_read()\n",
    "\n",
    "        self.last_checked_location = location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Two methods can suppress this reset of the `last_read` list: \n",
    "\n",
    "* `ignore_next_location_change()` suppresses the reset for the next line. This is useful when returning from a function, when the return value is still in the list of \"read\" variables.\n",
    "* `ignore_location_change()` suppresses the reset for the current line. This is useful if we already have returned from a function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.685609Z",
     "iopub.status.busy": "2023-11-12T12:40:26.685528Z",
     "iopub.status.idle": "2023-11-12T12:40:26.687436Z",
     "shell.execute_reply": "2023-11-12T12:40:26.687182Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def ignore_next_location_change(self) -> None:\n",
    "        self._ignore_location_change = True\n",
    "\n",
    "    def ignore_location_change(self) -> None:\n",
    "        self.last_checked_location = self.caller_location()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Watch how `DependencyTracker` resets `last_read` when a new line is executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.689196Z",
     "iopub.status.busy": "2023-11-12T12:40:26.689094Z",
     "iopub.status.idle": "2023-11-12T12:40:26.690790Z",
     "shell.execute_reply": "2023-11-12T12:40:26.690529Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "_test_data = DependencyTracker()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.692502Z",
     "iopub.status.busy": "2023-11-12T12:40:26.692358Z",
     "iopub.status.idle": "2023-11-12T12:40:26.694780Z",
     "shell.execute_reply": "2023-11-12T12:40:26.694399Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.get('x', x) + _test_data.get('y', y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.696502Z",
     "iopub.status.busy": "2023-11-12T12:40:26.696370Z",
     "iopub.status.idle": "2023-11-12T12:40:26.698653Z",
     "shell.execute_reply": "2023-11-12T12:40:26.698298Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y']"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.last_read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.700712Z",
     "iopub.status.busy": "2023-11-12T12:40:26.700438Z",
     "iopub.status.idle": "2023-11-12T12:40:26.703061Z",
     "shell.execute_reply": "2023-11-12T12:40:26.702817Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 42\n",
    "b = -1\n",
    "_test_data.get('a', a) + _test_data.get('b', b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.704783Z",
     "iopub.status.busy": "2023-11-12T12:40:26.704656Z",
     "iopub.status.idle": "2023-11-12T12:40:26.706665Z",
     "shell.execute_reply": "2023-11-12T12:40:26.706372Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['x', 'y', 'a', 'b']"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.last_read"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Setting Variables\n",
    "\n",
    "The method `set()` creates dependencies. It is invoked as `_data.set('x', value)` whenever a variable `x` is set. \n",
    "\n",
    "First and foremost, it takes the list of variables read `last_read`, and for each of the variables $v$, it takes their origin $o$ (the place where they were last set) and appends the pair ($v$, $o$) to the list of data dependencies. It then does a similar thing with control dependencies (more on these below), and finally marks (in `self.origins`) the current location of $v$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.708486Z",
     "iopub.status.busy": "2023-11-12T12:40:26.708341Z",
     "iopub.status.idle": "2023-11-12T12:40:26.710211Z",
     "shell.execute_reply": "2023-11-12T12:40:26.709938Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.711841Z",
     "iopub.status.busy": "2023-11-12T12:40:26.711685Z",
     "iopub.status.idle": "2023-11-12T12:40:26.716053Z",
     "shell.execute_reply": "2023-11-12T12:40:26.715725Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    TEST = '<test>'  # Name of pseudo-variables for testing conditions\n",
    "\n",
    "    def set(self, name: str, value: Any, loads: Optional[Set[str]] = None) -> Any:\n",
    "        \"\"\"Add a dependency for `name` = `value`\"\"\"\n",
    "\n",
    "        def add_dependencies(dependencies: Set[Node], \n",
    "                             vars_read: List[str], tp: str) -> None:\n",
    "            \"\"\"Add origins of `vars_read` to `dependencies`.\"\"\"\n",
    "            for var_read in vars_read:\n",
    "                if var_read in self.origins:\n",
    "                    if var_read == self.TEST and tp == \"data\":\n",
    "                        # Can't have data dependencies on conditions\n",
    "                        continue\n",
    "\n",
    "                    origin = self.origins[var_read]\n",
    "                    dependencies.add((var_read, origin))\n",
    "\n",
    "                    if self.log:\n",
    "                        origin_func, origin_lineno = origin\n",
    "                        caller_func, lineno = self.caller_location()\n",
    "                        print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                              f\"new {tp} dependency: \"\n",
    "                              f\"{name} <= {var_read} \"\n",
    "                              f\"({origin_func.__name__}:{origin_lineno})\")\n",
    "\n",
    "        self.check_location()\n",
    "        ret = super().set(name, value)\n",
    "        location = self.caller_location()\n",
    "\n",
    "        add_dependencies(self.data_dependencies.setdefault\n",
    "                         ((name, location), set()),\n",
    "                         self.last_read, tp=\"data\")\n",
    "        add_dependencies(self.control_dependencies.setdefault\n",
    "                         ((name, location), set()),\n",
    "                         cast(List[str], itertools.chain.from_iterable(self.control)),\n",
    "                         tp=\"control\")\n",
    "\n",
    "        self.origins[name] = location\n",
    "\n",
    "        # Reset read info for next line\n",
    "        self.last_read = [name]\n",
    "\n",
    "        # Next line is a new location\n",
    "        self._ignore_location_change = False\n",
    "\n",
    "        return ret\n",
    "\n",
    "    def dependencies(self) -> Dependencies:\n",
    "        \"\"\"Return dependencies\"\"\"\n",
    "        return Dependencies(self.data_dependencies,\n",
    "                            self.control_dependencies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us illustrate `set()` by example. Here's a set of variables read and written:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.717705Z",
     "iopub.status.busy": "2023-11-12T12:40:26.717603Z",
     "iopub.status.idle": "2023-11-12T12:40:26.719968Z",
     "shell.execute_reply": "2023-11-12T12:40:26.719679Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "_test_data = DependencyTracker()\n",
    "x = _test_data.set('x', 1)\n",
    "y = _test_data.set('y', _test_data.get('x', x))\n",
    "z = _test_data.set('z', _test_data.get('x', x) + _test_data.get('y', y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The attribute `origins` saves for each variable where it was last written:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.721585Z",
     "iopub.status.busy": "2023-11-12T12:40:26.721482Z",
     "iopub.status.idle": "2023-11-12T12:40:26.723847Z",
     "shell.execute_reply": "2023-11-12T12:40:26.723547Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x': (<function __main__.<cell line: 2>()>, 2),\n",
       " 'y': (<function __main__.<cell line: 3>()>, 3),\n",
       " 'z': (<function __main__.<cell line: 4>()>, 4)}"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.origins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The attribute `data_dependencies` tracks for each variable the variables it was read from:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.725687Z",
     "iopub.status.busy": "2023-11-12T12:40:26.725552Z",
     "iopub.status.idle": "2023-11-12T12:40:26.728080Z",
     "shell.execute_reply": "2023-11-12T12:40:26.727823Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('x', (<function __main__.<cell line: 2>()>, 2)): set(),\n",
       " ('y',\n",
       "  (<function __main__.<cell line: 3>()>, 3)): {('x',\n",
       "   (<function __main__.<cell line: 2>()>, 2))},\n",
       " ('z',\n",
       "  (<function __main__.<cell line: 4>()>, 4)): {('x',\n",
       "   (<function __main__.<cell line: 2>()>, 2)), ('y',\n",
       "   (<function __main__.<cell line: 3>()>, 3))}}"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.data_dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hence, the above code already gives us a small dependency graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:26.729709Z",
     "iopub.status.busy": "2023-11-12T12:40:26.729582Z",
     "iopub.status.idle": "2023-11-12T12:40:27.150451Z",
     "shell.execute_reply": "2023-11-12T12:40:27.150062Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"134pt\" height=\"200pt\"\n",
       " viewBox=\"0.00 0.00 133.50 200.00\" 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 196)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-196 129.5,-196 129.5,4 -4,4\"/>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"&lt;cell line: 2&gt;:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"125.5,-192 36,-192 36,-152 125.5,-152 125.5,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"76.62\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"44\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 2&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functioncellline_3at0x105d98a60_3 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>y_functioncellline_3at0x105d98a60_3</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"&lt;cell line: 3&gt;:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"89.5,-116 0,-116 0,-76 89.5,-76 89.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"40.62\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 3&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2&#45;&gt;y_functioncellline_3at0x105d98a60_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2&#45;&gt;y_functioncellline_3at0x105d98a60_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M71.29,-151.56C67.57,-143.91 63.22,-134.96 59.12,-126.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"62.33,-125.14 54.81,-117.67 56.03,-128.2 62.33,-125.14\"/>\n",
       "</g>\n",
       "<!-- z_functioncellline_4at0x105d98dc0_4 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>z_functioncellline_4at0x105d98dc0_4</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"&lt;cell line: 4&gt;:4\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"125.5,-40 36,-40 36,0 125.5,0 125.5,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"76.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"44\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 4&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2&#45;&gt;z_functioncellline_4at0x105d98dc0_4 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2&#45;&gt;z_functioncellline_4at0x105d98dc0_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M88.8,-151.52C92.64,-141.16 96.82,-128.1 98.75,-116 101.55,-98.44 101.55,-93.56 98.75,-76 97.44,-67.77 95.09,-59.1 92.51,-51.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"95.89,-50.2 89.29,-41.91 89.28,-52.51 95.89,-50.2\"/>\n",
       "</g>\n",
       "<!-- y_functioncellline_3at0x105d98a60_3&#45;&gt;z_functioncellline_4at0x105d98dc0_4 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>y_functioncellline_3at0x105d98a60_3&#45;&gt;z_functioncellline_4at0x105d98dc0_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M54.21,-75.56C57.93,-67.91 62.28,-58.96 66.38,-50.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"69.47,-52.2 70.69,-41.67 63.17,-49.14 69.47,-52.2\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x107471270>"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "_test_data.dependencies().graph()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In the remainder of this section, we define methods to\n",
    "\n",
    "* track control dependencies (`test()`, `__enter__()`, `__exit__()`)\n",
    "* track function calls and returns (`call()`, `ret()`)\n",
    "* track function arguments (`arg()`, `param()`)\n",
    "* check the validity of our dependencies (`validate()`).\n",
    "\n",
    "Like our `get()` and `set()` methods above, these work by refining the appropriate methods defined in the `DataTracker` class, building on our `NodeTransformer` transformations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Control Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us detail control dependencies. As discussed with `DataTracker()`, we invoke `test()` methods for all control conditions, and place the controlled blocks into `with` clauses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `test()` method simply sets a `<test>` variable; this also places it in `last_read`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.152161Z",
     "iopub.status.busy": "2023-11-12T12:40:27.152043Z",
     "iopub.status.idle": "2023-11-12T12:40:27.154219Z",
     "shell.execute_reply": "2023-11-12T12:40:27.153943Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def test(self, value: Any) -> Any:\n",
    "        \"\"\"Track a test for condition `value`\"\"\"\n",
    "        self.set(self.TEST, value)\n",
    "        return super().test(value)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When entering a `with` block, the set of `last_read` variables holds the `<test>` variable read. We save it in the `control` stack, with the effect of any further variables written now being marked as controlled by `<test>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.155682Z",
     "iopub.status.busy": "2023-11-12T12:40:27.155563Z",
     "iopub.status.idle": "2023-11-12T12:40:27.157619Z",
     "shell.execute_reply": "2023-11-12T12:40:27.157344Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def __enter__(self) -> Any:\n",
    "        \"\"\"Track entering an if/while/for block\"\"\"\n",
    "        self.control.append(self.last_read)\n",
    "        self.clear_read()\n",
    "        return super().__enter__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "When we exit the `with` block, we restore earlier `last_read` values, preparing for `else` blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.159153Z",
     "iopub.status.busy": "2023-11-12T12:40:27.159036Z",
     "iopub.status.idle": "2023-11-12T12:40:27.161222Z",
     "shell.execute_reply": "2023-11-12T12:40:27.160961Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def __exit__(self, exc_type: Type, exc_value: BaseException,\n",
    "                 traceback: TracebackType) -> Optional[bool]:\n",
    "        \"\"\"Track exiting an if/while/for block\"\"\"\n",
    "        self.clear_read()\n",
    "        self.last_read = self.control.pop()\n",
    "        self.ignore_next_location_change()\n",
    "        return super().__exit__(exc_type, exc_value, traceback)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here's an example of all these parts in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.163231Z",
     "iopub.status.busy": "2023-11-12T12:40:27.163078Z",
     "iopub.status.idle": "2023-11-12T12:40:27.165259Z",
     "shell.execute_reply": "2023-11-12T12:40:27.164956Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "_test_data = DependencyTracker()\n",
    "x = _test_data.set('x', 1)\n",
    "y = _test_data.set('y', _test_data.get('x', x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.166771Z",
     "iopub.status.busy": "2023-11-12T12:40:27.166651Z",
     "iopub.status.idle": "2023-11-12T12:40:27.168803Z",
     "shell.execute_reply": "2023-11-12T12:40:27.168541Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "if _test_data.test(_test_data.get('x', x) >= _test_data.get('y', y)):\n",
    "    with _test_data:\n",
    "        z = _test_data.set('z',\n",
    "                           _test_data.get('x', x) + _test_data.get('y', y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.170210Z",
     "iopub.status.busy": "2023-11-12T12:40:27.170096Z",
     "iopub.status.idle": "2023-11-12T12:40:27.172825Z",
     "shell.execute_reply": "2023-11-12T12:40:27.172541Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('x', (<function __main__.<cell line: 2>()>, 2)): set(),\n",
       " ('y', (<function __main__.<cell line: 3>()>, 3)): set(),\n",
       " ('<test>', (<function __main__.<cell line: 1>()>, 1)): set(),\n",
       " ('z',\n",
       "  (<function __main__.<cell line: 1>()>, 3)): {('<test>',\n",
       "   (<function __main__.<cell line: 1>()>, 1))}}"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_test_data.control_dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The control dependency for `z` is reflected in the dependency graph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.174270Z",
     "iopub.status.busy": "2023-11-12T12:40:27.174157Z",
     "iopub.status.idle": "2023-11-12T12:40:27.620469Z",
     "shell.execute_reply": "2023-11-12T12:40:27.620060Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"213pt\" height=\"276pt\"\n",
       " viewBox=\"0.00 0.00 212.50 276.00\" 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 272)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-272 208.5,-272 208.5,4 -4,4\"/>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"&lt;cell line: 2&gt;:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"176.5,-268 87,-268 87,-228 176.5,-228 176.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"127.62\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"95\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 2&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functioncellline_3at0x105d98a60_3 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>y_functioncellline_3at0x105d98a60_3</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"&lt;cell line: 3&gt;:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"176.5,-192 87,-192 87,-152 176.5,-152 176.5,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"127.62\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"95\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 3&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2&#45;&gt;y_functioncellline_3at0x105d98a60_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2&#45;&gt;y_functioncellline_3at0x105d98a60_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M131.75,-227.56C131.75,-220.25 131.75,-211.75 131.75,-203.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"135.25,-203.83 131.75,-193.83 128.25,-203.83 135.25,-203.83\"/>\n",
       "</g>\n",
       "<!-- test_functioncellline_1at0x104c69fc0_1 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>test_functioncellline_1at0x104c69fc0_1</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"&lt;cell line: 1&gt;:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"131.5,-116 0,-116 0,-76 131.5,-76 131.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"41\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">_test_data.get(&#39;x&#39;, x)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2&#45;&gt;test_functioncellline_1at0x104c69fc0_1 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2&#45;&gt;test_functioncellline_1at0x104c69fc0_1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M106.47,-227.68C95.83,-218.14 84.4,-205.73 77.75,-192 68.08,-172.02 65.23,-147.04 64.72,-127.71\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"68.22,-127.71 64.68,-117.73 61.22,-127.74 68.22,-127.71\"/>\n",
       "</g>\n",
       "<!-- z_functioncellline_1at0x105d993f0_3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>z_functioncellline_1at0x105d993f0_3</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"&lt;cell line: 1&gt;:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"204.5,-40 115,-40 115,0 204.5,0 204.5,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"155.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"123\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">&lt;cell line: 1&gt;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncellline_2at0x104c6a710_2&#45;&gt;z_functioncellline_1at0x105d993f0_3 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>x_functioncellline_2at0x104c6a710_2&#45;&gt;z_functioncellline_1at0x105d993f0_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M158.4,-227.54C169.03,-218.13 180.08,-205.87 185.75,-192 204.93,-145.1 187.53,-85.73 173.44,-50.71\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"176.72,-49.5 169.62,-41.64 170.27,-52.21 176.72,-49.5\"/>\n",
       "</g>\n",
       "<!-- y_functioncellline_3at0x105d98a60_3&#45;&gt;test_functioncellline_1at0x104c69fc0_1 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>y_functioncellline_3at0x105d98a60_3&#45;&gt;test_functioncellline_1at0x104c69fc0_1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M114.41,-151.56C107.13,-143.4 98.54,-133.76 90.61,-124.87\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"93.25,-122.58 83.98,-117.44 88.03,-127.23 93.25,-122.58\"/>\n",
       "</g>\n",
       "<!-- y_functioncellline_3at0x105d98a60_3&#45;&gt;z_functioncellline_1at0x105d993f0_3 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>y_functioncellline_3at0x105d98a60_3&#45;&gt;z_functioncellline_1at0x105d993f0_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M135.35,-151.7C140.1,-126.27 148.5,-81.28 154.1,-51.29\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"157.49,-52.19 155.88,-41.72 150.61,-50.9 157.49,-52.19\"/>\n",
       "</g>\n",
       "<!-- test_functioncellline_1at0x104c69fc0_1&#45;&gt;z_functioncellline_1at0x105d993f0_3 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>test_functioncellline_1at0x104c69fc0_1&#45;&gt;z_functioncellline_1at0x105d993f0_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M90.45,-75.56C101.46,-66.89 114.59,-56.55 126.45,-47.21\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"128.34,-50.18 134.03,-41.25 124.01,-44.68 128.34,-50.18\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        ('x', (<cell line: 2>, 2)): set(),\n",
       "        ('y', (<cell line: 3>, 3)): {('x', (<cell line: 2>, 2))},\n",
       "        ('<test>', (<cell line: 1>, 1)): {('x', (<cell line: 2>, 2)), ('y', (<cell line: 3>, 3))},\n",
       "        ('z', (<cell line: 1>, 3)): {('x', (<cell line: 2>, 2)), ('y', (<cell line: 3>, 3))}},\n",
       " control={\n",
       "        ('x', (<cell line: 2>, 2)): set(),\n",
       "        ('y', (<cell line: 3>, 3)): set(),\n",
       "        ('<test>', (<cell line: 1>, 1)): set(),\n",
       "        ('z', (<cell line: 1>, 3)): {('<test>', (<cell line: 1>, 1))}})"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "_test_data.dependencies()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Calls and Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.622285Z",
     "iopub.status.busy": "2023-11-12T12:40:27.622161Z",
     "iopub.status.idle": "2023-11-12T12:40:27.623997Z",
     "shell.execute_reply": "2023-11-12T12:40:27.623654Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To handle complex expressions involving functions, we introduce a _data stack_. Every time we invoke a function `func` (`call()` is invoked), we save the list of current variables read `last_read` on the `data` stack; when we return (`ret()` is invoked), we restore `last_read`. This also ensures that only those variables read while evaluating arguments will flow into the function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.625792Z",
     "iopub.status.busy": "2023-11-12T12:40:27.625661Z",
     "iopub.status.idle": "2023-11-12T12:40:27.628703Z",
     "shell.execute_reply": "2023-11-12T12:40:27.628376Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def call(self, func: Callable) -> Callable:\n",
    "        \"\"\"Track a call of function `func`\"\"\"\n",
    "        func = super().call(func)\n",
    "\n",
    "        if inspect.isgeneratorfunction(func):\n",
    "            return self.call_generator(func)\n",
    "\n",
    "        # Save context\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"saving read variables {self.last_read}\")\n",
    "\n",
    "        self.data.append(self.last_read)\n",
    "        self.clear_read()\n",
    "        self.ignore_next_location_change()\n",
    "\n",
    "        self.frames.append(self.args)\n",
    "        self.args = {}\n",
    "\n",
    "        return func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.630209Z",
     "iopub.status.busy": "2023-11-12T12:40:27.630114Z",
     "iopub.status.idle": "2023-11-12T12:40:27.633554Z",
     "shell.execute_reply": "2023-11-12T12:40:27.633249Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def ret(self, value: Any) -> Any:\n",
    "        \"\"\"Track a function return\"\"\"\n",
    "        value = super().ret(value)\n",
    "\n",
    "        if self.in_generator():\n",
    "            return self.ret_generator(value)\n",
    "\n",
    "        # Restore old context and add return value\n",
    "        ret_name = None\n",
    "        for var in self.last_read:\n",
    "            if var.startswith(\"<\"):  # \"<return value>\"\n",
    "                ret_name = var\n",
    "\n",
    "        self.last_read = self.data.pop()\n",
    "        if ret_name:\n",
    "            self.last_read.append(ret_name)\n",
    "\n",
    "        if self.args:\n",
    "            # We return from an uninstrumented function:\n",
    "            # Make return value depend on all args\n",
    "            for key, deps in self.args.items():\n",
    "                self.last_read += deps\n",
    "\n",
    "        self.ignore_location_change()\n",
    "\n",
    "        self.args = self.frames.pop()\n",
    "\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"restored read variables {self.last_read}\")\n",
    "\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Generator functions (those which `yield` a value) are not \"called\" in the sense that Python transfers control to them; instead, a \"call\" to a generator function creates a generator that is evaluated on demand. We mark generator function \"calls\" by saving `None` on the stacks. When the generator function returns the generator, we wrap the generator such that the arguments are being restored when it is invoked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.635090Z",
     "iopub.status.busy": "2023-11-12T12:40:27.634997Z",
     "iopub.status.idle": "2023-11-12T12:40:27.638676Z",
     "shell.execute_reply": "2023-11-12T12:40:27.638407Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def in_generator(self) -> bool:\n",
    "        \"\"\"True if we are calling a generator function\"\"\"\n",
    "        return len(self.data) > 0 and self.data[-1] is None\n",
    "\n",
    "    def call_generator(self, func: Callable) -> Callable:\n",
    "        \"\"\"Track a call of a generator function\"\"\"\n",
    "        # Mark the fact that we're in a generator with `None` values\n",
    "        self.data.append(None)  # type: ignore\n",
    "        self.frames.append(None)  # type: ignore\n",
    "        assert self.in_generator()\n",
    "\n",
    "        self.clear_read()\n",
    "        return func\n",
    "\n",
    "    def ret_generator(self, generator: Any) -> Any:\n",
    "        \"\"\"Track the return of a generator function\"\"\"\n",
    "        # Pop the two 'None' values pushed earlier\n",
    "        self.data.pop()\n",
    "        self.frames.pop()\n",
    "\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"wrapping generator {generator} (args={self.args})\")\n",
    "\n",
    "        # At this point, we already have collected the args.\n",
    "        # The returned generator depends on all of them.\n",
    "        for arg in self.args:\n",
    "            self.last_read += self.args[arg]\n",
    "\n",
    "        # Wrap the generator such that the args are restored \n",
    "        # when it is actually invoked, such that we can map them\n",
    "        # to parameters.\n",
    "        saved_args = copy.deepcopy(self.args)\n",
    "\n",
    "        def wrapper() -> Generator[Any, None, None]:\n",
    "            self.args = saved_args\n",
    "            if self.log:\n",
    "                caller_func, lineno = self.caller_location()\n",
    "                print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"calling generator (args={self.args})\")\n",
    "\n",
    "            self.ignore_next_location_change()\n",
    "            yield from generator\n",
    "\n",
    "        return wrapper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We see an example of how function calls and returns work in conjunction with function arguments, discussed in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Function Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Finally, we handle parameters and arguments. The `args` stack holds the current stack of function arguments, holding the `last_read` variable for each argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.640288Z",
     "iopub.status.busy": "2023-11-12T12:40:27.640196Z",
     "iopub.status.idle": "2023-11-12T12:40:27.643357Z",
     "shell.execute_reply": "2023-11-12T12:40:27.643053Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def arg(self, value: Any, pos: Optional[int] = None, kw: Optional[str] = None) -> Any:\n",
    "        \"\"\"\n",
    "        Track passing an argument `value`\n",
    "        (with given position `pos` 1..n or keyword `kw`)\n",
    "        \"\"\"\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"saving args read {self.last_read}\")\n",
    "\n",
    "        if pos:\n",
    "            self.args[pos] = self.last_read\n",
    "        if kw:\n",
    "            self.args[kw] = self.last_read\n",
    "\n",
    "        self.clear_read()\n",
    "        return super().arg(value, pos, kw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When accessing the arguments (with `param()`), we can retrieve this set of read variables for each argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.644903Z",
     "iopub.status.busy": "2023-11-12T12:40:27.644788Z",
     "iopub.status.idle": "2023-11-12T12:40:27.648345Z",
     "shell.execute_reply": "2023-11-12T12:40:27.648070Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTracker(DependencyTracker):\n",
    "    def param(self, name: str, value: Any,\n",
    "              pos: Optional[int] = None, vararg: str = \"\", last: bool = False) -> Any:\n",
    "        \"\"\"\n",
    "        Track getting a parameter `name` with value `value`\n",
    "        (with given position `pos`).\n",
    "        vararg parameters are indicated by setting `varargs` to \n",
    "        '*' (*args) or '**' (**kwargs)\n",
    "        \"\"\"\n",
    "        self.clear_read()\n",
    "\n",
    "        if vararg == '*':\n",
    "            # We over-approximate by setting `args` to _all_ positional args\n",
    "            for index in self.args:\n",
    "                if isinstance(index, int) and pos is not None and index >= pos:\n",
    "                    self.last_read += self.args[index]\n",
    "        elif vararg == '**':\n",
    "            # We over-approximate by setting `kwargs` to _all_ passed keyword args\n",
    "            for index in self.args:\n",
    "                if isinstance(index, str):\n",
    "                    self.last_read += self.args[index]\n",
    "        elif name in self.args:\n",
    "            self.last_read = self.args[name]\n",
    "        elif pos in self.args:\n",
    "            self.last_read = self.args[pos]\n",
    "\n",
    "        if self.log:\n",
    "            caller_func, lineno = self.caller_location()\n",
    "            print(f\"{caller_func.__name__}:{lineno}: \"\n",
    "                  f\"restored params read {self.last_read}\")\n",
    "\n",
    "        self.ignore_location_change()\n",
    "        ret = super().param(name, value, pos)\n",
    "\n",
    "        if last:\n",
    "            self.clear_read()\n",
    "            self.args = {}  # Mark `args` as processed\n",
    "\n",
    "        return ret"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us illustrate all these on a small example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.649927Z",
     "iopub.status.busy": "2023-11-12T12:40:27.649837Z",
     "iopub.status.idle": "2023-11-12T12:40:27.652448Z",
     "shell.execute_reply": "2023-11-12T12:40:27.652190Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def call_test() -> int:\n",
    "    c = 47\n",
    "\n",
    "    def sq(n: int) -> int:\n",
    "        return n * n\n",
    "\n",
    "    def gen(e: int) -> Generator[int, None, None]:\n",
    "        yield e * c\n",
    "\n",
    "    def just_x(x: Any, y: Any) -> Any:\n",
    "        return x\n",
    "\n",
    "    a = 42\n",
    "    b = gen(a)\n",
    "    d = list(b)[0]\n",
    "\n",
    "    xs = [1, 2, 3, 4]\n",
    "    ys = [sq(elem) for elem in xs if elem > 2]\n",
    "\n",
    "    return just_x(just_x(d, y=b), ys[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.654098Z",
     "iopub.status.busy": "2023-11-12T12:40:27.653988Z",
     "iopub.status.idle": "2023-11-12T12:40:27.656377Z",
     "shell.execute_reply": "2023-11-12T12:40:27.656141Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1974"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "call_test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We apply all our transformers on this code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.657884Z",
     "iopub.status.busy": "2023-11-12T12:40:27.657768Z",
     "iopub.status.idle": "2023-11-12T12:40:27.702145Z",
     "shell.execute_reply": "2023-11-12T12:40:27.701821Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mcall_test\u001b[39;49;00m() -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    c = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m47\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mdef\u001b[39;49;00m \u001b[32msq\u001b[39;49;00m(n: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "        _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mn\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, n, pos=\u001b[34m1\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<sq() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mn\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, n) * _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mn\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, n))\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mdef\u001b[39;49;00m \u001b[32mgen\u001b[39;49;00m(e: \u001b[36mint\u001b[39;49;00m) -> Generator[\u001b[36mint\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m]:\u001b[37m\u001b[39;49;00m\n",
      "        _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33me\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, e, pos=\u001b[34m1\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34myield\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<gen() yield value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33me\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, e) * _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mc\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, c))\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mdef\u001b[39;49;00m \u001b[32mjust_x\u001b[39;49;00m(x: Any, y: Any) -> Any:\u001b[37m\u001b[39;49;00m\n",
      "        _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "        _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, y, pos=\u001b[34m2\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<just_x() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "    a = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34m42\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    b = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mgen\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, gen))(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33ma\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, a), pos=\u001b[34m1\u001b[39;49;00m))))\u001b[37m\u001b[39;49;00m\n",
      "    d = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.ret(_data.call(\u001b[36mlist\u001b[39;49;00m)(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, b), pos=\u001b[34m1\u001b[39;49;00m)))[\u001b[34m0\u001b[39;49;00m])\u001b[37m\u001b[39;49;00m\n",
      "    xs = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mxs\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, [\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m, \u001b[34m3\u001b[39;49;00m, \u001b[34m4\u001b[39;49;00m])\u001b[37m\u001b[39;49;00m\n",
      "    ys = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mys\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, [_data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33msq\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, sq))(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33melem\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, elem), pos=\u001b[34m1\u001b[39;49;00m))) \u001b[34mfor\u001b[39;49;00m elem \u001b[35min\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33melem\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mxs\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, xs)) \u001b[34mif\u001b[39;49;00m _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33melem\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, elem) > \u001b[34m2\u001b[39;49;00m])\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<call_test() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mjust_x\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, just_x))(_data.arg(_data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mjust_x\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, just_x))(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33md\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, d), pos=\u001b[34m1\u001b[39;49;00m), y=_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mb\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, b), kw=\u001b[33m'\u001b[39;49;00m\u001b[33my\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m))), pos=\u001b[34m1\u001b[39;49;00m), _data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mys\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, ys)[\u001b[34m0\u001b[39;49;00m], pos=\u001b[34m2\u001b[39;49;00m))))\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "call_tree = ast.parse(inspect.getsource(call_test))\n",
    "TrackCallTransformer().visit(call_tree)\n",
    "TrackSetTransformer().visit(call_tree)\n",
    "TrackGetTransformer().visit(call_tree)\n",
    "TrackControlTransformer().visit(call_tree)\n",
    "TrackReturnTransformer().visit(call_tree)\n",
    "TrackParamsTransformer().visit(call_tree)\n",
    "dump_tree(call_tree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Again, we capture the dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.703924Z",
     "iopub.status.busy": "2023-11-12T12:40:27.703792Z",
     "iopub.status.idle": "2023-11-12T12:40:27.705822Z",
     "shell.execute_reply": "2023-11-12T12:40:27.705535Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DependencyTrackerTester(DataTrackerTester):\n",
    "    def make_data_tracker(self) -> DependencyTracker:\n",
    "        return DependencyTracker(log=self.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.707504Z",
     "iopub.status.busy": "2023-11-12T12:40:27.707359Z",
     "iopub.status.idle": "2023-11-12T12:40:27.711017Z",
     "shell.execute_reply": "2023-11-12T12:40:27.710667Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with DependencyTrackerTester(call_tree, call_test, log=False) as call_deps:\n",
    "    call_test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We see how \n",
    "\n",
    "* `a` flows into the generator `b` and into the parameter `e` of `gen()`.\n",
    "* `xs` flows into `elem` which in turn flows into the parameter `n` of `sq()`. Both flow into `ys`.\n",
    "* `just_x()` returns only its `x` argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:27.712950Z",
     "iopub.status.busy": "2023-11-12T12:40:27.712836Z",
     "iopub.status.idle": "2023-11-12T12:40:28.248111Z",
     "shell.execute_reply": "2023-11-12T12:40:28.247655Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"738pt\" height=\"656pt\"\n",
       " viewBox=\"0.00 0.00 737.50 656.00\" 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 652)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-652 733.5,-652 733.5,4 -4,4\"/>\n",
       "<!-- e_functioncall_testlocalsgenat0x105d98790_7 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>e_functioncall_testlocalsgenat0x105d98790_7</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"gen:7\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"655,-496 397.5,-496 397.5,-456 655,-456 655,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"522.12\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">e</text>\n",
       "<text text-anchor=\"start\" x=\"405.5\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def gen(e: int) &#45;&gt; Generator[int, None, None]:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- genyieldvalue_functioncall_testlocalsgenat0x105d98790_8 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>genyieldvalue_functioncall_testlocalsgenat0x105d98790_8</title>\n",
       "<g id=\"a_node11\"><a xlink:title=\"gen:8\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"612.62,-420 439.88,-420 439.88,-380 612.62,-380 612.62,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"447.88\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;gen() yield value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"497.38\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">yield e * c</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- e_functioncall_testlocalsgenat0x105d98790_7&#45;&gt;genyieldvalue_functioncall_testlocalsgenat0x105d98790_8 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>e_functioncall_testlocalsgenat0x105d98790_7&#45;&gt;genyieldvalue_functioncall_testlocalsgenat0x105d98790_8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M520.23,-455.56C519.57,-448.25 519.36,-439.75 519.59,-431.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"523.07,-432.01 520.15,-421.82 516.09,-431.61 523.07,-432.01\"/>\n",
       "</g>\n",
       "<!-- e_functioncall_testlocalsgenat0x105d98790_7&#45;&gt;genyieldvalue_functioncall_testlocalsgenat0x105d98790_8 -->\n",
       "<!-- a_functioncall_testat0x104da7e20_13 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>a_functioncall_testat0x104da7e20_13</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"call_test:13\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"470.25,-572 416.25,-572 416.25,-532 470.25,-532 470.25,-572\"/>\n",
       "<text text-anchor=\"start\" x=\"439.12\" y=\"-555.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">a</text>\n",
       "<text text-anchor=\"start\" x=\"427.5\" y=\"-537.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">a = 42</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- a_functioncall_testat0x104da7e20_13&#45;&gt;e_functioncall_testlocalsgenat0x105d98790_7 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>a_functioncall_testat0x104da7e20_13&#45;&gt;e_functioncall_testlocalsgenat0x105d98790_7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M465.06,-531.56C474.59,-523.06 485.92,-512.95 496.23,-503.76\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"498.32,-506.59 503.46,-497.32 493.67,-501.36 498.32,-506.59\"/>\n",
       "</g>\n",
       "<!-- b_functioncall_testat0x104da7e20_14 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>b_functioncall_testat0x104da7e20_14</title>\n",
       "<g id=\"a_node10\"><a xlink:title=\"call_test:14\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"394.5,-420 326,-420 326,-380 394.5,-380 394.5,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"356.12\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">b</text>\n",
       "<text text-anchor=\"start\" x=\"334\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">b = gen(a)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- a_functioncall_testat0x104da7e20_13&#45;&gt;b_functioncall_testat0x104da7e20_14 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>a_functioncall_testat0x104da7e20_13&#45;&gt;b_functioncall_testat0x104da7e20_14</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M415.97,-535.8C402.91,-525.68 388.42,-511.44 379.25,-496 367.47,-476.17 360.35,-451.03 357.53,-431.6\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"361.03,-431.41 356.49,-421.84 354.07,-432.15 361.03,-431.41\"/>\n",
       "</g>\n",
       "<!-- a_functioncall_testat0x104da7e20_13&#45;&gt;b_functioncall_testat0x104da7e20_14 -->\n",
       "<!-- elem_functioncall_testat0x104da7e20_18 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>elem_functioncall_testat0x104da7e20_18</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"call_test:18\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"729.5,-192 493,-192 493,-152 729.5,-152 729.5,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"594.75\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">elem</text>\n",
       "<text text-anchor=\"start\" x=\"501\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">ys = [sq(elem) for elem in xs if elem &gt; 2]</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- n_functioncall_testlocalssqat0x104c68b80_4 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>n_functioncall_testlocalssqat0x104c68b80_4</title>\n",
       "<g id=\"a_node13\"><a xlink:title=\"sq:4\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"677,-116 545.5,-116 545.5,-76 677,-76 677,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"607.12\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">n</text>\n",
       "<text text-anchor=\"start\" x=\"553.5\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def sq(n: int) &#45;&gt; int:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- elem_functioncall_testat0x104da7e20_18&#45;&gt;n_functioncall_testlocalssqat0x104c68b80_4 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>elem_functioncall_testat0x104da7e20_18&#45;&gt;n_functioncall_testlocalssqat0x104c68b80_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M611.25,-151.56C611.25,-144.25 611.25,-135.75 611.25,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"614.75,-127.83 611.25,-117.83 607.75,-127.83 614.75,-127.83\"/>\n",
       "</g>\n",
       "<!-- xs_functioncall_testat0x104da7e20_17 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>xs_functioncall_testat0x104da7e20_17</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"call_test:17\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"663.88,-268 558.62,-268 558.62,-228 663.88,-228 663.88,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"603\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">xs</text>\n",
       "<text text-anchor=\"start\" x=\"566.62\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">xs = [1, 2, 3, 4]</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- xs_functioncall_testat0x104da7e20_17&#45;&gt;elem_functioncall_testat0x104da7e20_18 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>xs_functioncall_testat0x104da7e20_17&#45;&gt;elem_functioncall_testat0x104da7e20_18</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M605.23,-227.56C604.57,-220.25 604.36,-211.75 604.59,-203.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"608.07,-204.01 605.15,-193.82 601.09,-203.61 608.07,-204.01\"/>\n",
       "</g>\n",
       "<!-- xs_functioncall_testat0x104da7e20_17&#45;&gt;elem_functioncall_testat0x104da7e20_18 -->\n",
       "<!-- x_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>x_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"just_x:10\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"540.5,-268 346,-268 346,-228 540.5,-228 540.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"439.12\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"354\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def just_x(x: Any, y: Any) &#45;&gt; Any:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"just_x:11\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"408.12,-192 202.38,-192 202.38,-152 408.12,-152 408.12,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"210.38\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;just_x() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"284.25\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return x</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functioncall_testlocalsjust_xat0x105d99cf0_10&#45;&gt;just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11 -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>x_functioncall_testlocalsjust_xat0x105d99cf0_10&#45;&gt;just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M400.97,-227.56C383.2,-218.47 362.68,-207.53 345.17,-197.85\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"347.01,-194.87 336.58,-193.05 343.6,-200.98 347.01,-194.87\"/>\n",
       "</g>\n",
       "<!-- d_functioncall_testat0x104da7e20_15 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>d_functioncall_testat0x104da7e20_15</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"call_test:15\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"488,-344 398.5,-344 398.5,-304 488,-304 488,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"439.12\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">d</text>\n",
       "<text text-anchor=\"start\" x=\"406.5\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">d = list(b)[0]</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- d_functioncall_testat0x104da7e20_15&#45;&gt;xs_functioncall_testat0x104da7e20_17 -->\n",
       "<!-- d_functioncall_testat0x104da7e20_15&#45;&gt;x_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>d_functioncall_testat0x104da7e20_15&#45;&gt;x_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M443.25,-303.56C443.25,-296.25 443.25,-287.75 443.25,-279.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"446.75,-279.83 443.25,-269.83 439.75,-279.83 446.75,-279.83\"/>\n",
       "</g>\n",
       "<!-- just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11&#45;&gt;x_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11&#45;&gt;x_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M347.53,-192.44C365.23,-201.5 385.66,-212.38 403.12,-222.04\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"401.26,-225 411.69,-226.82 404.67,-218.89 401.26,-225\"/>\n",
       "</g>\n",
       "<!-- call_testreturnvalue_functioncall_testat0x104da7e20_20 -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>call_testreturnvalue_functioncall_testat0x104da7e20_20</title>\n",
       "<g id=\"a_node14\"><a xlink:title=\"call_test:20\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"287.5,-116 57,-116 57,-76 287.5,-76 287.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"65\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;call_test() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"77.75\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return just_x(just_x(d, y=b), ys[0])</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11&#45;&gt;call_testreturnvalue_functioncall_testat0x104da7e20_20 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11&#45;&gt;call_testreturnvalue_functioncall_testat0x104da7e20_20</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M270.31,-151.56C253.96,-142.47 234.31,-131.53 216.91,-121.85\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"218.72,-118.85 208.28,-117.05 215.32,-124.97 218.72,-118.85\"/>\n",
       "</g>\n",
       "<!-- ys_functioncall_testat0x104da7e20_18 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>ys_functioncall_testat0x104da7e20_18</title>\n",
       "<g id=\"a_node8\"><a xlink:title=\"call_test:18\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"236.5,-344 0,-344 0,-304 236.5,-304 236.5,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"110\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">ys</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">ys = [sq(elem) for elem in xs if elem &gt; 2]</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- ys_functioncall_testat0x104da7e20_18&#45;&gt;call_testreturnvalue_functioncall_testat0x104da7e20_20 -->\n",
       "<!-- y_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"node15\" class=\"node\">\n",
       "<title>y_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<g id=\"a_node15\"><a xlink:title=\"just_x:10\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"327.5,-268 133,-268 133,-228 327.5,-228 327.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"226.12\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"141\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def just_x(x: Any, y: Any) &#45;&gt; Any:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- ys_functioncall_testat0x104da7e20_18&#45;&gt;y_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>ys_functioncall_testat0x104da7e20_18&#45;&gt;y_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M147.68,-303.56C161.18,-294.63 177.37,-283.94 191.82,-274.39\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"193.34,-277.58 199.76,-269.15 189.48,-271.74 193.34,-277.58\"/>\n",
       "</g>\n",
       "<!-- c_functioncall_testat0x104da7e20_2 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>c_functioncall_testat0x104da7e20_2</title>\n",
       "<g id=\"a_node9\"><a xlink:title=\"call_test:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"548.25,-648 494.25,-648 494.25,-608 548.25,-608 548.25,-648\"/>\n",
       "<text text-anchor=\"start\" x=\"517.12\" y=\"-631.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">c</text>\n",
       "<text text-anchor=\"start\" x=\"505.5\" y=\"-613.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">c = 47</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functioncall_testat0x104da7e20_2&#45;&gt;a_functioncall_testat0x104da7e20_13 -->\n",
       "<!-- c_functioncall_testat0x104da7e20_2&#45;&gt;genyieldvalue_functioncall_testlocalsgenat0x105d98790_8 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>c_functioncall_testat0x104da7e20_2&#45;&gt;genyieldvalue_functioncall_testlocalsgenat0x105d98790_8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M548.6,-611.79C583.07,-590.87 640.65,-549.62 664.25,-496 671.41,-479.73 674.23,-470.71 664.25,-456 654.18,-441.15 639.4,-430.31 623.2,-422.4\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"624.9,-419.32 614.35,-418.45 622.06,-425.72 624.9,-419.32\"/>\n",
       "</g>\n",
       "<!-- b_functioncall_testat0x104da7e20_14&#45;&gt;d_functioncall_testat0x104da7e20_15 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>b_functioncall_testat0x104da7e20_14&#45;&gt;d_functioncall_testat0x104da7e20_15</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M376.03,-379.56C384.89,-370.97 396.2,-360.75 407.04,-351.49\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"409.01,-354.4 414.42,-345.29 404.51,-349.04 409.01,-354.4\"/>\n",
       "</g>\n",
       "<!-- b_functioncall_testat0x104da7e20_14&#45;&gt;d_functioncall_testat0x104da7e20_15 -->\n",
       "<!-- b_functioncall_testat0x104da7e20_14&#45;&gt;y_functioncall_testlocalsjust_xat0x105d99cf0_10 -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>b_functioncall_testat0x104da7e20_14&#45;&gt;y_functioncall_testlocalsjust_xat0x105d99cf0_10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M343.52,-379.7C320.8,-353.48 280.06,-306.47 254.13,-276.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"257.1,-274.64 247.91,-269.37 251.81,-279.22 257.1,-274.64\"/>\n",
       "</g>\n",
       "<!-- genyieldvalue_functioncall_testlocalsgenat0x105d98790_8&#45;&gt;d_functioncall_testat0x104da7e20_15 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>genyieldvalue_functioncall_testlocalsgenat0x105d98790_8&#45;&gt;d_functioncall_testat0x104da7e20_15</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M504.44,-379.56C494.91,-371.06 483.58,-360.95 473.27,-351.76\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"475.83,-349.36 466.04,-345.32 471.18,-354.59 475.83,-349.36\"/>\n",
       "</g>\n",
       "<!-- sqreturnvalue_functioncall_testlocalssqat0x104c68b80_5 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>sqreturnvalue_functioncall_testlocalssqat0x104c68b80_5</title>\n",
       "<g id=\"a_node12\"><a xlink:title=\"sq:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"697.62,-40 524.88,-40 524.88,0 697.62,0 697.62,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"532.88\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;sq() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"579.75\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return n * n</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- n_functioncall_testlocalssqat0x104c68b80_4&#45;&gt;sqreturnvalue_functioncall_testlocalssqat0x104c68b80_5 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>n_functioncall_testlocalssqat0x104c68b80_4&#45;&gt;sqreturnvalue_functioncall_testlocalssqat0x104c68b80_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M605.23,-75.56C604.57,-68.25 604.36,-59.75 604.59,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"608.07,-52.01 605.15,-41.82 601.09,-51.61 608.07,-52.01\"/>\n",
       "</g>\n",
       "<!-- n_functioncall_testlocalssqat0x104c68b80_4&#45;&gt;sqreturnvalue_functioncall_testlocalssqat0x104c68b80_5 -->\n",
       "<!-- y_functioncall_testlocalsjust_xat0x105d99cf0_10&#45;&gt;just_xreturnvalue_functioncall_testlocalsjust_xat0x105d99cf0_11 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        ('c', (call_test, 2)): set(),\n",
       "        ('a', (call_test, 13)): set(),\n",
       "        ('b', (call_test, 14)): {('a', (call_test, 13))},\n",
       "        ('e', (gen, 7)): {('a', (call_test, 13))},\n",
       "        ('<gen() yield value>', (gen, 8)): {('c', (call_test, 2)), ('e', (gen, 7))},\n",
       "        ('d', (call_test, 15)): {('<gen() yield value>', (gen, 8)), ('b', (call_test, 14))},\n",
       "        ('xs', (call_test, 17)): set(),\n",
       "        ('elem', (call_test, 18)): {('xs', (call_test, 17))},\n",
       "        ('n', (sq, 4)): {('elem', (call_test, 18))},\n",
       "        ('<sq() return value>', (sq, 5)): {('n', (sq, 4))},\n",
       "        ('ys', (call_test, 18)): set(),\n",
       "        ('x', (just_x, 10)): {('d', (call_test, 15)), ('<just_x() return value>', (just_x, 11))},\n",
       "        ('y', (just_x, 10)): {('ys', (call_test, 18)), ('b', (call_test, 14))},\n",
       "        ('<just_x() return value>', (just_x, 11)): {('x', (just_x, 10))},\n",
       "        ('<call_test() return value>', (call_test, 20)): {('<just_x() return value>', (just_x, 11))}},\n",
       " control={\n",
       "        ('c', (call_test, 2)): set(),\n",
       "        ('a', (call_test, 13)): set(),\n",
       "        ('b', (call_test, 14)): set(),\n",
       "        ('e', (gen, 7)): set(),\n",
       "        ('<gen() yield value>', (gen, 8)): set(),\n",
       "        ('d', (call_test, 15)): set(),\n",
       "        ('xs', (call_test, 17)): set(),\n",
       "        ('elem', (call_test, 18)): set(),\n",
       "        ('n', (sq, 4)): set(),\n",
       "        ('<sq() return value>', (sq, 5)): set(),\n",
       "        ('ys', (call_test, 18)): set(),\n",
       "        ('x', (just_x, 10)): set(),\n",
       "        ('y', (just_x, 10)): set(),\n",
       "        ('<just_x() return value>', (just_x, 11)): set(),\n",
       "        ('<call_test() return value>', (call_test, 20)): set()})"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "call_deps.dependencies()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `code()` view lists each function separately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:28.249922Z",
     "iopub.status.busy": "2023-11-12T12:40:28.249760Z",
     "iopub.status.idle": "2023-11-12T12:40:29.043907Z",
     "shell.execute_reply": "2023-11-12T12:40:29.043529Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*    7     \u001b[34mdef\u001b[39;49;00m \u001b[32mgen\u001b[39;49;00m(e: \u001b[36mint\u001b[39;49;00m) -> Generator[\u001b[36mint\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m]:  \u001b[37m# <= a (call_test:13)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    8         \u001b[34myield\u001b[39;49;00m e * c  \u001b[37m# <= c (call_test:2), e (7)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "     1 \u001b[34mdef\u001b[39;49;00m \u001b[32mcall_test\u001b[39;49;00m() -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "*    2     c = \u001b[34m47\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "     3 \u001b[37m\u001b[39;49;00m\n",
      "     4     \u001b[34mdef\u001b[39;49;00m \u001b[32msq\u001b[39;49;00m(n: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "     5         \u001b[34mreturn\u001b[39;49;00m n * n\u001b[37m\u001b[39;49;00m\n",
      "     6 \u001b[37m\u001b[39;49;00m\n",
      "     7     \u001b[34mdef\u001b[39;49;00m \u001b[32mgen\u001b[39;49;00m(e: \u001b[36mint\u001b[39;49;00m) -> Generator[\u001b[36mint\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m]:\u001b[37m\u001b[39;49;00m\n",
      "     8         \u001b[34myield\u001b[39;49;00m e * c\u001b[37m\u001b[39;49;00m\n",
      "     9 \u001b[37m\u001b[39;49;00m\n",
      "    10     \u001b[34mdef\u001b[39;49;00m \u001b[32mjust_x\u001b[39;49;00m(x: Any, y: Any) -> Any:\u001b[37m\u001b[39;49;00m\n",
      "    11         \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m\n",
      "    12 \u001b[37m\u001b[39;49;00m\n",
      "*   13     a = \u001b[34m42\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   14     b = gen(a)  \u001b[37m# <= a (13)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   15     d = \u001b[36mlist\u001b[39;49;00m(b)[\u001b[34m0\u001b[39;49;00m]  \u001b[37m# <= <gen() yield value> (gen:8), b (14)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    16 \u001b[37m\u001b[39;49;00m\n",
      "*   17     xs = [\u001b[34m1\u001b[39;49;00m, \u001b[34m2\u001b[39;49;00m, \u001b[34m3\u001b[39;49;00m, \u001b[34m4\u001b[39;49;00m]\u001b[37m\u001b[39;49;00m\n",
      "*   18     ys = [sq(elem) \u001b[34mfor\u001b[39;49;00m elem \u001b[35min\u001b[39;49;00m xs \u001b[34mif\u001b[39;49;00m elem > \u001b[34m2\u001b[39;49;00m]  \u001b[37m# <= xs (17)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    19 \u001b[37m\u001b[39;49;00m\n",
      "*   20     \u001b[34mreturn\u001b[39;49;00m just_x(just_x(d, y=b), ys[\u001b[34m0\u001b[39;49;00m])  \u001b[37m# <= <just_x() return value> (just_x:11)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "*   10     \u001b[34mdef\u001b[39;49;00m \u001b[32mjust_x\u001b[39;49;00m(x: Any, y: Any) -> Any:  \u001b[37m# <= d (call_test:15), <just_x() return value> (11), ys (call_test:18), b (call_test:14)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   11         \u001b[34mreturn\u001b[39;49;00m x  \u001b[37m# <= x (10)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "*    4     \u001b[34mdef\u001b[39;49;00m \u001b[32msq\u001b[39;49;00m(n: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:  \u001b[37m# <= elem (call_test:18)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    5         \u001b[34mreturn\u001b[39;49;00m n * n  \u001b[37m# <= n (4)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "call_deps.dependencies().code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Diagnostics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To check the dependencies we obtain, we perform some minimal checks on whether a referenced variable actually also occurs in the source code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.045780Z",
     "iopub.status.busy": "2023-11-12T12:40:29.045642Z",
     "iopub.status.idle": "2023-11-12T12:40:29.047457Z",
     "shell.execute_reply": "2023-11-12T12:40:29.047148Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.049030Z",
     "iopub.status.busy": "2023-11-12T12:40:29.048924Z",
     "iopub.status.idle": "2023-11-12T12:40:29.052367Z",
     "shell.execute_reply": "2023-11-12T12:40:29.052081Z"
    },
    "ipub": {
     "ignore": true
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dependencies(Dependencies):\n",
    "    def validate(self) -> None:\n",
    "        \"\"\"Perform a simple syntactic validation of dependencies\"\"\"\n",
    "        super().validate()\n",
    "\n",
    "        for var in self.all_vars():\n",
    "            source = self.source(var)\n",
    "            if not source:\n",
    "                continue\n",
    "            if source.startswith('<'):\n",
    "                continue   # no source\n",
    "\n",
    "            for dep_var in self.data[var] | self.control[var]:\n",
    "                dep_name, dep_location = dep_var\n",
    "\n",
    "                if dep_name == DependencyTracker.TEST:\n",
    "                    continue  # dependency on <test>\n",
    "\n",
    "                if dep_name.endswith(' value>'):\n",
    "                    if source.find('(') < 0:\n",
    "                        warnings.warn(f\"Warning: {self.format_var(var)} \"\n",
    "                                  f\"depends on {self.format_var(dep_var)}, \"\n",
    "                                  f\"but {repr(source)} does not \"\n",
    "                                  f\"seem to have a call\")\n",
    "                    continue\n",
    "\n",
    "                if source.startswith('def'):\n",
    "                    continue   # function call\n",
    "\n",
    "                rx = re.compile(r'\\b' + dep_name + r'\\b')\n",
    "                if rx.search(source) is None:\n",
    "                    warnings.warn(f\"{self.format_var(var)} \"\n",
    "                              f\"depends on {self.format_var(dep_var)}, \"\n",
    "                              f\"but {repr(dep_name)} does not occur \"\n",
    "                              f\"in {repr(source)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`validate()` is automatically called whenever dependencies are output, so if you see any of its error messages, something may be wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "At this point, `DependencyTracker` is complete; we have all in place to track even complex dependencies in instrumented code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slicing Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us now put all these pieces together. We have a means to instrument the source code (our various `NodeTransformer` classes) and a means to track dependencies (the `DependencyTracker` class). Now comes the time to put all these things together in a single tool, which we call `Slicer`.\n",
    "\n",
    "The basic idea of `Slicer` is that you can use it as follows:\n",
    "\n",
    "```python\n",
    "with Slicer(func_1, func_2, ...) as slicer:\n",
    "    func(...)\n",
    "```\n",
    "\n",
    "which first _instruments_ the functions given in the constructor (i.e., replaces their definitions with instrumented counterparts), and then runs the code in the body, calling instrumented functions, and allowing the slicer to collect dependencies. When the body returns, the original definition of the instrumented functions is restored."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### An Instrumenter Base Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The basic functionality of instrumenting a number of functions (and restoring them at the end of the `with` block) comes in a `Instrumenter` base class. It invokes `instrument()` on all items to instrument; this is to be overloaded in subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.054057Z",
     "iopub.status.busy": "2023-11-12T12:40:29.053960Z",
     "iopub.status.idle": "2023-11-12T12:40:29.057650Z",
     "shell.execute_reply": "2023-11-12T12:40:29.057253Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Instrumenter(StackInspector):\n",
    "    \"\"\"Instrument functions for dynamic tracking\"\"\"\n",
    "\n",
    "    def __init__(self, *items_to_instrument: Callable,\n",
    "                 globals: Optional[Dict[str, Any]] = None,\n",
    "                 log: Union[bool, int] = False) -> None:\n",
    "        \"\"\"\n",
    "        Create an instrumenter.\n",
    "        `items_to_instrument` is a list of items to instrument.\n",
    "        `globals` is a namespace to use (default: caller's globals())\n",
    "        \"\"\"\n",
    "\n",
    "        self.log = log\n",
    "        self.items_to_instrument: List[Callable] = list(items_to_instrument)\n",
    "        self.instrumented_items: Set[Any] = set()\n",
    "\n",
    "        if globals is None:\n",
    "            globals = self.caller_globals()\n",
    "        self.globals = globals\n",
    "\n",
    "    def __enter__(self) -> Any:\n",
    "        \"\"\"Instrument sources\"\"\"\n",
    "        items = self.items_to_instrument\n",
    "        if not items:\n",
    "            items = self.default_items_to_instrument()\n",
    "\n",
    "        for item in items:\n",
    "            self.instrument(item)\n",
    "\n",
    "        return self\n",
    "\n",
    "    def default_items_to_instrument(self) -> List[Callable]:\n",
    "        return []\n",
    "\n",
    "    def instrument(self, item: Any) -> Any:\n",
    "        \"\"\"Instrument `item`. To be overloaded in subclasses.\"\"\"\n",
    "        if self.log:\n",
    "            print(\"Instrumenting\", item)\n",
    "        self.instrumented_items.add(item)\n",
    "        return item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "At the end of the `with` block, we restore the given functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.059539Z",
     "iopub.status.busy": "2023-11-12T12:40:29.059294Z",
     "iopub.status.idle": "2023-11-12T12:40:29.061720Z",
     "shell.execute_reply": "2023-11-12T12:40:29.061395Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Instrumenter(Instrumenter):\n",
    "    def __exit__(self, exc_type: Type, exc_value: BaseException,\n",
    "                 traceback: TracebackType) -> Optional[bool]:\n",
    "        \"\"\"Restore sources\"\"\"\n",
    "        self.restore()\n",
    "        return None\n",
    "\n",
    "    def restore(self) -> None:\n",
    "        for item in self.instrumented_items:\n",
    "            self.globals[item.__name__] = item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "By default, an `Instrumenter` simply outputs a log message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.063235Z",
     "iopub.status.busy": "2023-11-12T12:40:29.063118Z",
     "iopub.status.idle": "2023-11-12T12:40:29.065026Z",
     "shell.execute_reply": "2023-11-12T12:40:29.064755Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instrumenting <function middle at 0x1048dec20>\n"
     ]
    }
   ],
   "source": [
    "with Instrumenter(middle, log=True) as ins:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The Slicer Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `Slicer` class comes as a subclass of `Instrumenter`. It sets its own dependency tracker (which can be overwritten by setting the `dependency_tracker` keyword argument)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.066865Z",
     "iopub.status.busy": "2023-11-12T12:40:29.066647Z",
     "iopub.status.idle": "2023-11-12T12:40:29.069770Z",
     "shell.execute_reply": "2023-11-12T12:40:29.069485Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Instrumenter):\n",
    "    \"\"\"Track dependencies in an execution\"\"\"\n",
    "\n",
    "    def __init__(self, *items_to_instrument: Any,\n",
    "                 dependency_tracker: Optional[DependencyTracker] = None,\n",
    "                 globals: Optional[Dict[str, Any]] = None,\n",
    "                 log: Union[bool, int] = False):\n",
    "        \"\"\"Create a slicer.\n",
    "        `items_to_instrument` are Python functions or modules with source code.\n",
    "        `dependency_tracker` is the tracker to be used (default: DependencyTracker).\n",
    "        `globals` is the namespace to be used(default: caller's `globals()`)\n",
    "        `log`=True or `log` > 0 turns on logging\n",
    "        \"\"\"\n",
    "        super().__init__(*items_to_instrument, globals=globals, log=log)\n",
    "\n",
    "        if dependency_tracker is None:\n",
    "            dependency_tracker = DependencyTracker(log=(log > 1))\n",
    "        self.dependency_tracker = dependency_tracker\n",
    "\n",
    "        self.saved_dependencies = None\n",
    "\n",
    "    def default_items_to_instrument(self) -> List[Callable]:\n",
    "        raise ValueError(\"Need one or more items to instrument\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `parse()` method parses a given item, returning its AST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.071367Z",
     "iopub.status.busy": "2023-11-12T12:40:29.071253Z",
     "iopub.status.idle": "2023-11-12T12:40:29.073708Z",
     "shell.execute_reply": "2023-11-12T12:40:29.073395Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def parse(self, item: Any) -> AST:\n",
    "        \"\"\"Parse `item`, returning its AST\"\"\"\n",
    "        source_lines, lineno = inspect.getsourcelines(item)\n",
    "        source = \"\".join(source_lines)\n",
    "\n",
    "        if self.log >= 2:\n",
    "            print_content(source, '.py', start_line_number=lineno)\n",
    "            print()\n",
    "            print()\n",
    "\n",
    "        tree = ast.parse(source)\n",
    "        ast.increment_lineno(tree, lineno - 1)\n",
    "        return tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `transform()` method applies the list of transformers defined earlier in this chapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.075799Z",
     "iopub.status.busy": "2023-11-12T12:40:29.075645Z",
     "iopub.status.idle": "2023-11-12T12:40:29.078886Z",
     "shell.execute_reply": "2023-11-12T12:40:29.078581Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def transformers(self) -> List[NodeTransformer]:\n",
    "        \"\"\"List of transformers to apply. To be extended in subclasses.\"\"\"\n",
    "        return [\n",
    "            TrackCallTransformer(),\n",
    "            TrackSetTransformer(),\n",
    "            TrackGetTransformer(),\n",
    "            TrackControlTransformer(),\n",
    "            TrackReturnTransformer(),\n",
    "            TrackParamsTransformer()\n",
    "        ]\n",
    "\n",
    "    def transform(self, tree: AST) -> AST:\n",
    "        \"\"\"Apply transformers on `tree`. May be extended in subclasses.\"\"\"\n",
    "        # Apply transformers\n",
    "        for transformer in self.transformers():\n",
    "            if self.log >= 3:\n",
    "                print(transformer.__class__.__name__ + ':')\n",
    "\n",
    "            transformer.visit(tree)\n",
    "            ast.fix_missing_locations(tree)\n",
    "            if self.log >= 3:\n",
    "                print_content(ast.unparse(tree), '.py')\n",
    "                print()\n",
    "                print()\n",
    "\n",
    "        if 0 < self.log < 3:\n",
    "            print_content(ast.unparse(tree), '.py')\n",
    "            print()\n",
    "            print()\n",
    "\n",
    "        return tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `execute()` method executes the transformed tree (such that we get the new definitions). We also make the dependency tracker available for the code in the `with` block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.080511Z",
     "iopub.status.busy": "2023-11-12T12:40:29.080384Z",
     "iopub.status.idle": "2023-11-12T12:40:29.082864Z",
     "shell.execute_reply": "2023-11-12T12:40:29.082608Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def execute(self, tree: AST, item: Any) -> None:\n",
    "        \"\"\"Compile and execute `tree`. May be extended in subclasses.\"\"\"\n",
    "\n",
    "        # We pass the source file of `item` such that we can retrieve it\n",
    "        # when accessing the location of the new compiled code\n",
    "        source = cast(str, inspect.getsourcefile(item))\n",
    "        code = compile(cast(ast.Module, tree), source, 'exec')\n",
    "\n",
    "        # Enable dependency tracker\n",
    "        self.globals[DATA_TRACKER] = self.dependency_tracker\n",
    "\n",
    "        # Execute the code, resulting in a redefinition of item\n",
    "        exec(code, self.globals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `instrument()` method puts all these together, first parsing the item into a tree, then transforming and executing the tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.084328Z",
     "iopub.status.busy": "2023-11-12T12:40:29.084200Z",
     "iopub.status.idle": "2023-11-12T12:40:29.086680Z",
     "shell.execute_reply": "2023-11-12T12:40:29.086398Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def instrument(self, item: Any) -> Any:\n",
    "        \"\"\"Instrument `item`, transforming its source code, and re-defining it.\"\"\"\n",
    "        if is_internal(item.__name__):\n",
    "            return item  # Do not instrument `print()` and the like\n",
    "\n",
    "        if inspect.isbuiltin(item):\n",
    "            return item  # No source code\n",
    "\n",
    "        item = super().instrument(item)\n",
    "        tree = self.parse(item)\n",
    "        tree = self.transform(tree)\n",
    "        self.execute(tree, item)\n",
    "\n",
    "        new_item = self.globals[item.__name__]\n",
    "        return new_item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When we restore the original definition (after the `with` block), we save the dependency tracker again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.088191Z",
     "iopub.status.busy": "2023-11-12T12:40:29.088086Z",
     "iopub.status.idle": "2023-11-12T12:40:29.090401Z",
     "shell.execute_reply": "2023-11-12T12:40:29.090091Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def restore(self) -> None:\n",
    "        \"\"\"Restore original code.\"\"\"\n",
    "        if DATA_TRACKER in self.globals:\n",
    "            self.saved_dependencies = self.globals[DATA_TRACKER]\n",
    "            del self.globals[DATA_TRACKER]\n",
    "\n",
    "        super().restore()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Three convenience functions allow us to see the dependencies as (well) dependencies, as code, and as graph. These simply invoke the respective functions on the saved dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.092169Z",
     "iopub.status.busy": "2023-11-12T12:40:29.092037Z",
     "iopub.status.idle": "2023-11-12T12:40:29.095157Z",
     "shell.execute_reply": "2023-11-12T12:40:29.094854Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def dependencies(self) -> Dependencies:\n",
    "        \"\"\"Return collected dependencies.\"\"\"\n",
    "        if self.saved_dependencies is None:\n",
    "            return Dependencies({}, {})\n",
    "        return self.saved_dependencies.dependencies()\n",
    "\n",
    "    def code(self, *args: Any, **kwargs: Any) -> None:\n",
    "        \"\"\"Show code of instrumented items, annotated with dependencies.\"\"\"\n",
    "        first = True\n",
    "        for item in self.instrumented_items:\n",
    "            if not first:\n",
    "                print()\n",
    "            self.dependencies().code(item, *args, **kwargs)  # type: ignore\n",
    "            first = False\n",
    "\n",
    "    def graph(self, *args: Any, **kwargs: Any) -> Digraph:\n",
    "        \"\"\"Show dependency graph.\"\"\"\n",
    "        return self.dependencies().graph(*args, **kwargs)  # type: ignore\n",
    "\n",
    "    def _repr_mimebundle_(self, include: Any = None, exclude: Any = None) -> Any:\n",
    "        \"\"\"If the object is output in Jupyter, render dependencies as a SVG graph\"\"\"\n",
    "        return self.graph()._repr_mimebundle_(include, exclude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let us put `Slicer` into action. We track our `middle()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.096654Z",
     "iopub.status.busy": "2023-11-12T12:40:29.096533Z",
     "iopub.status.idle": "2023-11-12T12:40:29.102618Z",
     "shell.execute_reply": "2023-11-12T12:40:29.102337Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with Slicer(middle) as slicer:\n",
    "    m = middle(2, 1, 3)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "These are the dependencies in string form (used when printed):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.104213Z",
     "iopub.status.busy": "2023-11-12T12:40:29.104098Z",
     "iopub.status.idle": "2023-11-12T12:40:29.108294Z",
     "shell.execute_reply": "2023-11-12T12:40:29.108003Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "middle():\n",
      "    <test> (2) <= y (1), z (1)\n",
      "    <test> (3) <= x (1), y (1); <- <test> (2)\n",
      "    <test> (5) <= x (1), z (1); <- <test> (3)\n",
      "    <middle() return value> (6) <= y (1); <- <test> (5)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(slicer.dependencies())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This is the code form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.110090Z",
     "iopub.status.busy": "2023-11-12T12:40:29.109966Z",
     "iopub.status.idle": "2023-11-12T12:40:29.468080Z",
     "shell.execute_reply": "2023-11-12T12:40:29.467781Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*    1 \u001b[34mdef\u001b[39;49;00m \u001b[32mmiddle\u001b[39;49;00m(x, y, z):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    2     \u001b[34mif\u001b[39;49;00m y < z:  \u001b[37m# <= y (1), z (1)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    3         \u001b[34mif\u001b[39;49;00m x < y:  \u001b[37m# <= x (1), y (1); <- <test> (2)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "     4             \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      "*    5         \u001b[34melif\u001b[39;49;00m x < z:  \u001b[37m# <= x (1), z (1); <- <test> (3)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    6             \u001b[34mreturn\u001b[39;49;00m y  \u001b[37m# <= y (1); <- <test> (5)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "     7     \u001b[34melse\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "     8         \u001b[34mif\u001b[39;49;00m x > y:\u001b[37m\u001b[39;49;00m\n",
      "     9             \u001b[34mreturn\u001b[39;49;00m y\u001b[37m\u001b[39;49;00m\n",
      "    10         \u001b[34melif\u001b[39;49;00m x > z:\u001b[37m\u001b[39;49;00m\n",
      "    11             \u001b[34mreturn\u001b[39;49;00m x\u001b[37m\u001b[39;49;00m\n",
      "    12     \u001b[34mreturn\u001b[39;49;00m z\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "slicer.code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And this is the graph form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.469835Z",
     "iopub.status.busy": "2023-11-12T12:40:29.469716Z",
     "iopub.status.idle": "2023-11-12T12:40:29.896014Z",
     "shell.execute_reply": "2023-11-12T12:40:29.895616Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"463pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 462.65 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 458.65,-348 458.65,4 -4,4\"/>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_5 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_5</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"middle:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"219.38,-116 145.62,-116 145.62,-76 219.38,-76 219.38,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"157.75\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"153.62\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif x &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- middlereturnvalue_functionmiddleat0x105d9a5f0_6 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>middlereturnvalue_functionmiddleat0x105d9a5f0_6</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"middle:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"285.38,-40 79.62,-40 79.62,0 285.38,0 285.38,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"87.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;middle() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"161.5\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_5&#45;&gt;middlereturnvalue_functionmiddleat0x105d9a5f0_6 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_5&#45;&gt;middlereturnvalue_functionmiddleat0x105d9a5f0_6</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M176.48,-75.56C175.82,-68.25 175.61,-59.75 175.84,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"179.32,-52.01 176.4,-41.82 172.34,-51.61 179.32,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_5&#45;&gt;middlereturnvalue_functionmiddleat0x105d9a5f0_6 -->\n",
       "<!-- x_functionmiddleat0x105d9a5f0_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>x_functionmiddleat0x105d9a5f0_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"438,-268 233,-268 233,-228 438,-228 438,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"331.38\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"241\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_5 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M315.81,-227.7C288.96,-201.37 240.71,-154.07 210.21,-124.17\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"212.79,-121.79 203.19,-117.29 207.88,-126.79 212.79,-121.79\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_3</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"middle:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"215.25,-192 149.75,-192 149.75,-152 215.25,-152 215.25,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"157.75\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"158.88\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if x &lt; y:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_3 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>x_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M295.3,-227.56C274,-217.25 247.8,-204.58 226.02,-194.05\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"227.61,-190.93 217.08,-189.73 224.56,-197.23 227.61,-190.93\"/>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x105d9a5f0_1 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>z_functionmiddleat0x105d9a5f0_1</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"428,-344 223,-344 223,-304 428,-304 428,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"321.38\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"231\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_5 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M403.32,-303.64C420.73,-295.53 437.1,-284.1 447.5,-268 457.15,-253.07 456.88,-243.1 447.5,-228 400.08,-151.66 293.55,-118.47 230.96,-105.11\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"231.79,-101.71 221.29,-103.14 230.39,-108.56 231.79,-101.71\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_2 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_2</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"middle:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"215.25,-268 149.75,-268 149.75,-228 215.25,-228 215.25,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"157.75\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"158.88\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if y &lt; z:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_2 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>z_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M281.91,-303.56C263.44,-294.42 242.06,-283.43 223.85,-273.71\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"225.61,-270.68 215.14,-269.03 222.29,-276.85 225.61,-270.68\"/>\n",
       "</g>\n",
       "<!-- z_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_2 -->\n",
       "<!-- test_functionmiddleat0x105d9a5f0_3&#45;&gt;test_functionmiddleat0x105d9a5f0_5 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_3&#45;&gt;test_functionmiddleat0x105d9a5f0_5</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M176.48,-151.56C175.82,-144.25 175.61,-135.75 175.84,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"179.32,-128.01 176.4,-117.82 172.34,-127.61 179.32,-128.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_3&#45;&gt;test_functionmiddleat0x105d9a5f0_5 -->\n",
       "<!-- y_functionmiddleat0x105d9a5f0_1 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>y_functionmiddleat0x105d9a5f0_1</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"middle:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"205,-344 0,-344 0,-304 205,-304 205,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"98.38\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def middle(x, y, z): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_3 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M108.48,-303.74C114.99,-284.03 126.38,-252.87 140.5,-228 145.67,-218.89 152.19,-209.61 158.54,-201.32\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"161.16,-203.66 164.62,-193.65 155.67,-199.31 161.16,-203.66\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x105d9a5f0_1&#45;&gt;middlereturnvalue_functionmiddleat0x105d9a5f0_6 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x105d9a5f0_1&#45;&gt;middlereturnvalue_functionmiddleat0x105d9a5f0_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M101.63,-303.76C100.43,-260.86 101.55,-154.97 136.5,-76 140.83,-66.22 147.43,-56.81 154.3,-48.62\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"156.71,-51.18 160.75,-41.39 151.48,-46.52 156.71,-51.18\"/>\n",
       "</g>\n",
       "<!-- y_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_2 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>y_functionmiddleat0x105d9a5f0_1&#45;&gt;test_functionmiddleat0x105d9a5f0_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M123.52,-303.56C132.61,-295.14 143.41,-285.16 153.27,-276.04\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"155.55,-278.7 160.51,-269.34 150.79,-273.56 155.55,-278.7\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_2&#45;&gt;test_functionmiddleat0x105d9a5f0_3 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>test_functionmiddleat0x105d9a5f0_2&#45;&gt;test_functionmiddleat0x105d9a5f0_3</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M176.48,-227.56C175.82,-220.25 175.61,-211.75 175.84,-203.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"179.32,-204.01 176.4,-193.82 172.34,-203.61 179.32,-204.01\"/>\n",
       "</g>\n",
       "<!-- test_functionmiddleat0x105d9a5f0_2&#45;&gt;test_functionmiddleat0x105d9a5f0_3 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x107471d50>"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also access the raw `repr()` form, which allows you to reconstruct dependencies at any time. (This is how we showed off dependencies at the beginning of this chapter, before even introducing the code that computes them.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.897862Z",
     "iopub.status.busy": "2023-11-12T12:40:29.897695Z",
     "iopub.status.idle": "2023-11-12T12:40:29.901481Z",
     "shell.execute_reply": "2023-11-12T12:40:29.901203Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dependencies(\n",
      "    data={\n",
      "        ('x', (middle, 1)): set(),\n",
      "        ('y', (middle, 1)): set(),\n",
      "        ('z', (middle, 1)): set(),\n",
      "        ('<test>', (middle, 2)): {('y', (middle, 1)), ('z', (middle, 1))},\n",
      "        ('<test>', (middle, 3)): {('x', (middle, 1)), ('y', (middle, 1))},\n",
      "        ('<test>', (middle, 5)): {('x', (middle, 1)), ('z', (middle, 1))},\n",
      "        ('<middle() return value>', (middle, 6)): {('y', (middle, 1))}},\n",
      " control={\n",
      "        ('x', (middle, 1)): set(),\n",
      "        ('y', (middle, 1)): set(),\n",
      "        ('z', (middle, 1)): set(),\n",
      "        ('<test>', (middle, 2)): set(),\n",
      "        ('<test>', (middle, 3)): {('<test>', (middle, 2))},\n",
      "        ('<test>', (middle, 5)): {('<test>', (middle, 3))},\n",
      "        ('<middle() return value>', (middle, 6)): {('<test>', (middle, 5))}})\n"
     ]
    }
   ],
   "source": [
    "print(repr(slicer.dependencies()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Diagnostics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `Slicer` constructor accepts a `log` argument (default: False), which can be set to show various intermediate results:\n",
    "\n",
    "* `log=True` (or `log=1`): Show instrumented source code\n",
    "* `log=2`: Also log execution\n",
    "* `log=3`: Also log individual transformer steps\n",
    "* `log=4`: Also log source line numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us demonstrate our `Slicer` class on a few more examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Square Root"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `square_root()` function from [the chapter on assertions](Assertions.ipynb) demonstrates a nice interplay between data and control dependencies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.903110Z",
     "iopub.status.busy": "2023-11-12T12:40:29.903021Z",
     "iopub.status.idle": "2023-11-12T12:40:29.904693Z",
     "shell.execute_reply": "2023-11-12T12:40:29.904397Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.905981Z",
     "iopub.status.busy": "2023-11-12T12:40:29.905898Z",
     "iopub.status.idle": "2023-11-12T12:40:29.907719Z",
     "shell.execute_reply": "2023-11-12T12:40:29.907326Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from Assertions import square_root  # minor dependency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is the original source code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.909568Z",
     "iopub.status.busy": "2023-11-12T12:40:29.909453Z",
     "iopub.status.idle": "2023-11-12T12:40:29.943669Z",
     "shell.execute_reply": "2023-11-12T12:40:29.943298Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mdef\u001b[39;49;00m \u001b[32msquare_root\u001b[39;49;00m(x):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m x >= \u001b[34m0\u001b[39;49;00m  \u001b[37m# precondition\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    approx = \u001b[34mNone\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    guess = x / \u001b[34m2\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mwhile\u001b[39;49;00m approx != guess:\u001b[37m\u001b[39;49;00m\n",
      "        approx = guess\u001b[37m\u001b[39;49;00m\n",
      "        guess = (approx + x / approx) / \u001b[34m2\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m math.isclose(approx * approx, x)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m approx\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "print_content(inspect.getsource(square_root), '.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Turning on logging shows the instrumented version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.945525Z",
     "iopub.status.busy": "2023-11-12T12:40:29.945360Z",
     "iopub.status.idle": "2023-11-12T12:40:29.985726Z",
     "shell.execute_reply": "2023-11-12T12:40:29.985429Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instrumenting <function square_root at 0x104da79a0>\n",
      "\u001b[34mdef\u001b[39;49;00m \u001b[32msquare_root\u001b[39;49;00m(x):\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<assertion>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) >= \u001b[34m0\u001b[39;49;00m, loads=(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x),))\u001b[37m\u001b[39;49;00m\n",
      "    approx = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, \u001b[34mNone\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    guess = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mguess\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) / \u001b[34m2\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mwhile\u001b[39;49;00m _data.test(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx) != _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mguess\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, guess)):\u001b[37m\u001b[39;49;00m\n",
      "        \u001b[34mwith\u001b[39;49;00m _data:\u001b[37m\u001b[39;49;00m\n",
      "            approx = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mguess\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, guess))\u001b[37m\u001b[39;49;00m\n",
      "            guess = _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33mguess\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, (_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx) + _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x) / _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx)) / \u001b[34m2\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34massert\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<assertion>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mmath\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, math).isclose)(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx) * _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx), pos=\u001b[34m1\u001b[39;49;00m), _data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x), pos=\u001b[34m2\u001b[39;49;00m))), loads=(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x), _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mmath\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, math), _data, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx)))\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<square_root() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mapprox\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, approx))\u001b[37m\u001b[39;49;00m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with Slicer(square_root, log=True) as root_slicer:\n",
    "    y = square_root(2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The dependency graph shows how `guess` and `approx` flow into each other until they are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:29.987417Z",
     "iopub.status.busy": "2023-11-12T12:40:29.987277Z",
     "iopub.status.idle": "2023-11-12T12:40:30.426087Z",
     "shell.execute_reply": "2023-11-12T12:40:30.425594Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"630pt\" height=\"580pt\"\n",
       " viewBox=\"0.00 0.00 629.50 580.00\" 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 576)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-576 625.5,-576 625.5,4 -4,4\"/>\n",
       "<!-- square_rootreturnvalue_functionsquare_rootat0x105d38160_64 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>square_rootreturnvalue_functionsquare_rootat0x105d38160_64</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"square_root:64\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"565.62,-40 318.62,-40 318.62,0 565.62,0 565.62,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"326.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;square_root() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"408\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return approx</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_60</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"square_root:60\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"221.88,-268 132.38,-268 132.38,-228 221.88,-228 221.88,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"152.38\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">approx</text>\n",
       "<text text-anchor=\"start\" x=\"140.38\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">approx = guess</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60&#45;&gt;square_rootreturnvalue_functionsquare_rootat0x105d38160_64 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_60&#45;&gt;square_rootreturnvalue_functionsquare_rootat0x105d38160_64</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M222.22,-244.32C261.94,-239.61 318.82,-226.77 354.12,-192 392.78,-153.93 364.83,-122.89 392.12,-76 397.76,-66.32 405.33,-56.87 412.87,-48.62\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"415.21,-51.24 419.58,-41.59 410.15,-46.4 415.21,-51.24\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_61 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_61</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"square_root:61\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"344.75,-192 155.5,-192 155.5,-152 344.75,-152 344.75,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"229.5\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">guess</text>\n",
       "<text text-anchor=\"start\" x=\"163.5\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">guess = (approx + x / approx) / 2</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60&#45;&gt;guess_functionsquare_rootat0x105d38160_61 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_60&#45;&gt;guess_functionsquare_rootat0x105d38160_61</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M184.26,-227.56C191.12,-219.06 200.76,-208.95 210.69,-199.76\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"212.79,-202.59 217.92,-193.32 208.13,-197.36 212.79,-202.59\"/>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60&#45;&gt;guess_functionsquare_rootat0x105d38160_61 -->\n",
       "<!-- test_functionsquare_rootat0x105d38160_59 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>test_functionsquare_rootat0x105d38160_59</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"square_root:59\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"174.88,-116 43.38,-116 43.38,-76 174.88,-76 174.88,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"84.38\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"51.38\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">while approx != guess:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60&#45;&gt;test_functionsquare_rootat0x105d38160_59 -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_60&#45;&gt;test_functionsquare_rootat0x105d38160_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M149.19,-227.5C141.16,-217.14 133.85,-204.09 128.12,-192 118.13,-170.9 108.62,-146.33 104.2,-127.47\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"107.66,-126.94 102.39,-117.75 100.78,-128.22 107.66,-126.94\"/>\n",
       "</g>\n",
       "<!-- assertion_functionsquare_rootat0x105d38160_63 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>assertion_functionsquare_rootat0x105d38160_63</title>\n",
       "<g id=\"a_node9\"><a xlink:title=\"square_root:63\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"621.5,-116 400.75,-116 400.75,-76 621.5,-76 621.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"465.75\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;assertion&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"408.75\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">assert math.isclose(approx * approx, x)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_60&#45;&gt;assertion_functionsquare_rootat0x105d38160_63 -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_60&#45;&gt;assertion_functionsquare_rootat0x105d38160_63</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M222.37,-240.49C266.18,-232.98 333.63,-218.17 387.12,-192 423.36,-174.28 459.35,-145.08 483.14,-123.72\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"485.19,-126.59 490.22,-117.27 480.47,-121.42 485.19,-126.59\"/>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x105d38160_54 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>x_functionsquare_rootat0x105d38160_54</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"square_root:54\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"296,-572 96.25,-572 96.25,-532 296,-532 296,-572\"/>\n",
       "<text text-anchor=\"start\" x=\"192\" y=\"-555.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"104.25\" y=\"-537.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def square_root(x): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x105d38160_54&#45;&gt;guess_functionsquare_rootat0x105d38160_61 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x105d38160_54&#45;&gt;guess_functionsquare_rootat0x105d38160_61</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M207.84,-531.9C223.72,-504.14 250.12,-450.54 250.12,-401 250.12,-401 250.12,-401 250.12,-323 250.12,-281.8 250.12,-234.24 250.12,-203.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"253.63,-203.93 250.13,-193.93 246.63,-203.93 253.63,-203.93\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_58 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_58</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"square_root:58\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"117.25,-344 33,-344 33,-304 117.25,-304 117.25,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"54.5\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">guess</text>\n",
       "<text text-anchor=\"start\" x=\"41\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">guess = x / 2</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x105d38160_54&#45;&gt;guess_functionsquare_rootat0x105d38160_58 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x105d38160_54&#45;&gt;guess_functionsquare_rootat0x105d38160_58</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M194.51,-531.79C192.36,-512.13 187.53,-481 177.12,-456 160.29,-415.53 127.46,-376.91 103.58,-352.23\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.13,-349.83 96.62,-345.18 101.15,-354.75 106.13,-349.83\"/>\n",
       "</g>\n",
       "<!-- assertion_functionsquare_rootat0x105d38160_55 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>assertion_functionsquare_rootat0x105d38160_55</title>\n",
       "<g id=\"a_node8\"><a xlink:title=\"square_root:55\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"168.25,-496 0,-496 0,-456 168.25,-456 168.25,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"38.75\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;assertion&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">assert x &gt;= 0 &#160;# precondition</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x105d38160_54&#45;&gt;assertion_functionsquare_rootat0x105d38160_55 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x105d38160_54&#45;&gt;assertion_functionsquare_rootat0x105d38160_55</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M160.68,-531.56C146.51,-522.72 130.35,-512.14 116.51,-502.66\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"118.8,-499.99 108.59,-497.17 114.81,-505.75 118.8,-499.99\"/>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x105d38160_54&#45;&gt;assertion_functionsquare_rootat0x105d38160_55 -->\n",
       "<!-- x_functionsquare_rootat0x105d38160_54&#45;&gt;assertion_functionsquare_rootat0x105d38160_63 -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x105d38160_54&#45;&gt;assertion_functionsquare_rootat0x105d38160_63</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M296.44,-542C383.65,-528.01 496.12,-492.28 496.12,-401 496.12,-401 496.12,-401 496.12,-247 496.12,-205.41 501.9,-157.66 506.29,-127.42\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"509.7,-128.26 507.72,-117.85 502.78,-127.22 509.7,-128.26\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_61&#45;&gt;approx_functionsquare_rootat0x105d38160_60 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_61&#45;&gt;approx_functionsquare_rootat0x105d38160_60</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M231.07,-192.31C222.87,-200.62 213.14,-210.49 204.21,-219.54\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"201.9,-216.9 197.37,-226.48 206.88,-221.82 201.9,-216.9\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_61&#45;&gt;test_functionsquare_rootat0x105d38160_59 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_61&#45;&gt;test_functionsquare_rootat0x105d38160_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M207.06,-151.56C188.83,-142.42 167.76,-131.43 149.8,-121.71\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"151.7,-118.76 141.24,-117.04 148.34,-124.9 151.7,-118.76\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_61&#45;&gt;assertion_functionsquare_rootat0x105d38160_63 -->\n",
       "<!-- guess_functionsquare_rootat0x105d38160_58&#45;&gt;approx_functionsquare_rootat0x105d38160_60 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_58&#45;&gt;approx_functionsquare_rootat0x105d38160_60</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M101.92,-303.56C113.99,-294.8 128.4,-284.35 141.37,-274.94\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"143.24,-277.91 149.28,-269.2 139.13,-272.24 143.24,-277.91\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_58&#45;&gt;test_functionsquare_rootat0x105d38160_59 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x105d38160_58&#45;&gt;test_functionsquare_rootat0x105d38160_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M74.04,-303.73C76.56,-264.37 89.82,-174.47 99.8,-127.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"103.17,-128.22 101.93,-117.7 96.34,-126.7 103.17,-128.22\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x105d38160_58&#45;&gt;test_functionsquare_rootat0x105d38160_59 -->\n",
       "<!-- test_functionsquare_rootat0x105d38160_59&#45;&gt;approx_functionsquare_rootat0x105d38160_60 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>test_functionsquare_rootat0x105d38160_59&#45;&gt;approx_functionsquare_rootat0x105d38160_60</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M115.72,-116.26C122.58,-135.69 134,-166.41 146.12,-192 150.15,-200.5 154.96,-209.48 159.57,-217.66\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"156.46,-219.27 164.49,-226.19 162.53,-215.78 156.46,-219.27\"/>\n",
       "</g>\n",
       "<!-- test_functionsquare_rootat0x105d38160_59&#45;&gt;approx_functionsquare_rootat0x105d38160_60 -->\n",
       "<!-- test_functionsquare_rootat0x105d38160_59&#45;&gt;guess_functionsquare_rootat0x105d38160_61 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionsquare_rootat0x105d38160_59&#45;&gt;guess_functionsquare_rootat0x105d38160_61</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M152.19,-116.44C170.34,-125.54 191.32,-136.48 209.23,-146.17\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"207.32,-149.12 217.77,-150.83 210.67,-142.97 207.32,-149.12\"/>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_57 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_57</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"square_root:57\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"117.25,-420 33,-420 33,-380 117.25,-380 117.25,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"50.38\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">approx</text>\n",
       "<text text-anchor=\"start\" x=\"41\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">approx = None</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x105d38160_57&#45;&gt;guess_functionsquare_rootat0x105d38160_58 -->\n",
       "<!-- approx_functionsquare_rootat0x105d38160_57&#45;&gt;test_functionsquare_rootat0x105d38160_59 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x105d38160_57&#45;&gt;test_functionsquare_rootat0x105d38160_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M50.19,-379.51C40.07,-370.02 29.5,-357.7 24.12,-344 17.63,-327.45 20.68,-321.44 24.12,-304 37.25,-237.49 71.98,-165.47 92.76,-126.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"95.71,-128.25 97.37,-117.79 89.55,-124.93 95.71,-128.25\"/>\n",
       "</g>\n",
       "<!-- assertion_functionsquare_rootat0x105d38160_55&#45;&gt;approx_functionsquare_rootat0x105d38160_57 -->\n",
       "<!-- assertion_functionsquare_rootat0x105d38160_63&#45;&gt;square_rootreturnvalue_functionsquare_rootat0x105d38160_64 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105de88e0>"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root_slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Again, we can show the code annotated with dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:30.427994Z",
     "iopub.status.busy": "2023-11-12T12:40:30.427867Z",
     "iopub.status.idle": "2023-11-12T12:40:30.764670Z",
     "shell.execute_reply": "2023-11-12T12:40:30.764224Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*   54 \u001b[34mdef\u001b[39;49;00m \u001b[32msquare_root\u001b[39;49;00m(x):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   55     \u001b[34massert\u001b[39;49;00m x >= \u001b[34m0\u001b[39;49;00m  \u001b[37m# precondition  # <= x (54)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    56 \u001b[37m\u001b[39;49;00m\n",
      "*   57     approx = \u001b[34mNone\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   58     guess = x / \u001b[34m2\u001b[39;49;00m  \u001b[37m# <= x (54)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   59     \u001b[34mwhile\u001b[39;49;00m approx != guess:  \u001b[37m# <= guess (61), approx (57), guess (58), approx (60)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   60         approx = guess  \u001b[37m# <= guess (61), guess (58); <- <test> (59)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   61         guess = (approx + x / approx) / \u001b[34m2\u001b[39;49;00m  \u001b[37m# <= x (54), approx (60); <- <test> (59)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "    62 \u001b[37m\u001b[39;49;00m\n",
      "*   63     \u001b[34massert\u001b[39;49;00m math.isclose(approx * approx, x)  \u001b[37m# <= x (54), approx (60)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*   64     \u001b[34mreturn\u001b[39;49;00m approx  \u001b[37m# <= approx (60)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "root_slicer.code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The astute reader may find that a statement `assert p` does not control the following code, although it would be equivalent to `if not p: raise Exception`. Why is that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:30.767001Z",
     "iopub.status.busy": "2023-11-12T12:40:30.766849Z",
     "iopub.status.idle": "2023-11-12T12:40:30.771871Z",
     "shell.execute_reply": "2023-11-12T12:40:30.771560Z"
    },
    "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\">Why don't <code>assert</code> statements induce control dependencies?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Pick a choice.\">\n",
       "    \n",
       "        <input type=\"radio\" name=\"aa339036-8158-11ee-a31f-6298cf1a5790\" id=\"aa339036-8158-11ee-a31f-6298cf1a5790-1\" onclick=\"clear_selection('aa339036-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"aa339036-8158-11ee-a31f-6298cf1a5790-1-label\" for=\"aa339036-8158-11ee-a31f-6298cf1a5790-1\">We have no special handling of <code>raise</code> statements</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"aa339036-8158-11ee-a31f-6298cf1a5790\" id=\"aa339036-8158-11ee-a31f-6298cf1a5790-2\" onclick=\"clear_selection('aa339036-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"aa339036-8158-11ee-a31f-6298cf1a5790-2-label\" for=\"aa339036-8158-11ee-a31f-6298cf1a5790-2\">We have no special handling of exceptions</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"aa339036-8158-11ee-a31f-6298cf1a5790\" id=\"aa339036-8158-11ee-a31f-6298cf1a5790-3\" onclick=\"clear_selection('aa339036-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"aa339036-8158-11ee-a31f-6298cf1a5790-3-label\" for=\"aa339036-8158-11ee-a31f-6298cf1a5790-3\">Assertions are not supposed to act as controlling mechanisms</label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"aa339036-8158-11ee-a31f-6298cf1a5790\" id=\"aa339036-8158-11ee-a31f-6298cf1a5790-4\" onclick=\"clear_selection('aa339036-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"aa339036-8158-11ee-a31f-6298cf1a5790-4-label\" for=\"aa339036-8158-11ee-a31f-6298cf1a5790-4\">All of the above</label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"aa339036-8158-11ee-a31f-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('aa339036-8158-11ee-a31f-6298cf1a5790', 16, 0, '(1 * 1 &lt;&lt; 1 * 1 &lt;&lt; 1 * 1)')\">\n",
       "    <span class=\"quiz_hint\" id=\"aa339036-8158-11ee-a31f-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quiz(\"Why don't `assert` statements induce control dependencies?\",\n",
    "     [\n",
    "         \"We have no special handling of `raise` statements\",\n",
    "         \"We have no special handling of exceptions\",\n",
    "         \"Assertions are not supposed to act as controlling mechanisms\",\n",
    "         \"All of the above\",\n",
    "     ], '(1 * 1 << 1 * 1 << 1 * 1)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Indeed: we treat assertions as \"neutral\" in the sense that they do not affect the remainder of the program – if they are turned off, they have no effect; and if they are turned on, the remaining program logic should not depend on them. (Our instrumentation also has no special treatment of `raise` or even `return` statements; they should be handled by our `with` blocks, though.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:30.773423Z",
     "iopub.status.busy": "2023-11-12T12:40:30.773297Z",
     "iopub.status.idle": "2023-11-12T12:40:30.774933Z",
     "shell.execute_reply": "2023-11-12T12:40:30.774645Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# print(repr(root_slicer))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Removing HTML Markup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Let us come to our ongoing example, `remove_html_markup()`. This is how its instrumented code looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:30.776764Z",
     "iopub.status.busy": "2023-11-12T12:40:30.776633Z",
     "iopub.status.idle": "2023-11-12T12:40:30.786841Z",
     "shell.execute_reply": "2023-11-12T12:40:30.786486Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with Slicer(remove_html_markup) as rhm_slicer:\n",
    "    s = remove_html_markup(\"<foo>bar</foo>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The graph is as discussed in the introduction to this chapter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:30.788862Z",
     "iopub.status.busy": "2023-11-12T12:40:30.788574Z",
     "iopub.status.idle": "2023-11-12T12:40:31.210345Z",
     "shell.execute_reply": "2023-11-12T12:40:31.209886Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"566pt\" height=\"960pt\"\n",
       " viewBox=\"0.00 0.00 566.38 960.00\" 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 956)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-956 562.38,-956 562.38,4 -4,4\"/>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>s_functionremove_html_markupat0x105d9b2e0_238</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"remove_html_markup:238\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"427.25,-952 190.75,-952 190.75,-912 427.25,-912 427.25,-952\"/>\n",
       "<text text-anchor=\"start\" x=\"304.88\" y=\"-935.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">s</text>\n",
       "<text text-anchor=\"start\" x=\"198.75\" y=\"-917.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def remove_html_markup(s): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"remove_html_markup:243\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"398.88,-648 325.12,-648 325.12,-608 398.88,-608 398.88,-648\"/>\n",
       "<text text-anchor=\"start\" x=\"357.88\" y=\"-631.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">c</text>\n",
       "<text text-anchor=\"start\" x=\"333.12\" y=\"-613.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">for c in s:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M319.77,-911.5C338.89,-875.69 378.02,-796.42 392,-724 395.37,-706.54 396.39,-701.23 392,-684 389.76,-675.21 385.79,-666.3 381.46,-658.29\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"384.5,-656.55 376.44,-649.67 378.45,-660.08 384.5,-656.55\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_239 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_239</title>\n",
       "<g id=\"a_node12\"><a xlink:title=\"remove_html_markup:239\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"288.88,-876 215.12,-876 215.12,-836 288.88,-836 288.88,-876\"/>\n",
       "<text text-anchor=\"start\" x=\"239.62\" y=\"-859.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"223.12\" y=\"-841.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">tag = False</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_239 -->\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_247</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"remove_html_markup:247\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"147.25,-496 78.75,-496 78.75,-456 147.25,-456 147.25,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"100.62\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"86.75\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">tag = True</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_248 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_248</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"remove_html_markup:248\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"403.5,-420 240.5,-420 240.5,-380 403.5,-380 403.5,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"297.25\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"248.5\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif c == &#39;&gt;&#39; and not quote:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_247&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248 -->\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_252 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_252</title>\n",
       "<g id=\"a_node10\"><a xlink:title=\"remove_html_markup:252\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"383.12,-192 298.88,-192 298.88,-152 383.12,-152 383.12,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"316.25\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"306.88\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif not tag:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_247&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252 -->\n",
       "<g id=\"edge13\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_247&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M96.25,-455.62C59.41,-410.57 -20.96,-297.38 37,-228 68.3,-190.53 208.81,-178.54 287.39,-174.74\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"287.16,-178.25 297,-174.3 286.85,-171.26 287.16,-178.25\"/>\n",
       "</g>\n",
       "<!-- assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<g id=\"node14\" class=\"node\">\n",
       "<title>assertion_functionremove_html_markupat0x105d9b2e0_244</title>\n",
       "<g id=\"a_node14\"><a xlink:title=\"remove_html_markup:244\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"182.38,-268 45.62,-268 45.62,-228 182.38,-228 182.38,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"68.62\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;assertion&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"53.62\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">assert tag or not quote</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_247&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<g id=\"edge21\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_247&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M113.09,-455.73C113.26,-416.45 113.66,-326.85 113.86,-279.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"117.36,-279.75 113.91,-269.73 110.36,-279.72 117.36,-279.75\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"remove_html_markup:246\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"231.25,-572 78.75,-572 78.75,-532 231.25,-532 231.25,-572\"/>\n",
       "<text text-anchor=\"start\" x=\"130.25\" y=\"-555.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"86.75\" y=\"-537.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if c == &#39;&lt;&#39; and not quote:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M137.94,-531.56C132.92,-523.91 127.64,-514.96 123.14,-506.55\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"126.28,-505 118.63,-497.66 120.04,-508.16 126.28,-505\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M176.49,-531.7C205.85,-505.33 258.62,-457.92 291.9,-428.03\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"294.1,-430.76 299.2,-421.48 289.42,-425.56 294.1,-430.76\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M324.99,-613.77C295.8,-603.33 254.37,-588.52 219.72,-576.14\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"221.22,-572.96 210.63,-572.89 218.87,-579.55 221.22,-572.96\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M358.59,-607.73C351.64,-568.45 335.78,-478.85 327.41,-431.55\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"330.85,-430.95 325.67,-421.71 323.96,-432.17 330.85,-430.95\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>out_functionremove_html_markupat0x105d9b2e0_253</title>\n",
       "<g id=\"a_node9\"><a xlink:title=\"remove_html_markup:253\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"448.12,-116 363.88,-116 363.88,-76 448.12,-76 448.12,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"393.62\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">out</text>\n",
       "<text text-anchor=\"start\" x=\"371.88\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">out = out + c</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M389.19,-607.54C421.77,-581.73 472,-532.87 472,-477 472,-477 472,-477 472,-247 472,-201.5 446.24,-154.31 426.91,-125.3\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"430.05,-123.69 421.5,-117.43 424.28,-127.66 430.05,-123.69\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_250 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_250</title>\n",
       "<g id=\"a_node11\"><a xlink:title=\"remove_html_markup:250\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"443.5,-268 238.5,-268 238.5,-228 443.5,-228 443.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"316.25\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"246.5\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">elif (c == &#39;&quot;&#39; or c == &quot;&#39;&quot;) and tag:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_250 -->\n",
       "<g id=\"edge16\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_250</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M377.54,-607.96C398.16,-580.69 432,-528.15 432,-477 432,-477 432,-477 432,-399 432,-350.42 396.67,-304.15 370.04,-276.16\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"372.67,-273.84 363.17,-269.16 367.68,-278.75 372.67,-273.84\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"remove_html_markup:240\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"294.12,-800 209.88,-800 209.88,-760 294.12,-760 294.12,-800\"/>\n",
       "<text text-anchor=\"start\" x=\"231.38\" y=\"-783.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">quote</text>\n",
       "<text text-anchor=\"start\" x=\"217.88\" y=\"-765.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">quote = False</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M243.73,-759.73C226.76,-720.2 187.92,-629.71 167.73,-582.65\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"171.01,-581.42 163.85,-573.61 164.57,-584.18 171.01,-581.42\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_241 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>out_functionremove_html_markupat0x105d9b2e0_241</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"remove_html_markup:241\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"383,-724 325,-724 325,-684 383,-684 383,-724\"/>\n",
       "<text text-anchor=\"start\" x=\"341.62\" y=\"-707.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">out</text>\n",
       "<text text-anchor=\"start\" x=\"333\" y=\"-689.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">out = &quot;&quot;</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_241 -->\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_248</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M261.76,-759.66C275,-731.61 297,-677.67 297,-629 297,-629 297,-629 297,-551 297,-509.05 306.63,-461.38 313.94,-431.26\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"317.3,-432.27 316.33,-421.71 310.51,-430.56 317.3,-432.27\"/>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<g id=\"edge20\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M209.86,-768.06C150.92,-749.93 51,-707.59 51,-629 51,-629 51,-629 51,-551 51,-449.71 85.38,-333.25 103.35,-279.32\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"106.64,-280.52 106.53,-269.93 100.01,-278.27 106.64,-280.52\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_241&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_241&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x105d9b2e0_241&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M383.34,-690.83C428.53,-669.89 510,-622.51 510,-553 510,-553 510,-553 510,-247 510,-196.82 470.2,-151.32 439.84,-123.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"442.15,-121.28 432.32,-117.34 437.54,-126.55 442.15,-121.28\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_249 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_249</title>\n",
       "<g id=\"a_node8\"><a xlink:title=\"remove_html_markup:249\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"313.88,-344 240.12,-344 240.12,-304 313.88,-304 313.88,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"264.62\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"248.12\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">tag = False</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_248&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_249 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_248&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_249</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M304.15,-379.56C298.76,-371.82 293.05,-362.76 288.18,-354.26\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"291.33,-352.73 283.46,-345.64 285.19,-356.09 291.33,-352.73\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_248&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_249 -->\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_248&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_250 -->\n",
       "<g id=\"edge17\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_248&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_250</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M324.45,-379.7C327.67,-354.27 333.36,-309.28 337.16,-279.29\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"340.59,-280.09 338.37,-269.73 333.65,-279.21 340.59,-280.09\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_249&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252 -->\n",
       "<g id=\"edge14\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_249&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M254.01,-303.74C244.32,-294.13 234.12,-281.65 229,-268 222.76,-251.35 219.6,-243.09 229,-228 242.04,-207.06 265.64,-193.87 287.82,-185.68\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"288.77,-189.05 297.12,-182.53 286.52,-182.42 288.77,-189.05\"/>\n",
       "</g>\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_249&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_250 -->\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_249&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<g id=\"edge22\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_249&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M240.01,-306.21C218.49,-296.44 191,-283.96 167.19,-273.15\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"168.83,-270.05 158.27,-269.1 165.93,-276.42 168.83,-270.05\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_253&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x105d9b2e0_253&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M448.42,-110C458.59,-108.9 466.12,-104.24 466.12,-96 466.12,-91.11 463.47,-87.48 459.18,-85.1\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"460.45,-81.83 449.87,-82.42 458.51,-88.55 460.45,-81.83\"/>\n",
       "</g>\n",
       "<!-- remove_html_markupreturnvalue_functionremove_html_markupat0x105d9b2e0_255 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>remove_html_markupreturnvalue_functionremove_html_markupat0x105d9b2e0_255</title>\n",
       "<g id=\"a_node13\"><a xlink:title=\"remove_html_markup:255\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"558.38,-40 253.62,-40 253.62,0 558.38,0 558.38,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"261.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;remove_html_markup() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"379.75\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return out</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_253&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x105d9b2e0_255 -->\n",
       "<g id=\"edge18\" class=\"edge\">\n",
       "<title>out_functionremove_html_markupat0x105d9b2e0_253&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x105d9b2e0_255</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M399.98,-75.56C399.32,-68.25 399.11,-59.75 399.34,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"402.82,-52.01 399.9,-41.82 395.84,-51.61 402.82,-52.01\"/>\n",
       "</g>\n",
       "<!-- out_functionremove_html_markupat0x105d9b2e0_253&#45;&gt;remove_html_markupreturnvalue_functionremove_html_markupat0x105d9b2e0_255 -->\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_252&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_252&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M352.05,-151.56C358.56,-143.31 366.95,-133.56 375.21,-124.59\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"377.67,-127.09 381.99,-117.41 372.58,-122.28 377.67,-127.09\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_252&#45;&gt;out_functionremove_html_markupat0x105d9b2e0_253 -->\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_250&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252 -->\n",
       "<g id=\"edge15\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_250&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M334.98,-227.56C334.32,-220.25 334.11,-211.75 334.34,-203.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"337.82,-204.01 334.9,-193.82 330.84,-203.61 337.82,-204.01\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_250&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_252 -->\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_239&#45;&gt;quote_functionremove_html_markupat0x105d9b2e0_240 -->\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_239&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244 -->\n",
       "<g id=\"edge19\" class=\"edge\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_239&#45;&gt;assertion_functionremove_html_markupat0x105d9b2e0_244</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M214.82,-850.25C144.72,-838.99 0,-803.77 0,-705 0,-705 0,-705 0,-475 0,-396.72 55.19,-317.96 88.77,-277.29\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"91.44,-279.55 95.21,-269.65 86.09,-275.04 91.44,-279.55\"/>\n",
       "</g>\n",
       "<!-- assertion_functionremove_html_markupat0x105d9b2e0_244&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105deb0d0>"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rhm_slicer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:31.212477Z",
     "iopub.status.busy": "2023-11-12T12:40:31.212235Z",
     "iopub.status.idle": "2023-11-12T12:40:31.214184Z",
     "shell.execute_reply": "2023-11-12T12:40:31.213875Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# print(repr(rhm_slicer.dependencies()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:31.215930Z",
     "iopub.status.busy": "2023-11-12T12:40:31.215773Z",
     "iopub.status.idle": "2023-11-12T12:40:31.764425Z",
     "shell.execute_reply": "2023-11-12T12:40:31.764148Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*  238 \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",
      "*  239     tag = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  240     quote = \u001b[34mFalse\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  241     out = \u001b[33m\"\u001b[39;49;00m\u001b[33m\"\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   242 \u001b[37m\u001b[39;49;00m\n",
      "*  243     \u001b[34mfor\u001b[39;49;00m c \u001b[35min\u001b[39;49;00m s:  \u001b[37m# <= s (238)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  244         \u001b[34massert\u001b[39;49;00m tag \u001b[35mor\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m quote  \u001b[37m# <= tag (239), quote (240), tag (247), tag (249)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   245 \u001b[37m\u001b[39;49;00m\n",
      "*  246         \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# <= c (243), quote (240)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  247             tag = \u001b[34mTrue\u001b[39;49;00m  \u001b[37m# <- <test> (246)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  248         \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# <= c (243), quote (240); <- <test> (246)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  249             tag = \u001b[34mFalse\u001b[39;49;00m  \u001b[37m# <- <test> (248)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  250         \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# <= c (243); <- <test> (248)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   251             quote = \u001b[35mnot\u001b[39;49;00m quote\u001b[37m\u001b[39;49;00m\n",
      "*  252         \u001b[34melif\u001b[39;49;00m \u001b[35mnot\u001b[39;49;00m tag:  \u001b[37m# <= tag (247), tag (249); <- <test> (250)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*  253             out = out + c  \u001b[37m# <= out (241), c (243), out (253); <- <test> (252)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "   254 \u001b[37m\u001b[39;49;00m\n",
      "*  255     \u001b[34mreturn\u001b[39;49;00m out  \u001b[37m# <= out (253)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "rhm_slicer.code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can also compute slices over the dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:31.766159Z",
     "iopub.status.busy": "2023-11-12T12:40:31.766028Z",
     "iopub.status.idle": "2023-11-12T12:40:31.768740Z",
     "shell.execute_reply": "2023-11-12T12:40:31.768454Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "238"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_, start_remove_html_markup = inspect.getsourcelines(remove_html_markup)\n",
    "start_remove_html_markup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:31.770406Z",
     "iopub.status.busy": "2023-11-12T12:40:31.770282Z",
     "iopub.status.idle": "2023-11-12T12:40:32.197448Z",
     "shell.execute_reply": "2023-11-12T12:40:32.197077Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"245pt\" height=\"352pt\"\n",
       " viewBox=\"0.00 0.00 244.50 352.00\" 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 348)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-348 240.5,-348 240.5,4 -4,4\"/>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>s_functionremove_html_markupat0x105d9b2e0_238</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"remove_html_markup:238\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"236.5,-344 0,-344 0,-304 236.5,-304 236.5,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"114.12\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">s</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def remove_html_markup(s): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"remove_html_markup:243\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"125.12,-192 51.38,-192 51.38,-152 125.12,-152 125.12,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"84.12\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">c</text>\n",
       "<text text-anchor=\"start\" x=\"59.38\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">for c in s:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M111.89,-303.57C108.65,-293.11 104.86,-279.95 102.25,-268 97.62,-246.76 94.07,-222.5 91.71,-203.81\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"95.19,-203.43 90.51,-193.93 88.24,-204.28 95.19,-203.43\"/>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"remove_html_markup:240\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"195.38,-268 111.12,-268 111.12,-228 195.38,-228 195.38,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"132.62\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">quote</text>\n",
       "<text text-anchor=\"start\" x=\"119.12\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">quote = False</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- s_functionremove_html_markupat0x105d9b2e0_238&#45;&gt;quote_functionremove_html_markupat0x105d9b2e0_240 -->\n",
       "<!-- tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>tag_functionremove_html_markupat0x105d9b2e0_247</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"remove_html_markup:247\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"122.5,-40 54,-40 54,0 122.5,0 122.5,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"75.88\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">tag</text>\n",
       "<text text-anchor=\"start\" x=\"62\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">tag = True</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"remove_html_markup:246\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"164.5,-116 12,-116 12,-76 164.5,-76 164.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"63.5\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"20\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if c == &#39;&lt;&#39; and not quote:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M82.23,-75.56C81.57,-68.25 81.36,-59.75 81.59,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"85.07,-52.01 82.15,-41.82 78.09,-51.61 85.07,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionremove_html_markupat0x105d9b2e0_246&#45;&gt;tag_functionremove_html_markupat0x105d9b2e0_247 -->\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M82.23,-151.56C81.57,-144.25 81.36,-135.75 81.59,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"85.07,-128.01 82.15,-117.82 78.09,-127.61 85.07,-128.01\"/>\n",
       "</g>\n",
       "<!-- c_functionremove_html_markupat0x105d9b2e0_243&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;test_functionremove_html_markupat0x105d9b2e0_246</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M152.18,-227.55C150.45,-207.7 145.95,-176.42 134.25,-152 129.63,-142.36 122.93,-132.99 116.06,-124.8\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"118.89,-122.72 109.64,-117.55 113.65,-127.36 118.89,-122.72\"/>\n",
       "</g>\n",
       "<!-- quote_functionremove_html_markupat0x105d9b2e0_240&#45;&gt;c_functionremove_html_markupat0x105d9b2e0_243 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        ('tag', (remove_html_markup, 247)): set(),\n",
       "        ('<test>', (remove_html_markup, 246)): {('c', (remove_html_markup, 243)), ('quote', (remove_html_markup, 240))},\n",
       "        ('c', (remove_html_markup, 243)): {('s', (remove_html_markup, 238))},\n",
       "        ('quote', (remove_html_markup, 240)): set(),\n",
       "        ('s', (remove_html_markup, 238)): set()},\n",
       " control={\n",
       "        ('tag', (remove_html_markup, 247)): {('<test>', (remove_html_markup, 246))},\n",
       "        ('<test>', (remove_html_markup, 246)): set(),\n",
       "        ('c', (remove_html_markup, 243)): set(),\n",
       "        ('quote', (remove_html_markup, 240)): set(),\n",
       "        ('s', (remove_html_markup, 238)): set()})"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicing_criterion = ('tag', (remove_html_markup,\n",
    "                             start_remove_html_markup + 9))\n",
    "tag_deps = rhm_slicer.dependencies().backward_slice(slicing_criterion)  # type: ignore\n",
    "tag_deps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.199410Z",
     "iopub.status.busy": "2023-11-12T12:40:32.199284Z",
     "iopub.status.idle": "2023-11-12T12:40:32.201001Z",
     "shell.execute_reply": "2023-11-12T12:40:32.200752Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# repr(tag_deps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Calls and Augmented Assign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Our last example covers augmented assigns and data flow across function calls. We introduce two simple functions `add_to()` and `mul_with()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.202441Z",
     "iopub.status.busy": "2023-11-12T12:40:32.202344Z",
     "iopub.status.idle": "2023-11-12T12:40:32.204031Z",
     "shell.execute_reply": "2023-11-12T12:40:32.203775Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add_to(n, m):  # type: ignore\n",
    "    n += m\n",
    "    return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.205483Z",
     "iopub.status.busy": "2023-11-12T12:40:32.205365Z",
     "iopub.status.idle": "2023-11-12T12:40:32.207085Z",
     "shell.execute_reply": "2023-11-12T12:40:32.206803Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def mul_with(x, y):  # type: ignore\n",
    "    x *= y\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And we put these two together in a single call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.208859Z",
     "iopub.status.busy": "2023-11-12T12:40:32.208678Z",
     "iopub.status.idle": "2023-11-12T12:40:32.210766Z",
     "shell.execute_reply": "2023-11-12T12:40:32.210471Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def test_math() -> None:\n",
    "    return mul_with(1, add_to(2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.212225Z",
     "iopub.status.busy": "2023-11-12T12:40:32.212118Z",
     "iopub.status.idle": "2023-11-12T12:40:32.217243Z",
     "shell.execute_reply": "2023-11-12T12:40:32.216985Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with Slicer(add_to, mul_with, test_math) as math_slicer:\n",
    "    test_math()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The resulting dependence graph nicely captures the data flow between these calls, notably arguments and parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.218688Z",
     "iopub.status.busy": "2023-11-12T12:40:32.218598Z",
     "iopub.status.idle": "2023-11-12T12:40:32.629216Z",
     "shell.execute_reply": "2023-11-12T12:40:32.628842Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"628pt\" height=\"504pt\"\n",
       " viewBox=\"0.00 0.00 627.50 504.00\" 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 500)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-500 623.5,-500 623.5,4 -4,4\"/>\n",
       "<!-- x_functionmul_withat0x105d39d80_1 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>x_functionmul_withat0x105d39d80_1</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"mul_with:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"199.75,-268 0,-268 0,-228 199.75,-228 199.75,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"95.75\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def mul_with(x, y): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmul_withat0x105d39d80_2 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>x_functionmul_withat0x105d39d80_2</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"mul_with:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"344.88,-192 290.88,-192 290.88,-152 344.88,-152 344.88,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"313.75\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"302.12\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">x *= y</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionmul_withat0x105d39d80_1&#45;&gt;x_functionmul_withat0x105d39d80_2 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>x_functionmul_withat0x105d39d80_1&#45;&gt;x_functionmul_withat0x105d39d80_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M157.15,-227.56C195.8,-214.44 245.74,-197.48 279.63,-185.98\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"280.68,-189.32 289.03,-182.79 278.43,-182.69 280.68,-189.32\"/>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>n_functionadd_toat0x105d39990_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"add_to:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"412.5,-496 223.25,-496 223.25,-456 412.5,-456 412.5,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"313.75\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">n</text>\n",
       "<text text-anchor=\"start\" x=\"231.25\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def add_to(n, m): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_2 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>n_functionadd_toat0x105d39990_2</title>\n",
       "<g id=\"a_node8\"><a xlink:title=\"add_to:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"344.88,-420 290.88,-420 290.88,-380 344.88,-380 344.88,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"313.75\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">n</text>\n",
       "<text text-anchor=\"start\" x=\"302.12\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">n += m</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_1&#45;&gt;n_functionadd_toat0x105d39990_2 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>n_functionadd_toat0x105d39990_1&#45;&gt;n_functionadd_toat0x105d39990_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M311.85,-455.56C311.2,-448.25 310.99,-439.75 311.21,-431.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"314.7,-432.01 311.78,-421.82 307.71,-431.61 314.7,-432.01\"/>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_1&#45;&gt;n_functionadd_toat0x105d39990_2 -->\n",
       "<!-- mul_withreturnvalue_functionmul_withat0x105d39d80_3 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>mul_withreturnvalue_functionmul_withat0x105d39d80_3</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"mul_with:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"429,-116 206.75,-116 206.75,-76 429,-76 429,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"214.75\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;mul_with() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"296.88\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return x</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_mathreturnvalue_functiontest_mathat0x105d3a170_2 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>test_mathreturnvalue_functiontest_mathat0x105d3a170_2</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"test_math:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"433.12,-40 202.62,-40 202.62,0 433.12,0 433.12,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"210.62\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test_math() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"233.88\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return mul_with(1, add_to(2, 3))</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- mul_withreturnvalue_functionmul_withat0x105d39d80_3&#45;&gt;test_mathreturnvalue_functiontest_mathat0x105d3a170_2 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>mul_withreturnvalue_functionmul_withat0x105d39d80_3&#45;&gt;test_mathreturnvalue_functiontest_mathat0x105d3a170_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M317.88,-75.56C317.88,-68.25 317.88,-59.75 317.88,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"321.38,-51.83 317.88,-41.83 314.38,-51.83 321.38,-51.83\"/>\n",
       "</g>\n",
       "<!-- x_functionmul_withat0x105d39d80_2&#45;&gt;mul_withreturnvalue_functionmul_withat0x105d39d80_3 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionmul_withat0x105d39d80_2&#45;&gt;mul_withreturnvalue_functionmul_withat0x105d39d80_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M311.85,-151.56C311.2,-144.25 310.99,-135.75 311.21,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"314.7,-128.01 311.78,-117.82 307.71,-127.61 314.7,-128.01\"/>\n",
       "</g>\n",
       "<!-- x_functionmul_withat0x105d39d80_2&#45;&gt;mul_withreturnvalue_functionmul_withat0x105d39d80_3 -->\n",
       "<!-- y_functionmul_withat0x105d39d80_1 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>y_functionmul_withat0x105d39d80_1</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"mul_with:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"417.75,-268 218,-268 218,-228 417.75,-228 417.75,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"313.75\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">y</text>\n",
       "<text text-anchor=\"start\" x=\"226\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def mul_with(x, y): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- y_functionmul_withat0x105d39d80_1&#45;&gt;x_functionmul_withat0x105d39d80_2 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>y_functionmul_withat0x105d39d80_1&#45;&gt;x_functionmul_withat0x105d39d80_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M311.85,-227.56C311.2,-220.25 310.99,-211.75 311.21,-203.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"314.7,-204.01 311.78,-193.82 307.71,-203.61 314.7,-204.01\"/>\n",
       "</g>\n",
       "<!-- y_functionmul_withat0x105d39d80_1&#45;&gt;x_functionmul_withat0x105d39d80_2 -->\n",
       "<!-- add_toreturnvalue_functionadd_toat0x105d39990_3 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>add_toreturnvalue_functionadd_toat0x105d39990_3</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"add_to:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"420.75,-344 215,-344 215,-304 420.75,-304 420.75,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"223\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;add_to() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"296.88\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return n</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- add_toreturnvalue_functionadd_toat0x105d39990_3&#45;&gt;y_functionmul_withat0x105d39d80_1 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>add_toreturnvalue_functionadd_toat0x105d39990_3&#45;&gt;y_functionmul_withat0x105d39d80_1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M317.88,-303.56C317.88,-296.25 317.88,-287.75 317.88,-279.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"321.38,-279.83 317.88,-269.83 314.38,-279.83 321.38,-279.83\"/>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_2&#45;&gt;add_toreturnvalue_functionadd_toat0x105d39990_3 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>n_functionadd_toat0x105d39990_2&#45;&gt;add_toreturnvalue_functionadd_toat0x105d39990_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M311.85,-379.56C311.2,-372.25 310.99,-363.75 311.21,-355.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"314.7,-356.01 311.78,-345.82 307.71,-355.61 314.7,-356.01\"/>\n",
       "</g>\n",
       "<!-- n_functionadd_toat0x105d39990_2&#45;&gt;add_toreturnvalue_functionadd_toat0x105d39990_3 -->\n",
       "<!-- m_functionadd_toat0x105d39990_1 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>m_functionadd_toat0x105d39990_1</title>\n",
       "<g id=\"a_node9\"><a xlink:title=\"add_to:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"619.5,-496 430.25,-496 430.25,-456 619.5,-456 619.5,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"520.75\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">m</text>\n",
       "<text text-anchor=\"start\" x=\"438.25\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def add_to(n, m): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- m_functionadd_toat0x105d39990_1&#45;&gt;n_functionadd_toat0x105d39990_2 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>m_functionadd_toat0x105d39990_1&#45;&gt;n_functionadd_toat0x105d39990_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M470.49,-455.56C434.48,-442.69 388.16,-426.13 356.04,-414.64\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"357.33,-411.39 346.73,-411.32 354.97,-417.98 357.33,-411.39\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105dea140>"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math_slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "These are also reflected in the code view:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.631090Z",
     "iopub.status.busy": "2023-11-12T12:40:32.630868Z",
     "iopub.status.idle": "2023-11-12T12:40:32.972851Z",
     "shell.execute_reply": "2023-11-12T12:40:32.966966Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1 \u001b[34mdef\u001b[39;49;00m \u001b[32mtest_math\u001b[39;49;00m() -> \u001b[34mNone\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "*    2     \u001b[34mreturn\u001b[39;49;00m mul_with(\u001b[34m1\u001b[39;49;00m, add_to(\u001b[34m2\u001b[39;49;00m, \u001b[34m3\u001b[39;49;00m))  \u001b[37m# <= <mul_with() return value> (mul_with:3)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "*    1 \u001b[34mdef\u001b[39;49;00m \u001b[32madd_to\u001b[39;49;00m(n, m):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    2     n += m  \u001b[37m# <= n (1), m (1)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    3     \u001b[34mreturn\u001b[39;49;00m n  \u001b[37m# <= n (2)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "*    1 \u001b[34mdef\u001b[39;49;00m \u001b[32mmul_with\u001b[39;49;00m(x, y):  \u001b[37m# type: ignore  # <= <add_to() return value> (add_to:3)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    2     x *= y  \u001b[37m# <= x (1), y (1)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    3     \u001b[34mreturn\u001b[39;49;00m x  \u001b[37m# <= x (2)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "math_slicer.code()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dynamic Instrumentation\n",
    "\n",
    "When initializing `Slicer()`, one has to provide the set of functions to be instrumented. This is because the instrumentation has to take place _before_ the code in the `with` block is executed. Can we determine this list on the fly – while `Slicer()` is executed? \n",
    "\n",
    "The answer is: Yes, but the solution is a bit hackish – even more so than what we have seen above. In essence, we proceed in two steps:\n",
    "\n",
    "1. When `DynamicSlicer.__init__()` is called:\n",
    "    * Use the `inspect` module to determine the source code of the call\n",
    "    * Analyze the enclosed `with` block for function calls\n",
    "    * Instrument these functions\n",
    "2. Whenever a function is about to be called (`DataTracker.call()`)\n",
    "    * Create an instrumented version of that function\n",
    "    * Have the `call()` method return the instrumented function instead"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Excursion: Implementing Dynamic Instrumentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We start with the aim of determining the `with` block to which our slicer is applied. The `our_with_block()` method inspects the source code of the `Slicer()` caller, and returns the one `with` block (as an AST) whose source line is currently active."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.976764Z",
     "iopub.status.busy": "2023-11-12T12:40:32.976605Z",
     "iopub.status.idle": "2023-11-12T12:40:32.980554Z",
     "shell.execute_reply": "2023-11-12T12:40:32.980085Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class WithVisitor(NodeVisitor):\n",
    "    def __init__(self) -> None:\n",
    "        self.withs: List[ast.With] = []\n",
    "\n",
    "    def visit_With(self, node: ast.With) -> AST:\n",
    "        self.withs.append(node)\n",
    "        return self.generic_visit(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.983713Z",
     "iopub.status.busy": "2023-11-12T12:40:32.983561Z",
     "iopub.status.idle": "2023-11-12T12:40:32.986663Z",
     "shell.execute_reply": "2023-11-12T12:40:32.986177Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def our_with_block(self) -> ast.With:\n",
    "        \"\"\"Return the currently active `with` block.\"\"\"\n",
    "        frame = self.caller_frame()\n",
    "        source_lines, starting_lineno = inspect.getsourcelines(frame)\n",
    "        starting_lineno = max(starting_lineno, 1)\n",
    "        if len(source_lines) == 1:\n",
    "            # We only get one `with` line, rather than the full block\n",
    "            # This happens in Jupyter notebooks with iPython 8.1.0 and later.\n",
    "            # Here's a hacky workaround to get the cell contents:\n",
    "            # https://stackoverflow.com/questions/51566497/getting-the-source-of-an-object-defined-in-a-jupyter-notebook\n",
    "            source_lines = inspect.linecache.getlines(inspect.getfile(frame))  # type: ignore\n",
    "            starting_lineno = 1\n",
    "\n",
    "        source_ast = ast.parse(''.join(source_lines))\n",
    "        wv = WithVisitor()\n",
    "        wv.visit(source_ast)\n",
    "\n",
    "        for with_ast in wv.withs:\n",
    "            if starting_lineno + (with_ast.lineno - 1) == frame.f_lineno:\n",
    "                return with_ast\n",
    "\n",
    "        raise ValueError(\"Cannot find 'with' block\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Within the `with` AST, we can identify all calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.988517Z",
     "iopub.status.busy": "2023-11-12T12:40:32.988423Z",
     "iopub.status.idle": "2023-11-12T12:40:32.991425Z",
     "shell.execute_reply": "2023-11-12T12:40:32.991102Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class CallCollector(NodeVisitor):\n",
    "    def __init__(self) -> None:\n",
    "        self.calls: Set[str] = set()\n",
    "\n",
    "    def visit_Call(self, node: ast.Call) -> AST:\n",
    "        caller_id = ast.unparse(node.func).strip()\n",
    "        self.calls.add(caller_id)\n",
    "        return self.generic_visit(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.993540Z",
     "iopub.status.busy": "2023-11-12T12:40:32.993413Z",
     "iopub.status.idle": "2023-11-12T12:40:32.995646Z",
     "shell.execute_reply": "2023-11-12T12:40:32.995328Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def calls_in_our_with_block(self) -> Set[str]:\n",
    "        \"\"\"Return a set of function names called in the `with` block.\"\"\"\n",
    "        block_ast = self.our_with_block()\n",
    "        cc = CallCollector()\n",
    "        for stmt in block_ast.body:\n",
    "            cc.visit(stmt)\n",
    "        return cc.calls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The method `funcs_in_our_with_block()` finally returns a list of all functions used in the `with` block. This is the list of functions we will instrument upfront."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:32.997276Z",
     "iopub.status.busy": "2023-11-12T12:40:32.997158Z",
     "iopub.status.idle": "2023-11-12T12:40:32.999512Z",
     "shell.execute_reply": "2023-11-12T12:40:32.999162Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def funcs_in_our_with_block(self) -> List[Callable]:\n",
    "        funcs = []\n",
    "        for id in self.calls_in_our_with_block():\n",
    "            func = self.search_func(id)\n",
    "            if func:\n",
    "                funcs.append(func)\n",
    "\n",
    "        return funcs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The method `default_items_to_instrument()` is already provided for dynamic instrumentation – it is invoked whenever no list of functions to instrument is provided. So we have it return the list of functions as computed above.\n",
    "\n",
    "However, `default_items_to_instrument()` does one more thing: Using the (also provided) `instrument_call()` hook in our dependency tracker, we ensure that all (later) calls are redirected to instrumented functions! This way, if further functions are called, these will be instrumented on the fly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.001396Z",
     "iopub.status.busy": "2023-11-12T12:40:33.001267Z",
     "iopub.status.idle": "2023-11-12T12:40:33.003472Z",
     "shell.execute_reply": "2023-11-12T12:40:33.003124Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Slicer(Slicer):\n",
    "    def default_items_to_instrument(self) -> List[Callable]:\n",
    "        # In _data.call(), return instrumented function\n",
    "        self.dependency_tracker.instrument_call = self.instrument  # type: ignore\n",
    "\n",
    "        # Start instrumenting the functions in our `with` block\n",
    "        return self.funcs_in_our_with_block()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### End of Excursion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Both these hacks are effective, as shown in the following example. We use the `Slicer()` constructor without arguments; it automatically identifies `fun_2()` as a function in the `with` block. As the instrumented `fun2()` is invoked, its `_data.call()` method instruments the call to `fun_1()` (and ensures the instrumented version is called)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.005048Z",
     "iopub.status.busy": "2023-11-12T12:40:33.004929Z",
     "iopub.status.idle": "2023-11-12T12:40:33.006674Z",
     "shell.execute_reply": "2023-11-12T12:40:33.006380Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def fun_1(x: int) -> int:\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.008274Z",
     "iopub.status.busy": "2023-11-12T12:40:33.008150Z",
     "iopub.status.idle": "2023-11-12T12:40:33.010310Z",
     "shell.execute_reply": "2023-11-12T12:40:33.009947Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def fun_2(x: int) -> int:\n",
    "    return fun_1(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.012138Z",
     "iopub.status.busy": "2023-11-12T12:40:33.012020Z",
     "iopub.status.idle": "2023-11-12T12:40:33.083214Z",
     "shell.execute_reply": "2023-11-12T12:40:33.082770Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instrumenting <function fun_2 at 0x104c6b880>\n",
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mfun_2\u001b[39;49;00m(x: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<fun_2() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.ret(_data.call(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mfun_1\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, fun_1))(_data.arg(_data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x), pos=\u001b[34m1\u001b[39;49;00m))))\u001b[37m\u001b[39;49;00m\n",
      "\n",
      "Instrumenting <function fun_1 at 0x104c69bd0>\n",
      "\u001b[34mdef\u001b[39;49;00m \u001b[32mfun_1\u001b[39;49;00m(x: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "    _data.param(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x, pos=\u001b[34m1\u001b[39;49;00m, last=\u001b[34mTrue\u001b[39;49;00m)\u001b[37m\u001b[39;49;00m\n",
      "    \u001b[34mreturn\u001b[39;49;00m _data.set(\u001b[33m'\u001b[39;49;00m\u001b[33m<fun_1() return value>\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, _data.get(\u001b[33m'\u001b[39;49;00m\u001b[33mx\u001b[39;49;00m\u001b[33m'\u001b[39;49;00m, x))\u001b[37m\u001b[39;49;00m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with Slicer(log=True) as slicer:\n",
    "    fun_2(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.085221Z",
     "iopub.status.busy": "2023-11-12T12:40:33.085103Z",
     "iopub.status.idle": "2023-11-12T12:40:33.524800Z",
     "shell.execute_reply": "2023-11-12T12:40:33.524418Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"269pt\" height=\"276pt\"\n",
       " viewBox=\"0.00 0.00 268.50 276.00\" 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 272)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-272 264.5,-272 264.5,4 -4,4\"/>\n",
       "<!-- fun_1returnvalue_functionfun_1at0x104c68dc0_2 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>fun_1returnvalue_functionfun_1at0x104c68dc0_2</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"fun_1:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"197.5,-116 0,-116 0,-76 197.5,-76 197.5,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;fun_1() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"77.75\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return x</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- fun_2returnvalue_functionfun_2at0x105d9b520_2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>fun_2returnvalue_functionfun_2at0x105d9b520_2</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"fun_2:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"260.5,-40 63,-40 63,0 260.5,0 260.5,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"71\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;fun_2() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"122.38\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return fun_1(x)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- fun_1returnvalue_functionfun_1at0x104c68dc0_2&#45;&gt;fun_2returnvalue_functionfun_2at0x105d9b520_2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>fun_1returnvalue_functionfun_1at0x104c68dc0_2&#45;&gt;fun_2returnvalue_functionfun_2at0x105d9b520_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M115.3,-75.56C122.25,-67.4 130.45,-57.76 138.02,-48.87\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"140.51,-51.35 144.33,-41.47 135.18,-46.81 140.51,-51.35\"/>\n",
       "</g>\n",
       "<!-- x_functionfun_1at0x104c68dc0_1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>x_functionfun_1at0x104c68dc0_1</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"fun_1:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"172.38,-192 25.12,-192 25.12,-152 172.38,-152 172.38,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"94.62\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"33.12\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def fun_1(x: int) &#45;&gt; int:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionfun_1at0x104c68dc0_1&#45;&gt;fun_1returnvalue_functionfun_1at0x104c68dc0_2 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functionfun_1at0x104c68dc0_1&#45;&gt;fun_1returnvalue_functionfun_1at0x104c68dc0_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M92.73,-151.56C92.07,-144.25 91.86,-135.75 92.09,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"95.57,-128.01 92.65,-117.82 88.59,-127.61 95.57,-128.01\"/>\n",
       "</g>\n",
       "<!-- x_functionfun_1at0x104c68dc0_1&#45;&gt;fun_1returnvalue_functionfun_1at0x104c68dc0_2 -->\n",
       "<!-- x_functionfun_2at0x105d9b520_1 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>x_functionfun_2at0x105d9b520_1</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"fun_2:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"235.38,-268 88.12,-268 88.12,-228 235.38,-228 235.38,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"157.62\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"96.12\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def fun_2(x: int) &#45;&gt; int:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionfun_2at0x105d9b520_1&#45;&gt;x_functionfun_1at0x104c68dc0_1 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>x_functionfun_2at0x105d9b520_1&#45;&gt;x_functionfun_1at0x104c68dc0_1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M145.2,-227.56C138.25,-219.4 130.05,-209.76 122.48,-200.87\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"125.32,-198.81 116.17,-193.47 119.99,-203.35 125.32,-198.81\"/>\n",
       "</g>\n",
       "<!-- x_functionfun_2at0x105d9b520_1&#45;&gt;fun_2returnvalue_functionfun_2at0x105d9b520_2 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105f4d510>"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## More Applications\n",
    "\n",
    "The main use of dynamic slices is for _debugging tools_, where they show the origins of individual values. However, beyond facilitating debugging, tracking information flows has a number of additional applications, some of which we briefly sketch here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Verifying Information Flows\n",
    "\n",
    "Using dynamic slices, we can check all the locations where (potentially sensitive) information is used. As an example, consider the following function `password_checker()`, which requests a password from the user and returns `True` if it is the correct one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.526742Z",
     "iopub.status.busy": "2023-11-12T12:40:33.526558Z",
     "iopub.status.idle": "2023-11-12T12:40:33.528607Z",
     "shell.execute_reply": "2023-11-12T12:40:33.528301Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import hashlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.530524Z",
     "iopub.status.busy": "2023-11-12T12:40:33.530335Z",
     "iopub.status.idle": "2023-11-12T12:40:33.532679Z",
     "shell.execute_reply": "2023-11-12T12:40:33.532180Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from bookutils import input, next_inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.534655Z",
     "iopub.status.busy": "2023-11-12T12:40:33.534481Z",
     "iopub.status.idle": "2023-11-12T12:40:33.536302Z",
     "shell.execute_reply": "2023-11-12T12:40:33.536027Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "SECRET_HASH_DIGEST = '59f2da35bcc39525b87932b4cc1f3d68'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.537785Z",
     "iopub.status.busy": "2023-11-12T12:40:33.537664Z",
     "iopub.status.idle": "2023-11-12T12:40:33.539731Z",
     "shell.execute_reply": "2023-11-12T12:40:33.539475Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def password_checker() -> bool:\n",
    "    \"\"\"Request a password. Return True if correct.\"\"\"\n",
    "    secret_password = input(\"Enter secret password: \")\n",
    "    password_digest = hashlib.md5(secret_password.encode('utf-8')).hexdigest()\n",
    "\n",
    "    if password_digest == SECRET_HASH_DIGEST:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "(Note that this is a very naive implementation: A true password checker would use the Python `getpass` module to read in a password without echoing it in the clear, and possibly also use a more sophisticated hash function than `md5`.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "From a security perspective, the interesting question we can ask using slicing is: _Is the entered password stored in the clear somewhere_? For this, we can simply run our slicer to see where the inputs are going:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.541205Z",
     "iopub.status.busy": "2023-11-12T12:40:33.541101Z",
     "iopub.status.idle": "2023-11-12T12:40:33.543132Z",
     "shell.execute_reply": "2023-11-12T12:40:33.542881Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['secret123']"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "next_inputs(['secret123'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.544573Z",
     "iopub.status.busy": "2023-11-12T12:40:33.544460Z",
     "iopub.status.idle": "2023-11-12T12:40:33.551976Z",
     "shell.execute_reply": "2023-11-12T12:40:33.551721Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<samp>Enter secret password: <b>secret123</b></samp>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "with Slicer() as slicer:\n",
    "    valid_pwd = password_checker()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.553435Z",
     "iopub.status.busy": "2023-11-12T12:40:33.553324Z",
     "iopub.status.idle": "2023-11-12T12:40:33.960010Z",
     "shell.execute_reply": "2023-11-12T12:40:33.959555Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"413pt\" height=\"276pt\"\n",
       " viewBox=\"0.00 0.00 412.50 276.00\" 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 272)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-272 408.5,-272 408.5,4 -4,4\"/>\n",
       "<!-- password_checkerreturnvalue_functionpassword_checkerat0x10582eb00_9 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>password_checkerreturnvalue_functionpassword_checkerat0x10582eb00_9</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"password_checker:9\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"346.38,-40 58.12,-40 58.12,0 346.38,0 346.38,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"66.12\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;password_checker() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"170.75\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return False</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionpassword_checkerat0x10582eb00_6 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>test_functionpassword_checkerat0x10582eb00_6</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"password_checker:6\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"317.88,-116 86.62,-116 86.62,-76 317.88,-76 317.88,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"177.5\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"94.62\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">if password_digest == SECRET_HASH_DIGEST:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- test_functionpassword_checkerat0x10582eb00_6&#45;&gt;password_checkerreturnvalue_functionpassword_checkerat0x10582eb00_9 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>test_functionpassword_checkerat0x10582eb00_6&#45;&gt;password_checkerreturnvalue_functionpassword_checkerat0x10582eb00_9</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M196.23,-75.56C195.57,-68.25 195.36,-59.75 195.59,-51.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"199.07,-52.01 196.15,-41.82 192.09,-51.61 199.07,-52.01\"/>\n",
       "</g>\n",
       "<!-- test_functionpassword_checkerat0x10582eb00_6&#45;&gt;password_checkerreturnvalue_functionpassword_checkerat0x10582eb00_9 -->\n",
       "<!-- password_digest_functionpassword_checkerat0x10582eb00_4 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>password_digest_functionpassword_checkerat0x10582eb00_4</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"password_checker:4\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"404.5,-192 0,-192 0,-152 404.5,-152 404.5,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"140.38\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">password_digest</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">password_digest = hashlib.md5(secret_password.encode(&#39;utf&#45;8&#39;)).hexdigest()</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- password_digest_functionpassword_checkerat0x10582eb00_4&#45;&gt;test_functionpassword_checkerat0x10582eb00_6 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>password_digest_functionpassword_checkerat0x10582eb00_4&#45;&gt;test_functionpassword_checkerat0x10582eb00_6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M196.23,-151.56C195.57,-144.25 195.36,-135.75 195.59,-127.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"199.07,-128.01 196.15,-117.82 192.09,-127.61 199.07,-128.01\"/>\n",
       "</g>\n",
       "<!-- password_digest_functionpassword_checkerat0x10582eb00_4&#45;&gt;test_functionpassword_checkerat0x10582eb00_6 -->\n",
       "<!-- secret_password_functionpassword_checkerat0x10582eb00_3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>secret_password_functionpassword_checkerat0x10582eb00_3</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"password_checker:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"341.5,-268 63,-268 63,-228 341.5,-228 341.5,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"140.38\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">secret_password</text>\n",
       "<text text-anchor=\"start\" x=\"71\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">secret_password = input(&quot;Enter secret password: &quot;)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- secret_password_functionpassword_checkerat0x10582eb00_3&#45;&gt;password_digest_functionpassword_checkerat0x10582eb00_4 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>secret_password_functionpassword_checkerat0x10582eb00_3&#45;&gt;password_digest_functionpassword_checkerat0x10582eb00_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M196.23,-227.56C195.57,-220.25 195.36,-211.75 195.59,-203.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"199.07,-204.01 196.15,-193.82 192.09,-203.61 199.07,-204.01\"/>\n",
       "</g>\n",
       "<!-- secret_password_functionpassword_checkerat0x10582eb00_3&#45;&gt;password_digest_functionpassword_checkerat0x10582eb00_4 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105de8eb0>"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We see that the password only flows into `password_digest`, where it is already encrypted. If the password were flowing into some other function or variable, we would see this in our slice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "(Note that an attacker may still be able to find out which password was entered, for instance, by checking memory contents.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.962111Z",
     "iopub.status.busy": "2023-11-12T12:40:33.961930Z",
     "iopub.status.idle": "2023-11-12T12:40:33.967814Z",
     "shell.execute_reply": "2023-11-12T12:40:33.967520Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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 is the secret password, actually?</div>\n",
       "    </p>\n",
       "    <p>\n",
       "    <div class=\"quiz_options\" title=\"Pick a choice.\">\n",
       "    \n",
       "        <input type=\"radio\" name=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790\" id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-1\" onclick=\"clear_selection('ac1b2f6c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-1-label\" for=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-1\"><code>'automated'</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790\" id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-2\" onclick=\"clear_selection('ac1b2f6c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-2-label\" for=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-2\"><code>'debugging'</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790\" id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-3\" onclick=\"clear_selection('ac1b2f6c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-3-label\" for=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-3\"><code>'is'</code></label><br>\n",
       "    \n",
       "        <input type=\"radio\" name=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790\" id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-4\" onclick=\"clear_selection('ac1b2f6c-8158-11ee-a31f-6298cf1a5790')\">\n",
       "        <label id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-4-label\" for=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-4\"><code>'fun'</code></label><br>\n",
       "    \n",
       "    </div>\n",
       "    </p>\n",
       "    <input id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-submit\" type=\"submit\" value=\"Submit\" onclick=\"check_selection('ac1b2f6c-8158-11ee-a31f-6298cf1a5790', 4, 0, '')\">\n",
       "    <span class=\"quiz_hint\" id=\"ac1b2f6c-8158-11ee-a31f-6298cf1a5790-hint\"></span>\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "secret_answers = [\n",
    "    'automated',\n",
    "    'debugging',\n",
    "    'is',\n",
    "    'fun'\n",
    "]\n",
    "\n",
    "quiz(\"What is the secret password, actually?\", \n",
    "     [f\"`{repr(s)}`\" for s in secret_answers],\n",
    "     min([i + 1 for i, ans in enumerate(secret_answers) \n",
    "          if hashlib.md5(ans.encode('utf-8')).hexdigest() == \n",
    "              SECRET_HASH_DIGEST])\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Assessing Test Quality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Another interesting usage of dynamic slices is to _assess test quality_. With our `square_root()` function, we have seen that the included assertions well test the arguments and the result for correctness:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.969369Z",
     "iopub.status.busy": "2023-11-12T12:40:33.969255Z",
     "iopub.status.idle": "2023-11-12T12:40:33.971213Z",
     "shell.execute_reply": "2023-11-12T12:40:33.970946Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "_, start_square_root = inspect.getsourcelines(square_root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:33.972591Z",
     "iopub.status.busy": "2023-11-12T12:40:33.972484Z",
     "iopub.status.idle": "2023-11-12T12:40:34.006133Z",
     "shell.execute_reply": "2023-11-12T12:40:34.005863Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54  \u001b[34mdef\u001b[39;49;00m \u001b[32msquare_root\u001b[39;49;00m(x):  \u001b[37m# type: ignore\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "55      \u001b[34massert\u001b[39;49;00m x >= \u001b[34m0\u001b[39;49;00m  \u001b[37m# precondition\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "56  \u001b[37m\u001b[39;49;00m\n",
      "57      approx = \u001b[34mNone\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "58      guess = x / \u001b[34m2\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "59      \u001b[34mwhile\u001b[39;49;00m approx != guess:\u001b[37m\u001b[39;49;00m\n",
      "60          approx = guess\u001b[37m\u001b[39;49;00m\n",
      "61          guess = (approx + x / approx) / \u001b[34m2\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "62  \u001b[37m\u001b[39;49;00m\n",
      "63      \u001b[34massert\u001b[39;49;00m math.isclose(approx * approx, x)\u001b[37m\u001b[39;49;00m\n",
      "64      \u001b[34mreturn\u001b[39;49;00m approx\u001b[37m\u001b[39;49;00m"
     ]
    }
   ],
   "source": [
    "# ignore\n",
    "print_content(inspect.getsource(square_root), '.py',\n",
    "              start_line_number=start_square_root)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "However, a lazy programmer could also omit these tests – or worse yet, include tests that always pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.007959Z",
     "iopub.status.busy": "2023-11-12T12:40:34.007819Z",
     "iopub.status.idle": "2023-11-12T12:40:34.010216Z",
     "shell.execute_reply": "2023-11-12T12:40:34.009822Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def square_root_unchecked(x):  # type: ignore\n",
    "    assert True  # <-- new \"precondition\"\n",
    "\n",
    "    approx = None\n",
    "    guess = x / 2\n",
    "    while approx != guess:\n",
    "        approx = guess\n",
    "        guess = (approx + x / approx) / 2\n",
    "\n",
    "    assert True  # <-- new \"postcondition\"\n",
    "    return approx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How can one check that the tests supplied actually are effective? This is a problem of \"Who watches the watchmen\" – we need to find a way to ensure that the tests do their job."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The \"classical\" way of testing tests is so-called *mutation testing* – that is, introducing _artificial errors_ into the code to see whether the tests catch them. Mutation testing is effective: The above \"weak\" tests would not catch any change to the `square_root()` computation code, and hence quickly be determined as ineffective. However, mutation testing is also _costly_, as tests have to be ran again and again for every small code mutation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Slices offer a cost-effective alternative to determine the quality of tests. The idea is that if there are statements in the code whose result does _not_ flow into an assertion, then any errors in these statements will go unnoticed. In consequence, the larger the backward slice of an assertion, the higher its ability to catch errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can easily validate this assumption using the two examples, above. Here is the backward slice for the \"full\" postcondition in `square_root()`. We see that the entire computation code flows into the final postcondition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.012084Z",
     "iopub.status.busy": "2023-11-12T12:40:34.011967Z",
     "iopub.status.idle": "2023-11-12T12:40:34.014255Z",
     "shell.execute_reply": "2023-11-12T12:40:34.013886Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "postcondition_lineno = start_square_root + 9\n",
    "postcondition_lineno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.015864Z",
     "iopub.status.busy": "2023-11-12T12:40:34.015747Z",
     "iopub.status.idle": "2023-11-12T12:40:34.480976Z",
     "shell.execute_reply": "2023-11-12T12:40:34.480643Z"
    },
    "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"364pt\" height=\"504pt\"\n",
       " viewBox=\"0.00 0.00 363.77 504.00\" 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 500)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-500 359.77,-500 359.77,4 -4,4\"/>\n",
       "<!-- assertion_functionsquare_rootat0x10582f400_63 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>assertion_functionsquare_rootat0x10582f400_63</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"square_root:63\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"220.75,-40 0,-40 0,0 220.75,0 220.75,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"65\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;assertion&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">assert math.isclose(approx * approx, x)</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_60 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_60</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"square_root:60\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"212.12,-268 122.62,-268 122.62,-228 212.12,-228 212.12,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"142.62\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">approx</text>\n",
       "<text text-anchor=\"start\" x=\"130.62\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">approx = guess</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_60&#45;&gt;assertion_functionsquare_rootat0x10582f400_63 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_60&#45;&gt;assertion_functionsquare_rootat0x10582f400_63</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M162.52,-227.73C152.59,-188.37 129.91,-98.47 118,-51.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"121.43,-50.53 115.59,-41.69 114.64,-52.24 121.43,-50.53\"/>\n",
       "</g>\n",
       "<!-- test_functionsquare_rootat0x10582f400_59 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>test_functionsquare_rootat0x10582f400_59</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"square_root:59\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"326.12,-192 194.62,-192 194.62,-152 326.12,-152 326.12,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"235.62\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"202.62\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">while approx != guess:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_60&#45;&gt;test_functionsquare_rootat0x10582f400_59 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_60&#45;&gt;test_functionsquare_rootat0x10582f400_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M179.76,-227.56C189.2,-218.8 202.04,-208.35 214.83,-198.94\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"216.76,-201.86 222.85,-193.19 212.68,-196.17 216.76,-201.86\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x10582f400_61 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>guess_functionsquare_rootat0x10582f400_61</title>\n",
       "<g id=\"a_node7\"><a xlink:title=\"square_root:61\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"341,-116 151.75,-116 151.75,-76 341,-76 341,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"225.75\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">guess</text>\n",
       "<text text-anchor=\"start\" x=\"159.75\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">guess = (approx + x / approx) / 2</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_60&#45;&gt;guess_functionsquare_rootat0x10582f400_61 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_60&#45;&gt;guess_functionsquare_rootat0x10582f400_61</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M160.76,-227.57C159.38,-207.45 163.05,-175.7 176.38,-152 182.37,-141.34 191.19,-131.65 200.61,-123.48\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"202.6,-126.37 208.19,-117.37 198.21,-120.92 202.6,-126.37\"/>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_60&#45;&gt;guess_functionsquare_rootat0x10582f400_61 -->\n",
       "<!-- x_functionsquare_rootat0x10582f400_54 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>x_functionsquare_rootat0x10582f400_54</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"square_root:54\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"349.25,-496 149.5,-496 149.5,-456 349.25,-456 349.25,-496\"/>\n",
       "<text text-anchor=\"start\" x=\"245.25\" y=\"-479.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"157.5\" y=\"-461.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def square_root(x): &#160;# type: ignore</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x10582f400_54&#45;&gt;assertion_functionsquare_rootat0x10582f400_63 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x10582f400_54&#45;&gt;assertion_functionsquare_rootat0x10582f400_63</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M195.31,-455.57C143.25,-432.99 72.38,-390.25 72.38,-325 72.38,-325 72.38,-325 72.38,-171 72.38,-128.36 86.98,-80.93 98.08,-51.05\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"101.28,-52.5 101.59,-41.91 94.74,-49.99 101.28,-52.5\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x10582f400_58 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>guess_functionsquare_rootat0x10582f400_58</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"square_root:58\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"268.5,-344 184.25,-344 184.25,-304 268.5,-304 268.5,-344\"/>\n",
       "<text text-anchor=\"start\" x=\"205.75\" y=\"-327.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">guess</text>\n",
       "<text text-anchor=\"start\" x=\"192.25\" y=\"-309.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">guess = x / 2</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x10582f400_54&#45;&gt;guess_functionsquare_rootat0x10582f400_58 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x10582f400_54&#45;&gt;guess_functionsquare_rootat0x10582f400_58</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M242.66,-455.64C239.32,-445.2 235.54,-432.04 233.38,-420 229.55,-398.77 227.8,-374.51 227.01,-355.83\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"230.52,-355.82 226.67,-345.95 223.52,-356.06 230.52,-355.82\"/>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_57 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_57</title>\n",
       "<g id=\"a_node6\"><a xlink:title=\"square_root:57\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"326.5,-420 242.25,-420 242.25,-380 326.5,-380 326.5,-420\"/>\n",
       "<text text-anchor=\"start\" x=\"259.62\" y=\"-403.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">approx</text>\n",
       "<text text-anchor=\"start\" x=\"250.25\" y=\"-385.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">approx = None</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functionsquare_rootat0x10582f400_54&#45;&gt;approx_functionsquare_rootat0x10582f400_57 -->\n",
       "<!-- x_functionsquare_rootat0x10582f400_54&#45;&gt;guess_functionsquare_rootat0x10582f400_61 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>x_functionsquare_rootat0x10582f400_54&#45;&gt;guess_functionsquare_rootat0x10582f400_61</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M293.77,-455.69C309.14,-446.92 325.07,-435.07 335.38,-420 359.67,-384.45 354.38,-368.06 354.38,-325 354.38,-325 354.38,-325 354.38,-247 354.38,-203.94 359.95,-187.36 335.38,-152 326.95,-139.88 314.9,-129.91 302.38,-121.95\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"304.46,-119.11 294.07,-117.02 300.89,-125.13 304.46,-119.11\"/>\n",
       "</g>\n",
       "<!-- test_functionsquare_rootat0x10582f400_59&#45;&gt;approx_functionsquare_rootat0x10582f400_60 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>test_functionsquare_rootat0x10582f400_59&#45;&gt;approx_functionsquare_rootat0x10582f400_60</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M236.1,-192.31C225.23,-200.96 212.24,-211.3 200.49,-220.65\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"198.64,-217.65 192.99,-226.61 203,-223.13 198.64,-217.65\"/>\n",
       "</g>\n",
       "<!-- test_functionsquare_rootat0x10582f400_59&#45;&gt;approx_functionsquare_rootat0x10582f400_60 -->\n",
       "<!-- test_functionsquare_rootat0x10582f400_59&#45;&gt;guess_functionsquare_rootat0x10582f400_61 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>test_functionsquare_rootat0x10582f400_59&#45;&gt;guess_functionsquare_rootat0x10582f400_61</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M250.67,-151.56C248.64,-144.25 246.82,-135.75 245.52,-127.67\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"248.99,-127.27 244.22,-117.81 242.05,-128.19 248.99,-127.27\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x10582f400_58&#45;&gt;approx_functionsquare_rootat0x10582f400_60 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x10582f400_58&#45;&gt;approx_functionsquare_rootat0x10582f400_60</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M210.87,-303.56C204.44,-295.48 196.84,-285.96 189.82,-277.15\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"192.69,-275.13 183.72,-269.5 187.21,-279.5 192.69,-275.13\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x10582f400_58&#45;&gt;test_functionsquare_rootat0x10582f400_59 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x10582f400_58&#45;&gt;test_functionsquare_rootat0x10582f400_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M226.05,-303.7C229.41,-278.16 239.4,-232.88 248.08,-202.9\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"251.32,-204.26 250.88,-193.68 244.62,-202.23 251.32,-204.26\"/>\n",
       "</g>\n",
       "<!-- guess_functionsquare_rootat0x10582f400_58&#45;&gt;test_functionsquare_rootat0x10582f400_59 -->\n",
       "<!-- approx_functionsquare_rootat0x10582f400_57&#45;&gt;test_functionsquare_rootat0x10582f400_59 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>approx_functionsquare_rootat0x10582f400_57&#45;&gt;test_functionsquare_rootat0x10582f400_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M283.27,-379.69C282.09,-360.47 280.03,-330.16 277.38,-304 273.88,-269.57 268.6,-230.22 264.85,-203.71\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"268.34,-203.39 263.46,-193.99 261.41,-204.38 268.34,-203.39\"/>\n",
       "</g>\n",
       "<!-- approx_functionsquare_rootat0x10582f400_57&#45;&gt;guess_functionsquare_rootat0x10582f400_58 -->\n",
       "<!-- guess_functionsquare_rootat0x10582f400_61&#45;&gt;assertion_functionsquare_rootat0x10582f400_63 -->\n",
       "<!-- guess_functionsquare_rootat0x10582f400_61&#45;&gt;test_functionsquare_rootat0x10582f400_59 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>guess_functionsquare_rootat0x10582f400_61&#45;&gt;test_functionsquare_rootat0x10582f400_59</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M256.04,-116.31C258.08,-123.61 259.9,-132.1 261.21,-140.19\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"257.74,-140.6 262.52,-150.06 264.67,-139.68 257.74,-140.6\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        ('<assertion>', (square_root, 63)): {('approx', (square_root, 60)), ('x', (square_root, 54))},\n",
       "        ('approx', (square_root, 60)): {('guess', (square_root, 58))},\n",
       "        ('x', (square_root, 54)): set(),\n",
       "        ('guess', (square_root, 58)): {('x', (square_root, 54))},\n",
       "        ('<test>', (square_root, 59)): {('guess', (square_root, 58)), ('approx', (square_root, 60)), ('approx', (square_root, 57)), ('guess', (square_root, 61))},\n",
       "        ('approx', (square_root, 57)): set(),\n",
       "        ('guess', (square_root, 61)): {('approx', (square_root, 60)), ('x', (square_root, 54))}},\n",
       " control={\n",
       "        ('<assertion>', (square_root, 63)): set(),\n",
       "        ('approx', (square_root, 60)): {('<test>', (square_root, 59))},\n",
       "        ('x', (square_root, 54)): set(),\n",
       "        ('guess', (square_root, 58)): set(),\n",
       "        ('<test>', (square_root, 59)): set(),\n",
       "        ('approx', (square_root, 57)): set(),\n",
       "        ('guess', (square_root, 61)): {('<test>', (square_root, 59))}})"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with Slicer() as slicer:\n",
    "    y = square_root(4)\n",
    "\n",
    "slicer.dependencies().backward_slice((square_root, postcondition_lineno))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In contrast, the \"lazy\" assertion in `square_root_unchecked()` has an empty backward slice, showing that it depends on no other value at all:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.482862Z",
     "iopub.status.busy": "2023-11-12T12:40:34.482615Z",
     "iopub.status.idle": "2023-11-12T12:40:34.512622Z",
     "shell.execute_reply": "2023-11-12T12:40:34.512068Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"8pt\" height=\"8pt\"\n",
       " viewBox=\"0.00 0.00 8.00 8.00\" 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 4)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-4 4,-4 4,4 -4,4\"/>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "Dependencies(\n",
       "    data={\n",
       "        },\n",
       " control={\n",
       "        })"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with Slicer() as slicer:\n",
    "    y = square_root_unchecked(4)\n",
    "\n",
    "slicer.dependencies().backward_slice((square_root, postcondition_lineno))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In \\cite{Schuler2011}, Schuler et al. have tried out this technique and found their \"checked coverage\" to be a sure indicator for the quality of the checks in tests. Using our dynamic slices, you may wish to try this out on Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Use in Statistical Debugging"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Collecting dynamic slices over several runs allows for _correlating dependencies with other execution features_, notably _failures_: \"The program fails whenever the value of `weekday` comes from `calendar()`.\" We will revisit this idea in [the chapter on statistical debugging](StatisticalDebugger.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Synopsis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This chapter provides a `Slicer` class to automatically determine and visualize dynamic flows and dependencies. When we say that a variable $x$ _depends_ on a variable $y$ (and that $y$ _flows_ into $x$), we distinguish two kinds of dependencies:\n",
    "\n",
    "* **Data dependency**: $x$ is assigned a value computed from $y$.\n",
    "* **Control dependency**: A statement involving $x$ is executed _only_ because a _condition_ involving $y$ was evaluated, influencing the execution path.\n",
    "\n",
    "Such dependencies are crucial for debugging, as they allow determininh the origins of individual values (and notably incorrect values)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To determine dynamic dependencies in a function `func`, use\n",
    "\n",
    "```python\n",
    "with Slicer() as slicer:\n",
    "    <Some call to func()>\n",
    "```\n",
    "\n",
    "and then `slicer.graph()` or `slicer.code()` to examine dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can also explicitly specify the functions to be instrumented, as in \n",
    "\n",
    "```python\n",
    "with Slicer(func, func_1, func_2) as slicer:\n",
    "    <Some call to func()>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here is an example. The `demo()` function computes some number from `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.515589Z",
     "iopub.status.busy": "2023-11-12T12:40:34.515372Z",
     "iopub.status.idle": "2023-11-12T12:40:34.517869Z",
     "shell.execute_reply": "2023-11-12T12:40:34.517488Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def demo(x: int) -> int:\n",
    "    z = x\n",
    "    while x <= z <= 64:\n",
    "        z *= 2\n",
    "    return z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "By using `with Slicer()`, we first instrument `demo()` and then execute it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.519491Z",
     "iopub.status.busy": "2023-11-12T12:40:34.519375Z",
     "iopub.status.idle": "2023-11-12T12:40:34.525224Z",
     "shell.execute_reply": "2023-11-12T12:40:34.524933Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with Slicer() as slicer:\n",
    "    demo(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "After execution is complete, you can output `slicer` to visualize the dependencies and flows as graph. Data dependencies are shown as black solid edges; control dependencies are shown as grey dashed edges. The arrows indicate influence: If $y$ depends on $x$ (and thus $x$ flows into $y$), then we have an arrow $x \\rightarrow y$.\n",
    "We see how the parameter `x` flows into `z`, which is returned after some computation that is control dependent on a `<test>` involving `z`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.527197Z",
     "iopub.status.busy": "2023-11-12T12:40:34.527037Z",
     "iopub.status.idle": "2023-11-12T12:40:34.986988Z",
     "shell.execute_reply": "2023-11-12T12:40:34.986614Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"341pt\" height=\"276pt\"\n",
       " viewBox=\"0.00 0.00 340.62 276.00\" 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 272)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-272 336.62,-272 336.62,4 -4,4\"/>\n",
       "<!-- demoreturnvalue_functiondemoat0x105d9bd90_5 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>demoreturnvalue_functiondemoat0x105d9bd90_5</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"demo:5\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"332.62,-40 143.38,-40 143.38,0 332.62,0 332.62,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"151.38\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;demo() return value&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"217\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">return z</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_4 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>z_functiondemoat0x105d9bd90_4</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"demo:4\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"158,-116 104,-116 104,-76 158,-76 158,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"126.88\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"115.25\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">z *= 2</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_4&#45;&gt;demoreturnvalue_functiondemoat0x105d9bd90_5 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>z_functiondemoat0x105d9bd90_4&#45;&gt;demoreturnvalue_functiondemoat0x105d9bd90_5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M153.09,-75.56C165.19,-66.63 180.52,-55.94 194.84,-46.39\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"196.38,-49.57 202.8,-41.15 192.52,-43.73 196.38,-49.57\"/>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_4&#45;&gt;demoreturnvalue_functiondemoat0x105d9bd90_5 -->\n",
       "<!-- z_functiondemoat0x105d9bd90_4&#45;&gt;z_functiondemoat0x105d9bd90_4 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>z_functiondemoat0x105d9bd90_4&#45;&gt;z_functiondemoat0x105d9bd90_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M158.24,-110.24C168.02,-110.54 176,-105.8 176,-96 176,-90.34 173.33,-86.36 169.19,-84.07\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"170.23,-80.71 159.72,-82.08 168.78,-87.56 170.23,-80.71\"/>\n",
       "</g>\n",
       "<!-- test_functiondemoat0x105d9bd90_3 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>test_functiondemoat0x105d9bd90_3</title>\n",
       "<g id=\"a_node3\"><a xlink:title=\"demo:3\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"124.88,-40 9.12,-40 9.12,0 124.88,0 124.88,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"42.25\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\">&lt;test&gt;</text>\n",
       "<text text-anchor=\"start\" x=\"17.12\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">while x &lt;= z &lt;= 64:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_4&#45;&gt;test_functiondemoat0x105d9bd90_3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>z_functiondemoat0x105d9bd90_4&#45;&gt;test_functiondemoat0x105d9bd90_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M103.75,-77.09C94.86,-68.75 85.64,-58.62 78.3,-49.28\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"81.33,-47.49 72.57,-41.52 75.69,-51.65 81.33,-47.49\"/>\n",
       "</g>\n",
       "<!-- test_functiondemoat0x105d9bd90_3&#45;&gt;z_functiondemoat0x105d9bd90_4 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>test_functiondemoat0x105d9bd90_3&#45;&gt;z_functiondemoat0x105d9bd90_4</title>\n",
       "<path fill=\"none\" stroke=\"grey\" stroke-dasharray=\"5,2\" d=\"M83.7,-40.31C90.74,-48.45 99.08,-58.09 106.77,-66.99\"/>\n",
       "<polygon fill=\"grey\" stroke=\"grey\" points=\"104.01,-69.14 113.19,-74.41 109.3,-64.56 104.01,-69.14\"/>\n",
       "</g>\n",
       "<!-- test_functiondemoat0x105d9bd90_3&#45;&gt;z_functiondemoat0x105d9bd90_4 -->\n",
       "<!-- x_functiondemoat0x105d9bd90_1 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>x_functiondemoat0x105d9bd90_1</title>\n",
       "<g id=\"a_node4\"><a xlink:title=\"demo:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"142,-268 0,-268 0,-228 142,-228 142,-268\"/>\n",
       "<text text-anchor=\"start\" x=\"66.88\" y=\"-251.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-233.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def demo(x: int) &#45;&gt; int:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functiondemoat0x105d9bd90_1&#45;&gt;test_functiondemoat0x105d9bd90_3 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>x_functiondemoat0x105d9bd90_1&#45;&gt;test_functiondemoat0x105d9bd90_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M54.25,-227.53C46.8,-217.6 38.85,-204.9 35,-192 20.52,-143.42 38.78,-85.04 53.07,-50.59\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"56.17,-52.25 56.93,-41.68 49.75,-49.47 56.17,-52.25\"/>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_2 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>z_functiondemoat0x105d9bd90_2</title>\n",
       "<g id=\"a_node5\"><a xlink:title=\"demo:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"98,-192 44,-192 44,-152 98,-152 98,-192\"/>\n",
       "<text text-anchor=\"start\" x=\"66.88\" y=\"-175.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"57.88\" y=\"-157.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">z = x</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M64.98,-227.56C64.32,-220.25 64.11,-211.75 64.34,-203.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"67.82,-204.01 64.9,-193.82 60.84,-203.61 67.82,-204.01\"/>\n",
       "</g>\n",
       "<!-- x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2 -->\n",
       "<!-- z_functiondemoat0x105d9bd90_2&#45;&gt;z_functiondemoat0x105d9bd90_4 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>z_functiondemoat0x105d9bd90_2&#45;&gt;z_functiondemoat0x105d9bd90_4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M86.76,-151.56C93.31,-143.48 101.03,-133.96 108.18,-125.15\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"110.81,-127.46 114.39,-117.49 105.37,-123.05 110.81,-127.46\"/>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_2&#45;&gt;test_functiondemoat0x105d9bd90_3 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>z_functiondemoat0x105d9bd90_2&#45;&gt;test_functiondemoat0x105d9bd90_3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M65.78,-151.7C62.71,-126.38 61.22,-81.68 62.25,-51.69\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"65.74,-51.9 62.74,-41.74 58.75,-51.55 65.74,-51.9\"/>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_2&#45;&gt;test_functiondemoat0x105d9bd90_3 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<__main__.Slicer at 0x105debeb0>"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "An alternate representation is `slicer.code()`, annotating the instrumented source code with (backward) dependencies. Data dependencies are shown with `<=`, control dependencies with `<-`; locations (lines) are shown in parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:34.988719Z",
     "iopub.status.busy": "2023-11-12T12:40:34.988593Z",
     "iopub.status.idle": "2023-11-12T12:40:35.145352Z",
     "shell.execute_reply": "2023-11-12T12:40:35.145041Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*    1 \u001b[34mdef\u001b[39;49;00m \u001b[32mdemo\u001b[39;49;00m(x: \u001b[36mint\u001b[39;49;00m) -> \u001b[36mint\u001b[39;49;00m:\u001b[37m\u001b[39;49;00m\n",
      "*    2     z = x  \u001b[37m# <= x (1)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    3     \u001b[34mwhile\u001b[39;49;00m x <= z <= \u001b[34m64\u001b[39;49;00m:  \u001b[37m# <= x (1), z (4), z (2)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    4         z *= \u001b[34m2\u001b[39;49;00m  \u001b[37m# <= z (4), z (2); <- <test> (3)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n",
      "*    5     \u001b[34mreturn\u001b[39;49;00m z  \u001b[37m# <= z (4)\u001b[39;49;00m\u001b[37m\u001b[39;49;00m\n"
     ]
    }
   ],
   "source": [
    "slicer.code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Dependencies can also be retrieved programmatically. The `dependencies()` method returns a `Dependencies` object encapsulating the dependency graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The method `all_vars()` returns all variables in the dependency graph. Each variable is encoded as a pair (_name_, _location_) where _location_ is a pair (_codename_, _lineno_)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.147211Z",
     "iopub.status.busy": "2023-11-12T12:40:35.147098Z",
     "iopub.status.idle": "2023-11-12T12:40:35.150592Z",
     "shell.execute_reply": "2023-11-12T12:40:35.150163Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('<demo() return value>', (<function __main__.demo(x: int) -> int>, 5)),\n",
       " ('<test>', (<function __main__.demo(x: int) -> int>, 3)),\n",
       " ('x', (<function __main__.demo(x: int) -> int>, 1)),\n",
       " ('z', (<function __main__.demo(x: int) -> int>, 2)),\n",
       " ('z', (<function __main__.demo(x: int) -> int>, 4))}"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer.dependencies().all_vars()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`code()` and `graph()` methods can also be applied on dependencies. The method `backward_slice(var)` returns a backward slice for the given variable (again given as a pair (_name_, _location_)). To retrieve where `z` in Line 2 came from, use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.152337Z",
     "iopub.status.busy": "2023-11-12T12:40:35.152239Z",
     "iopub.status.idle": "2023-11-12T12:40:35.154891Z",
     "shell.execute_reply": "2023-11-12T12:40:35.154622Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_, start_demo = inspect.getsourcelines(demo)\n",
    "start_demo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.156362Z",
     "iopub.status.busy": "2023-11-12T12:40:35.156270Z",
     "iopub.status.idle": "2023-11-12T12:40:35.565871Z",
     "shell.execute_reply": "2023-11-12T12:40:35.565514Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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",
       "<!-- Title: dependencies Pages: 1 -->\n",
       "<svg width=\"150pt\" height=\"124pt\"\n",
       " viewBox=\"0.00 0.00 150.00 124.00\" 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 120)\">\n",
       "<title>dependencies</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-120 146,-120 146,4 -4,4\"/>\n",
       "<!-- x_functiondemoat0x105d9bd90_1 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>x_functiondemoat0x105d9bd90_1</title>\n",
       "<g id=\"a_node1\"><a xlink:title=\"demo:1\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"142,-116 0,-116 0,-76 142,-76 142,-116\"/>\n",
       "<text text-anchor=\"start\" x=\"66.88\" y=\"-99.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">x</text>\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-81.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">def demo(x: int) &#45;&gt; int:</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- z_functiondemoat0x105d9bd90_2 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>z_functiondemoat0x105d9bd90_2</title>\n",
       "<g id=\"a_node2\"><a xlink:title=\"demo:2\">\n",
       "<polygon fill=\"peachpuff\" stroke=\"black\" points=\"98,-40 44,-40 44,0 98,0 98,-40\"/>\n",
       "<text text-anchor=\"start\" x=\"66.88\" y=\"-23.7\" font-family=\"Courier,monospace\" font-weight=\"bold\" font-size=\"14.00\">z</text>\n",
       "<text text-anchor=\"start\" x=\"57.88\" y=\"-5.45\" font-family=\"Courier,monospace\" font-size=\"9.00\">z = x</text>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M64.98,-75.56C64.32,-68.25 64.11,-59.75 64.34,-51.67\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"67.82,-52.01 64.9,-41.82 60.84,-51.61 67.82,-52.01\"/>\n",
       "</g>\n",
       "<!-- x_functiondemoat0x105d9bd90_1&#45;&gt;z_functiondemoat0x105d9bd90_2 -->\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x105f4d570>"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slicer.dependencies().backward_slice(('z', (demo, start_demo + 1))).graph()  # type: ignore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here are the classes defined in this chapter. A `Slicer` instruments a program, using a `DependencyTracker` at run time to collect `Dependencies`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.567709Z",
     "iopub.status.busy": "2023-11-12T12:40:35.567590Z",
     "iopub.status.idle": "2023-11-12T12:40:35.569460Z",
     "shell.execute_reply": "2023-11-12T12:40:35.569174Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "from ClassDiagram import display_class_hierarchy, class_tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.570895Z",
     "iopub.status.busy": "2023-11-12T12:40:35.570790Z",
     "iopub.status.idle": "2023-11-12T12:40:35.572485Z",
     "shell.execute_reply": "2023-11-12T12:40:35.572184Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# ignore\n",
    "assert class_tree(Slicer)[0][0] == Slicer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:35.574350Z",
     "iopub.status.busy": "2023-11-12T12:40:35.573878Z",
     "iopub.status.idle": "2023-11-12T12:40:36.067255Z",
     "shell.execute_reply": "2023-11-12T12:40:36.066884Z"
    },
    "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=\"544pt\" height=\"814pt\"\n",
       " viewBox=\"0.00 0.00 543.62 814.25\" 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 810.25)\">\n",
       "<g id=\"a_graph0\"><a xlink:title=\"Slicer class hierarchy\">\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-810.25 539.62,-810.25 539.62,4 -4,4\"/>\n",
       "</a>\n",
       "</g>\n",
       "<!-- Slicer -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>Slicer</title>\n",
       "<g id=\"a_node1\"><a xlink:href=\"#\" xlink:title=\"class Slicer:&#10;Track dependencies in an execution\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"0,-27 0,-229 190,-229 190,-27 0,-27\"/>\n",
       "<text text-anchor=\"start\" x=\"77.75\" y=\"-212.7\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">Slicer</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"0,-203.75 190,-203.75\"/>\n",
       "<g id=\"a_node1_0\"><a xlink:href=\"#\" xlink:title=\"Slicer\">\n",
       "<g id=\"a_node1_1\"><a xlink:href=\"#\" xlink:title=\"__init__(self, *items_to_instrument: Any, dependency_tracker: Optional[DependencyTracker] = None, globals: Optional[Dict[str, Any]] = None, log: Union[bool, int] = False):&#10;Create a slicer.&#10;`items_to_instrument` are Python functions or modules with source code.&#10;`dependency_tracker` is the tracker to be used (default: DependencyTracker).&#10;`globals` is the namespace to be used(default: caller&#39;s `globals()`)&#10;`log`=True or `log` &gt; 0 turns on logging\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-191.25\" 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=\"_repr_mimebundle_(self, include: Any = None, exclude: Any = None) &#45;&gt; Any:&#10;If the object is output in Jupyter, render dependencies as a SVG graph\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-180\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">_repr_mimebundle_()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_3\"><a xlink:href=\"#\" xlink:title=\"code(self, *args: Any, **kwargs: Any) &#45;&gt; None:&#10;Show code of instrumented items, annotated with dependencies.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-168.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">code()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_4\"><a xlink:href=\"#\" xlink:title=\"dependencies(self) &#45;&gt; Dependencies:&#10;Return collected dependencies.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-157.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">dependencies()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_5\"><a xlink:href=\"#\" xlink:title=\"graph(self, *args: Any, **kwargs: Any) &#45;&gt; graphviz.graphs.Digraph:&#10;Show dependency graph.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-146.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">graph()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_6\"><a xlink:href=\"#\" xlink:title=\"calls_in_our_with_block(self) &#45;&gt; Set[str]:&#10;Return a set of function names called in the `with` block.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-134\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">calls_in_our_with_block()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_7\"><a xlink:href=\"#\" xlink:title=\"default_items_to_instrument(self) &#45;&gt; List[Callable]\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-123.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">default_items_to_instrument()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_8\"><a xlink:href=\"#\" xlink:title=\"execute(self, tree: ast.AST, item: Any) &#45;&gt; None:&#10;Compile and execute `tree`. May be extended in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-112.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">execute()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_9\"><a xlink:href=\"#\" xlink:title=\"funcs_in_our_with_block(self) &#45;&gt; List[Callable]\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-100.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">funcs_in_our_with_block()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_10\"><a xlink:href=\"#\" xlink:title=\"instrument(self, item: Any) &#45;&gt; Any:&#10;Instrument `item`, transforming its source code, and re&#45;defining it.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-90\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">instrument()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_11\"><a xlink:href=\"#\" xlink:title=\"our_with_block(self) &#45;&gt; ast.With:&#10;Return the currently active `with` block.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-77.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">our_with_block()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_12\"><a xlink:href=\"#\" xlink:title=\"parse(self, item: Any) &#45;&gt; ast.AST:&#10;Parse `item`, returning its AST\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-66.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">parse()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_13\"><a xlink:href=\"#\" xlink:title=\"restore(self) &#45;&gt; None:&#10;Restore original code.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-56.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">restore()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_14\"><a xlink:href=\"#\" xlink:title=\"transform(self, tree: ast.AST) &#45;&gt; ast.AST:&#10;Apply transformers on `tree`. May be extended in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-45\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">transform()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node1_15\"><a xlink:href=\"#\" xlink:title=\"transformers(self) &#45;&gt; List[ast.NodeTransformer]:&#10;List of transformers to apply. To be extended in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"8\" y=\"-33.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">transformers()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Instrumenter -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>Instrumenter</title>\n",
       "<g id=\"a_node2\"><a xlink:href=\"#\" xlink:title=\"class Instrumenter:&#10;Instrument functions for dynamic tracking\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"18,-414.62 18,-515.38 208,-515.38 208,-414.62 18,-414.62\"/>\n",
       "<text text-anchor=\"start\" x=\"75.5\" y=\"-499.07\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\" fill=\"#6a0dad\">Instrumenter</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"18,-490.12 208,-490.12\"/>\n",
       "<g id=\"a_node2_16\"><a xlink:href=\"#\" xlink:title=\"Instrumenter\">\n",
       "<g id=\"a_node2_17\"><a xlink:href=\"#\" xlink:title=\"__enter__(self) &#45;&gt; Any:&#10;Instrument sources\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-477.62\" 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=\"#\" xlink:title=\"__exit__(self, exc_type: Type, exc_value: BaseException, traceback: traceback) &#45;&gt; Optional[bool]:&#10;Restore sources\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-466.38\" 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=\"#\" xlink:title=\"__init__(self, *items_to_instrument: Callable, globals: Optional[Dict[str, Any]] = None, log: Union[bool, int] = False) &#45;&gt; None:&#10;Create an instrumenter.&#10;`items_to_instrument` is a list of items to instrument.&#10;`globals` is a namespace to use (default: caller&#39;s globals())\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-455.12\" 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=\"#\" xlink:title=\"instrument(self, item: Any) &#45;&gt; Any:&#10;Instrument `item`. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-443.88\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">instrument()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node2_21\"><a xlink:href=\"#\" xlink:title=\"default_items_to_instrument(self) &#45;&gt; List[Callable]\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-432.62\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">default_items_to_instrument()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node2_22\"><a xlink:href=\"#\" xlink:title=\"restore(self) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"26\" y=\"-421.38\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">restore()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Slicer&#45;&gt;Instrumenter -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>Slicer&#45;&gt;Instrumenter</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M100.38,-229.06C103.42,-285.64 107.12,-354.55 109.73,-403.06\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"106.22,-403.01 110.25,-412.81 113.21,-402.63 106.22,-403.01\"/>\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=\"211,-674.5 211,-805.75 377,-805.75 377,-674.5 211,-674.5\"/>\n",
       "<text text-anchor=\"start\" x=\"248.62\" y=\"-789.45\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-style=\"italic\" font-size=\"14.00\" fill=\"#6a0dad\">StackInspector</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"211,-780.5 377,-780.5\"/>\n",
       "<g id=\"a_node3_23\"><a xlink:href=\"#\" xlink:title=\"StackInspector\">\n",
       "<g id=\"a_node3_24\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"_generated_function_cache = {(&#39;&lt;cell line: 2&gt;&#39;, 2): &lt;function &lt;cell line: 2&gt; at 0x104c6a710&gt;, (&#39;&lt;cell line: 1&gt;&#39;, 1): &lt;function &lt;cell line: 1&gt; at 0x104c69fc0&gt;, (&#39;&lt;cell line: 3&gt;&#39;, 3): &lt;function &lt;cell line: 3&gt; at 0x105d98a60&gt;, (&#39;&lt;cell line: 4&gt;&#39;, 4): &lt;function &lt;cell line: 4&gt; at 0x105d98dc0&gt;, (&#39;&lt;cell line: 1&gt;&#39;, 4): &lt;function &lt;cell line: 1&gt; at 0x105d992d0&gt;, (&#39;&lt;cell line: 1&gt;&#39;, 3): &lt;function &lt;cell line: 1&gt; at 0x105d993f0&gt;, (&#39;&lt;listcomp&gt;&#39;, 18): &lt;bound method StackInspector.unknown of &lt;__main__.DependencyTracker object at 0x107471bd0&gt;&gt;}\">\n",
       "<text text-anchor=\"start\" x=\"219\" y=\"-767\" 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",
       "<polyline fill=\"none\" stroke=\"black\" points=\"211,-761.25 377,-761.25\"/>\n",
       "<g id=\"a_node3_25\"><a xlink:href=\"#\" xlink:title=\"StackInspector\">\n",
       "<g id=\"a_node3_26\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"caller_frame(self) &#45;&gt; frame:&#10;Return the frame of the caller.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-748.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">caller_frame()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_27\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"caller_function(self) &#45;&gt; Callable:&#10;Return the calling function\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-737.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">caller_function()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_28\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"caller_globals(self) &#45;&gt; Dict[str, Any]:&#10;Return the globals() environment of the caller.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-726.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">caller_globals()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_29\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"caller_locals(self) &#45;&gt; Dict[str, Any]:&#10;Return the locals() environment of the caller.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-715\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">caller_locals()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_30\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"caller_location(self) &#45;&gt; Tuple[Callable, int]:&#10;Return the location (func, lineno) of the caller.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-703.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">caller_location()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_31\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"search_frame(self, name: str, frame: Optional[frame] = None) &#45;&gt; Tuple[Optional[frame], Optional[Callable]]:&#10;Return a pair (`frame`, `item`)&#10;in which the function `name` is defined as `item`.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-692.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">search_frame()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node3_32\"><a xlink:href=\"StackInspector.ipynb\" xlink:title=\"search_func(self, name: str, frame: Optional[frame] = None) &#45;&gt; Optional[Callable]:&#10;Search in callers for a definition of the function `name`\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-681.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">search_func()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Instrumenter&#45;&gt;StackInspector -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>Instrumenter&#45;&gt;StackInspector</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M145.5,-515.77C168,-550.16 198.71,-596.94 226,-638 231.78,-646.7 237.86,-655.8 243.91,-664.83\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"240.86,-666.57 249.34,-672.93 246.68,-662.67 240.86,-666.57\"/>\n",
       "</g>\n",
       "<!-- DependencyTracker -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>DependencyTracker</title>\n",
       "<g id=\"a_node4\"><a xlink:href=\"#\" xlink:title=\"class DependencyTracker:&#10;Track dependencies during execution\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"208,-0.5 208,-255.5 398,-255.5 398,-0.5 208,-0.5\"/>\n",
       "<text text-anchor=\"start\" x=\"239.25\" y=\"-239.2\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">DependencyTracker</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"208,-230.25 398,-230.25\"/>\n",
       "<g id=\"a_node4_33\"><a xlink:href=\"#\" xlink:title=\"DependencyTracker\">\n",
       "<g id=\"a_node4_34\"><a xlink:href=\"#\" xlink:title=\"TEST = &#39;&lt;test&gt;&#39;\">\n",
       "<text text-anchor=\"start\" x=\"291\" y=\"-216.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">TEST</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"208,-211 398,-211\"/>\n",
       "<g id=\"a_node4_35\"><a xlink:href=\"#\" xlink:title=\"DependencyTracker\">\n",
       "<g id=\"a_node4_36\"><a xlink:href=\"#\" xlink:title=\"__enter__(self) &#45;&gt; Any:&#10;Track entering an if/while/for block\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-198.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__enter__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_37\"><a xlink:href=\"#\" xlink:title=\"__exit__(self, exc_type: Type, exc_value: BaseException, traceback: traceback) &#45;&gt; Optional[bool]:&#10;Track exiting an if/while/for block\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-187.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__exit__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_38\"><a xlink:href=\"#\" xlink:title=\"__init__(self, *args: Any, **kwargs: Any) &#45;&gt; None:&#10;Constructor. Arguments are passed to DataTracker.__init__()\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-176\" 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_node4_39\"><a xlink:href=\"#\" xlink:title=\"arg(self, value: Any, pos: Optional[int] = None, kw: Optional[str] = None) &#45;&gt; Any:&#10;Track passing an argument `value`&#10;(with given position `pos` 1..n or keyword `kw`)\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-164.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">arg()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_40\"><a xlink:href=\"#\" xlink:title=\"call(self, func: Callable) &#45;&gt; Callable:&#10;Track a call of function `func`\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-153.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">call()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_41\"><a xlink:href=\"#\" xlink:title=\"get(self, name: str, value: Any) &#45;&gt; Any:&#10;Track a read access for variable `name` with value `value`\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-142.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">get()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_42\"><a xlink:href=\"#\" xlink:title=\"param(self, name: str, value: Any, pos: Optional[int] = None, vararg: str = &#39;&#39;, last: bool = False) &#45;&gt; Any:&#10;Track getting a parameter `name` with value `value`&#10;(with given position `pos`).&#10;vararg parameters are indicated by setting `varargs` to&#10;&#39;*&#39; (*args) or &#39;**&#39; (**kwargs)\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-131\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">param()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_43\"><a xlink:href=\"#\" xlink:title=\"ret(self, value: Any) &#45;&gt; Any:&#10;Track a function return\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-119.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">ret()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_44\"><a xlink:href=\"#\" xlink:title=\"set(self, name: str, value: Any, loads: Optional[Set[str]] = None) &#45;&gt; Any:&#10;Add a dependency for `name` = `value`\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-108.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">set()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_45\"><a xlink:href=\"#\" xlink:title=\"test(self, value: Any) &#45;&gt; Any:&#10;Track a test for condition `value`\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-97.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">test()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_46\"><a xlink:href=\"#\" xlink:title=\"call_generator(self, func: Callable) &#45;&gt; Callable:&#10;Track a call of a generator function\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-85\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">call_generator()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_47\"><a xlink:href=\"#\" xlink:title=\"check_location(self) &#45;&gt; None:&#10;If we are in a new location, clear set of read variables\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-73.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">check_location()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_48\"><a xlink:href=\"#\" xlink:title=\"clear_read(self) &#45;&gt; None:&#10;Clear set of read variables\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-62.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">clear_read()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_49\"><a xlink:href=\"#\" xlink:title=\"dependencies(self) &#45;&gt; Dependencies:&#10;Return dependencies\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-51.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">dependencies()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_50\"><a xlink:href=\"#\" xlink:title=\"ignore_location_change(self) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-40\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">ignore_location_change()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_51\"><a xlink:href=\"#\" xlink:title=\"ignore_next_location_change(self) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-28.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">ignore_next_location_change()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_52\"><a xlink:href=\"#\" xlink:title=\"in_generator(self) &#45;&gt; bool:&#10;True if we are calling a generator function\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-17.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">in_generator()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node4_53\"><a xlink:href=\"#\" xlink:title=\"ret_generator(self, generator: Any) &#45;&gt; Any:&#10;Track the return of a generator function\">\n",
       "<text text-anchor=\"start\" x=\"216\" y=\"-6.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">ret_generator()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- DataTracker -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>DataTracker</title>\n",
       "<g id=\"a_node5\"><a xlink:href=\"#\" xlink:title=\"class DataTracker:&#10;Track data accesses during execution\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"235,-380.88 235,-549.12 353,-549.12 353,-380.88 235,-380.88\"/>\n",
       "<text text-anchor=\"start\" x=\"257.25\" y=\"-532.83\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">DataTracker</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"235,-523.88 353,-523.88\"/>\n",
       "<g id=\"a_node5_54\"><a xlink:href=\"#\" xlink:title=\"DataTracker\">\n",
       "<g id=\"a_node5_55\"><a xlink:href=\"#\" xlink:title=\"__enter__(self) &#45;&gt; Any:&#10;Enter `with` block. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-511.38\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__enter__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_56\"><a xlink:href=\"#\" xlink:title=\"__exit__(self, exc_type: Type, exc_value: BaseException, traceback: traceback) &#45;&gt; Optional[bool]:&#10;Exit `with` block. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-500.12\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">__exit__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_57\"><a xlink:href=\"#\" xlink:title=\"__init__(self, log: bool = False) &#45;&gt; None:&#10;Constructor. If `log` is set, turn on logging.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-488.88\" 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_node5_58\"><a xlink:href=\"#\" xlink:title=\"arg(self, value: Any, pos: Optional[int] = None, kw: Optional[str] = None) &#45;&gt; Any:&#10;Track `value` being passed as argument.&#10;`pos` (if given) is the argument position (starting with 1).&#10;`kw` (if given) is the argument keyword.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-477.62\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">arg()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_59\"><a xlink:href=\"#\" xlink:title=\"augment(self, name: str, value: Any) &#45;&gt; Any:&#10;Track augmenting `name` with `value`.&#10;To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-466.38\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">augment()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_60\"><a xlink:href=\"#\" xlink:title=\"call(self, func: Callable) &#45;&gt; Callable:&#10;Track a call to `func`.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-455.12\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">call()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_61\"><a xlink:href=\"#\" xlink:title=\"get(self, name: str, value: Any) &#45;&gt; Any:&#10;Track getting `value` from `name`.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-443.88\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">get()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_62\"><a xlink:href=\"#\" xlink:title=\"param(self, name: str, value: Any, pos: Optional[int] = None, vararg: str = &#39;&#39;, last: bool = False) &#45;&gt; Any:&#10;At the beginning of a function, track parameter `name` being set to `value`.&#10;`pos` is the position of the argument (starting with 1).&#10;`vararg` is &quot;*&quot; if `name` is a vararg parameter (as in *args),&#10;and &quot;**&quot; is `name` is a kwargs parameter (as in *kwargs).&#10;`last` is True if `name` is the last parameter.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-432.62\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">param()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_63\"><a xlink:href=\"#\" xlink:title=\"ret(self, value: Any) &#45;&gt; Any:&#10;Track `value` being used as return value.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-421.38\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">ret()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_64\"><a xlink:href=\"#\" xlink:title=\"set(self, name: str, value: Any, loads: Optional[Set[str]] = None) &#45;&gt; Any:&#10;Track setting `name` to `value`.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-410.12\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">set()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_65\"><a xlink:href=\"#\" xlink:title=\"test(self, cond: ast.AST) &#45;&gt; ast.AST:&#10;Test condition `cond`. To be overloaded in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-398.88\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-style=\"italic\" font-size=\"10.00\">test()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node5_66\"><a xlink:href=\"#\" xlink:title=\"instrument_call(self, func: Callable) &#45;&gt; Callable:&#10;Instrument a call to `func`. To be implemented in subclasses.\">\n",
       "<text text-anchor=\"start\" x=\"243\" y=\"-387.62\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-style=\"italic\" font-size=\"10.00\">instrument_call()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- DependencyTracker&#45;&gt;DataTracker -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>DependencyTracker&#45;&gt;DataTracker</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M299.6,-255.65C298.58,-293.35 297.49,-333.99 296.54,-369.28\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"293.05,-368.94 296.28,-379.03 300.05,-369.13 293.05,-368.94\"/>\n",
       "</g>\n",
       "<!-- DataTracker&#45;&gt;StackInspector -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>DataTracker&#45;&gt;StackInspector</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M294,-549.43C294,-585.67 294,-627.82 294,-663.17\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"290.5,-662.88 294,-672.88 297.5,-662.88 290.5,-662.88\"/>\n",
       "</g>\n",
       "<!-- Dependencies -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>Dependencies</title>\n",
       "<g id=\"a_node6\"><a xlink:href=\"#\" xlink:title=\"class Dependencies:&#10;A dependency graph\">\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"371,-292.5 371,-637.5 501,-637.5 501,-292.5 371,-292.5\"/>\n",
       "<text text-anchor=\"start\" x=\"389.5\" y=\"-621.2\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"14.00\" fill=\"#6a0dad\">Dependencies</text>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"371,-612.25 501,-612.25\"/>\n",
       "<g id=\"a_node6_67\"><a xlink:href=\"#\" xlink:title=\"Dependencies\">\n",
       "<g id=\"a_node6_68\"><a xlink:href=\"#\" xlink:title=\"FONT_NAME = &#39;Courier&#39;\">\n",
       "<text text-anchor=\"start\" x=\"406\" y=\"-598.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">FONT_NAME</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_69\"><a xlink:href=\"#\" xlink:title=\"NODE_COLOR = &#39;peachpuff&#39;\">\n",
       "<text text-anchor=\"start\" x=\"406\" y=\"-587.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">NODE_COLOR</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "<polyline fill=\"none\" stroke=\"black\" points=\"371,-581.75 501,-581.75\"/>\n",
       "<g id=\"a_node6_70\"><a xlink:href=\"#\" xlink:title=\"Dependencies\">\n",
       "<g id=\"a_node6_71\"><a xlink:href=\"#\" xlink:title=\"__init__(self, data: Optional[Dict[Tuple[str, Tuple[Callable, int]], Set[Tuple[str, Tuple[Callable, int]]]]] = None, control: Optional[Dict[Tuple[str, Tuple[Callable, int]], Set[Tuple[str, Tuple[Callable, int]]]]] = None) &#45;&gt; None:&#10;Create a dependency graph from `data` and `control`.&#10;Both `data` and `control` are dictionaries&#10;holding _nodes_ as keys and sets of nodes as values.&#10;Each node comes as a tuple (variable_name, location)&#10;where `variable_name` is a string&#10;and `location` is a pair (function, lineno)&#10;where `function` is a callable and `lineno` is a line number&#10;denoting a unique location in the code.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-569.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">__init__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_72\"><a xlink:href=\"#\" xlink:title=\"__repr__(self) &#45;&gt; str:&#10;Represent dependencies as a Python expression\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-558\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">__repr__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_73\"><a xlink:href=\"#\" xlink:title=\"__str__(self) &#45;&gt; str:&#10;Return string representation of dependencies\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-546.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">__str__()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_74\"><a xlink:href=\"#\" xlink:title=\"_repr_mimebundle_(self, include: Any = None, exclude: Any = None) &#45;&gt; Any:&#10;If the object is output in Jupyter, render dependencies as a SVG graph\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-535.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">_repr_mimebundle_()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_75\"><a xlink:href=\"#\" xlink:title=\"all_functions(self) &#45;&gt; Dict[Callable, List[Tuple[int, Tuple[str, Tuple[Callable, int]]]]]:&#10;Return mapping&#10;{`function`: [(`lineno`, `var`), (`lineno`, `var`), ...], ...}&#10;for all functions in the dependencies.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-524.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">all_functions()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_76\"><a xlink:href=\"#\" xlink:title=\"all_vars(self) &#45;&gt; Set[Tuple[str, Tuple[Callable, int]]]:&#10;Return a set of all variables (as `var_name`, `location`) in the dependencies\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-513\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">all_vars()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_77\"><a xlink:href=\"#\" xlink:title=\"backward_slice(self, *criteria: Union[str, Tuple[Callable, int], Tuple[str, Tuple[Callable, int]]], mode: str = &#39;cd&#39;, depth: int = &#45;1) &#45;&gt; Dependencies:&#10;Create a backward slice from nodes `criteria`.&#10;`mode` can contain &#39;c&#39; (draw control dependencies)&#10;and &#39;d&#39; (draw data dependencies) (default: &#39;cd&#39;)\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-501.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">backward_slice()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_78\"><a xlink:href=\"#\" xlink:title=\"code(self, *items: Callable, mode: str = &#39;cd&#39;) &#45;&gt; None:&#10;List `items` on standard output, including dependencies as comments.&#10;If `items` is empty, all included functions are listed.&#10;`mode` can contain &#39;c&#39; (draw control dependencies) and &#39;d&#39; (draw data dependencies)&#10;(default: &#39;cd&#39;).\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-490.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">code()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_79\"><a xlink:href=\"#\" xlink:title=\"graph(self, *, mode: str = &#39;flow&#39;) &#45;&gt; graphviz.graphs.Digraph:&#10;Draw dependencies. `mode` is either&#10;* `&#39;flow&#39;`: arrows indicate information flow (from A to B); or&#10;* `&#39;depend&#39;`: arrows indicate dependencies (B depends on A)\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-479.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-weight=\"bold\" font-size=\"10.00\">graph()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_80\"><a xlink:href=\"#\" xlink:title=\"_code(self, item: Callable, mode: str) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-467\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">_code()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_81\"><a xlink:href=\"#\" xlink:title=\"_source(self, node: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-455.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">_source()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_82\"><a xlink:href=\"#\" xlink:title=\"add_hierarchy(self, g: graphviz.graphs.Digraph) &#45;&gt; graphviz.graphs.Digraph:&#10;Add invisible edges for a proper hierarchy.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-444.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">add_hierarchy()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_83\"><a xlink:href=\"#\" xlink:title=\"draw_dependencies(self, g: graphviz.graphs.Digraph, mode: str) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-433.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">draw_dependencies()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_84\"><a xlink:href=\"#\" xlink:title=\"draw_edge(self, g: graphviz.graphs.Digraph, mode: str, node_from: str, node_to: str, **kwargs: Any) &#45;&gt; None\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-422\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">draw_edge()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_85\"><a xlink:href=\"#\" xlink:title=\"expand_criteria(self, criteria: List[Union[str, Tuple[Callable, int], Tuple[str, Tuple[Callable, int]]]]) &#45;&gt; List[Tuple[str, Tuple[Callable, int]]]:&#10;Return list of vars matched by `criteria`.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-410.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">expand_criteria()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_86\"><a xlink:href=\"#\" xlink:title=\"format_var(self, var: Tuple[str, Tuple[Callable, int]], current_func: Optional[Callable] = None) &#45;&gt; str:&#10;Return string for `var` in `current_func`.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-399.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">format_var()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_87\"><a xlink:href=\"#\" xlink:title=\"id(self, var: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str:&#10;Return a unique ID for `var`.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-388.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">id()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_88\"><a xlink:href=\"#\" xlink:title=\"label(self, var: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str:&#10;Render node `var` using HTML style.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-377\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">label()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_89\"><a xlink:href=\"#\" xlink:title=\"make_graph(self, name: str = &#39;dependencies&#39;, comment: str = &#39;Dependencies&#39;) &#45;&gt; graphviz.graphs.Digraph\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-365.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">make_graph()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_90\"><a xlink:href=\"#\" xlink:title=\"repr_dependencies(self, vars: Dict[Tuple[str, Tuple[Callable, int]], Set[Tuple[str, Tuple[Callable, int]]]]) &#45;&gt; str\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-354.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">repr_dependencies()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_91\"><a xlink:href=\"#\" xlink:title=\"repr_deps(self, var_set: Set[Tuple[str, Tuple[Callable, int]]]) &#45;&gt; str\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-343.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">repr_deps()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_92\"><a xlink:href=\"#\" xlink:title=\"repr_var(self, var: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-332\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">repr_var()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_93\"><a xlink:href=\"#\" xlink:title=\"source(self, node: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str:&#10;Return the source code for a given node.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-320.75\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">source()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_94\"><a xlink:href=\"#\" xlink:title=\"tooltip(self, var: Tuple[str, Tuple[Callable, int]]) &#45;&gt; str:&#10;Return a tooltip for node `var`.\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-309.5\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">tooltip()</text>\n",
       "</a>\n",
       "</g>\n",
       "<g id=\"a_node6_95\"><a xlink:href=\"#\" xlink:title=\"validate(self) &#45;&gt; None:&#10;Perform a simple syntactic validation of dependencies\">\n",
       "<text text-anchor=\"start\" x=\"379\" y=\"-298.25\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"10.00\">validate()</text>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</a>\n",
       "</g>\n",
       "</g>\n",
       "<!-- Dependencies&#45;&gt;StackInspector -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>Dependencies&#45;&gt;StackInspector</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M370.54,-621.8C367.73,-627.3 364.88,-632.72 362,-638 357.2,-646.8 351.85,-655.8 346.32,-664.64\"/>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"343.5,-662.55 341.07,-672.86 349.4,-666.31 343.5,-662.55\"/>\n",
       "</g>\n",
       "<!-- Legend -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>Legend</title>\n",
       "<text text-anchor=\"start\" x=\"416.38\" y=\"-144\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-weight=\"bold\" font-size=\"10.00\" fill=\"#6a0dad\">Legend</text>\n",
       "<text text-anchor=\"start\" x=\"416.38\" y=\"-134\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"422.38\" y=\"-134\" 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=\"416.38\" y=\"-124\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"422.38\" y=\"-124\" font-family=\"'Fira Mono', 'Source Code Pro', 'Courier', monospace\" font-size=\"8.00\">private_method()</text>\n",
       "<text text-anchor=\"start\" x=\"416.38\" y=\"-114\" font-family=\"Raleway, Helvetica, Arial, sans-serif\" font-size=\"10.00\">• </text>\n",
       "<text text-anchor=\"start\" x=\"422.38\" y=\"-114\" 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=\"416.38\" y=\"-104.95\" 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 0x105d40340>"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ignore\n",
    "display_class_hierarchy([Slicer, DependencyTracker, \n",
    "                         StackInspector, Dependencies],\n",
    "                        abstract_classes=[\n",
    "                            StackInspector,\n",
    "                            Instrumenter\n",
    "                        ],\n",
    "                        public_methods=[\n",
    "                            StackInspector.caller_frame,\n",
    "                            StackInspector.caller_function,\n",
    "                            StackInspector.caller_globals,\n",
    "                            StackInspector.caller_locals,\n",
    "                            StackInspector.caller_location,\n",
    "                            StackInspector.search_frame,\n",
    "                            StackInspector.search_func,\n",
    "                            Instrumenter.__init__,\n",
    "                            Instrumenter.__enter__,\n",
    "                            Instrumenter.__exit__,\n",
    "                            Instrumenter.instrument,\n",
    "                            Slicer.__init__,\n",
    "                            Slicer.code,\n",
    "                            Slicer.dependencies,\n",
    "                            Slicer.graph,\n",
    "                            Slicer._repr_mimebundle_,\n",
    "                            DataTracker.__init__,\n",
    "                            DataTracker.__enter__,\n",
    "                            DataTracker.__exit__,\n",
    "                            DataTracker.arg,\n",
    "                            DataTracker.augment,\n",
    "                            DataTracker.call,\n",
    "                            DataTracker.get,\n",
    "                            DataTracker.param,\n",
    "                            DataTracker.ret,\n",
    "                            DataTracker.set,\n",
    "                            DataTracker.test,\n",
    "                            DataTracker.__repr__,\n",
    "                            DependencyTracker.__init__,\n",
    "                            DependencyTracker.__enter__,\n",
    "                            DependencyTracker.__exit__,\n",
    "                            DependencyTracker.arg,\n",
    "                            # DependencyTracker.augment,\n",
    "                            DependencyTracker.call,\n",
    "                            DependencyTracker.get,\n",
    "                            DependencyTracker.param,\n",
    "                            DependencyTracker.ret,\n",
    "                            DependencyTracker.set,\n",
    "                            DependencyTracker.test,\n",
    "                            DependencyTracker.__repr__,\n",
    "                            Dependencies.__init__,\n",
    "                            Dependencies.__repr__,\n",
    "                            Dependencies.__str__,\n",
    "                            Dependencies._repr_mimebundle_,\n",
    "                            Dependencies.code,\n",
    "                            Dependencies.graph,\n",
    "                            Dependencies.backward_slice,\n",
    "                            Dependencies.all_functions,\n",
    "                            Dependencies.all_vars,\n",
    "                        ],\n",
    "                        project='debuggingbook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Things that do not Work"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Our slicer (and especially the underlying dependency tracker) is still a proof of concept. A number of Python features are not or only partially supported, and/or hardly tested:\n",
    "\n",
    "* __Exceptions__ can lead to missing or erroneous dependencies. The code assumes that for every `call()`, there is a matching `ret()`; when exceptions break this, dependencies across function calls and arguments may be missing or be assigned incorrectly.\n",
    "* __Multiple definitions on a single line__ as in `x = y; x = 1` can lead to missing or erroneous dependencies. Our implementation assumes that there is one statement per line.\n",
    "* __If-Expressions__ (`y = 1 if x else 0`) do not create control dependencies, as there are no statements to control. Neither do `if` clauses in comprehensions.\n",
    "* __Asynchronous functions__ (`async`, `await`) are not tested.\n",
    "\n",
    "In these cases, the instrumentation and the underlying dependency tracker may fail to identify control and/or data flows. The semantics of the code, however, should always stay unchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lessons Learned\n",
    "\n",
    "* To track the origin of some incorrect value, follow back its _dependencies_:\n",
    "    * _Data dependencies_ indicate where the value came from.\n",
    "    * _Control dependencies_ show why a statement was executed.\n",
    "* A _slice_ is a subset of the code that could have influenced a specific value. It can be computed by transitively following all dependencies.\n",
    "* _Instrument code_ to automatically determine and visualize dependencies."
   ]
  },
  {
   "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](StatisticalDebugger.ipynb), we will explore how to make use of _multiple_ passing and failing executions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Background\n",
    "\n",
    "Slicing as computing a subset of a program by means of data and control dependencies was invented by Mark Weiser \\cite{Weiser1981}. In his seminal work \"Programmers use Slices when Debugging\", \\cite{Weiser1982}, Weiser demonstrated how such dependencies are crucial for systematic debugging:\n",
    "\n",
    "> When debugging unfamiliar programs programmers use program pieces called _slices_ which are sets of statements related by their flow of data. The statements in a slice are not necessarily textually contiguous, but may be scattered through a program."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Weiser's slices (and dependencies) were determined _statically_ from program code. Both Korel and Laski \\cite{Korel1988} as well as Agrawal and Horgan \\cite{Agrawal1990} introduced _dynamic_ program slicing, building on _dynamic_ dependencies, which would be more specific to a given (failing) run. (The `Slicer` we implement in this chapter is a dynamic slicer.) Tip \\cite{Tip1995} gives a survey on program slicing techniques. Chen et al. \\cite{Chen2014} describe and evaluate the first dynamic slicer for Python programs (which is independent of our implementation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "One exemplary application of program slices is [the Whyline](https://github.com/amyjko/whyline) by Ko and Myers \\cite{Ko2004}. The Whyline is a debugging interface for asking questions about program behavior. It allows querying interactively where a particular variable came from (a data dependency) and why or why not specific things took place (control dependencies)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In \\cite{Soremekun2021}, Soremekun et al. evaluated the performance of slicing as a fault localization mechanism and found that following dependencies was one of the most successful strategies to determine fault locations. Notably, if programmers first examine at most the top five most suspicious locations from [statistical debugging](StatisticalDebugger.ipynb), and then switch to dynamic slices, on average, they will need to examine only 15% (12 lines) of the code. "
   ]
  },
  {
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 1: Control Slices\n",
    "\n",
    "Augment the `Slicer` class with two keyword arguments, `include` and `exclude`, each taking a list of functions to instrument or not to instrument, respectively. These can be helpful when using \"automatic\" instrumentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 2: Incremental Exploration\n",
    "\n",
    "This is more of a programming project than a simple exercise. Rather than showing all dependencies as a whole, as we do, build a system that allows the user to _explore_ dependencies interactively."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 3: Forward Slicing\n",
    "\n",
    "Extend `Dependencies` with a variant of `backward_slice()` named `forward_slice()` that, instead of computing the dependencies that go _into_ a location, computes the dependencies that go _out_ of a location."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 4: Code with Forward Dependencies\n",
    "\n",
    "Create a variant of `Dependencies.code()` that, for each statement `s`, instead of showing a \"passive\" view (which variables and locations influenced `s`?), shows an \"active\" view (which variables and locations were influenced by `s`?). For `middle()`, for instance, the first line should show which lines are influenced by `x`, `y`, and `z`, respectively. Use `->` for control flows and `=>` for data flows."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 5: Flow Assertions\n",
    "\n",
    "In line with [Verifying Flows at Runtime](#Verifying-Flows-at-Runtime), above, implement a function `assert_flow(target, source)` that checks at runtime that the data flowing into `target` only comes from the variables named in `source`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:36.069634Z",
     "iopub.status.busy": "2023-11-12T12:40:36.069363Z",
     "iopub.status.idle": "2023-11-12T12:40:36.071548Z",
     "shell.execute_reply": "2023-11-12T12:40:36.071262Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def assert_flow(target: Any, source: List[Any]) -> bool:\n",
    "    \"\"\"\n",
    "    Raise an `AssertionError` if the dependencies of `target`\n",
    "    are not equal to `source`.\n",
    "    \"\"\"\n",
    "    ...\n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`assert_flow()` would be used in conjunction with `Slicer()` as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:36.073039Z",
     "iopub.status.busy": "2023-11-12T12:40:36.072935Z",
     "iopub.status.idle": "2023-11-12T12:40:36.074820Z",
     "shell.execute_reply": "2023-11-12T12:40:36.074524Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def demo4() -> int:\n",
    "    x = 25\n",
    "    y = 26\n",
    "    assert_flow(y, [x])  # ensures that `y` depends on `x` only\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-12T12:40:36.076711Z",
     "iopub.status.busy": "2023-11-12T12:40:36.076476Z",
     "iopub.status.idle": "2023-11-12T12:40:36.083635Z",
     "shell.execute_reply": "2023-11-12T12:40:36.083303Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with Slicer() as slicer:\n",
    "    demo4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To check dependencies, have `assert_flow()` check the contents of the `_data` dependency collector as set up by the slicer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 6: Checked Coverage\n",
    "\n",
    "Implement checked coverage, as sketched in [Assessing Test Quality](#Assessing-Test-Quality) above. For every `assert` statement encountered during a run, produce the number of statements it depends upon."
   ]
  }
 ],
 "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,
  "vscode": {
   "interpreter": {
    "hash": "0af4f07dd039d1b4e562c7a7d0340393b1c66f50605ac6af30beb81aa23b7ef5"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}