notebooks/shared/ClassDiagram.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Class Diagrams\n",
    "\n",
    "This is a simple viewer for class diagrams.  Customized towards the book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "**Prerequisites**\n",
    "\n",
    "* _Refer to earlier chapters as notebooks here, as here:_ [Earlier Chapter](Debugger.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import bookutils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 fuzzingbook.ClassDiagram import <identifier>\n",
    "```\n",
    "\n",
    "and then make use of the following features.\n",
    "\n",
    "\n",
    "The `display_class_hierarchy()` function shows the class hierarchy for the given class.  Methods with docstrings (intended to be used by the public) are shown in bold.\n",
    "\n",
    "```python\n",
    ">>> display_class_hierarchy(GrammarFuzzer)\n",
    "```\n",
    "\n",
    "![](PICS/ClassDiagram-synopsis-1.svg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": true,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "## Getting a Class Hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `mro()`, we can access the class hierarchy.  We make sure to avoid duplicates created by `class X(X)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ignore\n",
    "from typing import Callable, Dict, Type, Set, List, Union, Any, Tuple, Optional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_hierarchy(cls: Type) -> List[Type]:\n",
    "    superclasses = cls.mro()\n",
    "    hierarchy = []\n",
    "    last_superclass_name = \"\"\n",
    "\n",
    "    for superclass in superclasses:\n",
    "        if superclass.__name__ != last_superclass_name:\n",
    "            hierarchy.append(superclass)\n",
    "            last_superclass_name = superclass.__name__\n",
    "\n",
    "    return hierarchy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A_Class:\n",
    "    \"\"\"A Class which does A thing right.\n",
    "    Comes with a longer docstring.\"\"\"\n",
    "\n",
    "    def foo(self) -> None:\n",
    "        \"\"\"The Adventures of the glorious Foo\"\"\"\n",
    "        pass\n",
    "\n",
    "    def quux(self) -> None:\n",
    "        \"\"\"A method that is not used.\"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A_Class(A_Class):\n",
    "    # We define another function in a separate cell.\n",
    "\n",
    "    def second(self) -> None:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class B_Class(A_Class):\n",
    "    \"\"\"A subclass inheriting some methods.\"\"\"\n",
    "\n",
    "    VAR = \"A variable\"\n",
    "\n",
    "    def foo(self) -> None:\n",
    "        \"\"\"A WW2 foo fighter.\"\"\"\n",
    "        pass\n",
    "\n",
    "    def bar(self, qux: Any = None, bartender: int = 42) -> None:\n",
    "        \"\"\"A qux walks into a bar.\n",
    "        `bartender` is an optional attribute.\"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SomeType = List[Optional[Union[str, int]]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class C_Class:\n",
    "    \"\"\"A class injecting some method\"\"\"\n",
    "\n",
    "    def qux(self, arg: SomeType) -> SomeType:\n",
    "        return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class D_Class(B_Class, C_Class):\n",
    "    \"\"\"A subclass inheriting from multiple superclasses.\n",
    "    Comes with a fairly long, but meaningless documentation.\"\"\"\n",
    "\n",
    "    def foo(self) -> None:\n",
    "        B_Class.foo(self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class D_Class(D_Class):\n",
    "    pass  # An incremental addiiton that should not impact D's semantics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_hierarchy(D_Class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting a Class Tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `__bases__` to obtain the immediate base classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_Class.__bases__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`class_tree()` returns a class tree, using the \"lowest\" (most specialized) class with the same name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_tree(cls: Type, lowest: Optional[Type] = None) -> List[Tuple[Type, List]]:\n",
    "    ret = []\n",
    "    for base in cls.__bases__:\n",
    "        if base.__name__ == cls.__name__:\n",
    "            if not lowest:\n",
    "                lowest = cls\n",
    "            ret += class_tree(base, lowest)\n",
    "        else:\n",
    "            if lowest:\n",
    "                cls = lowest\n",
    "            ret.append((cls, class_tree(base)))\n",
    "\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_tree(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_tree(D_Class)[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert class_tree(D_Class)[0][0] == D_Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`class_set()` flattens the tree into a set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_set(classes: Union[Type, List[Type]]) -> Set[Type]:\n",
    "    if not isinstance(classes, list):\n",
    "        classes = [classes]\n",
    "\n",
    "    ret = set()\n",
    "\n",
    "    def traverse_tree(tree: List[Tuple[Type, List]]) -> None:\n",
    "        for (cls, subtrees) in tree:\n",
    "            ret.add(cls)\n",
    "            for subtree in subtrees:\n",
    "                traverse_tree(subtrees)\n",
    "\n",
    "    for cls in classes:\n",
    "        traverse_tree(class_tree(cls))\n",
    "\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_set(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert A_Class in class_set(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert B_Class in class_set(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert C_Class in class_set(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert D_Class in class_set(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_set([B_Class, C_Class])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting Docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_Class.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_Class.__bases__[0].__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_Class.__bases__[0].__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_Class.foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D_Class.foo.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_Class.foo.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def docstring(obj: Any) -> str:\n",
    "    doc = inspect.getdoc(obj)\n",
    "    return doc if doc else \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docstring(A_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docstring(D_Class.foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unknown() -> None:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "docstring(unknown)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def escape(text: str) -> str:\n",
    "    text = html.escape(text)\n",
    "    assert '<' not in text\n",
    "    assert '>' not in text\n",
    "    text = text.replace('{', '&#x7b;')\n",
    "    text = text.replace('|', '&#x7c;')\n",
    "    text = text.replace('}', '&#x7d;')\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "escape(\"f(foo={})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def escape_doc(docstring: str) -> str:\n",
    "    DOC_INDENT = 0\n",
    "    docstring = \"&#x0a;\".join(\n",
    "        ' ' * DOC_INDENT + escape(line).strip()\n",
    "        for line in docstring.split('\\n')\n",
    "    )\n",
    "    return docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(escape_doc(\"'Hello\\n    {You|Me}'\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "## Getting Methods and Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inspect.getmembers(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_items(cls: Type, pred: Callable) -> List[Tuple[str, Any]]:\n",
    "    def _class_items(cls: Type) -> List:\n",
    "        all_items = inspect.getmembers(cls, pred)\n",
    "        for base in cls.__bases__:\n",
    "            all_items += _class_items(base)\n",
    "\n",
    "        return all_items\n",
    "\n",
    "    unique_items = []\n",
    "    items_seen = set()\n",
    "    for (name, item) in _class_items(cls):\n",
    "        if name not in items_seen:\n",
    "            unique_items.append((name, item))\n",
    "            items_seen.add(name)\n",
    "\n",
    "    return unique_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_methods(cls: Type) -> List[Tuple[str, Callable]]:\n",
    "    return class_items(cls, inspect.isfunction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def defined_in(name: str, cls: Type) -> bool:\n",
    "    if not hasattr(cls, name):\n",
    "        return False\n",
    "\n",
    "    defining_classes = []\n",
    "\n",
    "    def search_superclasses(name: str, cls: Type) -> None:\n",
    "        if not hasattr(cls, name):\n",
    "            return\n",
    "\n",
    "        for base in cls.__bases__:\n",
    "            if hasattr(base, name):\n",
    "                defining_classes.append(base)\n",
    "                search_superclasses(name, base)\n",
    "\n",
    "    search_superclasses(name, cls)\n",
    "\n",
    "    if any(cls.__name__ != c.__name__ for c in defining_classes):\n",
    "        return False  # Already defined in superclass\n",
    "\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert not defined_in('VAR', A_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert defined_in('VAR', B_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert not defined_in('VAR', C_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert not defined_in('VAR', D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def class_vars(cls: Type) -> List[Any]:\n",
    "    def is_var(item: Any) -> bool:\n",
    "        return not callable(item)\n",
    "\n",
    "    return [item for item in class_items(cls, is_var) \n",
    "            if not item[0].startswith('__') and defined_in(item[0], cls)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_methods(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_vars(B_Class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're only interested in \n",
    "\n",
    "* functions _defined_ in that class\n",
    "* functions that come with a docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def public_class_methods(cls: Type) -> List[Tuple[str, Callable]]:\n",
    "    return [(name, method) for (name, method) in class_methods(cls) \n",
    "            if method.__qualname__.startswith(cls.__name__)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def doc_class_methods(cls: Type) -> List[Tuple[str, Callable]]:\n",
    "    return [(name, method) for (name, method) in public_class_methods(cls) \n",
    "            if docstring(method) is not None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "public_class_methods(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_class_methods(D_Class)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overloaded_class_methods(classes: Union[Type, List[Type]]) -> Set[str]:\n",
    "    all_methods: Dict[str, Set[Callable]] = {}\n",
    "    for cls in class_set(classes):\n",
    "        for (name, method) in class_methods(cls):\n",
    "            if method.__qualname__.startswith(cls.__name__):\n",
    "                all_methods.setdefault(name, set())\n",
    "                all_methods[name].add(cls)\n",
    "\n",
    "    return set(name for name in all_methods if len(all_methods[name]) >= 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "overloaded_class_methods(D_Class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drawing Class Hierarchy with Method Names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from inspect import signature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_class_hierarchy(classes: Union[Type, List[Type]], *,\n",
    "                            public_methods: Optional[List] = None,\n",
    "                            abstract_classes: Optional[List] = None,\n",
    "                            include_methods: bool = True,\n",
    "                            include_class_vars: bool = True,\n",
    "                            include_legend: bool = True,\n",
    "                            local_defs_only: bool = True,\n",
    "                            types: Dict[str, Any] = {},\n",
    "                            project: str = 'fuzzingbook',\n",
    "                            log: bool = False) -> Any:\n",
    "    \"\"\"Visualize a class hierarchy.\n",
    "`classes` is a Python class (or a list of classes) to be visualized.\n",
    "`public_methods`, if given, is a list of methods to be shown as \"public\" (bold).\n",
    "  (Default: all methods with a docstring)\n",
    "`abstract_classes`, if given, is a list of classes to be shown as \"abstract\" (cursive).\n",
    "  (Default: all classes with an abstract method)\n",
    "`include_methods`: if set (default), include all methods\n",
    "`include_legend`: if set (default), include a legend\n",
    "`local_defs_only`: if set (default), hide details of imported classes\n",
    "`types`: type names with definitions, to be used in docs\n",
    "    \"\"\"\n",
    "    from graphviz import Digraph  # type: ignore\n",
    "\n",
    "    if project == 'debuggingbook':\n",
    "        CLASS_FONT = 'Raleway, Helvetica, Arial, sans-serif'\n",
    "        CLASS_COLOR = '#6A0DAD'  # HTML 'purple'\n",
    "    else:\n",
    "        CLASS_FONT = 'Patua One, Helvetica, sans-serif'\n",
    "        CLASS_COLOR = '#B03A2E'\n",
    "\n",
    "    METHOD_FONT = \"'Fira Mono', 'Source Code Pro', 'Courier', monospace\"\n",
    "    METHOD_COLOR = 'black'\n",
    "\n",
    "    if isinstance(classes, list):\n",
    "        starting_class = classes[0]\n",
    "    else:\n",
    "        starting_class = classes\n",
    "        classes = [starting_class]\n",
    "\n",
    "    title = starting_class.__name__ + \" class hierarchy\"\n",
    "\n",
    "    dot = Digraph(comment=title)\n",
    "    dot.attr('node', shape='record', fontname=CLASS_FONT)\n",
    "    dot.attr('graph', rankdir='BT', tooltip=title)\n",
    "    dot.attr('edge', arrowhead='empty')\n",
    "    edges = set()\n",
    "    overloaded_methods: Set[str] = set()\n",
    "\n",
    "    drawn_classes = set()\n",
    "\n",
    "    def method_string(method_name: str, public: bool, overloaded: bool,\n",
    "                      fontsize: float = 10.0) -> str:\n",
    "        method_string = f'<font face=\"{METHOD_FONT}\" point-size=\"{str(fontsize)}\">'\n",
    "\n",
    "        if overloaded:\n",
    "            name = f'<i>{method_name}()</i>'\n",
    "        else:\n",
    "            name = f'{method_name}()'\n",
    "\n",
    "        if public:\n",
    "            method_string += f'<b>{name}</b>'\n",
    "        else:\n",
    "            method_string += f'<font color=\"{METHOD_COLOR}\">' \\\n",
    "                             f'{name}</font>'\n",
    "\n",
    "        method_string += '</font>'\n",
    "        return method_string\n",
    "\n",
    "    def var_string(var_name: str, fontsize: int = 10) -> str:\n",
    "        var_string = f'<font face=\"{METHOD_FONT}\" point-size=\"{str(fontsize)}\">'\n",
    "        var_string += f'{var_name}'\n",
    "        var_string += '</font>'\n",
    "        return var_string\n",
    "\n",
    "    def is_overloaded(method_name: str, f: Any) -> bool:\n",
    "        return (method_name in overloaded_methods or\n",
    "                (docstring(f) is not None and \"in subclasses\" in docstring(f)))\n",
    "\n",
    "    def is_abstract(cls: Type) -> bool:\n",
    "        if not abstract_classes:\n",
    "            return inspect.isabstract(cls)\n",
    "\n",
    "        return (cls in abstract_classes or\n",
    "                any(c.__name__ == cls.__name__ for c in abstract_classes))\n",
    "\n",
    "    def is_public(method_name: str, f: Any) -> bool:\n",
    "        if public_methods:\n",
    "            return (method_name in public_methods or\n",
    "                    f in public_methods or\n",
    "                    any(f.__qualname__ == m.__qualname__\n",
    "                        for m in public_methods))\n",
    "\n",
    "        return bool(docstring(f))\n",
    "\n",
    "    def frame_module(frameinfo: Any) -> str:\n",
    "        return os.path.splitext(os.path.basename(frameinfo.frame.f_code.co_filename))[0]\n",
    "\n",
    "    def callers() -> List[str]:\n",
    "        frames = inspect.getouterframes(inspect.currentframe())\n",
    "        return [frame_module(frameinfo) for frameinfo in frames]\n",
    "\n",
    "    def is_local_class(cls: Type) -> bool:\n",
    "        return cls.__module__ == '__main__' or cls.__module__ in callers()\n",
    "\n",
    "    def class_vars_string(cls: Type, url: str) -> str:\n",
    "        cls_vars = class_vars(cls)\n",
    "        if len(cls_vars) == 0:\n",
    "            return \"\"\n",
    "\n",
    "        vars_string = f'<table border=\"0\" cellpadding=\"0\" ' \\\n",
    "                      f'cellspacing=\"0\" ' \\\n",
    "                      f'align=\"left\" tooltip=\"{cls.__name__}\" href=\"#\">'\n",
    "\n",
    "        for (name, var) in cls_vars:\n",
    "            if log:\n",
    "                print(f\"    Drawing {name}\")\n",
    "\n",
    "            var_doc = escape(f\"{name} = {repr(var)}\")\n",
    "            tooltip = f' tooltip=\"{var_doc}\"'\n",
    "            href = f' href=\"{url}\"'\n",
    "            vars_string += f'<tr><td align=\"left\" border=\"0\"' \\\n",
    "                           f'{tooltip}{href}>'\n",
    "\n",
    "            vars_string += var_string(name)\n",
    "            vars_string += '</td></tr>'\n",
    "\n",
    "        vars_string += '</table>'\n",
    "        return vars_string\n",
    "\n",
    "    def class_methods_string(cls: Type, url: str) -> str:\n",
    "        methods = public_class_methods(cls)\n",
    "        # return \"<br/>\".join([name + \"()\" for (name, f) in methods])\n",
    "        methods_string = f'<table border=\"0\" cellpadding=\"0\" ' \\\n",
    "                         f'cellspacing=\"0\" ' \\\n",
    "                         f'align=\"left\" tooltip=\"{cls.__name__}\" href=\"#\">'\n",
    "\n",
    "        public_methods_only = local_defs_only and not is_local_class(cls)\n",
    "\n",
    "        methods_seen = False\n",
    "        for public in [True, False]:\n",
    "            for (name, f) in methods:\n",
    "                if public != is_public(name, f):\n",
    "                    continue\n",
    "\n",
    "                if public_methods_only and not public:\n",
    "                    continue\n",
    "\n",
    "                if log:\n",
    "                    print(f\"    Drawing {name}()\")\n",
    "\n",
    "                if is_public(name, f) and not docstring(f):\n",
    "                    warnings.warn(f\"{f.__qualname__}() is listed as public,\"\n",
    "                                  f\" but has no docstring\")\n",
    "\n",
    "                overloaded = is_overloaded(name, f)\n",
    "\n",
    "                sig = str(inspect.signature(f))\n",
    "                # replace 'List[Union[...]]' by the actual type def\n",
    "                for tp in types:\n",
    "                    tp_def = str(types[tp]).replace('typing.', '')\n",
    "                    sig = sig.replace(tp_def, tp)\n",
    "                sig = sig.replace('__main__.', '')\n",
    "\n",
    "                method_doc = escape(name + sig)\n",
    "                if docstring(f):\n",
    "                    method_doc += \":&#x0a;\" + escape_doc(docstring(f))\n",
    "\n",
    "                if log:\n",
    "                    print(f\"    Method doc: {method_doc}\")\n",
    "\n",
    "                # Tooltips are only shown if a href is present, too\n",
    "                tooltip = f' tooltip=\"{method_doc}\"'\n",
    "                href = f' href=\"{url}\"'\n",
    "                methods_string += f'<tr><td align=\"left\" border=\"0\"' \\\n",
    "                                  f'{tooltip}{href}>'\n",
    "\n",
    "                methods_string += method_string(name, public, overloaded)\n",
    "\n",
    "                methods_string += '</td></tr>'\n",
    "                methods_seen = True\n",
    "\n",
    "        if not methods_seen:\n",
    "            return \"\"\n",
    "\n",
    "        methods_string += '</table>'\n",
    "        return methods_string\n",
    "\n",
    "    def display_class_node(cls: Type) -> None:\n",
    "        name = cls.__name__\n",
    "\n",
    "        if name in drawn_classes:\n",
    "            return\n",
    "        drawn_classes.add(name)\n",
    "\n",
    "        if log:\n",
    "            print(f\"Drawing class {name}\")\n",
    "\n",
    "        if cls.__module__ == '__main__':\n",
    "            url = '#'\n",
    "        else:\n",
    "            url = cls.__module__ + '.ipynb'\n",
    "\n",
    "        if is_abstract(cls):\n",
    "            formatted_class_name = f'<i>{cls.__name__}</i>'\n",
    "        else:\n",
    "            formatted_class_name = cls.__name__\n",
    "\n",
    "        if include_methods or include_class_vars:\n",
    "            vars = class_vars_string(cls, url)\n",
    "            methods = class_methods_string(cls, url)\n",
    "            spec = '<{<b><font color=\"' + CLASS_COLOR + '\">' + \\\n",
    "                formatted_class_name + '</font></b>'\n",
    "            if include_class_vars and vars:\n",
    "                spec += '|' + vars\n",
    "            if include_methods and methods:\n",
    "                spec += '|' + methods\n",
    "            spec += '}>'\n",
    "        else:\n",
    "            spec = '<' + formatted_class_name + '>'\n",
    "\n",
    "        class_doc = escape('class ' + cls.__name__)\n",
    "        if docstring(cls):\n",
    "            class_doc += ':&#x0a;' + escape_doc(docstring(cls))\n",
    "        else:\n",
    "            warnings.warn(f\"Class {cls.__name__} has no docstring\")\n",
    "\n",
    "        dot.node(name, spec, tooltip=class_doc, href=url)\n",
    "\n",
    "    def display_class_trees(trees: List[Tuple[Type, List]]) -> None:\n",
    "        for tree in trees:\n",
    "            (cls, subtrees) = tree\n",
    "            display_class_node(cls)\n",
    "\n",
    "            for subtree in subtrees:\n",
    "                (subcls, _) = subtree\n",
    "\n",
    "                if (cls.__name__, subcls.__name__) not in edges:\n",
    "                    dot.edge(cls.__name__, subcls.__name__)\n",
    "                    edges.add((cls.__name__, subcls.__name__))\n",
    "\n",
    "            display_class_trees(subtrees)\n",
    "\n",
    "    def display_legend() -> None:\n",
    "        fontsize = 8.0\n",
    "\n",
    "        label = f'<b><font color=\"{CLASS_COLOR}\">Legend</font></b><br align=\"left\"/>' \n",
    "\n",
    "        for item in [\n",
    "            method_string(\"public_method\",\n",
    "                          public=True, overloaded=False, fontsize=fontsize),\n",
    "            method_string(\"private_method\",\n",
    "                          public=False, overloaded=False, fontsize=fontsize),\n",
    "            method_string(\"overloaded_method\",\n",
    "                          public=False, overloaded=True, fontsize=fontsize)\n",
    "        ]:\n",
    "            label += '&bull;&nbsp;' + item + '<br align=\"left\"/>'\n",
    "\n",
    "        label += f'<font face=\"Helvetica\" point-size=\"{str(fontsize + 1)}\">' \\\n",
    "                 'Hover over names to see doc' \\\n",
    "                 '</font><br align=\"left\"/>'\n",
    "\n",
    "        dot.node('Legend', label=f'<{label}>', shape='plain', fontsize=str(fontsize + 2))\n",
    "\n",
    "    for cls in classes:\n",
    "        tree = class_tree(cls)\n",
    "        overloaded_methods = overloaded_class_methods(cls)\n",
    "        display_class_trees(tree)\n",
    "\n",
    "    if include_legend:\n",
    "        display_legend()\n",
    "\n",
    "    return dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display_class_hierarchy(D_Class, types={'SomeType': SomeType},\n",
    "                        project='debuggingbook', log=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display_class_hierarchy(D_Class, types={'SomeType': SomeType},\n",
    "                        project='fuzzingbook')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a variant with abstract classes and logging:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display_class_hierarchy([A_Class, B_Class],\n",
    "                        abstract_classes=[A_Class],\n",
    "                        public_methods=[\n",
    "                            A_Class.quux,\n",
    "                        ],\n",
    "                        log=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Synopsis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `display_class_hierarchy()` function shows the class hierarchy for the given class (or list of classes). \n",
    "* The keyword parameter `public_methods`, if given, is a list of \"public\" methods to be used by clients (default: all methods with docstrings).\n",
    "* The keyword parameter `abstract_classes`, if given, is a list of classes to be displayed as \"abstract\" (i.e. with a cursive class name)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display_class_hierarchy(D_Class, abstract_classes=[A_Class])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enjoy!"
   ]
  }
 ],
 "metadata": {
  "ipub": {
   "bibliography": "fuzzingbook.bib",
   "toc": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.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
 },
 "nbformat": 4,
 "nbformat_minor": 4
}