qdat.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "eb0361ce",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2405204364.py, line 855)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/var/folders/l6/0_809sg93573s4dmbywnxgj80000gp/T/ipykernel_7679/2405204364.py\"\u001b[0;36m, line \u001b[0;32m855\u001b[0m\n\u001b[0;31m    update_rs_analysis():\u001b[0m\n\u001b[0m                         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
    "import ipywidgets as widgets\n",
    "import requests\n",
    "import json\n",
    "import ipyvuetify as viewtify\n",
    "\n",
    "my_headers        = {'accept' : 'application/json'}\n",
    "debug_flag        = True\n",
    "ls_init_display   = True\n",
    "rs_init_display   = True\n",
    "ls_qk_fvalues     = []\n",
    "rs_qk_fvalues     = []\n",
    "ls_eqn_comps      = []\n",
    "rs_eqn_comps      = []\n",
    "ls_dv_comps       = []\n",
    "rs_dv_comps       = []\n",
    "ls_eqn_elems      = []\n",
    "rs_eqn_elems      = []\n",
    "ls_eqn_btns       = []\n",
    "rs_eqn_btns       = []\n",
    "ls_dv_elems       = []\n",
    "ls_dv_vb_slabels  = []\n",
    "ls_dv_vb_dvlabels = []\n",
    "rs_dv_elems       = []\n",
    "rs_dv_vb_slabels  = []\n",
    "rs_dv_vb_dvlabels = []\n",
    "ls_eqn_eval       = ''\n",
    "rs_eqn_eval       = ''\n",
    "eqn_eval_text_un  = 'The equation is unbalanced'\n",
    "eqn_eval_text_bal = 'The equation is balanced'\n",
    "eqn_opers         = ['None', '+', '-', '*', '/', 'exp0.5', 'exp0.3', 'exp-1', 'exp-2', 'exp2', 'exp3', 'exp4', 'sin', 'cos', 'tan']\n",
    "\n",
    "\n",
    "# debug: A utility function to display debugging information (because I don't yet know a better way to debug)\n",
    "#\n",
    "# ARGUMENTS: variable, but first one will be a boolean flag, called debug_flag, to decide whether to print\n",
    "#            this statement. There is a global debug flag that is tested in the debug function definition\n",
    "# ALGORITHM: (1) Test to see if the global debug flag is set to True\n",
    "#                (a) If so, test to see if the 'local' debug flag (argument 0) is True\n",
    "#                    (i) If so, for the remaining arguments\n",
    "#                        (o) Print the argument\n",
    "\n",
    "def debug(*args):\n",
    "    if (debug_flag == True):\n",
    "        if (args[0] == True):\n",
    "            for arg in args[1:]:\n",
    "                print(arg)\n",
    "\n",
    "# Initialize the app title, help Text widget and start_value Text widget\n",
    "\n",
    "file           = open(\"qudt_logo-300x110.png\", \"rb\")\n",
    "image          = file.read()\n",
    "label_style    = {'description_width' : 'initial'}\n",
    "titleLabel     = widgets.HTML(value  = '<a href = \"qadt_help.html\"><b>Dimensional Analysis Tool</b></a>')\n",
    "title_text     = viewtify.Html(tag   = \"div\", children = ['Dimensional Analysis Tool'], style_ = \" color: #194188; font-family: helvetica; font-size: 20px\")\n",
    "#title_text     = viewtify.Html(tag = \"div\", children = [titleLabel], style_ = \" color: #194188; font-family: helvetica; font-size: 20px\") # colors.indigo.darken4  194188\n",
    "titleBox       = widgets.HBox([widgets.Image(value = image, format = 'png', width = 75, height = 27), title_text])\n",
    "ls_qk_text     = widgets.Text(value  = '', description = 'Type quantity kind name', style = label_style, disabled = False)\n",
    "rs_qk_text     = widgets.Text(value  = '', description = 'Type quantity kind name', style = label_style, disabled = False)\n",
    "lseqnLabel     = widgets.Label(value = 'Left Side of Equation')\n",
    "rseqnLabel     = widgets.Label(value = 'Right Side of Equation')\n",
    "evalHTML_UN    = viewtify.Html(tag   = \"div\", children = [eqn_eval_text_un], style_ = \" color: Red; font-family: helvetica; font-size: 20px; font-weight: Bold\")\n",
    "evalHTML_BAL   = viewtify.Html(tag   = \"div\", children = [eqn_eval_text_bal], style_ = \" color: Green; font-family: helvetica; font-size: 20px; font-weight: Bold\")\n",
    "evalBoxUN      = widgets.HBox([evalHTML_UN])\n",
    "evalBoxBAL     = widgets.HBox([evalHTML_BAL])\n",
    "evalBox        = widgets.HBox()\n",
    "evalBox.children = [evalHTML_UN]\n",
    "\n",
    "ls_qk_text_len = 0\n",
    "rs_qk_text_len = 0\n",
    "\n",
    "opers_dd = widgets.Dropdown(\n",
    "    options     = eqn_opers,\n",
    "    description = 'Possible operators:',\n",
    "    style       = label_style,\n",
    "    disabled    = True,\n",
    ")\n",
    "\n",
    "\n",
    "# qk_get_request: Constructs and issues the quantity kind SPARQL query, converts to json, \n",
    "#                 and parses the ressulting results and bindings values. The bindings are returned.\n",
    "#\n",
    "# ARGUMENTS: qk_text  - the text in the qk_text field\n",
    "# RETURN:    stubinds - the SPARQL query bindings array\n",
    "# CALLED BY: update_options_from_qk_text\n",
    "\n",
    "def qk_get_request(qk_text):\n",
    "    qk_query_start = \"https://qudt.org/fuseki/qudt/query?query=PREFIX qudt: <http://qudt.org/schema/qudt/> PREFIX quantitykind: <http://qudt.org/schema/qudt/quantitykind/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema%23> PREFIX fn: <http://www.w3.org/2005/xpath-functions%23> SELECT ?qk ?qkl ?qks WHERE { ?qk a qudt:QuantityKind . ?qk rdfs:label ?qkl . ?qk qudt:symbol ?qks . FILTER (fn:starts-with(?qkl, %22\"\n",
    "    qk_query_end   = \"%22)) . }\"\n",
    "    qk_query       = qk_query_start + qk_text + qk_query_end\n",
    "    qk_response    = requests.get(qk_query, headers = my_headers)\n",
    "    qk_data        = qk_response.json()\n",
    "    qk_results     = qk_data['results']\n",
    "    qk_binds       = qk_results['bindings']\n",
    "\n",
    "    return qk_binds\n",
    "\n",
    "\n",
    "# get_qks: Parses the 'qk' value array from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj     - a bindings array\n",
    "# RETURN:    qk_value, qk_label, qk_symbol tuples - the quantity kind SPARQL query array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qks(obj):\n",
    "    qk_tuples = []\n",
    "    i         = 0\n",
    "\n",
    "    for item in obj:\n",
    "        elem_qk = item['qk']\n",
    "        elem_qk_value = elem_qk['value']\n",
    "        elem_qkl = item['qkl']\n",
    "        elem_qkl_value = elem_qkl['value']\n",
    "        elem_qks = item['qks']\n",
    "        elem_qks_value = elem_qks['value']\n",
    "        elem_item = (elem_qk_value, elem_qkl_value, elem_qks_value)\n",
    "        qk_tuples.append(elem_item)\n",
    "        i += 1\n",
    "\n",
    "    debug(False, 'qk_tuples:', qk_tuples)\n",
    "    return qk_tuples\n",
    "\n",
    "\n",
    "# get_qk_values: Parses the 'qk' value array from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj     - a bindings array\n",
    "# RETURN:    qlabels - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qk_values(obj):\n",
    "    qk_values = []\n",
    "    i         = 0\n",
    "\n",
    "    for item in obj:\n",
    "        elem = item['qk']\n",
    "        qk_values.append(elem['value'])\n",
    "        i += 1\n",
    "\n",
    "    return qk_values\n",
    "\n",
    "\n",
    "# get_qk_labels: Parses the 'qkl' label array from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj     - a bindings array\n",
    "# RETURN:    qlabels - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qk_labels(obj):\n",
    "    qk_labels = []\n",
    "    i         = 0\n",
    "\n",
    "    for item in obj:\n",
    "        elem = item['qkl']\n",
    "        qk_labels.append(elem['value'])\n",
    "        i += 1\n",
    "\n",
    "    return qk_labels\n",
    "\n",
    "\n",
    "# get_qk_symbols: Parses the 'qk' symbol array from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj       - a bindings array\n",
    "# RETURN:    qksymbols - the quantity kind SPARQL query symbols array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qk_symbols(obj):\n",
    "    qk_symbols = []\n",
    "    i          = 0\n",
    "\n",
    "    for item in obj:\n",
    "        elem = item['qks']\n",
    "        qk_symbols.append(elem['value'])\n",
    "        i += 1\n",
    "\n",
    "    return qk_symbols\n",
    "\n",
    "\n",
    "# get_qk_labels_and_symbols: Concatenates quantity kind labels and symbols.\n",
    "#\n",
    "# ARGUMENTS: qkls, qkss - the labels and symbols arrays\n",
    "# RETURN:    qklsss     - the concatenation of labels and symbols array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qk_labels_and_symbols(qks):\n",
    "    qklsss = []\n",
    "    i      = 0\n",
    "\n",
    "    while i < len(qks):\n",
    "        lelem = (qks[i])[1]\n",
    "        selem = (qks[i])[2]\n",
    "        qklsss.append(lelem + \" - \" + selem)\n",
    "        i += 1\n",
    "\n",
    "    debug(False, 'qklsss:', qklsss)\n",
    "    return qklsss\n",
    "\n",
    "\n",
    "# get_qk_symbol_and_dv: Concatenates quantity kind symbol and dimension vector. NOT FINISHED YET\n",
    "#\n",
    "# ARGUMENTS: qks, qkdv - the quantity kind symbol and dimension vector\n",
    "# RETURN:    qklsss     - the concatenation of labels and symbols array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_qk_symbol_and_dv(qks, qkdv):\n",
    "    return qks + qkdv\n",
    "\n",
    "# Initialize the ls_qk_dd and rs_qk_dd content (options) by calling the request and constructing \n",
    "# the values, labels, symbols, and concatenated values arrays\n",
    "\n",
    "ls_qk_binds       = qk_get_request(ls_qk_text.value)\n",
    "ls_qks            = get_qks(ls_qk_binds)\n",
    "ls_qk_values      = get_qk_values(ls_qk_binds)\n",
    "ls_qk_labels      = get_qk_labels(ls_qk_binds)\n",
    "ls_qk_symbols     = get_qk_symbols(ls_qk_binds)\n",
    "ls_qk_ls_and_ss   = get_qk_labels_and_symbols(ls_qks)\n",
    "cur_ls_qks        = ls_qks\n",
    "ls_qk_values_cur  = ls_qk_values\n",
    "ls_qk_labels_cur  = ls_qk_labels\n",
    "ls_qk_symbols_cur = ls_qk_symbols\n",
    "\n",
    "rs_qk_binds       = qk_get_request(rs_qk_text.value)\n",
    "rs_qks            = get_qks(rs_qk_binds)\n",
    "rs_qk_values      = get_qk_values(rs_qk_binds)\n",
    "rs_qk_labels      = get_qk_labels(rs_qk_binds)\n",
    "rs_qk_symbols     = get_qk_symbols(rs_qk_binds)\n",
    "rs_qk_ls_and_ss   = get_qk_labels_and_symbols(rs_qks)\n",
    "cur_rs_qks        = rs_qks\n",
    "rs_qk_values_cur  = rs_qk_values\n",
    "rs_qk_labels_cur  = rs_qk_labels\n",
    "rs_qk_symbols_cur = rs_qk_symbols\n",
    "\n",
    "# Construct the ls_qk_dd Dropdown widget\n",
    "\n",
    "ls_qk_dd = widgets.Dropdown(\n",
    "    options     = ls_qk_ls_and_ss,\n",
    "    description = 'Possible quantity kinds:',\n",
    "    style       = label_style,\n",
    "    disabled    = False,\n",
    ")\n",
    "\n",
    "# Construct the ls_qk_dd Dropdown widget for values. This is not used. It is a place to store values and is a HACK.\n",
    "\n",
    "ls_qkv_dd = widgets.Dropdown(\n",
    "    options     = ls_qk_values,\n",
    "    description = 'Possible quantity kinds values:',\n",
    "    style       = label_style,\n",
    "    disabled    = True,\n",
    ")\n",
    "\n",
    "# Construct the ls_qk_dd Dropdown widget for values. This is not used. It is a place to store values and is a HACK.\n",
    "\n",
    "ls_qks_dd = widgets.Dropdown(\n",
    "    options     = ls_qk_symbols,\n",
    "    description = 'Possible quantity kinds symbols:',\n",
    "    style       = label_style,\n",
    "    disabled    = True,\n",
    ")\n",
    "\n",
    "# Construct the ls_qk_button Button widget\n",
    "\n",
    "ls_qk_button = widgets.Button(\n",
    "    description = 'Add Quantity',\n",
    "    disabled    = False,\n",
    "    icon        = 'check',\n",
    "    align       = 'right'\n",
    ")\n",
    "\n",
    "# Construct the rs_qk_dd Dropdown widget\n",
    "\n",
    "rs_qk_dd = widgets.Dropdown(\n",
    "    options     = rs_qk_ls_and_ss,\n",
    "    description = 'Possible quantity kinds:',\n",
    "    style       = label_style,\n",
    "    disabled    = False,\n",
    ")\n",
    "\n",
    "# Construct the rs_qk_dd Dropdown widget for values. This is not used. It is a place to store values and is a HACK.\n",
    "\n",
    "rs_qkv_dd = widgets.Dropdown(\n",
    "    options     = rs_qk_values,\n",
    "    description = 'Possible quantity kinds values:',\n",
    "    style       = label_style,\n",
    "    disabled    = True,\n",
    ")\n",
    "\n",
    "# Construct the rs_qk_dd Dropdown widget for symbols. This is not used. It is a place to store symbols and is a HACK.\n",
    "\n",
    "rs_qks_dd = widgets.Dropdown(\n",
    "    options     = rs_qk_symbols,\n",
    "    description = 'Possible quantity kinds symbols:',\n",
    "    style       = label_style,\n",
    "    disabled    = True,\n",
    ")\n",
    "\n",
    "# Construct the rs_qk_button Button widget\n",
    "\n",
    "rs_qk_button = widgets.Button(\n",
    "    description = 'Add Quantity',\n",
    "    disabled    = False,\n",
    "    icon        = 'check',\n",
    "    align       = 'right'\n",
    ")\n",
    "\n",
    "\n",
    "# restrict_ls_qk_labels: Restricts the content of the qk_dd dropdown options in qk_labels\n",
    "#                        list and the qk_text. Used by both sides of the equation.\n",
    "#\n",
    "# CALLED BY: update_ls_qk_options_from_input_text\n",
    "# CALLS:     [python] startswith, append\n",
    "\n",
    "def restrict_ls_qk_labels(qks, vlist, llist, slist, txt):\n",
    "    global cur_ls_qks\n",
    "    global filtered_ls_qks\n",
    "\n",
    "    item      = qks[0]\n",
    "    orig_item = ls_qks[0]\n",
    "    test      = item[1] == orig_item[1]\n",
    "\n",
    "    debug(False, 'test:', test)\n",
    "\n",
    "    filtered_ls_qks   = []\n",
    "    cur_ls_qks        = qks\n",
    "\n",
    "    for qk_item in qks:\n",
    "        qk_item_value  = qk_item[0]\n",
    "        qk_item_label  = qk_item[1]\n",
    "        qk_item_symbol = qk_item[2]\n",
    "        debug(False, 'txt: ' + txt, 'qk_item_label: ' + qk_item_label)\n",
    "\n",
    "        if test == True and qk_item_label.startswith(txt):\n",
    "            new_qk_item_label = qk_item[1] + ' - ' + qk_item[2]\n",
    "            debug(False, 'new_qk_item_label: ' + new_qk_item_label)\n",
    "            new_qk_tuple = (qk_item_value, new_qk_item_label, qk_item_symbol)\n",
    "            filtered_ls_qks.append(new_qk_tuple)\n",
    "        elif qk_item_label.startswith(txt):\n",
    "            debug(False, 'qk_item_label', qk_item_label)\n",
    "            filtered_ls_qks.append(qk_item)\n",
    "            debug(False, 'filtered_ls_qks:', filtered_ls_qks)\n",
    "        \n",
    "    if (len(filtered_ls_qks) > 0):\n",
    "        debug(False, 'In restrict_ls_qk_labels - End', (filtered_ls_qks[0])[1], (filtered_ls_qks[0])[0])\n",
    "\n",
    "    return filtered_ls_qks\n",
    "\n",
    "\n",
    "# restrict_rs_qk_labels: Restricts the content of the qk_dd dropdown options in qk_labels\n",
    "#                        list and the qk_text. Used by both sides of the equation.\n",
    "#\n",
    "# CALLED BY: update_rs_qk_options_from_input_text\n",
    "# CALLS:     [python] startswith, append\n",
    "\n",
    "def restrict_rs_qk_labels(qks, vlist, llist, slist, txt):\n",
    "    global cur_rs_qks\n",
    "    global filtered_rs_qks\n",
    "\n",
    "    debug(False, 'In restrict_rs_qk_labels - START')\n",
    "\n",
    "    item      = qks[0]\n",
    "    orig_item = rs_qks[0]\n",
    "    test      = item[1] == orig_item[1]\n",
    "\n",
    "    debug(False, 'test:', test)\n",
    "    \n",
    "    filtered_rs_qks = []\n",
    "    cur_rs_qks      = qks\n",
    "\n",
    "    for qk_item in qks:\n",
    "        qk_item_value  = qk_item[0]\n",
    "        qk_item_label  = qk_item[1]\n",
    "        qk_item_symbol = qk_item[2]\n",
    "        debug(False, 'txt: ' + txt, 'qk_item_label: ' + qk_item_label)\n",
    "\n",
    "        if test == True and qk_item_label.startswith(txt):\n",
    "            new_qk_item_label = qk_item[1] + ' - ' + qk_item[2]\n",
    "            debug(False, 'new_qk_item_label: ' + new_qk_item_label)\n",
    "            new_qk_tuple = (qk_item_value, new_qk_item_label, qk_item_symbol)\n",
    "            filtered_rs_qks.append(new_qk_tuple)\n",
    "        elif qk_item_label.startswith(txt):\n",
    "            filtered_rs_qks.append(qk_item)\n",
    "\n",
    "    if (len(filtered_rs_qks) > 0):\n",
    "        debug(False, 'In restrict_rs_qk_labels - END', (filtered_rs_qks[0])[1], (filtered_rs_qks[0])[0])\n",
    "\n",
    "    return filtered_rs_qks\n",
    "\n",
    "\n",
    "# on_change_lsqkt: Handles changes to the quantity kind input text widget\n",
    "#\n",
    "# CALLED BY: Changes to ls_qk_text value\n",
    "# CALLS:     update_qk_options_from_input_text\n",
    "\n",
    "def on_change_lsqkt(change):\n",
    "    if change['type'] == 'change' and change['name'] == 'value':\n",
    "        txt_filter_result = update_ls_qk_options_from_input_text()\n",
    "\n",
    "ls_qk_text.observe(on_change_lsqkt)\n",
    "\n",
    "\n",
    "# update_ls_qk_options_from_input_text: Performs model updates downstream of a changed selection in the quant_dd\n",
    "#                                       dropdown. That is, it updates the start_unit_dd and target_unit_dd \n",
    "#                                       model (options) contents, the conversion multipliers, and the converted \n",
    "#                                       value.\n",
    "#\n",
    "# ARGUMENTS: text (value of the ls_qk_text widget)\n",
    "# CALLED BY: on_change_lsqkt\n",
    "# CALLS:     construct_qk_tuples_from_options\n",
    "#            restrict_qk_labels\n",
    "#            get_tuples_components\n",
    "\n",
    "def update_ls_qk_options_from_input_text():\n",
    "    global ls_qk_text_len\n",
    "\n",
    "    debug(False, 'In update_ls_qk_options_from_input_text')\n",
    "\n",
    "    qk_text_v = ls_qk_text.value if ls_qk_text.value else \"\"\n",
    "\n",
    "    if len(qk_text_v) > ls_qk_text_len:\n",
    "        qks_start        = construct_qk_tuples_from_options(ls_qkv_dd.options, ls_qk_dd.options, ls_qks_dd.options)\n",
    "        qk_values_start  = ls_qkv_dd.options\n",
    "        qk_labels_start  = ls_qk_dd.options\n",
    "        qk_symbols_start = ls_qks_dd.options\n",
    "    elif len(qk_text_v) > 0:\n",
    "        qks_start        = cur_ls_qks\n",
    "        qk_values_start  = ls_qk_values_cur\n",
    "        qk_labels_start  = ls_qk_labels_cur\n",
    "        qk_symbols_start = ls_qk_symbols_cur\n",
    "    else:\n",
    "        debug(False, 'qk_text_v length is 0')\n",
    "        qks_start        = ls_qks # get_qk_labels_and_symbols (NOPE!)\n",
    "        qk_values_start  = ls_qk_values\n",
    "        qk_labels_start  = ls_qk_labels\n",
    "        qk_symbols_start = ls_qk_symbols\n",
    "\n",
    "    ls_qk_text_len = len(qk_text_v)\n",
    "    result         = restrict_ls_qk_labels(qks_start, qk_values_start, qk_labels_start, qk_symbols_start, qk_text_v)\n",
    "\n",
    "    if len(result) > 0:\n",
    "        result_arrays     = get_tuples_components(result)\n",
    "        ls_qkv_dd.options = result_arrays[0]\n",
    "        ls_qk_dd.options  = result_arrays[1]\n",
    "        ls_qks_dd.options = result_arrays[2]\n",
    "    else:\n",
    "        qk_text_start    = ls_qk_text.value\n",
    "        ls_qk_text.value = qk_text_start[0: ls_qk_text_len - 1:1]\n",
    "\n",
    "\n",
    "# construct_qk_tuples_from_options: Given lists of values, lavels, and symbols, construct a list\n",
    "#                                   of tuples from their aggregated values\n",
    "# ARGUMENTS: value_options  - The list of values\n",
    "#            label_options  - The list of labels\n",
    "#            symbol_options - The list of symbols\n",
    "# CALLED BY: update_ls_qk_options_from_input_text\n",
    "\n",
    "def construct_qk_tuples_from_options(value_options, label_options, symbol_options):\n",
    "    result = []\n",
    "    i      = 0\n",
    "    while (i < len(value_options)):\n",
    "        rtuple = (value_options[i], label_options[i], symbol_options[i])\n",
    "        result.append(rtuple)\n",
    "        i += 1\n",
    "\n",
    "    return result\n",
    "\n",
    "\n",
    "# get_tuples_components: Given a list of tuples separate them out into their value, label, and symbol component\n",
    "#                        lists and return them as a tuple\n",
    "# ARGUMENTS: tuples - The list of tuples to separate\n",
    "# CALLED BY: update_ls_qk_options_from_input_text\n",
    "\n",
    "def get_tuples_components(tuples): # get_qk_labels_and_symbols\n",
    "    value_options  = []\n",
    "    label_options  = []\n",
    "    symbol_options = []\n",
    "\n",
    "    for tuple in tuples:\n",
    "        value_options.append(tuple[0])\n",
    "        label_options.append(tuple[1])\n",
    "        symbol_options.append(tuple[2])\n",
    "\n",
    "    return value_options, label_options, symbol_options\n",
    "\n",
    "\n",
    "# on_change_rsqkt: Handles changes to the quantity kind input text widget\n",
    "#\n",
    "# CALLED BY: Changes to rs_qk_text value\n",
    "# CALLS:     update_rs_qk_options_from_input_text\n",
    "\n",
    "def on_change_rsqkt(change):\n",
    "    if change['type'] == 'change' and change['name'] == 'value':\n",
    "        update_rs_qk_options_from_input_text()\n",
    "\n",
    "rs_qk_text.observe(on_change_rsqkt)\n",
    "\n",
    "\n",
    "# update_rs_qk_options_from_input_text: Performs model updates downstream of a changed selection in the quant_dd\n",
    "#                                       dropdown. That is, it updates the start_unit_dd and target_unit_dd \n",
    "#                                       model (options) contents, the conversion multipliers, and the converted \n",
    "#                                       value.\n",
    "#\n",
    "# ARGUMENTS: text (value of the ls_qk_text widget)\n",
    "# CALLED BY: on_change_lsqkt\n",
    "# CALLS:     restrict_qk_labels\n",
    "\n",
    "def update_rs_qk_options_from_input_text():\n",
    "    debug(False, 'In update_rs_qk_options_from_input_text')\n",
    "    global rs_qk_text_len\n",
    "    qk_text_v = rs_qk_text.value if rs_qk_text.value else \"\"\n",
    "\n",
    "    if len(qk_text_v) > rs_qk_text_len:\n",
    "        qks_start        = construct_qk_tuples_from_options(rs_qkv_dd.options, rs_qk_dd.options, rs_qks_dd.options)\n",
    "        qk_values_start  = rs_qkv_dd.options\n",
    "        qk_labels_start  = rs_qk_dd.options\n",
    "        qk_symbols_start = rs_qks_dd.options\n",
    "    elif len(qk_text_v) > 0:\n",
    "        qks_start        = cur_rs_qks\n",
    "        qk_values_start  = rs_qk_values_cur\n",
    "        qk_labels_start  = rs_qk_labels_cur\n",
    "        qk_symbols_start = rs_qk_symbols_cur\n",
    "    else:\n",
    "        qks_start        = rs_qks\n",
    "        qk_values_start  = rs_qk_values\n",
    "        qk_labels_start  = rs_qk_labels\n",
    "        qk_symbols_start = rs_qk_symbols\n",
    "\n",
    "    rs_qk_text_len = len(qk_text_v)\n",
    "    result         = restrict_rs_qk_labels(qks_start, qk_values_start, qk_labels_start, qk_symbols_start, qk_text_v)\n",
    "\n",
    "    if len(result[0]) > 0:\n",
    "        result_arrays     = get_tuples_components(result)\n",
    "        debug(False, result_arrays[1])\n",
    "        rs_qkv_dd.options = result_arrays[0]\n",
    "        rs_qk_dd.options  = result_arrays[1]\n",
    "        rs_qks_dd.options = result_arrays[2]\n",
    "    else:\n",
    "        qk_text_start    = rs_qk_text.value\n",
    "        rs_qk_text.value = qk_text_start[0: rs_qk_text_len - 1:1]\n",
    "\n",
    "\n",
    "# on_change_lsqkb: Handles changes to the quantity kind button widget\n",
    "#\n",
    "# CALLED BY: Changes to ls_qk_button value\n",
    "# CALLS:     update_ls_eqn_from_button\n",
    "\n",
    "def on_change_lsqkb(change):\n",
    "    debug(False, 'In on_change_lsqkb')\n",
    "    update_ls_eqn_from_button()\n",
    "\n",
    "ls_qk_button.on_click(on_change_lsqkb)\n",
    "\n",
    "\n",
    "# update_ls_eqn_from_button: Performs model updates downstream of a left equation side button selection\n",
    "#                            It updates the left side equation quantity list and gets the selected\n",
    "#                            quantity kind's dimension vector and adds to the left side equation dimension\n",
    "#                            vector list.\n",
    "#\n",
    "# ALGORITHM: (1) Append the selected quantity kind to the equation elements list\n",
    "#            (2) Get the associated dimension vector for this quantity kind\n",
    "#            (3) Construct the symbol/dimension vector string\n",
    "#            (4) Append the string to the dimension vector list\n",
    "#\n",
    "# CALLED BY: on_change_lsqkb\n",
    "# CALLS:     update_eqn_elem_content\n",
    "#            eqn_elem_dv_get_request\n",
    "#            get_ls_eqn_elem_dv_value\n",
    "#            get_ls_eqn_elem_dv_label\n",
    "#            construct_qk_symbols_dv_tuple\n",
    "#            update_ls_eqn_dv_content\n",
    "#            qk_value_for_elem_symbol\n",
    "#            eqn_elem_dv_exps_get_request\n",
    "#            get_eqn_elem_amount_exp_value\n",
    "#            get_eqn_elem_current_exp_value\n",
    "#            get_eqn_elem_length_exp_value\n",
    "#            get_eqn_elem_luminosity_exp_value\n",
    "#            get_eqn_elem_mass_exp_value\n",
    "#            get_eqn_elem_temperature_exp_value\n",
    "#            get_eqn_elem_time_exp_value\n",
    "#            get_eqn_elem_dimensionless_exp_value\n",
    "#            construct_eval_dv_from_exps\n",
    "\n",
    "def update_ls_eqn_from_button(*args): # *args represent zero (case here) or more arguments.\n",
    "    global ls_eqn_elems\n",
    "    global ls_init_display\n",
    "    global ls_dv_elems\n",
    "    global ls_eqn_eval\n",
    "\n",
    "    lsevalamtexp      = 0\n",
    "    lsevalcrtexp      = 0\n",
    "    lsevallthexp      = 0\n",
    "    lsevalluminexp    = 0\n",
    "    lsevalmassexp     = 0\n",
    "    lsevaltempexp     = 0\n",
    "    lsevaltimeexp     = 0\n",
    "    lsevaldlessexp    = 0\n",
    "    ls_eqn_eval_items = []\n",
    "\n",
    "    debug(False, 'In update_ls_eqn_from_button')\n",
    "    debug(False, 'length of ls_eqn_elems before update: ' + str(len(ls_eqn_elems)))\n",
    "    debug(False, 'ls_eqn_elems BEFORE update: ', ls_eqn_elems)\n",
    "    debug(False, 'length of ls_dv_elems efore update: ' + str(len(ls_dv_elems)))\n",
    "\n",
    "    selected_qk_label = ls_qk_dd.options[ls_qk_dd.index]\n",
    "    selected_elem     = find_elem_tuple_from_option_label(selected_qk_label, ls_qks)\n",
    "    debug(False, 'selected_elem:', selected_elem)\n",
    "\n",
    "    if (ls_init_display == False):\n",
    "        ls_eqn_elems.append(selected_elem)\n",
    "\n",
    "    update_ls_eqn_elem_content(selected_elem)\n",
    "\n",
    "    debug(False, 'length of ls_eqn_elems AFTER update: ' + str(len(ls_eqn_elems)), 'ls_eqn_elems after update:', ls_eqn_elems)\n",
    "    debug(False, 'length of ls_eqn_btns AFTER update: ' + str(len(ls_eqn_btns)), 'ls_eqn_btns after update:', ls_eqn_btns)\n",
    "\n",
    "    # Get the dimension vector for the selected quantity kind\n",
    "\n",
    "    lseqndv_binds = eqn_elem_dv_get_request(ls_qkv_dd.options[ls_qk_dd.index])\n",
    "    lseqndvv      = get_eqn_elem_dv_value(lseqndv_binds)\n",
    "    debug(False, 'lseqndvv: ', lseqndvv)\n",
    "    lseqndvl      = get_eqn_elem_dv_label(lseqndv_binds)\n",
    "\n",
    "    # Construct the quantity kind, label, and symbol tuple\n",
    "\n",
    "    lseqnqksdv = construct_qk_symbols_dv_tuple(ls_qk_dd.options[ls_qk_dd.index], lseqndvl, ls_qkv_dd.options, ls_qk_dd.options, ls_qks_dd.options)\n",
    "\n",
    "    debug(False, 'ls_dv_elems BEFORE update:', ls_dv_elems, 'lseqnqksdv:', lseqnqksdv)\n",
    "\n",
    "    if (ls_init_display == False):\n",
    "        ls_dv_elems.append(lseqnqksdv)\n",
    "\n",
    "    update_ls_eqn_dv_content(lseqnqksdv)\n",
    "\n",
    "    debug(False, 'length of ls_dv_elems AFTER update: ' + str(len(ls_dv_elems)), 'ls_dv_elems AFTER update', ls_dv_elems)\n",
    "\n",
    "    ls_init_display = False\n",
    "\n",
    "    # Construct evaluation component content (not really written yet but will have to include these kinds of things)\n",
    "\n",
    "    if (len(ls_eqn_elems) == 1):\n",
    "        ls_eqn_eval = lseqnqksdv[3]\n",
    "    else:\n",
    "        for eqn_elem in ls_eqn_elems:\n",
    "            debug(False, 'Construct evaluation component')\n",
    "            debug(False, 'eqn_elem: ', eqn_elem, 'ls_qk_symbols:', ls_qk_symbols, 'ls_qk_values', ls_qk_values)\n",
    "#            ls_qk_value     = qk_value_for_eqn_elem(eqn_elem)\n",
    "            ls_qk_value     = eqn_elem[0]\n",
    "            debug(False, 'ls_qk_value: ', ls_qk_value)\n",
    "            lsevalexp_binds = eqn_elem_dv_exps_get_request(ls_qk_value)\n",
    "            debug(False, 'lsevalexp_binds:', lsevalexp_binds)\n",
    "            lsevalamtexp   += get_eqn_elem_amount_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevalamtexp: ' + str(lsevalamtexp))\n",
    "            lsevalcrtexp   += get_eqn_elem_current_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevalcrtexp: ' + str(lsevalcrtexp))\n",
    "            lsevallthexp   += get_eqn_elem_length_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevallthexp: ' + str(lsevallthexp))\n",
    "            lsevalluminexp += get_eqn_elem_luminosity_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevalluminexp: ' + str(lsevalluminexp))\n",
    "            lsevalmassexp  += get_eqn_elem_mass_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevalmassexp: ' + str(lsevalmassexp))\n",
    "            lsevaltempexp  += get_eqn_elem_temperature_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevaltempexp: ' + str(lsevaltempexp))\n",
    "            lsevaltimeexp  += get_eqn_elem_time_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevaltimeexp: ' + str(lsevaltimeexp))\n",
    "            lsevaldlessexp += get_eqn_elem_dimensionless_exp_value(lsevalexp_binds)\n",
    "            debug(False, 'lsevaldlessexp: ' + str(lsevaldlessexp))\n",
    "\n",
    "        ls_eqn_eval = construct_eval_dv_from_exps(lsevalamtexp, lsevalcrtexp, lsevallthexp, lsevalluminexp, lsevalmassexp, lsevaltempexp, lsevaltimeexp, lsevaldlessexp)\n",
    "\n",
    "    lseqnevallabel    = widgets.Label(layout = eval_vb_item_layout, value = ls_eqn_eval)\n",
    "    ls_eqn_eval_items.append(lseqnevallabel)\n",
    "    lsDABox.children  = ls_eqn_eval_items\n",
    "\n",
    "    if (ls_eqn_eval == rs_eqn_eval):\n",
    "        debug(False, 'ls balanced')\n",
    "        evalBox.children = [evalHTML_BAL]\n",
    "    else:\n",
    "        debug(False, 'ls unbalanced')\n",
    "        evalBox.children = [evalHTML_UN]\n",
    "\n",
    "\n",
    "# find_elem_tuple_from_option_label: Given a label, match it to the lapel in tuples and return the matching tuple\n",
    "#\n",
    "# ARGUMENTS: label  - the label for the tuple we are looking\n",
    "#            tuples - the list of tuples to test against\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "#            update_rs_eqn_from_button\n",
    "# RETURN:    tuple  - the desired tuple\n",
    "\n",
    "def find_elem_tuple_from_option_label(label, tuples):\n",
    "    debug(False, 'In find_elem_tuple - label: ' + label)\n",
    "\n",
    "    for tuple in tuples:\n",
    "        tlabel  = tuple[1]\n",
    "        tsymbol = tuple[2]\n",
    "        qklsss  = tlabel + \" - \" + tsymbol\n",
    "        debug(False, 'label: ' + label, 'tuple label: ' + qklsss)\n",
    "\n",
    "#        if (label == qklsss):\n",
    "        if (label.startswith(tlabel)):\n",
    "            return tuple\n",
    "\n",
    "\n",
    "# qk_value_for_eqn_elem: Given an equation element, return the value for the element\n",
    "# ARGUMENTS: eqn_elem - An eqn element\n",
    "# RETURN:    The value component of the eqn element\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "#            update_rs_eqn_from_button\n",
    "\n",
    "def qk_value_for_eqn_elem(eqn_elem):\n",
    "    return eqn_elem[0]\n",
    "\n",
    "#def qk_value_for_elem_symbol(eqn_elem_symbol, qks, qk_symbols, qk_labels, qk_values):\n",
    "#    qk_label = ''\n",
    "#    i        = 0\n",
    "#    while (i < len(qk_symbols)):\n",
    "#        qk_symbol = qk_symbols[i]\n",
    "#        qk_label  = qk_labels[i]\n",
    "#        if (str(qk_symbol) == eqn_elem_symbol and qk_label):\n",
    "#            qk_value = qk_values[i]\n",
    "#            return qk_value\n",
    "#        i += 1\n",
    "\n",
    "\n",
    "# on_change_rsqkb: Handles changes to the quantity kind button widget\n",
    "#\n",
    "# CALLED BY: Changes to ls_qk_button value\n",
    "# CALLS:     update_ls_eqn_from_button\n",
    "\n",
    "def on_change_rsqkb(change):\n",
    "    update_rs_eqn_from_button()\n",
    "\n",
    "rs_qk_button.on_click(on_change_rsqkb)\n",
    "\n",
    "\n",
    "# update_rs_eqn_from_button: Performs model updates downstream of a right equation side button selection\n",
    "#                            It updates the right side equation quantity list and gets the selected\n",
    "#                            quantity kind's dimension vector and adds to the right side equation dimension\n",
    "#                            vector list.\n",
    "#\n",
    "# ALGORITHM: (1) Append the selected quantity kind to the equation elements list\n",
    "#            (2) Get the associated dimension vector for this quantity kind\n",
    "#            (3) Construct the symbol/dimension vector string\n",
    "#            (4) Append the string to the dimension vector list\n",
    "#\n",
    "# CALLED BY: on_change_rsqkb\n",
    "# CALLS:     update_eqn_elem_content\n",
    "#            eqn_elem_dv_get_request\n",
    "#            get_rs_eqn_elem_dv_value\n",
    "#            get_rs_eqn_elem_dv_label\n",
    "#            construct_qk_symbols_dv_tuple\n",
    "#            update_rs_eqn_dv_content\n",
    "#            qk_value_for_qk_label\n",
    "#            eqn_elem_dv_exps_get_request\n",
    "#            get_eqn_elem_amount_exp_value\n",
    "#            get_eqn_elem_current_exp_value\n",
    "#            get_eqn_elem_length_exp_value\n",
    "#            get_eqn_elem_luminosity_exp_value\n",
    "#            get_eqn_elem_mass_exp_value\n",
    "#            get_eqn_elem_temperature_exp_value\n",
    "#            get_eqn_elem_time_exp_value\n",
    "#            get_eqn_elem_dimensionless_exp_value\n",
    "#            construct_eval_dv_from_exps\n",
    "\n",
    "def update_rs_eqn_from_button(*args): # *args represent zero (case here) or more arguments.\n",
    "    global rs_eqn_elems\n",
    "    global rs_init_display\n",
    "    global rs_dv_elems\n",
    "    global rs_eqn_eval\n",
    "\n",
    "    rsevalamtexp      = 0\n",
    "    rsevalcrtexp      = 0\n",
    "    rsevallthexp      = 0\n",
    "    rsevalluminexp    = 0\n",
    "    rsevalmassexp     = 0\n",
    "    rsevaltempexp     = 0\n",
    "    rsevaltimeexp     = 0\n",
    "    rsevaldlessexp    = 0\n",
    "    rs_eqn_eval_items = []\n",
    "\n",
    "    debug(False, 'In update_rs_eqn_from_button - rs_qk_dd.index: ' + str(rs_qk_dd.index))\n",
    "    debug(False, 'rs_eqn_elems BEFORE append:', rs_eqn_elems)\n",
    "\n",
    "    selected_qk_label = rs_qk_dd.options[rs_qk_dd.index]\n",
    "    selected_elem     = find_elem_tuple_from_option_label(selected_qk_label, rs_qks)\n",
    "    debug(False, 'selected_elem:', selected_elem)\n",
    "\n",
    "    if (rs_init_display == False):\n",
    "        rs_eqn_elems.append(selected_elem)\n",
    "\n",
    "    update_rs_eqn_elem_content(selected_elem)\n",
    "\n",
    "    debug(False, 'length of rs_eqn_elems: ' + str(len(rs_eqn_elems)), 'rs_eqn_elems after append:', rs_eqn_elems)\n",
    "\n",
    "    # Get the dimension vector for the selected quantity kind\n",
    "\n",
    "    rseqndv_binds = eqn_elem_dv_get_request(rs_qkv_dd.options[rs_qk_dd.index]) # not returning the right value so changed the original array to the current options array\n",
    "    rseqndvv      = get_eqn_elem_dv_value(rseqndv_binds)\n",
    "    rseqndvl      = get_eqn_elem_dv_label(rseqndv_binds)\n",
    "\n",
    "    debug(False, 'rseqndvl:', rseqndvl)\n",
    "\n",
    "    # Construct the quantity kind, label, and symbol tuple\n",
    "\n",
    "    rseqnqksdv = construct_qk_symbols_dv_tuple(rs_qk_dd.options[rs_qk_dd.index], rseqndvl, rs_qkv_dd.options, rs_qk_dd.options, rs_qks_dd.options)\n",
    "\n",
    "    debug(False, 'rs_dv_elems BEFORE append:', rs_dv_elems, 'rseqnqksdv:', rseqnqksdv)\n",
    "\n",
    "    if (rs_init_display == False):\n",
    "        rs_dv_elems.append(rseqnqksdv)\n",
    "\n",
    "    update_rs_eqn_dv_content(rseqnqksdv)\n",
    "\n",
    "    debug(False, 'rs_dv_elems AFTER append:', rs_dv_elems)\n",
    "\n",
    "    rs_init_display = False\n",
    "\n",
    "    # Construct evaluation component content (not really written yet but will have to include these kinds of things)\n",
    "\n",
    "    if (len(rs_eqn_elems) == 1):\n",
    "        rs_eqn_eval = rseqnqksdv[3] # was 1 before dv_elems upgraded to 4-tuple\n",
    "    else:\n",
    "        for eqn_elem in rs_eqn_elems:\n",
    "            debug(False, 'Construct evaluation component')\n",
    "            debug(False, 'eqn_elem: ', eqn_elem, 'rs_qk_symbols:', rs_qk_symbols, 'rs_qk_values:', rs_qk_values)\n",
    "            rs_qk_value     = qk_value_for_eqn_elem(eqn_elem)\n",
    "#            rs_qk_value     = elem[0]\n",
    "#            rs_qk_value     = qk_value_for_elem_symbol(eqn_elem, rs_qk_symbols, rs_qk_labels, rs_qk_values)\n",
    "            debug(False, 'rs_qk_value: ', rs_qk_value)\n",
    "            rsevalexp_binds = eqn_elem_dv_exps_get_request(rs_qk_value)\n",
    "            debug(False, 'rsevalexp_binds:', rsevalexp_binds)\n",
    "            rsevalamtexp   += get_eqn_elem_amount_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevalamtexp: ' + str(rsevalamtexp))\n",
    "            rsevalcrtexp   += get_eqn_elem_current_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevalcrtexp: ' + str(rsevalcrtexp))\n",
    "            rsevallthexp   += get_eqn_elem_length_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevallthexp: ' + str(rsevallthexp))\n",
    "            rsevalluminexp += get_eqn_elem_luminosity_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevalluminexp: ' + str(rsevalluminexp))\n",
    "            rsevalmassexp  += get_eqn_elem_mass_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevalmassexp: ' + str(rsevalmassexp))\n",
    "            rsevaltempexp  += get_eqn_elem_temperature_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevaltempexp: ' + str(rsevaltempexp))\n",
    "            rsevaltimeexp  += get_eqn_elem_time_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevaltimeexp: ' + str(rsevaltimeexp))\n",
    "            rsevaldlessexp += get_eqn_elem_dimensionless_exp_value(rsevalexp_binds)\n",
    "            debug(False, 'rsevaldlessexp: ' + str(rsevaldlessexp))\n",
    "\n",
    "        rs_eqn_eval = construct_eval_dv_from_exps(rsevalamtexp, rsevalcrtexp, rsevallthexp, rsevalluminexp, rsevalmassexp, rsevaltempexp, rsevaltimeexp, rsevaldlessexp)\n",
    "\n",
    "    rseqnevallabel   = widgets.Label(layout = eval_vb_item_layout, value = rs_eqn_eval)\n",
    "    rs_eqn_eval_items.append(rseqnevallabel)\n",
    "    rsDABox.children = rs_eqn_eval_items\n",
    "\n",
    "    if (ls_eqn_eval == rs_eqn_eval):\n",
    "        debug(False, 'rs balanced')\n",
    "        evalBox.children = [evalHTML_BAL]\n",
    "    else:\n",
    "        debug(False, 'rs unbalanced')\n",
    "        evalBox.children = [evalHTML_UN]\n",
    "\n",
    "\n",
    "# eqn_elem_dv_get_request: Constructs and issues the equation element dimension vector SPARQL query, \n",
    "#                          converts to json, and parses the ressulting results and bindings values. The \n",
    "#                          bindings are returned.\n",
    "#\n",
    "# ARGUMENTS: qk_value    - the selected quanity kind from the qk_dd dropdown\n",
    "# RETURN:    eqelembinds - the SPARQL query bindings array\n",
    "# CALLED BY: update_eqn_from_button\n",
    "\n",
    "def eqn_elem_dv_get_request(qk_value):\n",
    "    debug(False, 'In eqn_elem_dv_get_request - qk_value', qk_value)\n",
    "    eqn_elem_dv_query_start = \"https://qudt.org/fuseki/qudt/query?query=PREFIX qudt: <http://qudt.org/schema/qudt/> PREFIX quantitykind: <http://qudt.org/schema/qudt/quantitykind/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema%23> SELECT ?qkdv ?qkdvl WHERE { <\"\n",
    "    eqn_elem_dv_query_end   = \"> qudt:hasDimensionVector ?qkdv . ?qkdv rdfs:label ?qkdvl}\"\n",
    "    eqn_elem_dv_query       = eqn_elem_dv_query_start + qk_value + eqn_elem_dv_query_end\n",
    "    debug(False, 'eqn_elem_dv_query:', eqn_elem_dv_query)\n",
    "    eqn_elem_dv_response    = requests.get(eqn_elem_dv_query, headers = my_headers)\n",
    "    eqndv_data              = eqn_elem_dv_response.json()\n",
    "    eqndv_results           = eqndv_data['results']\n",
    "    eqndv_binds             = eqndv_results['bindings']\n",
    "    debug(False, 'eqndv_binds:', eqndv_binds)\n",
    "\n",
    "    return eqndv_binds\n",
    "\n",
    "\n",
    "# get_eqn_elem_dv_value: Parses the 'qkdv' value from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj               - a bindings array\n",
    "# RETURN:    eqn_elem_dv_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_dv_value(obj):\n",
    "    elem              = obj[0]\n",
    "    value             = elem['qkdv']\n",
    "    eqn_elem_dv_value = value['value']\n",
    "\n",
    "    return eqn_elem_dv_value\n",
    "\n",
    "\n",
    "# get_eqn_elem_dv_label: Parses the 'qkdvl' value from the SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj               - a bindings array\n",
    "# RETURN:    eqn_elem_dv_label - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_dv_label(obj):\n",
    "    elem              = obj[0]\n",
    "    value             = elem['qkdvl']\n",
    "    eqn_elem_dv_label = value['value']\n",
    "\n",
    "    return eqn_elem_dv_label\n",
    "\n",
    "\n",
    "# construct_qk_symbols_dv_tuple: Constructs a tuple for a QK's symbol and dimension vector.\n",
    "#\n",
    "# ARGUMENTS: qkl   - The quantity kind label from qk_dd dropdown\n",
    "#            dv    - The dimension vector\n",
    "#            vlist - The list of values\n",
    "#            llist - The list of labels\n",
    "#            slist - The list of symbols\n",
    "# RETURN:    A tuple of the qk value, label, symbol, and dimension vector\n",
    "# CALLED BY: update_ls_qk_options_from_input_text\n",
    "# CALLS:     [python] startswith\n",
    "\n",
    "def construct_qk_symbols_dv_tuple(qkl, dv, vlist, llist, slist):\n",
    "    debug(False, 'In construct_qk_symbols_dv_tuple', qkl, dv, vlist, slist)\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    while i < len(vlist):\n",
    "        litem = llist[i]\n",
    "        vitem = vlist[i]\n",
    "\n",
    "        if litem.startswith(qkl):\n",
    "            selem = slist[i]\n",
    "            debug(False, (vitem, litem, selem, dv))\n",
    "            return (vitem, litem, selem, dv)\n",
    "\n",
    "        i += 1\n",
    "\n",
    "\n",
    "# on_change_lseqnbtn: Handles changes to the equation element button widget\n",
    "#\n",
    "# CALLED BY: Changes to ls_eqn_btns value\n",
    "# CALLS:     update_ls_eqn_from_eqn_elem_button\n",
    "\n",
    "def on_change_lseqnbtn(change):\n",
    "    debug(False, 'in on_change_lseqnbtn', change)\n",
    "    update_ls_eqn_from_eqn_elem_button(change)\n",
    "\n",
    "\n",
    "# update_ls_eqn_from_eqn_elem_button: When selected, remove the associated element from the current\n",
    "#                                     equation and update other lists\n",
    "#\n",
    "# ALGORITHM: (1) Get the label and symbol components of the button\n",
    "#            (2) Construct a new label from them\n",
    "#            (3) Use the label to get the associated equation element\n",
    "#            (4) Use the equation element to get the associated dimension vector element\n",
    "#            (5) Remove these equation and dimension vector elements from the global lists\n",
    "#            (6) Update the user interface widgets associated with these lists\n",
    "#\n",
    "# CALLED BY: on_change_lseqnbtn\n",
    "# CALLS:     eqn_elem_for_label\n",
    "#            dv_elem_for_value\n",
    "#            remove_ls_eqn_and_dv_elems\n",
    "#            update_ls_elem_dv_in_interface\n",
    "\n",
    "\n",
    "def update_ls_eqn_from_eqn_elem_button(button):\n",
    "    blabel  = button.tooltip\n",
    "    bsymbol = button.description\n",
    "    btext   = blabel + ' - ' + bsymbol\n",
    "    eqnelem = eqn_elem_for_label(btext, ls_eqn_elems)\n",
    "    dvelem  = dv_elem_for_value(eqnelem[0], ls_dv_elems)\n",
    "    debug(False, 'BEFORE LS BUTTON REMOVE: length of ls_eqn_elems: ' + str(len(ls_eqn_elems)), 'length of ls_dv_elems: ' + str(len(ls_dv_elems)))\n",
    "    remove_ls_eqn_and_dv_elems(eqnelem, dvelem)\n",
    "    debug(False, 'AFTER LS BUTTON REMOVE: length of ls_eqn_elems: ' + str(len(ls_eqn_elems)), 'length of ls_dv_elems: ' + str(len(ls_dv_elems)))\n",
    "    update_ls_elem_dv_in_interface()\n",
    "\n",
    "\n",
    "# eqn_elem_for_label: Given a label and a collection of elements, return the element that matches the label.\n",
    "#\n",
    "# ARGUMENTS: label - the item we are looking for\n",
    "#            elems - the collection of tuples we are searching in\n",
    "# CALLED BY: update_ls_eqn_from_eqn_elem_button\n",
    "\n",
    "def eqn_elem_for_label(label, elems):\n",
    "    for elem in elems:\n",
    "        if (label.startswith(elem[1])):\n",
    "            return elem\n",
    "\n",
    "\n",
    "# dv_elem_for_value: Given a value (a URI) and a collection of elements, return the element that matches the value.\n",
    "#\n",
    "# ARGUMENTS: value - the URI we are looking for\n",
    "#            elems - the collection of tuples we are searching in\n",
    "# CALLED BY: update_ls_eqn_from_eqn_elem_button\n",
    "\n",
    "def dv_elem_for_value(value, elems):\n",
    "    for elem in elems:\n",
    "        if (value == elem[0]):\n",
    "            return elem\n",
    "\n",
    "\n",
    "# remove_ls_eqn_and_dv_elems: Update the global ls_eqn_elems and ls_dv_elems collections by removing the\n",
    "#                             selected (provided) elements.\n",
    "#\n",
    "# ARGUMENTS: eqn_elem - the equation element to remove\n",
    "#            dv_elem  - the dimension vector element to remove\n",
    "# CALLED BY: update_ls_eqn_from_eqn_elem_button\n",
    "\n",
    "def remove_ls_eqn_and_dv_elems(eqn_elem, dv_elem):\n",
    "    global ls_eqn_elems\n",
    "    global ls_dv_elems\n",
    "\n",
    "    if (eqn_elem[0] == dv_elem[0]):\n",
    "        for elem in ls_eqn_elems:\n",
    "            if (eqn_elem[0] == elem[0]):\n",
    "                ls_eqn_elems.remove(elem)\n",
    "        for dv in ls_dv_elems:\n",
    "            if (dv_elem[0] == dv[0]):\n",
    "                ls_dv_elems.remove(dv)\n",
    "\n",
    "\n",
    "# update_ls_elem_dv_in_interface: Update the interface widgets after removing equation and dimension\n",
    "#                                 vector elements.\n",
    "#\n",
    "# CALLED BY: update_ls_eqn_from_eqn_elem_button\n",
    "# CALLS:     update_ls_analysis\n",
    "\n",
    "def update_ls_elem_dv_in_interface():\n",
    "    global ls_eqn_btns\n",
    "    global ls_dv_vb_slabels\n",
    "    global ls_dv_vb_dvlabels\n",
    "\n",
    "    ls_eqn_btns       = []\n",
    "    ls_dv_vb_slabels  = []\n",
    "    ls_dv_vb_dvlabels = []\n",
    "\n",
    "    for eqn_elem in ls_eqn_elems:\n",
    "        eqnbtn = widgets.Button(layout = eqn_hb_item_layout, description = eqn_elem[2], tooltip = eqn_elem[1])\n",
    "        eqnbtn.on_click(on_change_lseqnbtn)\n",
    "        ls_eqn_btns.append(eqnbtn)\n",
    "\n",
    "    ls_elem_carousel.children = ls_eqn_btns\n",
    "\n",
    "    for dv_elem in ls_dv_elems:\n",
    "        slabel        = widgets.Label(layout = dv_vb_item_layout, value = dv_elem[2])\n",
    "        ls_dv_vb_slabels.append(slabel)\n",
    "        dvlabel       = widgets.Label(layout = dv_vb_item_layout, value = dv_elem[3])\n",
    "        ls_dv_vb_dvlabels.append(dvlabel)\n",
    "\n",
    "    ls_dv_slab_VBox.children  = ls_dv_vb_slabels\n",
    "    ls_dv_dvlab_VBox.children = ls_dv_vb_dvlabels\n",
    "\n",
    "    update_ls_analysis()\n",
    "\n",
    "\n",
    "# update_ls_analysis: Iterates through the ls_eqn_elems and aggregates their dv components and displays changes.\n",
    "#\n",
    "# CALLED-BY: update_ls_eqn_from_button\n",
    "# CALLS:     qk_value_for_eqn_elem\n",
    "#            eqn_elem_dv_exps_get_request\n",
    "#            construct_eval_dv_from_exps\n",
    "\n",
    "def update_ls_analysis():\n",
    "    global ls_eqn_eval\n",
    "\n",
    "    lsevalamtexp      = 0\n",
    "    lsevalcrtexp      = 0\n",
    "    lsevallthexp      = 0\n",
    "    lsevalluminexp    = 0\n",
    "    lsevalmassexp     = 0\n",
    "    lsevaltempexp     = 0\n",
    "    lsevaltimeexp     = 0\n",
    "    lsevaldlessexp    = 0\n",
    "    ls_eqn_eval_items = []\n",
    "\n",
    "    for eqn_elem in ls_eqn_elems:\n",
    "        debug(False, 'Construct evaluation component')\n",
    "        debug(False, 'eqn_elem: ', eqn_elem, 'ls_qk_symbols:', ls_qk_symbols, 'ls_qk_values:', ls_qk_values)\n",
    "        rs_qk_value     = qk_value_for_eqn_elem(eqn_elem)\n",
    "#        ls_qk_value     = elem[0]\n",
    "        debug(False, 'ls_qk_value: ', ls_qk_value)\n",
    "        lsevalexp_binds = eqn_elem_dv_exps_get_request(ls_qk_value)\n",
    "        debug(False, 'lsevalexp_binds:', lsevalexp_binds)\n",
    "        lsevalamtexp   += get_eqn_elem_amount_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevalamtexp: ' + str(lsevalamtexp))\n",
    "        lsevalcrtexp   += get_eqn_elem_current_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevalcrtexp: ' + str(lsevalcrtexp))\n",
    "        lsevallthexp   += get_eqn_elem_length_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevallthexp: ' + str(lsevallthexp))\n",
    "        lsevalluminexp += get_eqn_elem_luminosity_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevalluminexp: ' + str(lsevalluminexp))\n",
    "        lsevalmassexp  += get_eqn_elem_mass_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevalmassexp: ' + str(lsevalmassexp))\n",
    "        lsevaltempexp  += get_eqn_elem_temperature_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevaltempexp: ' + str(lsevaltempexp))\n",
    "        lsevaltimeexp  += get_eqn_elem_time_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevaltimeexp: ' + str(lsevaltimeexp))\n",
    "        lsevaldlessexp += get_eqn_elem_dimensionless_exp_value(lsevalexp_binds)\n",
    "        debug(False, 'lsevaldlessexp: ' + str(lsevaldlessexp))\n",
    "\n",
    "    ls_eqn_eval      = construct_eval_dv_from_exps(lsevalamtexp, lsevalcrtexp, lsevallthexp, lsevalluminexp, lsevalmassexp, lsevaltempexp, lsevaltimeexp, lsevaldlessexp)\n",
    "    lseqnevallabel   = widgets.Label(layout = eval_vb_item_layout, value = ls_eqn_eval)\n",
    "    ls_eqn_eval_items.append(lseqnevallabel)\n",
    "    lsDABox.children = ls_eqn_eval_items\n",
    "\n",
    "    if (ls_eqn_eval == rs_eqn_eval):\n",
    "        debug(False, 'ls balanced')\n",
    "        evalBox.children = [evalHTML_BAL]\n",
    "    else:\n",
    "        debug(False, 'ls unbalanced')\n",
    "        evalBox.children = [evalHTML_UN]\n",
    "\n",
    "\n",
    "# on_change_rseqnbtn: Handles changes to the equation element button widget\n",
    "#\n",
    "# CALLED BY: Changes to rs_eqn_btn value\n",
    "# CALLS:     update_rs_eqn_from_eqn_elem_button\n",
    "\n",
    "def on_change_rseqnbtn(change):\n",
    "    debug(False, 'in on_change_rseqnbtn', change)\n",
    "    update_rs_eqn_from_eqn_elem_button(change)\n",
    "\n",
    "\n",
    "# update_rs_eqn_from_eqn_elem_button: When selected, remove the associated element from the current\n",
    "#                                     equation and update other lists\n",
    "#\n",
    "# ALGORITHM: (1) Get the label and symbol components of the button\n",
    "#            (2) Construct a new label from them\n",
    "#            (3) Use the label to get the associated equation element\n",
    "#            (4) Use the equation element to get the associated dimension vector element\n",
    "#            (5) Remove these equation and dimension vector elements from the global lists\n",
    "#            (6) Update the user interface widgets associated with these lists\n",
    "#\n",
    "# CALLED BY: on_change_rseqnbtn\n",
    "# CALLS:     eqn_elem_for_label\n",
    "#            dv_elem_for_value\n",
    "#            remove_rs_eqn_and_dv_elems\n",
    "#            update_rs_elem_dv_in_interface\n",
    "\n",
    "def update_rs_eqn_from_eqn_elem_button(button):\n",
    "    blabel  = button.tooltip\n",
    "    bsymbol = button.description\n",
    "    btext   = blabel + ' - ' + bsymbol\n",
    "    eqnelem = eqn_elem_for_label(btext, rs_eqn_elems)\n",
    "    dvelem  = dv_elem_for_value(eqnelem[0], rs_dv_elems)\n",
    "    debug(False, 'BEFORE RS BUTTON REMOVE: length of rs_eqn_elems: ' + str(len(rs_eqn_elems)), 'length of rs_dv_elems: ' + str(len(rs_dv_elems)))\n",
    "    remove_rs_eqn_and_dv_elems(eqnelem, dvelem)\n",
    "    debug(False, 'AFTER RS BUTTON REMOVE: length of rs_eqn_elems: ' + str(len(rs_eqn_elems)), 'length of rs_dv_elems: ' + str(len(rs_dv_elems)))\n",
    "    update_rs_elem_dv_in_interface()\n",
    "\n",
    "    \n",
    "# remove_rs_eqn_and_dv_elems: Update the global rs_eqn_elems and rs_dv_elems collections by removing the\n",
    "#                             selected (provided) elements.\n",
    "#\n",
    "# ARGUMENTS: eqn_elem - the equation element to remove\n",
    "#            dv_elem  - the dimension vector element to remove\n",
    "# CALLED BY: update_rs_eqn_from_eqn_elem_button\n",
    "\n",
    "def remove_rs_eqn_and_dv_elems(eqn_elem, dv_elem):\n",
    "    global rs_eqn_elems\n",
    "    global rs_dv_elems\n",
    "\n",
    "    if (eqn_elem[0] == dv_elem[0]):\n",
    "        for elem in rs_eqn_elems:\n",
    "            if (eqn_elem[0] == elem[0]):\n",
    "                rs_eqn_elems.remove(elem)\n",
    "        for dv in rs_dv_elems:\n",
    "            if (dv_elem[0] == dv[0]):\n",
    "                rs_dv_elems.remove(dv)\n",
    "\n",
    "\n",
    "# update_rs_elem_dv_in_interface: Update the interface widgets after removing equation and dimension\n",
    "#                                 vector elements.\n",
    "#\n",
    "# CALLED BY: update_ls_eqn_from_eqn_elem_button\n",
    "# CALLS:     update_rs_analysis\n",
    "\n",
    "def update_rs_elem_dv_in_interface():\n",
    "    global rs_eqn_btns\n",
    "    global rs_dv_vb_slabels\n",
    "    global rs_dv_vb_dvlabels\n",
    "\n",
    "    rs_eqn_btns       = []\n",
    "    rs_dv_vb_slabels  = []\n",
    "    rs_dv_vb_dvlabels = []\n",
    "\n",
    "    for eqn_elem in rs_eqn_elems:\n",
    "        eqnbtn = widgets.Button(layout = eqn_hb_item_layout, description = eqn_elem[2], tooltip = eqn_elem[1])\n",
    "        eqnbtn.on_click(on_change_rseqnbtn)\n",
    "        rs_eqn_btns.append(eqnbtn)\n",
    "\n",
    "    rs_elem_carousel.children = rs_eqn_btns\n",
    "\n",
    "    for dv_elem in rs_dv_elems:\n",
    "        slabel        = widgets.Label(layout = dv_vb_item_layout, value = dv_elem[2])\n",
    "        rs_dv_vb_slabels.append(slabel)\n",
    "        dvlabel       = widgets.Label(layout = dv_vb_item_layout, value = dv_elem[3])\n",
    "        rs_dv_vb_dvlabels.append(dvlabel)\n",
    "\n",
    "    rs_dv_slab_VBox.children  = rs_dv_vb_slabels\n",
    "    rs_dv_dvlab_VBox.children = rs_dv_vb_dvlabels\n",
    "\n",
    "    update_rs_analysis()\n",
    "\n",
    "\n",
    "# update_rs_analysis: Iterates through the rs_eqn_elems and aggregates their dv components and displays changes.\n",
    "#\n",
    "# CALLED-BY: update_rs_eqn_from_button\n",
    "# CALLS:     qk_value_for_eqn_elem\n",
    "#            eqn_elem_dv_exps_get_request\n",
    "#            construct_eval_dv_from_exps\n",
    "\n",
    "def update_rs_analysis():\n",
    "    global rs_eqn_eval\n",
    "\n",
    "    rsevalamtexp      = 0\n",
    "    rsevalcrtexp      = 0\n",
    "    rsevallthexp      = 0\n",
    "    rsevalluminexp    = 0\n",
    "    rsevalmassexp     = 0\n",
    "    rsevaltempexp     = 0\n",
    "    rsevaltimeexp     = 0\n",
    "    rsevaldlessexp    = 0\n",
    "    rs_eqn_eval_items = []\n",
    "\n",
    "    for eqn_elem in rs_eqn_elems:\n",
    "        debug(False, 'Construct evaluation component')\n",
    "        debug(False, 'eqn_elem: ', eqn_elem, 'rs_qk_symbols:', rs_qk_symbols, 'rs_qk_values:', rs_qk_values)\n",
    "        rs_qk_value     = qk_value_for_eqn_elem(eqn_elem)\n",
    "#        rs_qk_value     = elem[0]\n",
    "        debug(False, 'rs_qk_value: ', rs_qk_value)\n",
    "        rsevalexp_binds = eqn_elem_dv_exps_get_request(rs_qk_value)\n",
    "        debug(False, 'rsevalexp_binds:', rsevalexp_binds)\n",
    "        rsevalamtexp   += get_eqn_elem_amount_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevalamtexp: ' + str(rsevalamtexp))\n",
    "        rsevalcrtexp   += get_eqn_elem_current_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevalcrtexp: ' + str(rsevalcrtexp))\n",
    "        rsevallthexp   += get_eqn_elem_length_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevallthexp: ' + str(rsevallthexp))\n",
    "        rsevalluminexp += get_eqn_elem_luminosity_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevalluminexp: ' + str(rsevalluminexp))\n",
    "        rsevalmassexp  += get_eqn_elem_mass_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevalmassexp: ' + str(rsevalmassexp))\n",
    "        rsevaltempexp  += get_eqn_elem_temperature_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevaltempexp: ' + str(rsevaltempexp))\n",
    "        rsevaltimeexp  += get_eqn_elem_time_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevaltimeexp: ' + str(rsevaltimeexp))\n",
    "        rsevaldlessexp += get_eqn_elem_dimensionless_exp_value(rsevalexp_binds)\n",
    "        debug(False, 'rsevaldlessexp: ' + str(rsevaldlessexp))\n",
    "\n",
    "    rs_eqn_eval      = construct_eval_dv_from_exps(rsevalamtexp, rsevalcrtexp, rsevallthexp, rsevalluminexp, rsevalmassexp, rsevaltempexp, rsevaltimeexp, rsevaldlessexp)\n",
    "    rseqnevallabel   = widgets.Label(layout = eval_vb_item_layout, value = rs_eqn_eval)\n",
    "    rs_eqn_eval_items.append(rseqnevallabel)\n",
    "    rsDABox.children = rs_eqn_eval_items\n",
    "\n",
    "    if (ls_eqn_eval == rs_eqn_eval):\n",
    "        debug(False, 'rs balanced')\n",
    "        evalBox.children = [evalHTML_BAL]\n",
    "    else:\n",
    "        debug(False, 'rs unbalanced')\n",
    "        evalBox.children = [evalHTML_UN]\n",
    "\n",
    "\n",
    "# eqn_elem_dv_exps_get_request: Constructs and issues the equation element dimension vector exponents\n",
    "#                               SPARQL query, converts to json, and parses the ressulting results and bindings \n",
    "#                               values. The bindings are returned. This is used for evaluation.\n",
    "#\n",
    "# ALGORITHM: (1) Construct the equation elements dimension vector exponents query based on a selected quantity\n",
    "#                kind's value\n",
    "#            (2) Invoke the GET request with this query\n",
    "#            (3) Convert the result into JSON\n",
    "#            (4) Parse the BINDINGS value from the JSON\n",
    "#            (5) Return the bindings list\n",
    "#\n",
    "# ARGUMENTS: qk_value        - the selected quantity kind from the qk_dd dropdown\n",
    "# RETURN:    eqndvexps_binds - the SPARQL query bindings array for the dv exponents\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "#            update_rs_eqn_from_button\n",
    "# CALLS:     requests.get\n",
    "\n",
    "def eqn_elem_dv_exps_get_request(qk_dv_value):\n",
    "    debug(False, 'In eqn_elem_dv_exps_get_request - qk_dv_value', qk_dv_value)\n",
    "    eqn_elem_dv_exps_query_start = \"https://qudt.org/fuseki/qudt/query?query=PREFIX qudt: <http://qudt.org/schema/qudt/> PREFIX quantitykind: <http://qudt.org/schema/qudt/quantitykind/> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema%23> SELECT ?qkdv ?qkdvas ?qkdvec ?qkdvl ?qkdvli ?qkdvm ?qkdvtt ?qkdvt ?qkdvd WHERE { <\"\n",
    "    eqn_elem_dv_exps_query_end   = \"> qudt:hasDimensionVector ?qkdv . ?qkdv qudt:dimensionExponentForAmountOfSubstance ?qkdvas . ?qkdv qudt:dimensionExponentForElectricCurrent ?qkdvec . ?qkdv qudt:dimensionExponentForLength ?qkdvl . ?qkdv qudt:dimensionExponentForLuminousIntensity ?qkdvli . ?qkdv qudt:dimensionExponentForMass ?qkdvm . ?qkdv qudt:dimensionExponentForThermodynamicTemperature ?qkdvtt . ?qkdv qudt:dimensionExponentForTime ?qkdvt . ?qkdv qudt:dimensionlessExponent ?qkdvd .}\"\n",
    "    eqn_elem_dv_exps_query       = eqn_elem_dv_exps_query_start + qk_dv_value + eqn_elem_dv_exps_query_end\n",
    "    debug(False, 'eqn_elem_dv_exps_query', eqn_elem_dv_exps_query)\n",
    "    eqn_elem_dv_exps_response    = requests.get(eqn_elem_dv_exps_query, headers = my_headers)\n",
    "    eqndvexps_data               = eqn_elem_dv_exps_response.json()\n",
    "    eqndvexps_results            = eqndvexps_data['results']\n",
    "    eqndvexps_binds              = eqndvexps_results['bindings']\n",
    "    debug(False, 'eqndvexps_binds', eqndvexps_binds)\n",
    "\n",
    "    return eqndvexps_binds\n",
    "\n",
    "\n",
    "# get_eqn_elem_amount_exp_value: Parses the 'qkdvas' (amount) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                       - a bindings array\n",
    "# RETURN:    eqn_elem_amount_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_amount_exp_value(obj):\n",
    "    elem                      = obj[0]\n",
    "    value                     = elem['qkdvas']\n",
    "    eqn_elem_amount_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_amount_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_current_exp_value: Parses the 'qkdvec' (current) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                        - a bindings array\n",
    "# RETURN:    eqn_elem_current_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_current_exp_value(obj):\n",
    "    elem                       = obj[0]\n",
    "    value                      = elem['qkdvec']\n",
    "    eqn_elem_current_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_current_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_length_exp_value: Parses the 'qkdvl' (length) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                       - a bindings array\n",
    "# RETURN:    eqn_elem_length_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_length_exp_value(obj):\n",
    "    elem                      = obj[0]\n",
    "    value                     = elem['qkdvl']\n",
    "    eqn_elem_length_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_length_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_luminosity_exp_value: Parses the 'qkdvli' (luminosity) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                           - a bindings array\n",
    "# RETURN:    eqn_elem_luminosity_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_luminosity_exp_value(obj):\n",
    "    elem                          = obj[0]\n",
    "    value                         = elem['qkdvli']\n",
    "    eqn_elem_luminosity_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_luminosity_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_mass_exp_value: Parses the 'qkdvm' (mass) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                     - a bindings array\n",
    "# RETURN:    eqn_elem_mass_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_mass_exp_value(obj):\n",
    "    elem                    = obj[0]\n",
    "    value                   = elem['qkdvm']\n",
    "    eqn_elem_mass_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_mass_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_temperature_exp_value: Parses the 'qkdvtt' (temperature) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                            - a bindings array\n",
    "# RETURN:    eqn_elem_temperature_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_temperature_exp_value(obj):\n",
    "    elem                           = obj[0]\n",
    "    value                          = elem['qkdvtt']\n",
    "    eqn_elem_temperature_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_temperature_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_time_exp_value: Parses the 'qkdvt' (time) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                     - a bindings array\n",
    "# RETURN:    eqn_elem_time_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_time_exp_value(obj):\n",
    "    elem                    = obj[0]\n",
    "    value                   = elem['qkdvt']\n",
    "    eqn_elem_time_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_time_exp_value)\n",
    "\n",
    "\n",
    "# get_eqn_elem_dimensionless_exp_value: Parses the 'qkdvd' (dimensionless) value from the 'exponents' SPARQL query results.\n",
    "#\n",
    "# ARGUMENTS: obj                              - a bindings array\n",
    "# RETURN:    eqn_elem_dimensionless_exp_value - the quantity kind SPARQL query labels array\n",
    "# CALLED BY: statement below\n",
    "\n",
    "def get_eqn_elem_dimensionless_exp_value(obj):\n",
    "    elem                             = obj[0]\n",
    "    value                            = elem['qkdvd']\n",
    "    eqn_elem_dimensionless_exp_value = value['value']\n",
    "\n",
    "    return int(eqn_elem_dimensionless_exp_value)\n",
    "\n",
    "\n",
    "# construct_eval_dv_from_exps: Given the 8 aggregrated exponents, create a dimension vector string\n",
    "#\n",
    "# ARGUMENTS: amtexp   - aggregated amount of substance exponent\n",
    "#            crtexp   - aggregated electrical current exponent\n",
    "#            lthexp   - aggregated length exponent\n",
    "#            luminexp - aggregated luminous intensity exponent\n",
    "#            massexp  - aggregated mass exponent\n",
    "#            tempexp  - aggregated temperature exponent\n",
    "#            timeexp  - aggregated time exponent\n",
    "#            dlessexp - aggregated dimensionless exponent\n",
    "\n",
    "def construct_eval_dv_from_exps(amtexp, crtexp, lthexp, luminexp, massexp, tempexp, timeexp, dlessexp):\n",
    "    dv_str = 'A' + str(amtexp) + 'E' + str(crtexp) + 'L' + str(lthexp) + 'I' + str(luminexp) + 'M' + str(massexp) + 'H' + str(tempexp) + 'T' +str(timeexp) + 'D' + str(dlessexp)\n",
    "    return dv_str\n",
    "\n",
    "\n",
    "# update_ls_eqn_elem_content: When the select quantity kind button is pressed the content of the equation element\n",
    "#                             button array will be updated. That is, a new button will be added to the button\n",
    "#                             array. The button widgets have already been defined.\n",
    "#\n",
    "# ARGUMENTS: cur_elem - the current qk equation element (a tuple), which will override the first element if the\n",
    "#            first button selection\n",
    "# ALGORITHM: (1) Iterate through all of the ls_eqn_elems items\n",
    "#                (a) If this is from the first button press (i.e., ls_init_display is True) and it is the first\n",
    "#                    element in the list,\n",
    "#                    (i) Reassign the element the value from the dropdown\n",
    "#                (b) Otherwise (ls_iinit_display is False or it isn't the first element of the list)\n",
    "#                    (i) Create a new button from the element item\n",
    "#                   (ii) Append the new button to the button list\n",
    "#            (2) Assign the carousel children the value of the new list\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "\n",
    "def update_ls_eqn_elem_content(cur_elem):\n",
    "    global ls_eqn_elems\n",
    "    global ls_eqn_btns\n",
    "\n",
    "    debug(False, 'In update_ls_eqn_elem_content')\n",
    "    debug(False, 'BEFORE loop: length of ls_eqn_elems: ' + str(len(ls_eqn_elems)), 'ls_eqn_elems:', ls_eqn_elems)\n",
    "    debug(False, 'BEFORE loop: length of ls_eqn_btns: ' + str(len(ls_eqn_btns)), 'ls_eqn_btns:', ls_eqn_btns)\n",
    "\n",
    "    if (ls_init_display == True):\n",
    "        debug(False, 'Initial item in ls_eqn_elems, overwrite button description')\n",
    "        ls_eqn_elems[0]    = cur_elem\n",
    "        eqnbtn             = ls_eqn_btns[0]\n",
    "        eqnbtn.description = cur_elem[2]\n",
    "    else:\n",
    "        debug(False, 'Not the initial item in ls_eqn_elems, or not the first time through; create a new button')\n",
    "        lseqnbtn = widgets.Button(layout = eqn_hb_item_layout, description = cur_elem[2], tooltip = cur_elem[1])\n",
    "        lseqnbtn.on_click(on_change_lseqnbtn)\n",
    "        ls_eqn_btns.append(lseqnbtn)\n",
    "        # recreate the carousel with the ls_eqn_btns list\n",
    "\n",
    "    ls_elem_carousel.children = ls_eqn_btns\n",
    "\n",
    "    debug(False, 'AFTER loop: length of ls_eqn_elems: ' + str(len(ls_eqn_elems)), 'ls_eqn_elems:', ls_eqn_elems)\n",
    "    debug(False, 'AFTER loop: length of ls_eqn_btns: ' + str(len(ls_eqn_btns)), 'ls_eqn_btns:', ls_eqn_btns)\n",
    "\n",
    "\n",
    "# update_rs_eqn_elem_content: When the select quantity kind button is pressed the content of the equation element\n",
    "#                             button array will be updated. The button widgets have already been defined.\n",
    "#\n",
    "# ARGUMENTS: cur_elem is the current qk dropdown element, which will override the first element if the first\n",
    "#            button selection\n",
    "# CALLED BY: update_rs_eqn_from_button\n",
    "\n",
    "def update_rs_eqn_elem_content(cur_elem):\n",
    "    global rs_eqn_elems\n",
    "    global rs_eqn_btns\n",
    "\n",
    "    debug(False, 'In update_rs_eqn_elem_content')\n",
    "    debug(False, 'BEFORE loop: length of rs_eqn_elems: ' + str(len(rs_eqn_elems)), 'rs_eqn_elems:', rs_eqn_elems)\n",
    "    debug(False, 'BEFORE loop: length of rs_eqn_btns: ' + str(len(rs_eqn_btns)), 'rs_eqn_btns:', rs_eqn_btns)\n",
    "\n",
    "    if (rs_init_display == True):\n",
    "        debug(False, 'This is the initial item in rs_eqn_elems, overwrite button description')\n",
    "        rs_eqn_elems[0]    = cur_elem\n",
    "        eqnbtn             = rs_eqn_btns[0]\n",
    "        eqnbtn.description = cur_elem[2]\n",
    "    else:\n",
    "        debug(False, 'This is not the initial item in rs_eqn_elems, create a new button')\n",
    "        rseqnbtn = widgets.Button(layout = eqn_hb_item_layout, description = cur_elem[2], tooltip = cur_elem[1])\n",
    "        rseqnbtn.on_click(on_change_rseqnbtn)\n",
    "        rs_eqn_btns.append(rseqnbtn)\n",
    "\n",
    "    rs_elem_carousel.children = rs_eqn_btns\n",
    "\n",
    "    debug(False, 'AFTER loop: length of rs_eqn_elems: ' + str(len(rs_eqn_elems)), 'rs_eqn_elems:', rs_eqn_elems)\n",
    "    debug(False, 'AFTER loop: length of rs_eqn_btns: ' + str(len(rs_eqn_btns)), 'rs_eqn_btns:', rs_eqn_btns)\n",
    "\n",
    "\n",
    "# update_ls_eqn_dv_content: When the select quantity kind button is pressed the content of the dimension vector\n",
    "#                           symbol label array and dimension vector label array will be updated from the current\n",
    "#                           dv elem tuple (value, label, symbol, dv group)\n",
    "#\n",
    "# ARGUMENTS: cur_elem is the current dv element, which will override the first element if the first\n",
    "#            button selection\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "\n",
    "def update_ls_eqn_dv_content(cur_elem):\n",
    "    global ls_dv_elems\n",
    "    global ls_dv_vb_slabels\n",
    "    global ls_dv_vb_dvlabels\n",
    "\n",
    "    debug(False, 'In update_ls_eqn_dv_content')\n",
    "    debug(False, 'BEFORE loop: length of ls_dv_elems: ' + str(len(ls_dv_elems)), 'ls_dv_elems:', ls_dv_elems)\n",
    "    debug(False, 'length of ls_dv_vb_slabels: ' + str(len(ls_dv_vb_slabels)), 'ls_dv_vb_slabels:', ls_dv_vb_slabels)\n",
    "    debug(False, 'length of ls_dv_vb_dvlabels: ' + str(len(ls_dv_vb_dvlabels)), 'ls_dv_vb_dvlabels:', ls_dv_vb_dvlabels)\n",
    "\n",
    "    if (ls_init_display == True):\n",
    "        debug(False, 'This is the initial element, overwrite the slabel value and dvlabel value')\n",
    "        ls_dv_elems[0]  = cur_elem\n",
    "        slabitem        = ls_dv_vb_slabels[0]\n",
    "        slabitem.value  = cur_elem[2]\n",
    "        dvlabitem       = ls_dv_vb_dvlabels[0]\n",
    "        dvlabitem.value = cur_elem[3]\n",
    "    else:\n",
    "        debug(False, 'This is not the initial element create a new elem, slabel, and dvlabel')\n",
    "        lsslabel        = widgets.Label(layout = dv_vb_item_layout, value = cur_elem[2])\n",
    "        ls_dv_vb_slabels.append(lsslabel)\n",
    "        lsdvlabel       = widgets.Label(layout = dv_vb_item_layout, value = cur_elem[3])\n",
    "        ls_dv_vb_dvlabels.append(lsdvlabel)\n",
    "\n",
    "    ls_dv_slab_VBox.children  = ls_dv_vb_slabels\n",
    "    ls_dv_dvlab_VBox.children = ls_dv_vb_dvlabels\n",
    "\n",
    "    debug(False, 'AFTER loop: length of ls_dv_elems: ' + str(len(ls_dv_elems)), 'ls_dv_elems:', ls_dv_elems)\n",
    "    debug(False, 'length of ls_dv_vb_slabels: ' + str(len(ls_dv_vb_slabels)), 'ls_dv_vb_slabels:', ls_dv_vb_slabels)\n",
    "    debug(False, 'length of ls_dv_vb_dvlabels: ' + str(len(ls_dv_vb_dvlabels)), 'ls_dv_vb_dvlabels:', ls_dv_vb_dvlabels)\n",
    "\n",
    "\n",
    "# update_rs_eqn_dv_content: When the select quantity kind button is pressed the content of the dimension vector\n",
    "#                           symbol label array and dimension vector label array will be updated from the current\n",
    "#                           dv elem tuple (value, label, symbol, dv group)\n",
    "#\n",
    "# ARGUMENTS: cur_elem is the current dv element, which will override the first element if the first\n",
    "#            button selection\n",
    "# CALLED BY: update_rs_eqn_from_button\n",
    "\n",
    "def update_rs_eqn_dv_content(cur_elem):\n",
    "    global rs_dv_elems\n",
    "    global rs_dv_vb_slabels\n",
    "    global rs_dv_vb_dvlabels\n",
    "\n",
    "    debug(False, 'In update_ls_eqn_dv_content')\n",
    "    debug(False, 'BEFORE loop: length of rs_dv_elems: ' + str(len(rs_dv_elems)), 'rs_dv_elems:', rs_dv_elems)\n",
    "    debug(False, 'length of rs_dv_vb_slabels: ' + str(len(rs_dv_vb_slabels)), 'rs_dv_vb_slabels:', rs_dv_vb_slabels)\n",
    "    debug(False, 'length of rs_dv_vb_dvlabels: ' + str(len(rs_dv_vb_dvlabels)), 'rs_dv_vb_dvlabels:', rs_dv_vb_dvlabels)\n",
    "\n",
    "    if (rs_init_display == True):\n",
    "        debug(False, 'This is the initial element, overwrite the slabel value and dvlabel value')\n",
    "        rs_dv_elems[0]  = cur_elem\n",
    "        slabitem        = rs_dv_vb_slabels[0]\n",
    "        slabitem.value  = cur_elem[2]\n",
    "        dvlabitem       = rs_dv_vb_dvlabels[0]\n",
    "        dvlabitem.value = cur_elem[3]\n",
    "    else:\n",
    "        debug(False, 'This is not the initial element, create a new slabel and dvlabel')\n",
    "        rsslabel  = widgets.Label(layout = dv_vb_item_layout, value = cur_elem[2])\n",
    "        rs_dv_vb_slabels.append(rsslabel)\n",
    "        rsdvlabel = widgets.Label(layout = dv_vb_item_layout, value = cur_elem[3])\n",
    "        rs_dv_vb_dvlabels.append(rsdvlabel)\n",
    "\n",
    "    rs_dv_slab_VBox.children  = rs_dv_vb_slabels\n",
    "    rs_dv_dvlab_VBox.children = rs_dv_vb_dvlabels\n",
    "\n",
    "    debug(False, 'AFTER loop: length of rs_dv_elems: ' + str(len(rs_dv_elems)), 'rs_dv_elems:', rs_dv_elems)\n",
    "    debug(False, 'length of rs_dv_vb_slabels: ' + str(len(rs_dv_vb_slabels)), 'rs_dv_vb_slabels:', rs_dv_vb_slabels)\n",
    "    debug(False, 'length of rs_dv_vb_dvlabels: ' + str(len(rs_dv_vb_dvlabels)), 'rs_dv_vb_dvlabels:', rs_dv_vb_dvlabels)\n",
    "\n",
    "\n",
    "# update_ls_eqn_eval_content: When the select quantity kind button is pressed the content of the evaluation element\n",
    "#                             exponent array will be updated and the evaluation performed.\n",
    "#\n",
    "# ALGORITHM: (1) Itereate over the dimension vector elements\n",
    "#                (a) Get a dimension vector element\n",
    "#                (b) If the length of the dimension vector elements list is 1 (we haven't hit the button twice)\n",
    "#                    (i) Get the dv label\n",
    "#                   (ii) Assign the label value from the dimension vector element's label\n",
    "#                (c) Otherwise\n",
    "#                    (i) Create a new label whose value is the dimension vector element's label\n",
    "#                   (ii) Append the new label to the dimension vectore labels array\n",
    "# CALLED BY: update_ls_eqn_from_button\n",
    "\n",
    "def update_ls_eqn_eval_content():\n",
    "    debug(False, 'In update_ls_eqn_eval_content')\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    while i < len(ls_dv_elems):\n",
    "        debug(False, 'ls eqn eval loop index:', i, 'dvitem:', ls_dv_elems[i], 'eqnbtn:', ls_dv_vb_dvlabels[i])\n",
    "        dvitem = ls_dv_elems[i]\n",
    "\n",
    "        if (len(ls_dv_elems) == 1):\n",
    "            evaldvlabel = ls_dv_vb_dvlabels[i]\n",
    "            evaldvlabel.value = dvitem[0]\n",
    "        else:\n",
    "            lsdvlabel = widgets.Label(layout = eval_vb_item_layout, value = dvitem[0])\n",
    "            ls_dv_vb_dvlabels.append(lsdvlabel)\n",
    "\n",
    "        i += 1\n",
    "\n",
    "\n",
    "# update_rs_eqn_eval_content: When the select quantity kind button is pressed the content of the evaluation element\n",
    "#                             exponent array will be updated and the evaluation performed.\n",
    "#\n",
    "# ALGORITHM: (1) Itereate over the dimension vector elements\n",
    "#                (a) Get a dimension vector element\n",
    "#                (b) If the length of the dimension vector elements list is 1 (we haven't hit the button twice)\n",
    "#                    (i) Get the dv label\n",
    "#                   (ii) Assign the label value from the dimension vector element's label\n",
    "#                (c) Otherwise\n",
    "#                    (i) Create a new label whose value is the dimension vector element's label\n",
    "#                   (ii) Append the new label to the dimension vectore labels array\n",
    "# CALLED BY: update_rs_eqn_from_button\n",
    "\n",
    "def update_rs_eqn_eval_content():\n",
    "    debug(False, 'In update_rs_eqn_eval_content')\n",
    "\n",
    "    i = 0\n",
    "\n",
    "    while i < len(rs_dv_elems):\n",
    "        dvitem             = rs_dv_elems[i]\n",
    "        eqnbtn             = rseqhb_items[i]\n",
    "        debug(False, 'rs eqn eval loop index:', i, 'item:', dvitem, 'btn', eqnbtn)\n",
    "        eqnbtn.description = dvitem[0]\n",
    "        i += 1\n",
    "\n",
    "\n",
    "###########################################################################################\n",
    "# Construct the the baseline app display\n",
    "###########################################################################################\n",
    "\n",
    "# Define the quantity kind elements (text, dropdown, and button), and box, and display them\n",
    "\n",
    "qk_vb_layout = widgets.Layout(border = 'solid 2px', margin = '7px', padding = '3px')\n",
    "lsQKVBox     = widgets.VBox([ls_qk_text, ls_qk_dd, ls_qk_button], layout = qk_vb_layout)\n",
    "rsQKVBox     = widgets.VBox([rs_qk_text, rs_qk_dd, rs_qk_button], layout = qk_vb_layout)\n",
    "\n",
    "# Define and initialize the equation horizontal box elements carousels and display them\n",
    "\n",
    "eqn_hb_item_layout = widgets.Layout(border = 'solid 1px', max_width = '40px', color = 'gray')\n",
    "ls_eqn_elems.append('F')\n",
    "rs_eqn_elems.append('M')\n",
    "lseqnbtn           = widgets.Button(layout = eqn_hb_item_layout, description = 'F', tooltip = 'Force - F')\n",
    "rseqnbtn           = widgets.Button(layout = eqn_hb_item_layout, description = 'M', tooltip = 'Mass - M')\n",
    "ls_eqn_btns.append(lseqnbtn)\n",
    "lseqnbtn.on_click(on_change_lseqnbtn)\n",
    "rs_eqn_btns.append(rseqnbtn)\n",
    "rseqnbtn.on_click(on_change_rseqnbtn)\n",
    "eqn_hb_layout      = widgets.Layout(overflow = 'scroll hidden', border = '1px solid green', flex_flow = 'row', display = 'flex')\n",
    "ls_elem_carousel   = widgets.Box(children = ls_eqn_btns) #, layout = lseqhb_layout)\n",
    "ls_eqn_elems_HBox  = widgets.HBox([ls_elem_carousel], layout = eqn_hb_layout)\n",
    "rs_elem_carousel   = widgets.Box(children = rs_eqn_btns) #, layout = rseqhb_layout)\n",
    "rs_eqn_elems_HBox  = widgets.HBox([rs_elem_carousel], layout = eqn_hb_layout)\n",
    "\n",
    "# Define the dimension vector vertical box elements and display them\n",
    "\n",
    "dv_vb_item_layout = widgets.Layout(border = 'solid 0px', min_height = '20px')\n",
    "dv_vb_layout      = widgets.Layout(min_width = '30px')\n",
    "\n",
    "lsslabel          = widgets.Label(layout = dv_vb_item_layout, value = 'F')\n",
    "ls_dv_vb_slabels.append(lsslabel)\n",
    "ls_dv_slab_VBox   = widgets.VBox(ls_dv_vb_slabels, layout = dv_vb_layout)\n",
    "lsdvlabel         = widgets.Label(layout = dv_vb_item_layout, value = 'A0E0L1I0M1H0T-2D0')\n",
    "ls_dv_vb_dvlabels.append(lsdvlabel)\n",
    "ls_dv_elems       = [('F', 'A0E0L1I0M1H0T-2D0')]\n",
    "ls_dv_dvlab_VBox  = widgets.VBox(ls_dv_vb_dvlabels)\n",
    "ls_dv_vb_items    = [ls_dv_slab_VBox, ls_dv_dvlab_VBox]\n",
    "ls_dv_elems_HBox  = widgets.HBox(ls_dv_vb_items)\n",
    "\n",
    "rsslabel          = widgets.Label(layout = dv_vb_item_layout, value = 'm')\n",
    "rs_dv_vb_slabels.append(rsslabel)\n",
    "rs_dv_slab_VBox   = widgets.VBox(rs_dv_vb_slabels, layout = dv_vb_layout)\n",
    "rsdvlabel         = widgets.Label(layout = dv_vb_item_layout, value = 'A0E0L0I0M1H0T0D0')\n",
    "rs_dv_vb_dvlabels.append(rsdvlabel)\n",
    "rs_dv_elems       = [('m', 'A0E0L0I0M1H0T0D0')]\n",
    "rs_dv_dvlab_VBox  = widgets.VBox(rs_dv_vb_dvlabels)\n",
    "rs_dv_vb_items    = [rs_dv_slab_VBox, rs_dv_dvlab_VBox]\n",
    "rs_dv_elems_HBox  = widgets.HBox(rs_dv_vb_items)\n",
    "\n",
    "# Define the equation and dimension vbox display\n",
    "\n",
    "eqn_dv_vb_layout = widgets.Layout(border = 'solid 2px', margin = '7px', padding = '3px')\n",
    "lsDVVBox         = widgets.VBox([ls_eqn_elems_HBox, ls_dv_elems_HBox], layout = eqn_dv_vb_layout) # ls_eqesHBox\n",
    "rsDVVBox         = widgets.VBox([rs_eqn_elems_HBox, rs_dv_elems_HBox], layout = eqn_dv_vb_layout) # ls_eqesHBox\n",
    "\n",
    "# Define the evaluation box elements and display them\n",
    "\n",
    "# Define the evaluation vertical box elements and display them\n",
    "\n",
    "eval_vb_item_layout = widgets.Layout(border = 'solid 0px', min_height = '20px')\n",
    "eval_vb_layout      = widgets.Layout(min_width = '30px')\n",
    "\n",
    "ls_eval_slabels    = []\n",
    "lsevslabel         = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L1I0M1H0T-2D0')\n",
    "ls_eval_slabels.append(lsevslabel)\n",
    "ls_eval_slab_VBox  = widgets.VBox(ls_eval_slabels, layout = eval_vb_layout)\n",
    "ls_eval_dvlabels   = []\n",
    "lsevdvlabel        = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L1I0M1H0T-2D0')\n",
    "ls_eval_dvlabels.append(lsevdvlabel)\n",
    "ls_eval_dvlab_VBox = widgets.VBox(ls_eval_dvlabels)\n",
    "ls_eval_vb_items   = [ls_eval_slab_VBox, ls_eval_dvlab_VBox]\n",
    "ls_eval_dv_HBox    = widgets.HBox(ls_dv_vb_items)\n",
    "\n",
    "rs_eval_vb_slabels = []\n",
    "rsevslabel         = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L0I0M1H0T0D0')\n",
    "rs_eval_vb_slabels.append(rsevslabel)\n",
    "rsdvsvb            = widgets.VBox(rs_dv_vb_slabels, layout = eval_vb_layout)\n",
    "rs_dv_vb_dvlabels  = []\n",
    "rsdvlabel          = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L0I0M1H0T0D0')\n",
    "rs_dv_vb_dvlabels.append(rsdvlabel)\n",
    "rsdvdvvb           = widgets.VBox(rs_dv_vb_dvlabels)\n",
    "rs_dv_vb_items     = [rsdvsvb, rsdvdvvb]\n",
    "rs_dvesHBox        = widgets.HBox(rs_dv_vb_items)\n",
    "\n",
    "# aggregate dv exps in eval:\n",
    "\n",
    "eval_layout    = widgets.Layout(border = 'solid 2px', margin = '7px', padding = '3px')\n",
    "\n",
    "lseqnevallabel = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L1I0M1H0T-2D0')\n",
    "rseqnevallabel = widgets.Label(layout = eval_vb_item_layout, value = 'A0E0L0I0M1H0T0D0')\n",
    "lsDABox        = widgets.Box([lseqnevallabel], layout = eval_layout)\n",
    "rsDABox        = widgets.Box([rseqnevallabel], layout = eval_layout)\n",
    "\n",
    "# Display the complete application\n",
    "\n",
    "#app_grid_items  = [lseqLabel, rseqLabel, lsQKVbox, rsQKVBox, lsDVVBox, lsDVVBox, lsDABox, rsDABox]\n",
    "app_grid_items  = [lseqnLabel, rseqnLabel, lsQKVBox, rsQKVBox, lsDVVBox, rsDVVBox, lsDABox, rsDABox]\n",
    "app_layout      = widgets.Layout(grid_template_columns = \"repeat(2,325px)\", border = 'solid 2px', margin = '2px', padding = '10px')\n",
    "dyn_box         = widgets.GridBox(app_grid_items, layout = app_layout)\n",
    "title_layout    = widgets.Layout(margin = '20px', padding = '3px')\n",
    "app_box         = widgets.VBox([titleBox, dyn_box, evalBox], layout = title_layout)\n",
    "display(app_box)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c6a1e83",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1194a8e2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00c51dd9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c665ab8b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}