pycoviz-appmode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# The Collation of Calpurnius Flaccus\n",
    "\n",
    "In this notebook, you can explore and analyze the collation of the *Declamations* of Calpurnius Flaccus obtained with [CollateX](collatex.net).\n",
    "\n",
    "## List of Witnesses\n",
    "There are six different documents compared in this collation: four manuscripts and two editions. Including corrections by second hands in the manuscripts, this makes a total of ten witnesses.\n",
    "\n",
    "\n",
    " * **B** Codex Monacensis Latinus 309, 15th century\n",
    " * **C** Codex Chigianus Latinus H VIII 8, 15th century\n",
    " * **LH** Håkanson's critical edition, 1978\n",
    " * **M** Codex Monacensis Latinus 316, 16th century\n",
    " * **N** Codex Bernensis (A) 9, 16th century\n",
    " * **P1594** Pithoeus editio princeps, 1594 (reprinted)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "#ipywidgets modules\n",
    "from __future__ import print_function\n",
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "from ipywidgets import Button, Layout, ButtonStyle\n",
    "import ipywidgets as widgets\n",
    "#python modules\n",
    "import json\n",
    "import sys\n",
    "import re\n",
    "from IPython.display import display,HTML,clear_output\n",
    "from datetime import datetime #for unique filenames\n",
    "import base64 #for download links\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "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": "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": "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": "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": "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": "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": "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": "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": "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": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def get_pos(row):\n",
    "    return collation.index(row)"
   ]
  },
  {
   "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": "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": "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": "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": "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_table = infile.read()\n",
    "    \n",
    "    #add base text to description\n",
    "    if base_text:\n",
    "        description = descr +'<br>Agreement with the base text '+base_text+' is marked in green.'\n",
    "        description += ' Variation from '+base_text+' is marked in red.' \n",
    "        \n",
    "    #modify template: replace the comment with description paragraph\n",
    "    html_table = re.sub(r'<!--descr-->',description,html_table)\n",
    "    \n",
    "    #modify template: replace the comment with table\n",
    "    html_table = re.sub(r'<!--table-->',table,html_table)\n",
    "    \n",
    "    #save\n",
    "    with open(path, 'w', encoding='utf-8') as outfile:\n",
    "        outfile.write(html_table)\n",
    "    \n",
    "    #generate download link\n",
    "    b64 = base64.b64encode(html_table.encode())\n",
    "    payload = b64.decode()\n",
    "    title = \"Download HTML file - \"+descr\n",
    "    filename = \"table.html\"\n",
    "    html = '<a download=\"{filename}\" href=\"data:text/csv;base64,{payload}\" target=\"_blank\">{title}</a>'\n",
    "    html = html.format(payload=payload,title=title,filename=filename)\n",
    "    return HTML(html)"
   ]
  },
  {
   "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.BoundedIntText(\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": "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": "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": "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 Interactions\n",
    "\n",
    "Possible interactions are grouped by category:\n",
    "1. **Extract**: view a collation extract.\n",
    "2. **Modifications**: update the collation by adding/deleting rows, moving tokens up or down, or adding/deleting notes.\n",
    "3. **Agreements**: select groups of witnesses to see what readings they have in common, against other witnesses.  \n",
    "Use cases: (1) selecting only witnesses from the first dropdown menu will show by default the readings they have in common against all others; (2) as a result, select only one witness in the first menu to see its unique readings. (3) Compare groups of witnesses: for instance, what do B, C and P1594 have in common against M and N? What do M, N and P1594 have in common against B and C? \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. one cell in the table (defined by a witness and a specific row)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "545f19cee1a84c6d8e1e02d8bebcbbca",
       "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",
    "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
}