docs/beta/notebooks/Project_Grammar_eval.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 2 - Grammars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import fuzzingbook_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: coverage in /opt/conda/lib/python3.6/site-packages (4.5.2)\r\n",
      "Requirement already satisfied: gcovr in /opt/conda/lib/python3.6/site-packages (4.1)\r\n",
      "Requirement already satisfied: jinja2 in /opt/conda/lib/python3.6/site-packages (from gcovr) (2.10)\r\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /opt/conda/lib/python3.6/site-packages (from jinja2->gcovr) (1.0)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install coverage gcovr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Testing regular expression (regex) parsers is a challenging task. A simple regex, such as `a?(b|c)+d*`, requires dozens of inputs to cover all possibilities.\n",
    "\n",
    "To test regex, we use the python [regex](https://pypi.org/project/regex/) module (provided in the `data/regex` directory of this project). We use the source code of the `regex` module so that we can compute the coverage of the module.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from data.regex.regex_3 import _regex_core\n",
    "from data.regex.regex_3 import regex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a matches a?(b|c)+d*$: False\n",
      "b matches a?(b|c)+d*$: True\n"
     ]
    }
   ],
   "source": [
    "pattern = 'a?(b|c)+d*$'\n",
    "print('a matches %s: %s' % (pattern, regex.match(pattern, 'a') != None))\n",
    "print('b matches %s: %s' % (pattern, regex.match(pattern, 'ab') != None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An efficient approach to test regex is to use grammars. Regex are instances of regular languages - a subset of context-free grammar (CFG) - and, thus, can be tested with the techniques presented in this course.\n",
    "\n",
    "Assume the following grammar, which represents the `a?(b|c)+d*` regular expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_grammar = {'<start>': ['<A><BC><D>'],\n",
    "                   '<A>': ['a', '<empty>'],\n",
    "                   '<BC>': ['b<BC2>', 'c<BC2>'],\n",
    "                   '<BC2>': ['b<BC2>', 'c<BC2>', '<empty>'],\n",
    "                   '<D>': ['d<D>', '<empty>'],\n",
    "                   '<empty>': [''],\n",
    "                   }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reusing the techniques from the lecture we expand and visualize it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from GrammarFuzzer import GrammarFuzzer, display_tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "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 2.40.1 (20161225.0304)\n",
       " -->\n",
       "<!-- Title: %3 Pages: 1 -->\n",
       "<svg width=\"240pt\" height=\"176pt\"\n",
       " viewBox=\"0.00 0.00 239.50 176.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 172)\">\n",
       "<title>%3</title>\n",
       "<polygon fill=\"#ffffff\" stroke=\"transparent\" points=\"-4,4 -4,-172 235.5,-172 235.5,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<text text-anchor=\"middle\" x=\"103.5\" y=\"-156.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;start&gt;</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<text text-anchor=\"middle\" x=\"35.5\" y=\"-105.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;A&gt;</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M93.4664,-152.9748C83.0204,-145.1403 66.4336,-132.7002 53.6742,-123.1307\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"55.6748,-120.2561 45.5748,-117.0561 51.4748,-125.8561 55.6748,-120.2561\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<text text-anchor=\"middle\" x=\"103.5\" y=\"-105.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;BC&gt;</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>0&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M103.5,-152.9748C103.5,-146.195 103.5,-135.966 103.5,-127.1331\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"107.0001,-127.0561 103.5,-117.0561 100.0001,-127.0561 107.0001,-127.0561\"/>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<text text-anchor=\"middle\" x=\"163.5\" y=\"-105.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;D&gt;</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>0&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M112.3532,-152.9748C121.3929,-145.291 135.6447,-133.177 146.8107,-123.6859\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"149.2578,-126.1994 154.6105,-117.0561 144.7243,-120.8658 149.2578,-126.1994\"/>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<text text-anchor=\"middle\" x=\"26.5\" y=\"-54.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;empty&gt;</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M34.172,-101.9748C32.9756,-95.195 31.1705,-84.966 29.6117,-76.1331\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"33.0181,-75.2957 27.8334,-66.0561 26.1246,-76.5122 33.0181,-75.2957\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<text text-anchor=\"middle\" x=\"75.5\" y=\"-54.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">b</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M99.3685,-101.9748C95.4808,-94.8936 89.5274,-84.05 84.5391,-74.9641\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"87.5291,-73.1375 79.6484,-66.0561 81.3931,-76.5063 87.5291,-73.1375\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<text text-anchor=\"middle\" x=\"119.5\" y=\"-54.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;BC2&gt;</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>3&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M105.8609,-101.9748C108.0115,-95.1196 111.2684,-84.7383 114.0602,-75.8392\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"117.4755,-76.6453 117.1295,-66.0561 110.7965,-74.5499 117.4755,-76.6453\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<text text-anchor=\"middle\" x=\"93.5\" y=\"-3.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">b</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M115.6636,-50.9748C112.092,-43.969 106.6429,-33.2803 102.0416,-24.2547\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"105.0122,-22.3755 97.3521,-15.0561 98.7759,-25.5548 105.0122,-22.3755\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<text text-anchor=\"middle\" x=\"137.5\" y=\"-3.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;BC2&gt;</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M122.156,-50.9748C124.602,-44.0443 128.3201,-33.5097 131.4836,-24.5464\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"134.8053,-25.6509 134.8331,-15.0561 128.2044,-23.3211 134.8053,-25.6509\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<text text-anchor=\"middle\" x=\"163.5\" y=\"-54.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">d</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M163.5,-101.9748C163.5,-95.195 163.5,-84.966 163.5,-76.1331\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"167.0001,-76.0561 163.5,-66.0561 160.0001,-76.0561 167.0001,-76.0561\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<text text-anchor=\"middle\" x=\"199.5\" y=\"-54.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;D&gt;</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>8&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M168.8119,-101.9748C173.9167,-94.743 181.7916,-83.5868 188.2859,-74.3866\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"191.2588,-76.2442 194.1663,-66.0561 185.54,-72.2074 191.2588,-76.2442\"/>\n",
       "</g>\n",
       "<!-- 11 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>11</title>\n",
       "<text text-anchor=\"middle\" x=\"181.5\" y=\"-3.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">d</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;11 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>10&#45;&gt;11</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M196.844,-50.9748C194.398,-44.0443 190.6799,-33.5097 187.5164,-24.5464\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"190.7956,-23.3211 184.1669,-15.0561 184.1947,-25.6509 190.7956,-23.3211\"/>\n",
       "</g>\n",
       "<!-- 12 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>12</title>\n",
       "<text text-anchor=\"middle\" x=\"217.5\" y=\"-3.8\" font-family=\"Times,serif\" font-size=\"14.00\" fill=\"#000000\">&lt;D&gt;</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;12 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>10&#45;&gt;12</title>\n",
       "<path fill=\"none\" stroke=\"#000000\" d=\"M202.156,-50.9748C204.602,-44.0443 208.3201,-33.5097 211.4836,-24.5464\"/>\n",
       "<polygon fill=\"#000000\" stroke=\"#000000\" points=\"214.8053,-25.6509 214.8331,-15.0561 208.2044,-23.3211 214.8053,-25.6509\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.dot.Digraph at 0x7f47f2dbcc88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def as_tree(grammar):\n",
    "    f = GrammarFuzzer(grammar)\n",
    "    \n",
    "    derivation_tree = f.init_tree()\n",
    "    for i in range(6):\n",
    "        derivation_tree = f.expand_tree_once(derivation_tree)    \n",
    "    display_tree(derivation_tree)\n",
    "\n",
    "as_tree(example_grammar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can use it to produce valid input values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ccbbcbbb matches a?(b|c)+d*$: True\n",
      "abbbbd matches a?(b|c)+d*$: True\n",
      "c matches a?(b|c)+d*$: True\n",
      "bbc matches a?(b|c)+d*$: True\n",
      "bbcbbccbcbcc matches a?(b|c)+d*$: True\n"
     ]
    }
   ],
   "source": [
    "def test_input(grammar):\n",
    "    f = GrammarFuzzer(grammar)\n",
    "    input_value =  f.fuzz()\n",
    "    print('%s matches %s: %s' % (input_value, pattern, regex.match(pattern, input_value) != None))\n",
    "\n",
    "for i in range(5):    \n",
    "    test_input(example_grammar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective\n",
    "\n",
    "The goal of this project is to _implement an algorithm that constructs a CFG from an arbitrary regular expression. Then, use the techniques learned in the lecture (i.e. efficient grammar-based fuzzing) to automatically expand your grammar and to automatically produce a set of inputs that match the given regular expression, covering as many grammar productions as possible._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regex specification\n",
    "\n",
    "In this project, we restrict the regex specification into its simpler constructions and grouped then into 3 categories: _basic syntax, complex syntax and bonus_ as follows:\n",
    "\n",
    "| Category | Components |\n",
    "|----------|-----------|\n",
    "| Basic Syntax | Anchors `^` and `$` <br> Groupings `()` <br> Whitespace `\\s =  [ \\t\\n\\r\\f\\v]` <br> Quantifiers `*`, `+`, `?` <br> concatenation <br> OR operator <code>&#124;</code> | \n",
    "| Complex syntax | Character classes `[0-9]`, `[a-z]`, `[A-Z]`, `[0-9A-Za-z]`  <br> Special character classes `\\d = [0-9]`, `\\w = [0-9a-zA-Z_]` <br> Bounded quantifier `{}` <br> Set Negation `[^]` (requires look-ahead) <br> `\\D = [^0-9]` <br> `\\W = [^0-9a-zA-Z_]` <br> `\\S = [^\\s]` | \n",
    "| Bonus | Boundaries `\\b` and `\\B`  |   |\n",
    "\n",
    "In your implementation, ignore any non-listed regex elements, such as flags, back references, other types of look-ahead, look-behind and greedy/lazy match.\n",
    "\n",
    "I have also updated the project accordingly, you can `git pull` to obtain the \n",
    "latest version of the project.\n",
    "\n",
    "We use the [regex parser](https://pypi.org/project/regex/), version 2.4.151, instead of Python's native `re`, because `re` is just a wrapper for a C library. Confirm regex version using: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.4.151\n"
     ]
    }
   ],
   "source": [
    "print(regex.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regex samples for development\n",
    "\n",
    "Ensure your implementation works on the following regex examples, and covers the provided minimum required coverage for parsing a represententative input for each regex:\n",
    "\n",
    "| Category | Examples | Min. Cov. LOC _regex_core.py | Min. Cov. LOC *.c|\n",
    "|--------------|----------|------|------|\n",
    "| Basic Syntax | `^ab$` | 241 (8%)  |  988     (7%)| \n",
    "| Basic Syntax | `b$` | 170 (6%) | 949     (6%) |\n",
    "| Basic Syntax | `ab*$` | 207 (7%) | 1142     (8%) |\n",
    "| Basic Syntax | <code>a&#124;b`$`</code> | 308 (11%) | 1024     (7%) |\n",
    "| Basic Syntax | <code>a(b&#124;c)`$`</code> | 321 (11%)  | 1198     (8%)|\n",
    "| Basic Syntax | <code>(a&#124;b)\\s`$`</code> | 334 (12%) |  1131     (8%) |\n",
    "| Basic Syntax | <code>^a*(b+&#124;c)d?`$`</code> | 413 (15%) | 1442    (10%) |\n",
    "| Basic Syntax | <code>^a*(b+&#124;c)d?\\se`$`</code> | 455 (16%)  | 1632    (11%) |\n",
    "| Basic Syntax | <code>^a+(b*&#124;c)d?\\se`$`</code> | 426     (15%) | 1564    (11%) |\n",
    "|  Complex Syntax | `^[0-9]+\\s[a-z]*\\s?[A-Z]+$`</code> | 303     (11%) | 1228     (9%) |\n",
    "| Complex Syntax | `\\w$` | 169 (6%)  |  878 (6%) |  \n",
    "| Complex Syntax | `\\d$` | 169 (6%) | 875 (6%) | \n",
    "| Complex Syntax | <code>(a&#124;b){2,5}$</code> | 401 (14%) |  1380    (10%)| \n",
    "| Complex Syntax | `[0-9a-zA-Z]$` | 252 (9%) | 902     (6%) |\n",
    "| Complex Syntax | `[0-9]$` | 222 (8%) | 852     (6%) |\n",
    "| Complex Syntax | `[a-z]$` | 222 (8%) | 852     (6%) |\n",
    "| Complex Syntax | `[^a-zA-Z]$` | 213 (7%)| 879     (6%) |\n",
    "| Complex Syntax | `[^0-9]$` | 178 (6%) | 825     (6%) | \n",
    "| Complex Syntax | `\\D$` | 168 (6%) |  877     (6%) |\n",
    "| Complex Syntax | `\\W$` | 122 (4%) |  852     (6%) |\n",
    "| Complex Syntax | `\\S$` | 122 (4%) |  852     (6%) |\n",
    "| Complex Syntax | `[a-zA-Z]\\s\\w+\\s\\d\\s$` | 324     (11%) | 1295     (9%) |\n",
    "| Complex Syntax |  `a(bc){2,5}$` | 297     (10%) | 1472 (10%) |\n",
    "| Bonus | `\\babc\\b$` | 258 (9%) | 865     (6%) |\n",
    "| Bonus | `abc\\B` | 177 (6%) | 987     (7%) |\n",
    "| Bonus | `\\babc\\B` | 247 (9%) | 928     (6%) |\n",
    "    \n",
    "\n",
    "Note that the code coverage during the execution of the import statement (`import regex`) is unacccounted for, since this module was executed before the collection of coverage data began. We also do not track or evaluate the coverage of the python code (`regex.py`), since it is always the same for`regex.match` method call.\n",
    "\n",
    "Coverage data for Python (i.e. `_regex_core.py`) were obtained using a python utility for measuring code coverage of Python programs called [Coverage.py](https://coverage.readthedocs.io/en/v4.5.x/), version 4.5.2. Confirm your Coverage.py version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coverage.py, version 4.5.2 with C extension\r\n",
      "Documentation at https://coverage.readthedocs.io\r\n"
     ]
    }
   ],
   "source": [
    "!coverage --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coverage data for the C extensions of regex (i.e. _regex.c  and _regex_unicode.c) were obtained using the python utility for GNU gcov utility [Gcovr](https://gcovr.com/), version 4.1. You can confirm your Gcovr version using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gcovr 4.1\r\n",
      "\r\n",
      "Copyright 2013-2018 the gcovr authors\r\n",
      "Copyright 2013 Sandia Corporation\r\n",
      "Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,\r\n",
      "the U.S. Government retains certain rights in this software.\r\n"
     ]
    }
   ],
   "source": [
    "!gcovr --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tips\n",
    "For more information on Python regex matching read the documentation of Python3 [re](https://docs.python.org/3/library/re.html).\n",
    "\n",
    "To test your implementation with sample regex inputs, use the following python libraries that generate matching strings for any regex: [rstr](https://bitbucket.org/leapfrogdevelopment/rstr) & [exrex](https://github.com/asciimoo/exrex)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluation\n",
    "\n",
    "Your generated test inputs will be executed on [the fuzzingbook server](https://fuzzingbook.cispa.saarland/), based on the amount of executed methods and lines of code (LOC). \n",
    "\n",
    "__Note: if you are developing locally, use the source code of version 2018.11.07 of the [regex parser](https://pypi.org/project/regex/), however test on [the fuzzingbook server](https://fuzzingbook.cispa.saarland/) before submission.__\n",
    "    \n",
    "Your implementation will be tested with a _secret_ set of regex, encompassing all previously specified syntax categories.\n",
    "\n",
    "## Grading framework\n",
    "\n",
    "For grading:\n",
    "  * __To pass__, your implementation should automatically construct a grammar for an arbitrary set of regular expressions encompassing the basic syntax in the Regex Specification. __Points__ will be assigned based on the coverage achieved by the generated test inputs.\n",
    "  * __To obtain extra points__, your implementation should support the construction of the grammar for all or some of the complex syntax specification. __Points__ will be assigned based on the number of features you cover, as well as on the coverage achieved by your generated test inputs.\n",
    "  * __Bonus Points__ will be awarded to implementation which support the bonus specification (boundaries).\n",
    "\n",
    "\n",
    "## Auxiliary functions\n",
    "\n",
    "The following functions are available to assist your implementation and tests:\n",
    "\n",
    "### Generating Sample inputs from your grammar\n",
    "\n",
    "Using the GrammarCoverageFuzzer, produce unique set of inputs from your grammar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from GrammarCoverageFuzzer import GrammarCoverageFuzzer\n",
    "from Grammars import is_valid_grammar, def_used_nonterminals\n",
    "import random, time\n",
    "\n",
    "def generate_inputs(grammar):\n",
    "    assert is_valid_grammar(grammar)\n",
    "    start_seed, end_seed = 2000, 2005\n",
    "    inputs = []\n",
    "    for seed in range(start_seed, end_seed):\n",
    "        random.seed(seed)\n",
    "        f = GrammarCoverageFuzzer(grammar)\n",
    "        #time_spent < 3 hrs = 10800 sec\n",
    "        start_time = time.time()\n",
    "        time_spent = 0\n",
    "        while (time_spent <= 10800) and (len(inputs) <= 1000) and (len(f.max_expansion_coverage() - f.expansion_coverage()) > 0):\n",
    "            inputs.append(f.fuzz())\n",
    "            end_time = time.time()\n",
    "            time_spent = end_time - start_time\n",
    "\n",
    "    #print(\"set(inputs): \", set(inputs))\n",
    "    return set(inputs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ensuring all inputs are valid\n",
    "\n",
    "Your grammar should produce __only__ valid inputs. To ensure that all inputs your grammar can produce are valid you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ensure_all_valid(pattern, inputs):\n",
    "    valid = True\n",
    "    res = [[inp, regex.match(pattern, inp) != None] for inp in inputs]\n",
    "    \n",
    "    failures = list(filter(lambda x: not x[1], res))\n",
    "    \n",
    "    if len(failures) > 0:\n",
    "        #raise ValueError(\"Invalid inputs: \" + str([x[0] for x in failures]))\n",
    "        valid = False\n",
    "\n",
    "    return valid\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python: Obtaining code coverage for an input\n",
    "\n",
    "You can use the `run_with_py_coverage` function to obtain the python code covered by each input generated by your grammar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from coverage import Coverage\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_with_py_coverage(pattern, inp):\n",
    "    cwd = os.getcwd()\n",
    "    if cwd.split(\"/\")[-2] != \"data\" and cwd.split(\"/\")[-1] != \"regex\": \n",
    "        target_dir = os.path.join(cwd,\"data\", \"regex\")\n",
    "    else: \n",
    "        target_dir = cwd\n",
    "    os.chdir(target_dir)\n",
    "    \n",
    "    regex._cache = {}\n",
    "    cov = Coverage(include=[\"*.py\"])\n",
    "    cov.start()\n",
    "    regex.match(pattern, str(inp))\n",
    "    cov.stop()\n",
    "    cov.save()\n",
    "    results = cov.analysis2(\"regex_3/_regex_core.py\")\n",
    "    covered = set(results[1]) - set(results[3])\n",
    "\n",
    "    os.chdir(cwd)\n",
    "    return covered, len(set(results[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### C Extensions: Obtaining code coverage for an input\n",
    "We implement helper function to execute bash commands:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess\n",
    "\n",
    "def execute_bash_command(command):\n",
    "    process = subprocess.Popen(command, shell=True,\n",
    "                       stdout=subprocess.PIPE, \n",
    "                       stderr=subprocess.PIPE)\n",
    "    out, error = process.communicate()\n",
    "    error = error.decode(\"utf-8\").strip() \n",
    "    if error:\n",
    "        raise ValueError(\"bash command error: '{0}',\\n during execution of command: \\n '{1}': \".format(error, command ))\n",
    "    res = out.decode(\"utf-8\").strip()\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We implement the function `replace_all_special_chars()` to escape all special chars in bash command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_all_special_chars(inp):\n",
    "    #print(\"inp: \", inp)\n",
    "    special_char_repl = {\"\\\\\": \"\\\\\\\\\\\\\\\\\", \"\\n\": \"\\\\\\n\", \"\\r\": \"\\\\\\r\", \\\n",
    "                         \"\\'\": \"\\\\\\'\", '\"':'\\\\\"', '`':'\\\\`'}\n",
    "    #\"\\\\\": \"\\\\\\\\\\\\\"\n",
    "\n",
    "    for key in special_char_repl:\n",
    "        inp = inp.replace(key, special_char_repl[key])\n",
    "    #print(\"replaced inp: \", inp)\n",
    "    return inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We implement the function `run_with_c_coverage()` to obtain coverage for the C classes in the regex module. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "def run_with_c_coverage(pattern, inp):\n",
    "    cwd = os.getcwd()\n",
    "    if cwd.split(\"/\")[-2] != \"data\" and cwd.split(\"/\")[-1] != \"regex\":\n",
    "        target_dir = os.path.join(cwd , \"data\", \"regex\")\n",
    "    else: \n",
    "        target_dir = cwd\n",
    "    if os.getcwd() != target_dir and os.path.isdir(target_dir):\n",
    "        os.chdir(target_dir)        \n",
    "    \n",
    "    #remove old build\n",
    "    build_dir = os.path.join(os.getcwd(), \"build\")\n",
    "    if os.path.isdir(build_dir):\n",
    "        rm_command = \"rm -r \" + build_dir \n",
    "        execute_bash_command(rm_command)\n",
    "        \n",
    "    #re-build regex \n",
    "    c_flags = 'CFLAGS=\"-fprofile-arcs -ftest-coverage -fPIC -g -O0\" ' \n",
    "    build_instr = 'python setup.py build_ext --inplace > /dev/null'\n",
    "    build_command = c_flags + build_instr\n",
    "    execute_bash_command(build_command)\n",
    "\n",
    "    #run regex match test\n",
    "    run_test_command = \"\"\"python -c \"from regex_3 import _regex_core;\\\n",
    "                        from regex_3 import regex;pattern = '{0}'; inp = '{1}';\\\n",
    "                        regex._cache = {{}}; regex.match(pattern, str(inp))\" \"\"\".\\\n",
    "                        format(pattern, replace_all_special_chars(inp))\n",
    "\n",
    "    execute_bash_command(run_test_command) \n",
    "\n",
    "    #obtain coverage of c extensions\n",
    "    gcovr_instr = 'gcovr -r . '\n",
    "    grep_TOTAL =  'grep -n \"TOTAL\" '\n",
    "    c_cov_command = gcovr_instr + \"| \" + grep_TOTAL \n",
    "    cov_out = execute_bash_command(c_cov_command) \n",
    "    coverage = cov_out.split()[2]\n",
    "    percent_coverage = cov_out.split()[3]\n",
    "\n",
    "    os.chdir(cwd)\n",
    "    return coverage, percent_coverage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtain both Python and C coverage for a population of inputs \n",
    "For all your inputs, use `population_coverage` to obtain the overall cummulative coverage of Python code and the maximum coverage for C Code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def population_coverage(pattern, population):\n",
    "    py_all_coverage = set()\n",
    "    c_max_coverage = 0\n",
    "    c_max_percent = 0\n",
    "    py_max_percent = \"\"\n",
    "\n",
    "    for inp in population:\n",
    "        #obtain all covered LOC for Python code\n",
    "        py_covered, py_length = run_with_py_coverage(pattern, inp)\n",
    "        py_all_coverage |= py_covered\n",
    "\n",
    "        #obtain max coverage for C code\n",
    "        c_covered, percent_covered = run_with_c_coverage(pattern, inp)\n",
    "        if c_max_coverage < int(c_covered):\n",
    "            c_max_coverage = int(c_covered)\n",
    "            c_max_percent = percent_covered\n",
    "    \n",
    "    py_max_percent = str(int(len(py_all_coverage)/py_length * 100)) + \"%\"\n",
    "        \n",
    "    return len(py_all_coverage), c_max_coverage, py_max_percent, c_max_percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your code\n",
    "Write your code here to create a grammar out of an arbitrary regular expression. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation code\n",
    "\n",
    "The following code will be used to run your evaluation.\n",
    "\n",
    "__Note that the set of regular expression which will be used for evaluation may be different from those provided as example.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "old_simple = [[r'^ab$', 241, 988], [r'b$', 170, 949],[r'ab*$', 207, 1142],\\\n",
    "                       [r'a|b$',308, 1024], [r'a(b|c)$', 321, 1198], [r'(a|b)\\s$',334, 1131],\\\n",
    "                       [r'^a*(b+|c)d?$', 413, 1442],[r'^a*(b+|c)d?\\se$', 455, 1632],\\\n",
    "                       [r'^a+(b*|c)d?\\se$',426, 1564]]\n",
    "\n",
    "new_simple =[[r'^\\s+$', 278, 1099],[r'^$', 157, 820], [r'/b(a|e|i|o|u)t/', 303, 1171], [r'^The$', 241, 988], \\\n",
    "             [r'of despair$', 170, 998], [r'^abc$', 241, 988], [r'grammar$', 170, 999], [r'hi|hello$', 272, 1088], \\\n",
    "             [r'ab+$', 207, 1153], [r'ab?$', 207, 1140], [r'a?b+$', 284, 1202],  [r'(b|cd)ef$', 389, 1294], \\\n",
    "             [r'a(bc)*$', 273, 1439], [r'(a|b)*c$', 398, 1482]]\n",
    "\n",
    "simple_regex = old_simple + new_simple\n",
    "\n",
    "old_complex = [[r'^[0-9]+\\s[a-z]*\\s?[A-Z]+$', 303, 1228],\\\n",
    "                       [r'\\w$', 169, 878], [r'\\d$', 169, 875], [r'(a|b){2,5}$', 401, 1380],\\\n",
    "                       [r'[0-9a-zA-Z]$', 252, 902], [r'[0-9]$', 222, 852], [r'[a-z]$', 222, 852],\\\n",
    "                       [r'[^a-zA-Z]', 213, 879], [r'[^0-9]', 178, 825],\\\n",
    "                       [r'\\D$', 168, 877], [r'\\W$', 122, 852] , [r'\\S$', 122, 852],\\\n",
    "                       [r'[a-zA-Z]\\s\\w+\\s\\d\\s$', 324, 1295], [r'a(bc){2,5}$', 297, 1472]]\n",
    "\n",
    "new_complex = [[r'(</?(\\w|\\s)*>|<.+\\W>)$', 423, 1752], [r'\\d{2}[ ]?\\d{3}$', 356, 1100], \\\n",
    "               [r'\\d{3}-\\d{4}$', 330, 1173], [r'[ABCEGHJKLMNPRSTVXY]\\d[ABCEGHJ-NPRSTV-Z][ ]?\\d[ABCEGHJ-NPRSTV-Z]\\d$', 342, 1160], \\\n",
    "               [r'\\d{5}([ -]\\d{4})?$', 430, 1470], [r'\\d{5}$', 299, 1072], [r'(/[*]+)((\\w| )*)([*]+/)$', 424, 1637], \\\n",
    "               [r'^((\\w| )+)/([^/]+)$', 473, 1618], [r'^[A-PR-WY][1-9]\\d\\s?\\d{4}[1-9]$', 390, 1201], \\\n",
    "               [r'(^\\d{5}(-\\d{4})?)|(^[ABCEGHJKLMNPRSTVXY]{1}\\d{1}[A-Z]{1} *\\d{1}[A-Z]{1}\\d{1})$', 524, 1587], \\\n",
    "               [r'^([1-9]|0[1-9]|[12][0-9]|3[01])\\D([1-9]|0[1-9]|1[012])\\D(19[0-9][0-9]|20[0-9][0-9])$', 455, 1366], \\\n",
    "               [r'^3[47][0-9]{13}$', 375, 1244], [r'^(\\w|,|\\s|-)+[.][A-Za-z]{3}$', 520, 1673], \\\n",
    "               [r'^([a-z][a-z0-9-]+([.]|-*[.]))+[a-z]{2,6}$', 494, 1763], \\\n",
    "               [r'^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$', 530, 1891], \\\n",
    "               [r'^(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])[.](\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]){3}$', 487, 1723], \\\n",
    "               [r'^((\\w| )*[a-z])((\\w| )*[A-Z])((\\w| )*\\d)(\\w| ){6,12}$', 482, 1640], [r'^[a-z0-9_-]{6,18}$', 361, 1149], \\\n",
    "               [r'^([a-z0-9_.+-]+)@([0-9a-z.-]+)[.]([a-z.]{2,6})$', 444, 1571], [r'^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+[.][a-zA-Z]{2,6})*$', 431, 1670], \\\n",
    "               [r'^([a-z0-9_.-]+)@([0-9a-z.-]+)[.]([a-z.]{2,6})$', 444, 1571],[r'^[a-z0-9_-]{3,16}$', 361, 1149], \\\n",
    "               [r'^(19|20)\\d{2}$', 465, 1415],[r'^[+]?([0-9]|\\s)+[(]?([0-9]|\\s){10,}$', 475, 1697], \\\n",
    "               [r'^[+]?([0-9]|\\s){3,}$', 475, 1638],[r'^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$', 401, 1324], \\\n",
    "               [r'^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$', 496, 1468],[r'^#?([a-f0-9]{6}|[a-f0-9]{3})$', 496, 1468], \\\n",
    "               [r'^[a-z0-9-]+$', 336, 1147], [r'^[+-<>., ]+$', 336, 1151],  \\\n",
    "               [r'^([01]?[0-9]|2[0-3]):[0-5][0-9]$', 462, 1584],[r'^(0?[1-9]|[12][0-9]|3[01])([ /-])(0?[1-9]|1[012])2([0-9][0-9][0-9][0-9])(([ -])([0-1]?[0-9]|2[0-3]):[0-5]?[0-9]:[0-5]?[0-9])?$', 465, 1786], \\\n",
    "               [r'^-?\\d*([.]\\d+)?$', 364, 1451], [r'^\\d*([.]\\d+)?$', 363, 1430], [r'^\\d*[.]\\d+$', 359, 1241], \\\n",
    "               [r'^-?\\d*[.]?\\d+$', 353, 1284], [r'^-\\d*[.]?\\d+$', 331, 1310],[r'^\\d*[.]?\\d+$', 352, 1262], \\\n",
    "               [r'^(\\w| )+[.](png|jpg|jpeg|gif|webp)$', 501, 1639],[r'[-]?[0-9]+[,.]?[0-9]*([/][0-9]+[,.]?[0-9]*)*$', 394, 1549], \\\n",
    "               [r'^-?\\d+$', 317, 1161], [r'^-\\d+$', 294, 1189], [r'^\\d+$', 278, 1097] , [r'^([0-9]{3}|)$', 0, 0]              \n",
    "              ]\n",
    "\n",
    "\n",
    "complex_regex = old_complex + new_complex\n",
    "\n",
    "old_bonus = [[r'\\babc\\b$', 258, 865], [r'abc\\B', 177, 987], [r'\\babc\\B', 247, 928]]\n",
    "new_bonus = [[r'\\b\\d{13,16}\\b$', 303, 1063],[r'\\bon\\w+=\\S+((\\w| )*>)$', 436, 1263]]\n",
    "bonus_regex = old_bonus + new_bonus\n",
    "\n",
    "\n",
    "old_secret_set_of_regex = old_simple + old_complex + old_bonus\n",
    "new_secret_set_of_regex = new_simple + new_complex + new_bonus\n",
    "\n",
    "\n",
    "\n",
    "secret_set_of_regex = old_secret_set_of_regex + new_secret_set_of_regex \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "from multiprocessing import Process\n",
    "import traceback\n",
    "\n",
    "def run_with_limited_time(func, args, kwargs, time):\n",
    "    p = Process(target=func, args=args, kwargs=kwargs)\n",
    "    p.start()\n",
    "    p.join(time)\n",
    "    if p.is_alive():\n",
    "        p.terminate()\n",
    "        return False\n",
    "\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "to_process = []\n",
    "for pattern, py_min_coverage, c_min_coverage in secret_set_of_regex:\n",
    "    try:\n",
    "        if run_with_limited_time(regex_to_CFG, (pattern,), {}, 60):\n",
    "            grammar = regex_to_CFG(pattern)\n",
    "            to_process.append([pattern, py_min_coverage, c_min_coverage, grammar])\n",
    "    except Exception as e:\n",
    "        e.__traceback__ = None\n",
    "        traceback.clear_frames(e.__traceback__)\n",
    "        pass\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each regex will be evaluated individually, against a minimum precomputed coverage.\n",
    "Plot coverage result and indicate errors.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def evaluate(grammar, pattern, py_min_coverage, c_min_coverage):\n",
    "    py_all_coverage, c_max_coverage = 0, 0\n",
    "    py_percent, c_percent = \"0\", \"0\"\n",
    "    \n",
    "    try:\n",
    "        inputs = generate_inputs(grammar)\n",
    "        if ensure_all_valid(pattern, inputs):\n",
    "            py_all_coverage, c_max_coverage,  py_percent, c_percent = population_coverage(pattern, inputs)    \n",
    "    except Exception as e:\n",
    "        e.__traceback__ = None\n",
    "        traceback.clear_frames(e.__traceback__)\n",
    "        pass\n",
    "    \n",
    "    return py_all_coverage >= py_min_coverage and c_max_coverage >= c_min_coverage, py_all_coverage, c_max_coverage, py_percent, c_percent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot coverage result and indicate errors.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_bar_chart(py_cov_tuple, c_cov_tuple,  py_err, c_err, num_grammars):\n",
    "    \n",
    "    fig, ax = plt.subplots(figsize=(20,10))\n",
    "    index = np.arange(num_grammars)\n",
    "    bar_width = 0.4\n",
    "    opacity = 0.4\n",
    "    error_config = {'ecolor': '0.3'}\n",
    "\n",
    "    rects1 = ax.bar(index, py_cov_tuple, bar_width,\n",
    "                    alpha=opacity, color='b', yerr=py_err,\n",
    "                    error_kw=error_config,\n",
    "                    label='Python Code')\n",
    "\n",
    "    rects2 = ax.bar(index + bar_width, c_cov_tuple, bar_width,\n",
    "                    alpha=opacity, color='r', yerr=c_err,\n",
    "                    error_kw=error_config,\n",
    "                    label='C Code')\n",
    "\n",
    "    ax.set_xlabel('Regex')\n",
    "    ax.set_ylabel('Coverage (LOC)')\n",
    "    ax.set_title('Coverage of Regex by Language (Python & C)')\n",
    "    ax.set_xticks(index + bar_width / 2)\n",
    "    ax.set_xticklabels(tuple([str(y) for y in tuple(range(1, len(secret_set_of_regex) + 1))]))\n",
    "    ax.legend()\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final result will be computed accordingly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_results():\n",
    "    overall_result, py_cov_list, c_cov_list, py_err, c_err, evaluation_list, failed_regexes = [], [], [], [], [], [], []\n",
    "    \n",
    "    dash = '-' * 98\n",
    "    print(dash)\n",
    "    print('{:<28s}{:>12s}{:>12s}{:>12s}{:>12s}{:>18s}'.format(\"Pattern\", \"Py_cov (LOC)\", \"Py_cov (%)\", \"C_cov (LOC)\", \"C_cov (%)\", \"Pass(1)/Fail(0)\"))\n",
    "    print(dash)\n",
    "\n",
    "    passed_regexes = set()\n",
    "    \n",
    "    for pattern, py_min_coverage, c_min_coverage, grammar in to_process:    \n",
    "        evaluation_result, py_all_coverage, c_max_coverage, py_percent, c_percent = evaluate(grammar, pattern, py_min_coverage, c_min_coverage)\n",
    "\n",
    "        py_cov_list.append(py_all_coverage)\n",
    "        c_cov_list.append(c_max_coverage)\n",
    "        evaluation_list.append(evaluation_result)\n",
    "        if py_all_coverage < py_min_coverage:\n",
    "            py_err.append((py_all_coverage - py_min_coverage ))\n",
    "            failed_regexes.append([pattern, \"Py\"])\n",
    "        else:\n",
    "            py_err.append(0)\n",
    "        if c_max_coverage < c_min_coverage:\n",
    "            c_err.append((c_max_coverage - c_min_coverage ))\n",
    "            failed_regexes.append([pattern, \"C\"])\n",
    "        else:\n",
    "            c_err.append(0)\n",
    "            \n",
    "        if py_all_coverage >= py_min_coverage and c_max_coverage >= c_min_coverage:\n",
    "            passed_regexes.add(pattern)\n",
    "\n",
    "        print('{:<28s}{:>12d}{:>12s}{:>12d}{:>12s}{:>12b}'.format(pattern, py_all_coverage, py_percent, c_max_coverage, c_percent, c_max_coverage >= c_min_coverage and  py_all_coverage >= py_min_coverage))\n",
    "\n",
    "        overall_result.append([pattern, evaluation_result])\n",
    "\n",
    "    plot_bar_chart(tuple(py_cov_list), tuple(c_cov_list), tuple(py_err), tuple(c_err), len(to_process))\n",
    "    score = sum(evaluation_list)\n",
    "    print(\"Score: {0}/{1}\\nScore Percentage: {2}%\".format(score,len(secret_set_of_regex), ((score*100)/len(secret_set_of_regex))))\n",
    "    if failed_regexes:\n",
    "        print(\"The following regexes failed the coverage baseline: \", failed_regexes)\n",
    "    \n",
    "    return failed_regexes, passed_regexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------------------------\n",
      "Pattern                     Py_cov (LOC)  Py_cov (%) C_cov (LOC)   C_cov (%)   Pass(1)/Fail(0)\n",
      "--------------------------------------------------------------------------------------------------\n",
      "^ab$                                 241          8%         988          7%           1\n",
      "b$                                   170          6%         949          6%           1\n",
      "ab*$                                 207          7%        1142          8%           1\n",
      "a|b$                                 308         11%        1024          7%           1\n",
      "a(b|c)$                              321         11%        1198          8%           1\n",
      "(a|b)\\s$                             334         12%        1131          8%           1\n",
      "^a*(b+|c)d?$                         413         15%        1442         10%           1\n",
      "^a*(b+|c)d?\\se$                      455         16%        1633         11%           1\n",
      "^a+(b*|c)d?\\se$                      426         15%        1564         11%           1\n",
      "^[0-9]+\\s[a-z]*\\s?[A-Z]+$            303         11%        1228          9%           1\n",
      "\\w$                                  169          6%         878          6%           1\n",
      "\\d$                                  169          6%         875          6%           1\n",
      "(a|b){2,5}$                          401         14%        1380         10%           1\n",
      "[0-9]$                               222          8%         852          6%           1\n",
      "[a-z]$                               222          8%         852          6%           1\n",
      "[^a-zA-Z]                            213          7%         879          6%           1\n",
      "[^0-9]                               178          6%         825          6%           1\n",
      "\\D$                                  168          6%         877          6%           1\n",
      "\\W$                                  168          6%         879          6%           1\n",
      "\\S$                                  168          6%         879          6%           1\n",
      "[a-zA-Z]\\s\\w+\\s\\d\\s$                 324         11%        1295          9%           1\n",
      "a(bc){2,5}$                          297         10%        1472         10%           1\n",
      "\\babc\\b$                             258          9%         865          6%           1\n",
      "abc\\B                                177          6%         987          7%           1\n",
      "\\babc\\B                              247          9%         928          6%           1\n",
      "^\\s+$                                278         10%        1099          8%           1\n",
      "^$                                   157          5%         820          6%           1\n",
      "/b(a|e|i|o|u)t/                      303         11%        1171          8%           1\n",
      "^The$                                241          8%         988          7%           1\n",
      "of despair$                          170          6%         998          7%           1\n",
      "^abc$                                241          8%         988          7%           1\n",
      "grammar$                             170          6%         999          7%           1\n",
      "hi|hello$                            272          9%        1088          8%           1\n",
      "ab+$                                 207          7%        1153          8%           1\n",
      "ab?$                                 207          7%        1140          8%           1\n",
      "a?b+$                                284         10%        1202          8%           1\n",
      "(b|cd)ef$                            389         14%        1294          9%           1\n",
      "a(bc)*$                              273          9%        1439         10%           1\n",
      "(a|b)*c$                             398         14%        1482         10%           1\n",
      "(</?(\\w|\\s)*>|<.+\\W>)$               423         15%        1752         12%           1\n",
      "\\d{2}[ ]?\\d{3}$                      356         12%        1100          8%           1\n",
      "\\d{3}-\\d{4}$                         330         12%        1173          8%           1\n",
      "[ABCEGHJKLMNPRSTVXY]\\d[ABCEGHJ-NPRSTV-Z][ ]?\\d[ABCEGHJ-NPRSTV-Z]\\d$         342         12%        1160          8%           1\n",
      "\\d{5}([ -]\\d{4})?$                   430         15%        1470         10%           1\n",
      "\\d{5}$                               299         10%        1072          7%           1\n",
      "(/[*]+)((\\w| )*)([*]+/)$             424         15%        1637         12%           1\n",
      "^((\\w| )+)/([^/]+)$                  473         17%        1618         11%           1\n",
      "^[A-PR-WY][1-9]\\d\\s?\\d{4}[1-9]$         390         14%        1201          8%           1\n",
      "(^\\d{5}(-\\d{4})?)|(^[ABCEGHJKLMNPRSTVXY]{1}\\d{1}[A-Z]{1} *\\d{1}[A-Z]{1}\\d{1})$         524         19%        1587         11%           1\n",
      "^([1-9]|0[1-9]|[12][0-9]|3[01])\\D([1-9]|0[1-9]|1[012])\\D(19[0-9][0-9]|20[0-9][0-9])$         455         16%        1366         10%           1\n",
      "^3[47][0-9]{13}$                     375         13%        1244          9%           1\n",
      "^(\\w|,|\\s|-)+[.][A-Za-z]{3}$         520         18%        1673         12%           1\n",
      "^([a-z][a-z0-9-]+([.]|-*[.]))+[a-z]{2,6}$         494         18%        1763         12%           1\n",
      "^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$           0           0           0           0           0\n",
      "^(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])[.](\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]){3}$         487         17%        1723         12%           1\n",
      "^((\\w| )*[a-z])((\\w| )*[A-Z])((\\w| )*\\d)(\\w| ){6,12}$         482         17%        1640         12%           1\n",
      "^[a-z0-9_-]{6,18}$                   361         13%        1149          8%           1\n",
      "^([a-z0-9_.+-]+)@([0-9a-z.-]+)[.]([a-z.]{2,6})$         444         16%        1571         11%           1\n",
      "^([a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+[.][a-zA-Z]{2,6})*$         431         15%        1670         12%           1\n",
      "^([a-z0-9_.-]+)@([0-9a-z.-]+)[.]([a-z.]{2,6})$         444         16%        1571         11%           1\n",
      "^[a-z0-9_-]{3,16}$                   361         13%        1149          8%           1\n",
      "^(19|20)\\d{2}$                       465         16%        1415         10%           1\n",
      "^[+]?([0-9]|\\s)+[(]?([0-9]|\\s){10,}$           0           0           0           0           0\n",
      "^[+]?([0-9]|\\s){3,}$                   0           0           0           0           0\n",
      "^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$         401         14%        1324          9%           1\n",
      "^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$         496         18%        1468         10%           1\n",
      "^#?([a-f0-9]{6}|[a-f0-9]{3})$         496         18%        1468         10%           1\n",
      "^[+-<>., ]+$                         336         12%        1151          8%           1\n",
      "^([01]?[0-9]|2[0-3]):[0-5][0-9]$         462         16%        1513         11%           0\n",
      "^(0?[1-9]|[12][0-9]|3[01])([ /-])(0?[1-9]|1[012])2([0-9][0-9][0-9][0-9])(([ -])([0-1]?[0-9]|2[0-3]):[0-5]?[0-9]:[0-5]?[0-9])?$         465         16%        1786         13%           1\n",
      "^-?\\d*([.]\\d+)?$                     364         13%        1451         10%           1\n",
      "^\\d*([.]\\d+)?$                       363         13%        1430         10%           1\n",
      "^\\d*[.]\\d+$                          359         13%        1241          9%           1\n",
      "^-?\\d*[.]?\\d+$                       353         12%        1284          9%           1\n",
      "^-\\d*[.]?\\d+$                        331         12%        1302          9%           0\n",
      "^\\d*[.]?\\d+$                         352         12%        1262          9%           1\n",
      "^(\\w| )+[.](png|jpg|jpeg|gif|webp)$         501         18%        1639         12%           1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-]?[0-9]+[,.]?[0-9]*([/][0-9]+[,.]?[0-9]*)*$         394         14%        1549         11%           1\n",
      "^-?\\d+$                              317         11%        1161          8%           1\n",
      "^-\\d+$                               294         10%        1189          8%           1\n",
      "^\\d+$                                278         10%        1097          8%           1\n",
      "^([0-9]{3}|)$                        412         15%        1334          9%           1\n",
      "\\b\\d{13,16}\\b$                       303         11%        1063          7%           1\n",
      "\\bon\\w+=\\S+((\\w| )*>)$               436         15%        1263          9%           1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 81/86\n",
      "Score Percentage: 94.18604651162791%\n",
      "The following regexes failed the coverage baseline:  [['^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$', 'Py'], ['^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$', 'C'], ['^[+]?([0-9]|\\\\s)+[(]?([0-9]|\\\\s){10,}$', 'Py'], ['^[+]?([0-9]|\\\\s)+[(]?([0-9]|\\\\s){10,}$', 'C'], ['^[+]?([0-9]|\\\\s){3,}$', 'Py'], ['^[+]?([0-9]|\\\\s){3,}$', 'C'], ['^([01]?[0-9]|2[0-3]):[0-5][0-9]$', 'C'], ['^-\\\\d*[.]?\\\\d+$', 'C']]\n"
     ]
    }
   ],
   "source": [
    "failed_regex, passed_regex = compute_results()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detailed report of the implementation's score for each category:\n",
      "\tSimple Regex: 23/23\n",
      "\tComplex Regex: 53/58\n",
      "\tBonus Regex: 5/5\n"
     ]
    }
   ],
   "source": [
    "total_simple = len(simple_regex)\n",
    "total_complex = len(complex_regex)\n",
    "total_bonus = len(bonus_regex)\n",
    "\n",
    "num_passed_simple, num_passed_complex, num_passed_bonus = 0,0,0\n",
    "\n",
    "def getRegexPatterns(eval_regex):\n",
    "    res = set()\n",
    "    for elem in eval_regex:\n",
    "        res.add(str(elem[0]))\n",
    "    return res\n",
    "\n",
    "simple_patterns = getRegexPatterns(simple_regex)\n",
    "complex_patterns = getRegexPatterns(complex_regex)\n",
    "bonus_patterns = getRegexPatterns(bonus_regex)\n",
    "\n",
    "for item in passed_regex:\n",
    "    if item in simple_patterns:\n",
    "        num_passed_simple += 1\n",
    "        continue\n",
    "    if item in complex_patterns:\n",
    "        num_passed_complex += 1\n",
    "        continue\n",
    "    if item in bonus_patterns:\n",
    "        num_passed_bonus += 1\n",
    "        continue\n",
    "            \n",
    "print(\"Detailed report of the implementation's score for each category:\")\n",
    "print(\"\\tSimple Regex: {0}/{1}\".format(num_passed_simple, total_simple))\n",
    "print(\"\\tComplex Regex: {0}/{1}\".format(num_passed_complex, total_complex))\n",
    "print(\"\\tBonus Regex: {0}/{1}\".format(num_passed_bonus, total_bonus))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "failed_regex:  {'^-\\\\d*[.]?\\\\d+$', '^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])[.]){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$', '^([01]?[0-9]|2[0-3]):[0-5][0-9]$', '^[+]?([0-9]|\\\\s)+[(]?([0-9]|\\\\s){10,}$', '^[+]?([0-9]|\\\\s){3,}$'}\n"
     ]
    }
   ],
   "source": [
    "print(\"failed_regex: \", getRegexPatterns(failed_regex))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set_unattempted_regex:  set()\n"
     ]
    }
   ],
   "source": [
    "set_unattempted_regex = getRegexPatterns(secret_set_of_regex) - getRegexPatterns(failed_regex) - passed_regex\n",
    "print(\"set_unattempted_regex: \", set_unattempted_regex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# failed_regex:  5\n",
      "# set_unattempted_regex:  0\n"
     ]
    }
   ],
   "source": [
    "print(\"# failed_regex: \", len(getRegexPatterns(failed_regex)))\n",
    "print(\"# set_unattempted_regex: \", len(set_unattempted_regex))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "178px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}