pycoviz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Exploring the collation of Calpurnius Flaccus\n",
    "\n",
    "In this notebook, I present an interactive method to manipulate the collation of the *Declamations* of Calpurnius Flaccus obtained with [CollateX](collatex.net).\n",
    "\n",
    "## Understanding the data\n",
    "\n",
    "First it is necessary to understand the structure of the collation data. [Here](http://www.w3resource.com/JSON/structures.php) you can find the generic description of json structures. An object (dictionary) is made of one or more pairs of name/value. The relation name/value is similar to the relation between a word and its definition in a dictionary. An array (list) is an ordered list of values. A json *object* corresponds to a python *dictionary*, and a json *array* to a python *list*. Lists can be combined: a table is a list of lists.\n",
    "\n",
    "There are two objects in the json collation, which are converted into their equivalent in python: \n",
    "* a list of witnesses (\"witnesses\")\n",
    "* a table with the aligned text versions (\"table\")\n",
    "\n",
    "The list of witnesses works as a header for the table, which can be itself described as:\n",
    "* a table is a list of rows\n",
    "* a row is a list of cells\n",
    "* a cell is a list of tokens\n",
    "* a token is a dictionary with the following entries:\n",
    "    * **t : exact word as it appears in the witness**\n",
    "    * n : optional normalized version of the word\n",
    "    * locus : optional exact location of the word in the manuscript/edition. Folio/page number, followed by line number\n",
    "    * note : optional comment \n",
    "    * decl: optional declamation number\n",
    "    * link : optional link to the page of a digital facsimile, where the token appears\n",
    "    \n",
    "The order of the rows is important, because it follows the order of the text. Row 0 has the first word(s) of the text, whereas the last row has also the last word(s) of the text. The row's number is called ID number, and will be used later for variant location identification.\n",
    "\n",
    "## Contents <a name=\"ToC\"></a>\n",
    "1. [Import Data](#part1).\n",
    "The first step is to import the collation results into python. \n",
    "\n",
    "2. [Functions](#part2).\n",
    "Then we will create functions to filter the data according to our need. For instance, we may want to find all the unique variants of one witness. Or we would like to see the places where one group of witnesses agrees with each other against another group of witnesses. Some functions will allow us to diplay only a section of the collation, or information specific to one variant location. Including:\n",
    "  1. [find agreements](#func2-4)\n",
    "  2. [table to html](#func2-6)\n",
    "  3. [move tokens](#func2-10)\n",
    "  4. [add/delete note](#func2-11)\n",
    "  5. [search](#func2-12)\n",
    "  6. [save](#func2-13)\n",
    "\n",
    "3. [Exploration of collation](#part3).\n",
    "Finally, we will use our functions to explore the collation of Calpurnius Flaccus, with interactive [widgets](http://ipywidgets.readthedocs.io/en/latest/index.html):\n",
    "  1. [Modify](#part3-1) collation (move tokens, add/del rows, add/del notes, save the new json)\n",
    "  2. [Find agreements](#part3-2) between witnesses, and save the result into a more complex html file\n",
    "  3. [Search](#part3-3) the collation\n",
    "  4. [Clarify](#part3-4) a reading\n",
    "  \n",
    "5. [Summary](#summary).\n",
    "Summary of all interactions gathered in one widget for ease of use.\n",
    "  \n",
    "Users may go straight to the [summary](#summary) to start exploring the collation of Calpurnius Flaccus. For those who would prefer to see the code behind the widgets and the various interactions, you can read through the [functions](#part2) or the [interactive widgets](#part3).\n",
    "\n",
    "\n",
    "## Notebook re-use\n",
    "Any JSON output from collateX, with **tokens \"t\"**. The other elements are optional.\n",
    "\n",
    "Some transformations may be needed. For instance:\n",
    " * In collation [import data](#import1-2) :  change the base base text. If you choose to have no base text, change also the description of the \"save_to_html\"  [function](#func2-13).\n",
    " * In the HTML template, title and credits should be updated. The transformation into complex HTML could also be adapted, according to the json model of the new user.\n",
    "\n",
    "## Possible Improvements\n",
    "- large amounts of modifications (moving many tokens at the same time)\n",
    "- find and delete empty rows automatically\n",
    "- prevent deletion of non empty rows\n",
    "- avoid moving first/last tokens\n",
    "- edit notes directly\n",
    "- save file with popup window\n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## IMPORT DATA <a name=\"part1\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Python modules import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#python modules\n",
    "import json\n",
    "import sys\n",
    "import re\n",
    "from IPython.display import display,HTML\n",
    "from datetime import datetime\n",
    "\n",
    "#ipywidgets modules\n",
    "from __future__ import print_function\n",
    "from ipywidgets import *\n",
    "import ipywidgets as widgets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Collation import <a name='import1-2'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['B1', 'B2', 'C1', 'C2', 'LH', 'M1', 'M2', 'N1', 'N2', 'P1594']\n"
     ]
    }
   ],
   "source": [
    "#path to the file with json results of the collation\n",
    "path = 'json-collations/calpurnius-collation-joint-BCMNPH.json'\n",
    "#path = 'json-collations/calpurnius-collation-joint-BCMNPH-corr.json'\n",
    "\n",
    "#open the file\n",
    "with open (path, encoding='utf-8') as jsonfile:\n",
    "    #transform the json structure (arrays, objects) into python structure (lists, dictionaries)\n",
    "    data = json.load(jsonfile)\n",
    "\n",
    "#list of witnesses\n",
    "witnesses = data[\"witnesses\"]\n",
    "print(witnesses)\n",
    "\n",
    "#table of the aligned text versions\n",
    "collation = data[\"table\"]\n",
    "\n",
    "#base text: choose a witness which variants are considered true readings (in green)\n",
    "#for Calpurnius, the most recent edition of Hakanson is used as the base text\n",
    "#if you do not want a base text, set it as an empty string ''\n",
    "base_text = 'LH'\n",
    "\n",
    "#the index of a witness is its position in the witness list:\n",
    "#for instance B1 has position 0, and P1594 has position 9."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## FUNCTIONS <a name=\"part2\"></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Transform a cell c (list of tokens) into a string of text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#original text\n",
    "def cell_to_string(c):    \n",
    "    #tokens t are joined together, separated by a space\n",
    "    string = ' '.join(token['t'] for token in c)\n",
    "    return string\n",
    "\n",
    "#text with normalized tokens\n",
    "def cell_to_string_norm(c):    \n",
    "    string = ''\n",
    "    #word division is not taken into account when comparing the normalized text\n",
    "    #for this reason we do not add a space in between tokens\n",
    "    for token in c:\n",
    "        if 'n' in token:\n",
    "            string += token['n']\n",
    "        elif 't' in token:\n",
    "            string += token['t']\n",
    "    return string\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Compare cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#compare two cells, original text\n",
    "def compare_cell(c1,c2):\n",
    "    return cell_to_string(c1) == cell_to_string(c2)\n",
    "\n",
    "#compare two cells, normalized text\n",
    "def compare_cell_norm(c1,c2):\n",
    "    return cell_to_string_norm(c1) == cell_to_string_norm(c2)    \n",
    "\n",
    "#compare a list of cells, original text\n",
    "#return true if all the cells are equivalent (they contain the same string of tokens)    \n",
    "def compare_multiple_cell(cell_list):\n",
    "    #compare each cell to the next\n",
    "    for c1,c2 in zip(cell_list, cell_list[1:]):\n",
    "        if compare_cell(c1,c2) is False:\n",
    "            comparison = False\n",
    "            break\n",
    "    else:\n",
    "        comparison = True\n",
    "    return comparison\n",
    "\n",
    "#compare a list of cells, normalized text\n",
    "#return true if all the cells are equivalent (they contain the same string of tokens)\n",
    "def compare_multiple_cell_norm(cell_list):\n",
    "    #compare each cell to the next\n",
    "    for c1,c2 in zip(cell_list, cell_list[1:]):\n",
    "        if compare_cell_norm(c1,c2) is False:\n",
    "            comparison = False\n",
    "            break\n",
    "    else:\n",
    "        comparison = True\n",
    "    return comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Find agreements 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#this function returns rows of the collation table (table) where a list of x witnesses (witlist) agree together.\n",
    "#we display only variant locations, and not places where all witnesses agree.\n",
    "\n",
    "def find_agreements(table, witlist):\n",
    "    result_table = []\n",
    "    \n",
    "    #transform widget tuple into actual list\n",
    "    witlist = list(witlist)\n",
    "    \n",
    "    #transform the witnesses names (sigla) into indexes\n",
    "    witindex = [witnesses.index(wit) for wit in witlist]\n",
    "    nonwitindex = [witnesses.index(wit) for wit in witnesses if wit not in witlist]\n",
    "\n",
    "    for row in table:\n",
    "        #get list of cell for the x witnesses\n",
    "        cell_list = [row[i] for i in witindex]\n",
    "        #there must be agreement of the x witnesses (normalized tokens)\n",
    "        if compare_multiple_cell_norm(cell_list) is True:\n",
    "            for i in nonwitindex:\n",
    "                #if they disagree with at least one of the others\n",
    "                if compare_cell_norm(row[witindex[0]],row[i]) is False:\n",
    "                    #add row to the result\n",
    "                    result_table.append(row)\n",
    "                    #and go to next row\n",
    "                    break\n",
    "\n",
    "    return result_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Find agreements 2  <a name='func2-4'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#This function is similar to the previous one:\n",
    "#it returns rows of the collation table (table) where a list of x witnesses (witlist) agree together, but\n",
    "#do not agree with the witnesses in a second list (nonwitlist).\n",
    "\n",
    "#By default, the function will return the agreement of the x witnesses, against all the other witnesses.\n",
    "\n",
    "def compare_witnesses(table, witlist, nonwitlist=[]):\n",
    "    result_table = []\n",
    "    \n",
    "    #first list of x witnesses which agree together\n",
    "    witindex = [witnesses.index(wit) for wit in witlist]\n",
    "    #against all the other witnesses\n",
    "    if not nonwitlist:\n",
    "        nonwitindex = [witnesses.index(wit) for wit in witnesses if wit not in witlist]\n",
    "    #except if a second list of y witnesses is specified\n",
    "    else:\n",
    "        nonwitindex = [witnesses.index(wit) for wit in nonwitlist]\n",
    "    \n",
    "    #go through the collation table, row by row\n",
    "    #to find places where the x witnesses agree together against others\n",
    "    for row in table:\n",
    "        #get list of cell for the x witnesses\n",
    "        cell_list = [row[i] for i in witindex]\n",
    "        #there must be agreement of the x witnesses (normalised tokens)\n",
    "        if compare_multiple_cell_norm(cell_list) is True:\n",
    "            for i in nonwitindex:\n",
    "                #if they agree with one of the other y witnesses\n",
    "                if compare_cell_norm(row[witindex[0]],row[i]) is True:\n",
    "                    #go to next row\n",
    "                    break\n",
    "            #but if they do not agree with any of the y witnesses        \n",
    "            else:\n",
    "                #add row to the result\n",
    "                result_table.append(row)\n",
    "    return result_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Find all variants in the collation table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def view_variants(table):\n",
    "    result_table = []\n",
    "    #go through the collation table, row by row\n",
    "    for row in table:\n",
    "        #if there is a variant in the row (i.e. at least one cell is different from another cell, normalized form)\n",
    "        if compare_multiple_cell_norm(row) is False:\n",
    "            #add row to the result\n",
    "            result_table.append(row)       \n",
    "    return result_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Transform the result table into an html table  <a name='func2-6'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#this function returns a minimal HTML table, to display in the notebook.\n",
    "\n",
    "def table_to_html(collation,table):\n",
    "    \n",
    "    #table in an HTML format\n",
    "    html_table = ''\n",
    "    #div is for a better slides view. For notebook use, comment it out\n",
    "    #html_table += '<div style=\"overflow: scroll; width:960; height:417px; word-break: break-all;\">'\n",
    "    html_table += '<table border=\"1\" style=\"width: 100%; border: 1px solid #000000; border-collapse: collapse;\" cellpadding=\"4\">'\n",
    "    \n",
    "    #add a header to the table with columns, one for each witnesses and one for the row ID\n",
    "    html_table += '<tr>'\n",
    "    #a column for each witness\n",
    "    for wit in witnesses:\n",
    "        html_table += '<th>'+wit+'</th>'\n",
    "    #optional: column for the declamation number\n",
    "    #html_table += '<th>Decl</th>'\n",
    "    #column for the row id\n",
    "    html_table += '<th>ID</th>'\n",
    "    html_table += '</tr>'\n",
    "    \n",
    "    for row in table:\n",
    "        #add a row to the html table\n",
    "        html_table += '<tr>'\n",
    "        #optional : a variable to store the declamation number (will not be defined in empty rows)\n",
    "        #declamation = 0\n",
    "        #fill row with cell for each witness\n",
    "        for cell in row:\n",
    "            #transform the tokens t into a string.\n",
    "            #we display the original tokens, not the normalized form\n",
    "            token = cell_to_string(cell)\n",
    "            \n",
    "            #some cells are empty. Thus the declamation number is only available in cell with at least 1 token\n",
    "            #if len(cell)>0:\n",
    "            #    declamation = str(cell[0]['decl'])\n",
    "            \n",
    "            #if no base text is selected, background colour will be white\n",
    "            if not base_text:\n",
    "                bg = \"white\"\n",
    "            #if the tokens are the same as the base text tokens (normalized form)\n",
    "            #it is displayed as a \"true reading\" in a green cell\n",
    "            elif compare_cell_norm(cell,row[witnesses.index(base_text)]):\n",
    "                bg = \"d9ead3\"\n",
    "            #otherwise it is diplayed as an \"error\" in a red cell\n",
    "            else:\n",
    "                bg = \"ffb1b1\"\n",
    "            html_table += '<td bgcolor=\"'+bg+'\">'+token+'</td>'\n",
    "        \n",
    "        #optional: add declamation number  \n",
    "        #html_table += '<td>'+str(location)+'</td>'\n",
    "        \n",
    "        #add row ID\n",
    "        html_table += '<td>'+str(collation.index(row))+'</td>' \n",
    "        \n",
    "        #close the row\n",
    "        html_table += '</tr>'\n",
    "    \n",
    "    #close the table\n",
    "    html_table += '</table>'\n",
    "    #html_table += '</div>'\n",
    "\n",
    "    return html_table \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#this function returns a fancier HTML, but can't be displayed in the notebook (yet)\n",
    "\n",
    "def table_to_html_fancy(collation,table):\n",
    "    #table in an HTML format\n",
    "    html_table = '<table>'\n",
    "    \n",
    "    #add a header to the table with columns\n",
    "    html_table += '<thead><tr>'\n",
    "    #a column for each witness\n",
    "    for wit in witnesses:\n",
    "        html_table += '<th>'+'<p>'+wit+'</p>'+'</th>'\n",
    "    #a column for the row id\n",
    "    html_table += '<th><p>ID</p></th>'\n",
    "    #close header\n",
    "    html_table += '</tr></thead><tbody>'\n",
    "    \n",
    "    for row in table:\n",
    "        #add a row to the html table\n",
    "        html_table += '<tr>'\n",
    "        for cell in row:\n",
    "            #transform the tokens t into a string (original token) \n",
    "            token = cell_to_string(cell)\n",
    "            \n",
    "            #if there is no base text\n",
    "            if not base_text:\n",
    "                #arbitrary class for the HTML cells. It will have no effect on the result.\n",
    "                cl = \"foo\"\n",
    "            #if the normalized token is the same as the base text\n",
    "            #it is diplayed as a \"true reading\" in a cell with green left border\n",
    "            elif compare_cell_norm(cell,row[witnesses.index(base_text)]):\n",
    "                cl = \"green\"\n",
    "            #otherwise as an \"error\" in a cell with an orange left border\n",
    "            else:\n",
    "                cl = \"orange\"\n",
    "            #add token to the table, in a text paragraph    \n",
    "            html_table += '<td class=\"'+cl+'\">'+'<p>'+token\n",
    "            \n",
    "            #if there is a note to display, add a little 'i' to indicate there is more hidden information\n",
    "            for t in cell:\n",
    "                #in the cell, if we find a token with a note\n",
    "                if 'note' in t:\n",
    "                    #add info indicator\n",
    "                    html_table += ' <a href=\"#\" class=\"expander right\"><i class=\"fa fa-info-circle\"></i></a>'\n",
    "                    #then stop (even if there are several notes, we display only one indicator)\n",
    "                    break\n",
    "\n",
    "            #close the text paragraph in the cell\n",
    "            html_table += '</p>'\n",
    "            \n",
    "            #add paragraphs for hidden content (notes. Not limited to notes only: normalized form could be added, etc.)\n",
    "            for t in cell:\n",
    "                if 'note' in t:\n",
    "                    html_table += '<p class=\"expandable hidden more-info\">Note: '+t['note']+'</p>'\n",
    "            \n",
    "            #when the cell is not empty, add hidden info of page/line numbers. Adapted to make 'locus' optional\n",
    "            if len(cell)>0 and 'locus' in cell[0]:\n",
    "            #if len(cell)>0 :\n",
    "                #add link to images when possible\n",
    "                if 'link' in cell[0]:\n",
    "                    url = cell[0]['link']\n",
    "                    html_table += '<p class=\"expandable-row hidden more-info\"><a target=\"blank\" href='+url+'>'+cell[0]['locus']+'</a></p>'\n",
    "                else:\n",
    "                    html_table += '<p class=\"expandable-row hidden more-info\">'+cell[0]['locus']+'</p>'\n",
    "            \n",
    "            #close cell\n",
    "            html_table += '</td>'\n",
    "        \n",
    "        #add row ID with indicator of hidden content\n",
    "        html_table += '<td>'+'<p>'+str(collation.index(row))+' <a href=\"#\" class=\"expander-row right\"><i class=\"fa fa-ellipsis-v\"></i></a></p>'+'</td>' \n",
    "        #close the row\n",
    "        html_table += '</tr>'\n",
    "    #close the table\n",
    "    html_table += '</tbody></table>'\n",
    "    \n",
    "    return html_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Print collation in a text orientation\n",
    "To read a short passage quickly. The collation table is reversed so that each witness is displayed on a row instead of a column. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def print_witnesses_text(table):\n",
    "    reverse_table = [[row[i] for row in table] for i in range(len(witnesses))]\n",
    "    for index,row in enumerate(reverse_table):\n",
    "        text = ''\n",
    "        for cell in row:\n",
    "            #the row starts and ends with a token, not a space\n",
    "            if row.index(cell) == 0 or text == '' or not cell:\n",
    "                text += cell_to_string(cell)\n",
    "            #if it is not the start of the string or an empty cell, add a space to separate tokens\n",
    "            else:\n",
    "                text += ' '+cell_to_string(cell)\n",
    "        text += ', '+str(witnesses[index])\n",
    "        print(text)\n",
    "    #return reverse_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Print information about a reading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def print_info(rowID, wit):\n",
    "    #select cell\n",
    "    cell = collation[rowID][witnesses.index(wit)]\n",
    "    #if cell is empty, there is no token\n",
    "    if len(cell) == 0:\n",
    "            print('-')\n",
    "    else:\n",
    "        for token in cell:\n",
    "            #position of token in cell + content\n",
    "            print(cell.index(token), ':', ', '.join(token[feature] for feature in token))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Get the ID of a row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def get_pos(row):\n",
    "    return collation.index(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Move a token to the previous (up) or next (down) row  <a name='func2-10'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def move_token_up(rowID, wit):\n",
    "    try:\n",
    "        #the token cannot be in the first row \n",
    "        rowID > 0\n",
    "        #select the first token\n",
    "        token = collation[rowID][witnesses.index(wit)].pop(0)\n",
    "        #append it at the end of the cell in the previous row\n",
    "        collation[rowID-1][witnesses.index(wit)].append(token)\n",
    "        print(\"Token '\"+token['t']+\"' moved up!\")\n",
    "    except:\n",
    "        print(\"There is no token to move.\")\n",
    "\n",
    "def move_token_down(rowID, wit):\n",
    "    try:\n",
    "        #the token cannot be in the last row\n",
    "        rowID < len(collation)-1\n",
    "        #select the last token\n",
    "        token = collation[rowID][witnesses.index(wit)].pop()\n",
    "        #add it at the beginning of the cell in the next row\n",
    "        collation[rowID+1][witnesses.index(wit)].insert(0, token)\n",
    "        print(\"Token '\"+token['t']+\"' moved down!\")\n",
    "    except:\n",
    "        print(\"There is no token to move.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Add / delete a row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def add_row_after(rowID):\n",
    "    #rowID must be within collation table\n",
    "    if rowID < 0 or rowID > len(collation)-1:\n",
    "        print('Row '+str(rowID)+' does not exist.')\n",
    "    else:\n",
    "        #create an empty row\n",
    "        new_row = []\n",
    "        #for each witness in the collation\n",
    "        for wit in witnesses:\n",
    "            #add an empty list of tokens to the row\n",
    "            new_row.append([])\n",
    "        #insert new row in the collation, after the row passed in argument (+1)\n",
    "        collation.insert(rowID+1, new_row)\n",
    "        print('Row added!')\n",
    "    \n",
    "def delete_row(rowID):\n",
    "    #rowID must be within collation table\n",
    "    if rowID < 0 or rowID > len(collation)-1:\n",
    "        print('Row '+str(rowID)+' does not exist.')\n",
    "    else:\n",
    "        collation.pop(rowID)\n",
    "        print('Row deleted!')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Add / Delete a note  <a name='func2-11'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#add or modify a note\n",
    "def add_note(wit, rowID, token, note):\n",
    "    try:\n",
    "        #select token\n",
    "        t = collation[rowID][witnesses.index(wit)][token]     \n",
    "        if note is '':\n",
    "            print('Your note is empty.')\n",
    "        elif 'note' in t:\n",
    "            #add comment to an already existing note\n",
    "            t['note'] += ' '+note\n",
    "        else:\n",
    "            #or create a new note\n",
    "            t['note'] = note\n",
    "    except:\n",
    "        print('This token is not valid.')\n",
    "\n",
    "#delete completely a token's note            \n",
    "def del_note(wit, rowID, token):\n",
    "    try:\n",
    "        #select token\n",
    "        t = collation[rowID][witnesses.index(wit)][token]\n",
    "        if 'note' in t:\n",
    "            #delete note    \n",
    "            t.pop('note')\n",
    "        else:\n",
    "            #or print error message\n",
    "            print('There is no note to delete')\n",
    "    except:\n",
    "        print('This token is not valid.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Search  <a name='func2-12'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def search(table,text):\n",
    "    #result table to build\n",
    "    result_table = []\n",
    "    \n",
    "    #go through each row of the collation table\n",
    "    for row in table:\n",
    "        #go through each cell\n",
    "        for cell in row:\n",
    "            #if the search text matches the cell text (original or normalized form)\n",
    "            if text in cell_to_string_norm(cell) or text in cell_to_string(cell):\n",
    "                #add row to the result table\n",
    "                result_table.append(row)\n",
    "                #go to next row\n",
    "                break\n",
    "    \n",
    "    #if the result table is empty, the text was not found in the collation\n",
    "    if result_table == []:\n",
    "        print(text+\" was not found!\")\n",
    "    \n",
    "    return result_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Save results  <a name='func2-13'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#save the json file with update in the collation table\n",
    "def save_json(path, table):\n",
    "    #combine new collation table with witnesses, so as to have one data variable\n",
    "    data = {'witnesses':witnesses, 'table':table}\n",
    "    #open a file according to path\n",
    "    with open(path, 'w') as outfile:\n",
    "        #write the data in json format\n",
    "        json.dump(data, outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#save a subset of the collation table into fancy HTML version, with a small text description\n",
    "def save_table(descr, table, path):\n",
    "    #path to template\n",
    "    template_path = 'alignment-tables/template.html'\n",
    "    \n",
    "    #load the text of the template into a variable html\n",
    "    with open(template_path, 'r', encoding='utf-8') as infile:\n",
    "        html = infile.read()\n",
    "    \n",
    "    #add base text to description\n",
    "    if base_text:\n",
    "        descr += '<br>Agreement with the base text '+base_text+' is marked in green.'\n",
    "        descr += ' Variation from '+base_text+' is marked in red.' \n",
    "        \n",
    "    #modify template: replace the comment with descr paragraph\n",
    "    html = re.sub(r'<!--descr-->',descr,html)\n",
    "    \n",
    "    #modify template: replace the comment with table\n",
    "    html = re.sub(r'<!--table-->',table,html)\n",
    "    \n",
    "    #save\n",
    "    with open(path, 'w', encoding='utf-8') as outfile:\n",
    "        outfile.write(html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## INTERACTIVE EXPLORATION OF THE COLLATION TABLE <a name=\"part3\"></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "### Update the collation results <a name='part3-1'></a> [↑](#ToC)\n",
    "In this section, we will see how to view a selection of the collation table and update it.\n",
    "\n",
    "Possible updates:\n",
    "  1. Add/delete a row\n",
    "  3. Move one token up/down\n",
    "  4. Add notes\n",
    "  3. Save\n",
    "\n",
    "**Note** : it is only possible to move the last token (or word) in a cell down to the first place in the next cell; or vice-versa to move the first token of a cell up to the last place in the previous cell. This is to prevent any change in the word order of a witness, and *to keep the correct text sequence*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#select an extract of the collation table with interactive widgets\n",
    "\n",
    "#widget for HTML display\n",
    "w1_html = widgets.HTML(value=\"\")\n",
    "\n",
    "#define the beginning of extract\n",
    "w_from = widgets.BoundedIntText(\n",
    "    value=6,\n",
    "    min=0,\n",
    "    max=len(collation)-1,\n",
    "    description='From:',\n",
    "    continuous_update=True,\n",
    ")\n",
    "\n",
    "#define the end of extract\n",
    "#because of python list slicing, the last number is not included in the result.\n",
    "#to make it more intuitive, the \"to\" number is added +1 in collation_extract function\n",
    "w_to = widgets.BoundedIntText(\n",
    "    value=11,\n",
    "    min=0,\n",
    "    max=len(collation)-1,\n",
    "    description='To:',\n",
    "    continuous_update=True,\n",
    ")\n",
    "\n",
    "#binding widgets with table_to_html function\n",
    "def collation_extract(a, b):\n",
    "    x = a\n",
    "    y = b+1\n",
    "    if y <= x:\n",
    "        print(\"The table you have requested does not exist.\")\n",
    "    w1_html.value = table_to_html(collation,collation[x:y])\n",
    "\n",
    "#uncomment the next lines to see the widgets\n",
    "##interactive selection of a collation table extract\n",
    "#interact(collation_extract, a=w_from, b=w_to)\n",
    "##display HTML widget (rows 6-11)\n",
    "#display(w1_html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#Widgets for:\n",
    "#move tokens up/down\n",
    "#add/delete rows\n",
    "#add/delete notes to a specific token\n",
    "\n",
    "#widget to select a witness        \n",
    "w_wit = widgets.Dropdown(\n",
    "    options = witnesses,\n",
    "    description = 'Witness:',\n",
    ")\n",
    "#widget to select a row\n",
    "w_rowID = widgets.BoundedIntText(\n",
    "    min=0,\n",
    "    max=len(collation)-1,\n",
    "    description='ID:',\n",
    ")\n",
    "#widget to select a specific token\n",
    "w_token = widgets.Text(\n",
    "    min=0,\n",
    "    description = 'Token position:',\n",
    ")\n",
    "#widget to enter text note\n",
    "w_note = widgets.Text(\n",
    "    description = 'Note:',\n",
    ")\n",
    "\n",
    "out = widgets.Output()\n",
    "\n",
    "#link buttons and functions\n",
    "@out.capture(clear_output=True)#wait=True, clear_output=True\n",
    "def modif_on_click(b):\n",
    "    if b.description == 'add row after':\n",
    "        #add row\n",
    "        add_row_after(rowID=w_rowID.value)\n",
    "    if b.description == 'delete row':\n",
    "        #delete\n",
    "        delete_row(rowID=w_rowID.value)\n",
    "    if b.description == 'move token down':\n",
    "        move_token_down(rowID=w_rowID.value, wit=w_wit.value)\n",
    "    if b.description == 'move token up':\n",
    "        move_token_up(rowID=w_rowID.value, wit=w_wit.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#add row after\n",
    "b1 = widgets.Button(description=\"add row after\", \n",
    "                    style=ButtonStyle(button_color='#fae58b'))\n",
    "b1.on_click(modif_on_click)\n",
    "\n",
    "#uncomment the next line to see the widget\n",
    "#interact_manual(add_row_after, rowID=w_rowID, {'manual': True, 'manual_name': 'add row after'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#delete row\n",
    "b2 = widgets.Button(description=\"delete row\", \n",
    "                    style=b1.style)\n",
    "b2.on_click(modif_on_click)\n",
    "\n",
    "#uncomment the next line to see the widget\n",
    "#interact_manual(delete_row, rowID=w_rowID, {'manual': True, 'manual_name': 'delete row'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#move token down\n",
    "b3 = widgets.Button(description=\"move token down\", \n",
    "                    style=b1.style)\n",
    "b3.on_click(modif_on_click)\n",
    "\n",
    "#uncomment the next line to see the widget\n",
    "#interact_manual(move_token_down, rowID=w_rowID, wit=w_wit, {'manual': True, 'manual_name': 'move token down'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#move token up\n",
    "b4 = widgets.Button(description=\"move token up\", \n",
    "                    style=b1.style)\n",
    "b4.on_click(modif_on_click)\n",
    "\n",
    "#uncomment the next line to see the widget\n",
    "#interact_manual(move_token_up, rowID=w_rowID, wit=w_wit, {'manual': True, 'manual_name': 'move token up'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#add/delete notes\n",
    "#link add button and function\n",
    "@out.capture(clear_output=True)\n",
    "def add_on_click(b):\n",
    "    add_note(wit=w_wit.value, rowID=w_rowID.value, token=w_token.value, note=w_note.value)\n",
    "    #check result\n",
    "    print('Result:')\n",
    "    print_info(w_rowID.value, w_wit.value)\n",
    "    print('\\n')\n",
    "\n",
    "#add a note button\n",
    "w_add_note = widgets.Button(description='Add note', button_style='success')   \n",
    "w_add_note.on_click(add_on_click)\n",
    "\n",
    "#link del button and function\n",
    "@out.capture(clear_output=True)\n",
    "def del_on_click(b):\n",
    "    del_note(wit=w_wit.value, rowID=w_rowID.value, token=w_token.value)\n",
    "    #check result\n",
    "    print('Result:')\n",
    "    print_info(w_rowID.value, w_wit.value)\n",
    "\n",
    "#delete a note button\n",
    "w_del_note = widgets.Button(description='Delete note', button_style='danger')\n",
    "w_del_note.on_click(del_on_click)\n",
    "\n",
    "#dislpay widgets\n",
    "#uncomment the next line to see the widgets\n",
    "#display(w_wit, w_rowID, w_token, w_note)\n",
    "#display(w_add_note, w_del_note)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#save new json\n",
    "\n",
    "#path to the new file\n",
    "path_new_json = 'json-collations/calpurnius-collation-joint-BCMNPH-corr.json'\n",
    "\n",
    "#alternative path: take the original collation file name, and add a date/time identifier\n",
    "#file_name = os.path.split(path)[1]\n",
    "#file_id = datetime.now().strftime('%Y-%m-%d-%H%M%S')\n",
    "#path_new_json = 'json-collations/'+file_id+'-'+file_name\n",
    "\n",
    "#save button to click\n",
    "w_button = widgets.Button(description=\"Save JSON\", button_style='info')\n",
    "\n",
    "#on click\n",
    "def on_button_clicked(b):\n",
    "    #save json of the whole collation\n",
    "    save_json(path_new_json, collation)\n",
    "\n",
    "#link btw button and onclick function \n",
    "w_button.on_click(on_button_clicked)\n",
    "\n",
    "#save json\n",
    "#uncomment the next line to see the widget\n",
    "#display(w_button)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "### Find agreements of witnesses against others <a name='part3-2'></a> [↑](#ToC)\n",
    "\n",
    "In the first drop-down menu, you will be able to choose one or more witness(es) which agree together in places where all the other witnesses have a different reading. It means that, if you pick only one witness, you will see it's **unique variants**.\n",
    "\n",
    "On the other hand, you may want to see the **agreements of witnesses against another group of witnesses** selected in the second drop-down menu. This allows you for instance to ignore modern editors from the comparison. This option also allows to compare for groups of witnesses to see if they share erroneous readings (or innovations), for instance.\n",
    "\n",
    "Finally, if you chose only one witness in each dropdown menu, you will be able to see the **differences between the two witnesses**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#widget for HTML display\n",
    "w2_html = widgets.HTML(value=\"\")\n",
    "\n",
    "#selection of a group of witnesses which share the same readings\n",
    "w1 = widgets.SelectMultiple(\n",
    "    description=\"Agreements:\",\n",
    "    options=witnesses\n",
    ")\n",
    "\n",
    "#selection of a secong group of witnesses\n",
    "w2 = widgets.SelectMultiple(\n",
    "    description=\"Against:\",\n",
    "    options=witnesses\n",
    ")\n",
    "\n",
    "def collation_compare(table, a, b):\n",
    "    #transform widget tuple into actual list\n",
    "    if isinstance(a, (tuple)):\n",
    "        witlist = list(a)\n",
    "        nonwitlist = list(b)\n",
    "    else:\n",
    "        witlist = [a]\n",
    "        nonwitlist = [b]\n",
    "    if not a:\n",
    "        print(\"No witness selected.\")\n",
    "    else:\n",
    "        #create the result table\n",
    "        result = compare_witnesses(table, witlist, nonwitlist)\n",
    "        #transform table to HTML\n",
    "        html_table = table_to_html(table,result)\n",
    "        #add an indication of the number of rows in the result table\n",
    "        html_table += '<span>Total: '+str(len(result))+' rows in the table.</span>'\n",
    "        #set HTML display value\n",
    "        w2_html.value = html_table\n",
    "\n",
    "#-----------\n",
    "#save button\n",
    "w_save = widgets.Button(description=\"Save Table\", button_style='info')\n",
    "\n",
    "#description of the table\n",
    "w_descr = widgets.Text(value=\"Table description\")\n",
    "\n",
    "def on_button_clicked(x):\n",
    "    #transform widget tuple into actual list\n",
    "    if isinstance(w1.value, (tuple)):\n",
    "        witlist = list(w1.value)\n",
    "        nonwitlist = list(w2.value)\n",
    "    else:\n",
    "        witlist = [w1.value]\n",
    "        nonwitlist = [w2.value]\n",
    "    if not w1.value:\n",
    "        print(\"No table to save.\")\n",
    "    else:\n",
    "        #path for new result file\n",
    "        file_id = datetime.now().strftime('%Y-%m-%d-%H%M%S')\n",
    "        path_result = 'alignment-tables/collation-'+file_id+'.html'\n",
    "        #description\n",
    "        descr = str(w_descr.value)\n",
    "        #html table\n",
    "        table = table_to_html_fancy(collation,compare_witnesses(collation, witlist, nonwitlist))\n",
    "        #save\n",
    "        save_table(descr, table, path_result)\n",
    "\n",
    "#link button with saving action\n",
    "w_save.on_click(on_button_clicked)\n",
    "#---------------\n",
    "\n",
    "#find agreements between witnesses or unique readings\n",
    "#uncomment the next line to see the widgets\n",
    "#interact(collation_compare, table=fixed(collation), a=w1, b=w2)\n",
    "\n",
    "#display(w2_html)\n",
    "#display(w_descr)\n",
    "#display(w_save)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Search the collation <a name='part3-3'></a> [↑](#ToC)\n",
    "Basic search. It will check for token t or normalized form n, and return rows where there is at least one match. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "#widget for HTML display\n",
    "w3_html = widgets.HTML(value=\"\")\n",
    "\n",
    "#do the search\n",
    "def search_collation(table,text):\n",
    "    w3_html.value = table_to_html(table,search(table,text))\n",
    "    \n",
    "#search collation with interactive text input\n",
    "#uncomment the next line to see the widgets\n",
    "#interact(search_collation, table=fixed(collation),text=\"calpurnius\",__manual=True)\n",
    "#display(w3_html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Clarify one reading <a name='part3-4'></a> [↑](#ToC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "#Examples: 459/C1, 932/M1, 9/LH\n",
    "#uncomment the next line to see the widget\n",
    "#interact(print_info, rowID=w_rowID, wit=w_wit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary of Widgets <a name='summary'></a> [↑](#ToC)\n",
    "\n",
    "Here you will find all possible interactions gathered into one tab widget. It is a widget that displays several pages in tabs. each page is dedicated to a specific interaction: \n",
    "1. **Extract**: select a collation extract\n",
    "2. **Modifications**: update the collation by adding/deleting rows, moving tokens or adding/deleting notes\n",
    "3. **Agreements**: select groups of witnesses to see what readings they have in common, against other witnesses\n",
    "4. **Search**: search the collation for a single reading, for which you can see more information in the last page\n",
    "5. **Clarify**: see more information about one reading, i.e. all properties of the tokens in one witness, from a specific row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e34a3f8b6b74bcd90d648da7e8dad4e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Tab(children=(VBox(children=(interactive(children=(BoundedIntText(value=6, continuous_update=True, description…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Using the tab widget, gather all interactions in one place\n",
    "tab = widgets.Tab()\n",
    "\n",
    "#page 1 = view extract\n",
    "w_extract = interactive(collation_extract, a=w_from, b=w_to)\n",
    "page1 = widgets.VBox(children = [w_extract, w1_html])\n",
    "\n",
    "#page 2 = modify the collation\n",
    "w_modif1 = widgets.VBox(children=[w_rowID, b1, out])#add row\n",
    "w_modif2 = widgets.VBox(children=[w_rowID, b2, out])#delete row\n",
    "w_modif3 = widgets.VBox(children=[w_rowID, w_wit, b3, out])#move token down\n",
    "w_modif4 = widgets.VBox(children=[w_rowID, w_wit, b4, out])#move token up\n",
    "w_modif5 = widgets.VBox([w_wit, w_rowID, w_token, w_note, \n",
    "                         widgets.HBox(children=[w_add_note, w_del_note]), out])#add/del notes\n",
    "                       \n",
    "accordion = widgets.Accordion(children=[w_modif1, w_modif2, w_modif3, w_modif4, w_modif5])\n",
    "accordion.set_title(0, 'Add Row')\n",
    "accordion.set_title(1, 'Delete Row')\n",
    "accordion.set_title(2, 'Move Token Down')\n",
    "accordion.set_title(3, 'Move Token Up')\n",
    "accordion.set_title(4, 'Notes')\n",
    "accordion.selected_index = None\n",
    "page2 = widgets.VBox(children = [accordion, w_button])\n",
    "\n",
    "#page 3 = find agreements\n",
    "w_agr = interactive(collation_compare, table=fixed(collation), a=w1, b=w2)\n",
    "page3 = widgets.VBox(children = [w_agr, w2_html, w_descr, w_save])\n",
    "\n",
    "#page 4 = search\n",
    "w_search = interactive(search_collation, {'manual' : True, 'manual_name' : 'Search'}, table=fixed(collation),text=\"calpurnius\")\n",
    "page4 = widgets.VBox(children = [w_search, w3_html])\n",
    "\n",
    "#page 5 = clarify\n",
    "w_clar = interactive(print_info, rowID=w_rowID, wit=w_wit)\n",
    "page5 = widgets.VBox(children = [w_clar])\n",
    "\n",
    "tab.children = [page1, page2, page3, page4, page5]\n",
    "tab.set_title(0, 'Extract')\n",
    "tab.set_title(1, 'Modifications')\n",
    "tab.set_title(2, 'Find Agreements')\n",
    "tab.set_title(3, 'Search')\n",
    "tab.set_title(4, 'Clarify')\n",
    "\n",
    "display(tab)"
   ]
  }
 ],
 "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.5"
  },
  "livereveal": {
   "scroll": "True",
   "transition": "none"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}