Relational Model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Relational Model in Python\n",
    "\n",
    "Copyright Jens Dittrich & Marcel Maltry, [Big Data Analytics Group](https://bigdata.uni-saarland.de/), [CC-BY-SA](https://creativecommons.org/licenses/by-sa/4.0/legalcode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ra.utils import load_csv\n",
    "from ra.relation import Relation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `Relation` class\n",
    "\n",
    "The class `Relation` is implemented in `ra.relation` and implements the following methods:\n",
    "\n",
    "* `add_tuple(tup)`: Adds the tuple `tup` if the tuple's schema is valid.\n",
    "* Several print methods that are showcased below for the IMDb dataset.\n",
    "\n",
    "**Remember:** Neither the order of rows nor the order of columns carry any meaning in a relation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "---\n",
       "\u001b[1mfoo\u001b[0m \n",
       "--------------\n",
       "\u001b[1mid     name   \u001b[0m \n",
       "--------------\n",
       "7      World  \n",
       "1      !      \n",
       "2      Hello  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = Relation('foo', [('id', int), ('name', str)])\n",
    "foo.add_tuple( (2,'Hello') )\n",
    "foo.add_tuple( (7,'World') )\n",
    "foo.add_tuple( (1,'!') )\n",
    "\n",
    "foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IMDb\n",
    "\n",
    "In the following, we will introduce `Relation`'s `print` methods. We use the IMDb dataset that was introduced in the lecture. We first have to import the data from csv files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of csv files: ['movies_directors.csv', 'actors.csv', 'directors.csv', 'movies_genres.csv', 'directors_genres.csv', 'movies.csv', 'roles.csv']\n"
     ]
    }
   ],
   "source": [
    "from os import listdir\n",
    "\n",
    "# Data source: https://relational.fit.cvut.cz/dataset/IMDb\n",
    "# Information courtesy of IMDb (http://www.imdb.com). Used with permission.\n",
    "#\n",
    "# Notice: The data can only be used for personal and non-commercial use and must not\n",
    "# be altered/republished/resold/repurposed to create any kind of online/offline\n",
    "# database of movie information (except for individual personal use).\n",
    "\n",
    "path = 'data/IMDb_sample'  \n",
    "# create a list of all files in that directory that end with \"*.csv\":\n",
    "files = [file for file in listdir(path) if file.endswith('.csv')]\n",
    "print(f'List of csv files: {files}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading movies_directors.csv ...\n",
      "Reading actors.csv ...\n",
      "Reading directors.csv ...\n",
      "Reading movies_genres.csv ...\n",
      "Reading directors_genres.csv ...\n",
      "Reading movies.csv ...\n",
      "Reading roles.csv ...\n"
     ]
    }
   ],
   "source": [
    "# load all relations from csv files\n",
    "relations = list()\n",
    "for file in files:\n",
    "    print(\"Reading {} ...\".format(file))  # print currently parsed file\n",
    "    filepath = path + '/' + file  # preappend file name by path\n",
    "    name = file[:-4]  # removes .csv file ending and takes filename as relation name\n",
    "    relation = load_csv(filepath, name, delimiter='\\t')\n",
    "    relations.append(relation)\n",
    "\n",
    "# add relations into a dictionary such that they can be accessed by their name\n",
    "relations_dict = {}\n",
    "for rel in relations:\n",
    "    relations_dict[rel.name] = rel\n",
    "    # in addition, create a separate variable name for each relation:\n",
    "    globals()[rel.name] = rel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "------\n",
       "\u001b[1mactors\u001b[0m \n",
       "--------------------------------------------------------------------------------------------\n",
       "\u001b[1mid                     first_name             last_name              gender                 \u001b[0m \n",
       "--------------------------------------------------------------------------------------------\n",
       "717432                 Lana                   McKissack              F                      \n",
       "621910                 Bridget                Fonda                  F                      \n",
       "490228                 David (I)              Vaughan                M                      \n",
       "209799                 Adolf                  Hitler                 M                      \n",
       "661430                 Elizabeth              Inglis                 F                      \n",
       "510502                 Shane                  Wilder                 M                      \n",
       "773658                 Rochelle               Rose                   F                      \n",
       "259066                 Stanley                Kubrick                M                      \n",
       "198687                 Bob (II)               Hart                   M                      \n",
       "513249                 John (V)               Wilson                 M                      \n",
       "\n",
       "WARNING: skipping 1081 out of 1091 tuples..."
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now each relation has become a global variable:\n",
    "actors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "---------\n",
       "\u001b[1mdirectors\u001b[0m \n",
       "------------------------------------\n",
       "\u001b[1mid          first_name  last_name   \u001b[0m \n",
       "------------------------------------\n",
       "43095       Stanley     Kubrick     \n",
       "11652       James (I)   Cameron     \n",
       "78273       Quentin     Tarantino   "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "directors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like that the schema and the first ten rows are printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you may call `print_table()` directly. Optionally, we can limit the number of rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------\n",
      "\u001b[1mactors\u001b[0m \n",
      "--------------------------------------------------------------------------------------------\n",
      "\u001b[1mid                     first_name             last_name              gender                 \u001b[0m \n",
      "--------------------------------------------------------------------------------------------\n",
      "717432                 Lana                   McKissack              F                      \n",
      "621910                 Bridget                Fonda                  F                      \n",
      "490228                 David (I)              Vaughan                M                      \n",
      "209799                 Adolf                  Hitler                 M                      \n",
      "661430                 Elizabeth              Inglis                 F                      \n",
      "510502                 Shane                  Wilder                 M                      \n",
      "773658                 Rochelle               Rose                   F                      \n",
      "259066                 Stanley                Kubrick                M                      \n",
      "198687                 Bob (II)               Hart                   M                      \n",
      "513249                 John (V)               Wilson                 M                      \n",
      "\n",
      "WARNING: skipping 1081 out of 1091 tuples...\n"
     ]
    }
   ],
   "source": [
    "maxRowsLimit = 10\n",
    "actors.print_table(maxRowsLimit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an alternative, a set representation of the relation can be printed using the `set()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[directors] : {[id:int, first_name:str, last_name:str]}\n",
      "{\n",
      "\t(43095, Stanley, Kubrick),\n",
      "\t(11652, James (I), Cameron),\n",
      "\t(78273, Quentin, Tarantino)\n",
      "\tWARNING: skipping 0 out of 3 tuples...\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "directors.print_set(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a third alternative, a LaTeX representation of the relation can be printed using the `print_latex()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\definecolor{tableheadercolor}{rgb}{0.8,0.8,0.8}\\begin{tabular}{|l|l|l|}\\hline\n",
      "\\multicolumn{3}{|l|}{\\cellcolor{tableheadercolor}{\\textbf{directors}}}\\\\\\hline\n",
      "\t\\cellcolor{tableheadercolor}{\\textbf{id}} & \\cellcolor{tableheadercolor}{\\textbf{first\\textunderscore name}} & \\cellcolor{tableheadercolor}{\\textbf{last\\textunderscore name}} \\\\\n",
      "\t\\hline\\hline\n",
      "\t43095 & Stanley & Kubrick \\\\\n",
      "\t11652 & James (I) & Cameron \\\\\n",
      "\t78273 & Quentin & Tarantino \\\\\n",
      "\\hline\n",
      "\\end{tabular}\n"
     ]
    }
   ],
   "source": [
    "directors.print_latex()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an overview over all relations from the IMDb dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[movies_directors] : {[director_id:int, movie_id:int]}\n",
      "{\n",
      "\t(43095, 121538),\n",
      "\t(78273, 223710),\n",
      "\t(78273, 118367)\n",
      "\tWARNING: skipping 37 out of 40 tuples...\n",
      "}\n",
      "[actors] : {[id:int, first_name:str, last_name:str, gender:str]}\n",
      "{\n",
      "\t(717432, Lana, McKissack, F),\n",
      "\t(621910, Bridget, Fonda, F),\n",
      "\t(490228, David (I), Vaughan, M)\n",
      "\tWARNING: skipping 1088 out of 1091 tuples...\n",
      "}\n",
      "[directors] : {[id:int, first_name:str, last_name:str]}\n",
      "{\n",
      "\t(43095, Stanley, Kubrick),\n",
      "\t(11652, James (I), Cameron),\n",
      "\t(78273, Quentin, Tarantino)\n",
      "\tWARNING: skipping 0 out of 3 tuples...\n",
      "}\n",
      "[movies_genres] : {[movie_id:int, genre:str]}\n",
      "{\n",
      "\t(10934, Documentary),\n",
      "\t(328277, Drama),\n",
      "\t(65764, Drama)\n",
      "\tWARNING: skipping 99 out of 102 tuples...\n",
      "}\n",
      "[directors_genres] : {[director_id:int, genre:str, prob:float]}\n",
      "{\n",
      "\t(43095, Drama, 0.625),\n",
      "\t(78273, Action, 0.5),\n",
      "\t(11652, Adventure, 0.166667)\n",
      "\tWARNING: skipping 32 out of 35 tuples...\n",
      "}\n",
      "[movies] : {[id:int, name:str, year:int, rank:float]}\n",
      "{\n",
      "\t(177019, Killing, The, 1956, 8.1),\n",
      "\t(328277, Terminator 2: Judgment Day, 1991, 8.1),\n",
      "\t(1711, 2001: A Space Odyssey, 1968, 8.3)\n",
      "\tWARNING: skipping 37 out of 40 tuples...\n",
      "}\n",
      "[roles] : {[actor_id:int, movie_id:int, role:str]}\n",
      "{\n",
      "\t(128257, 105938, Karl Kuhn),\n",
      "\t(257870, 322652, Cyberdyne Video Host),\n",
      "\t(363245, 176711, Edgar McGraw)\n",
      "\tWARNING: skipping 1203 out of 1206 tuples...\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "for rel in relations:\n",
    "    rel.print_set(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extend class `Relation` to support keys and check for duplicates of keys when adding tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# upload the contents of this cell to our CMS as a text file\n",
    "\n",
    "# a relation subclass respecting key constraints:\n",
    "class KeyRelation(Relation):\n",
    "    # keys: names of the key attributes as a list\n",
    "    def __init__(self, name, schema, keys):\n",
    "        super().__init__(name, schema)\n",
    "        \n",
    "        # assert that the list of keys is subset-equal self-attributes:\n",
    "        assert set(keys) <= set(self.attributes)\n",
    "        # make sure that at least one key attribute is defined:\n",
    "        assert len(keys) >= 1\n",
    "        \n",
    "        # add your code here!\n",
    "        # ...\n",
    "        # initialize data structures that are required\n",
    "        # to check the key constraint for new tuples\n",
    "        pass\n",
    "        \n",
    "    def add_tuple(self, tup):\n",
    "        # add your code here!\n",
    "        # ...\n",
    "        # check if there is a tuple with the same key in the relation\n",
    "        # only insert it using super().add_tuple(tup) if there is not.\n",
    "        # raise a ValueError if the key is already present.\n",
    "        # Make sure to perform your check in O(1) time!\n",
    "        pass\n",
    "        \n",
    "    def print_schema(self):\n",
    "        super().print_schema()\n",
    "        # add your code here!\n",
    "        # ...\n",
    "        # should also print the key attributes\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unit Test for Relation\n",
    "\n",
    "Note that test cases are by no means exhaustive!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "class RelationTest(unittest.TestCase):\n",
    "\n",
    "    def setUp(self):\n",
    "        self.foo = Relation('foo', [('id', int), ('name', str)])\n",
    "        self.foo.add_tuple( (2,'Hello') )\n",
    "        self.foo.add_tuple( (7,'World') )\n",
    "        self.foo.add_tuple( (1,'!') )\n",
    "\n",
    "        self.bar = Relation('bar', [('a', int), ('b', int), ('c', int), ('d', int)])\n",
    "        self.bar.add_tuple( (1, 2, 3, 4) )\n",
    "        self.bar.add_tuple( (2, 2, 3, 4) )\n",
    "        self.bar.add_tuple( (3, 2, 3, 4) )\n",
    "        self.bar.add_tuple( (4, 2, 3, 4) )\n",
    "        self.bar.add_tuple( (5, 2, 3, 4) )\n",
    "        \n",
    "    def test_size(self):\n",
    "        # foo should contain 3 tuples\n",
    "        self.assertEqual(len(self.foo), 3)\n",
    "        # check valid insert\n",
    "        self.assertTrue(self.foo.add_tuple( (3, '?') ))\n",
    "        self.assertEqual(len(self.foo), 4)\n",
    "        # check duplicate insert\n",
    "        self.assertFalse(self.foo.add_tuple( (1,'!') ))\n",
    "        self.assertEqual(len(self.foo), 4)\n",
    "        \n",
    "        # bar should contain 5 tuples\n",
    "        self.assertEqual(len(self.bar), 5)\n",
    "        # check valid insert\n",
    "        self.assertTrue(self.bar.add_tuple( (6, 2, 3, 4) ))\n",
    "        self.assertEqual(len(self.bar), 6)\n",
    "        # check duplicate insert\n",
    "        self.assertFalse(self.bar.add_tuple( (5, 2, 3, 4) ))\n",
    "        self.assertEqual(len(self.bar), 6)\n",
    "    \n",
    "    def test_schema(self):\n",
    "        # incorrectly typed tuple\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( ('wrong order', 42) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (0.1, 'wrong type') )\n",
    "        # inccorectly sized tuples\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (6, 'wrong size', 12) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (42,) )\n",
    "        \n",
    "        # incorrectly typed tuple\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (0.1, 0.2, 0.3, 0.4) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( ('1', '3', '2', '4') )\n",
    "        # incorrectly sized\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (1, 2, 4, 5, 6) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (1, 2, 4) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unit Test for KeyRelation\n",
    "\n",
    "Note that test cases are by no means exhaustive!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KeyRelationTest(unittest.TestCase):\n",
    "    \n",
    "    def setUp(self):\n",
    "        keys = ['id']\n",
    "        self.foo = KeyRelation('foo', [('id', int), ('name', str)], keys)\n",
    "        self.foo.add_tuple( (1, 'first') )\n",
    "        self.foo.add_tuple( (2, 'second') )\n",
    "        self.foo.add_tuple( (3, 'thrid') )\n",
    "        \n",
    "        keys = ['a', 'c']\n",
    "        self.bar = KeyRelation('bar', [('a', int), ('b', int), ('c', int), ('d', int)], keys)\n",
    "        self.bar.add_tuple( (1, 2, 1, 3) )\n",
    "        self.bar.add_tuple( (1, 3, 2, 1) )\n",
    "        self.bar.add_tuple( (2, 3, 2, 1) )\n",
    "        self.bar.add_tuple( (2, 3, 1, 2) )\n",
    "        \n",
    "    def test_size(self):\n",
    "        # foo should contain 3 tuples\n",
    "        self.assertEqual(len(self.foo), 3)\n",
    "        # check valid insert\n",
    "        self.foo.add_tuple( (4, 'fourth') )\n",
    "        self.assertEqual(len(self.foo), 4)\n",
    "        # check duplicate key insert\n",
    "        with self.assertRaises(ValueError):\n",
    "            self.foo.add_tuple( (1, 'one') ) # should raise ValueError  \n",
    "        self.assertEqual(len(self.foo), 4)  # should not add tuple\n",
    "        # check duplicate tuple insert\n",
    "        with self.assertRaises(ValueError):\n",
    "            self.foo.add_tuple( (1,'first') )  #should raise ValueError\n",
    "        self.assertEqual(len(self.foo), 4)  # should not add tuple\n",
    "        \n",
    "        # bar should contain 4 tuples\n",
    "        self.assertEqual(len(self.bar), 4)\n",
    "        # check valid insert\n",
    "        self.bar.add_tuple( (3, 1, 2, 3) )\n",
    "        self.assertEqual(len(self.bar), 5)\n",
    "        # check duplicate key insert\n",
    "        with self.assertRaises(ValueError):\n",
    "            self.bar.add_tuple( (1, 3, 1, 2) )  # should raise ValueError\n",
    "        self.assertEqual(len(self.bar), 5)  # should not add tuple\n",
    "        # check duplicate tuple insert\n",
    "        with self.assertRaises(ValueError):\n",
    "            self.bar.add_tuple( (2, 3, 1, 2) )  # should raise ValueError\n",
    "        self.assertEqual(len(self.bar), 5)  # should not add tuple\n",
    "    \n",
    "    def test_schema(self):\n",
    "        # incorrectly typed tuple\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( ('seventh', 7) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (0.1, 'zero point first') )\n",
    "        # inccorectly sized tuples\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (42, 'oops', 12) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.foo.add_tuple( (43,) )\n",
    "        \n",
    "        # incorrectly typed tuple\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (0.1, 0.2, 0.3, 0.4) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( ('1', '3', '2', '4') )\n",
    "        # incorrectly sized\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (1, 2, 4, 5, 6) )\n",
    "        with self.assertRaises(AssertionError):\n",
    "            self.bar.add_tuple( (1, 2, 4) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_schema (__main__.KeyRelationTest) ... FAIL\n",
      "test_size (__main__.KeyRelationTest) ... FAIL\n",
      "test_schema (__main__.RelationTest) ... ok\n",
      "test_size (__main__.RelationTest) ... ok\n",
      "\n",
      "======================================================================\n",
      "FAIL: test_schema (__main__.KeyRelationTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-13-fc8a6f390d61>\", line 49, in test_schema\n",
      "    self.foo.add_tuple( ('seventh', 7) )\n",
      "AssertionError: AssertionError not raised\n",
      "\n",
      "======================================================================\n",
      "FAIL: test_size (__main__.KeyRelationTest)\n",
      "----------------------------------------------------------------------\n",
      "Traceback (most recent call last):\n",
      "  File \"<ipython-input-13-fc8a6f390d61>\", line 19, in test_size\n",
      "    self.assertEqual(len(self.foo), 3)\n",
      "AssertionError: 0 != 3\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 4 tests in 0.003s\n",
      "\n",
      "FAILED (failures=2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x12db11460>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the unit test without shutting down the jupyter kernel\n",
    "unittest.main(argv=['ignored', '-v'], verbosity=2, exit=False)"
   ]
  }
 ],
 "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.9.5"
  },
  "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
}