Centerline_addon.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f9fd6bd-38cb-4b1f-8c70-5e2a1a1fe0df",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from imports import *\n",
    "from centerlining_utils import *\n",
    "from config_settings import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f94ca60f-7416-4eb3-9640-58254aeb90b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hide all markdown cells (including the space they occupy) using CSS\n",
    "# This only happens when the notebook is ran in app mode\n",
    "if ('/addon/' or '/apps/') in jupyter_notebook_url:\n",
    "    display(HTML('''<style>\n",
    "    .jp-Cell.jp-Notebook-cell.jp-MarkdownCell { display: none !important; }\n",
    "    </style>'''))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1ed4fe2-eea1-4862-a3c1-7961c828b698",
   "metadata": {},
   "source": [
    "# Logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b983a4f0-a828-45d9-b5e1-845f39976013",
   "metadata": {},
   "outputs": [],
   "source": [
    "log_handler = RotatingFileHandler(log_file, mode='a', maxBytes=5*1024*1024, \n",
    "                                 backupCount=2, encoding=None, delay=0)\n",
    "\n",
    "\n",
    "# Create a Formatter\n",
    "formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(message)s')\n",
    "\n",
    "# Set the Formatter for the handler\n",
    "log_handler.setFormatter(formatter)\n",
    "\n",
    "# Create a logger\n",
    "app_log = logging.getLogger('root')\n",
    "app_log.setLevel(logging.INFO)\n",
    "\n",
    "# Add the handler to the logger\n",
    "app_log.addHandler(log_handler)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b485df76-6b09-4c4c-9f6c-ea9ee5c43c00",
   "metadata": {},
   "source": [
    "# Initialized Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "396e830a",
   "metadata": {},
   "outputs": [],
   "source": [
    "speed_tag_df = pd.DataFrame()\n",
    "unique_grades_list = []\n",
    "input_widgets = {}\n",
    "centerlining_table = pd.DataFrame(columns=column_order)\n",
    "current = pd.DataFrame()\n",
    "previous = pd.DataFrame()\n",
    "selected_grade = str()\n",
    "last_updated = str()\n",
    "current_data = pd.DataFrame()\n",
    "grades = list()\n",
    "tags = list()\n",
    "running_metrics = pd.DataFrame()\n",
    "tag_search_df = pd.DataFrame()\n",
    "centerline_metadata = pd.DataFrame()\n",
    "csv_file_upload = pd.DataFrame()\n",
    "tree = ''\n",
    "data = pd.DataFrame()\n",
    "required_columns = [\"Tag Name\", \"Friendly Name\", \"Category\"]\n",
    "optional_columns = [\"Path\", \"Asset\", \"Datasource Name\", \"Datasource Class\", \"Datasource ID\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a871dd4e-b030-415e-b36c-2c17466fe0f7",
   "metadata": {},
   "source": [
    "## Folder Directory Information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb377039-d3e9-49a2-9392-f6fe3d641b3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the current working directory\n",
    "current_directory = os.getcwd()\n",
    "# Create the full path for the new folder\n",
    "CENTERLINE_FOLDER_PATH = os.path.join(current_directory, CENTERLINE_FOLDER)\n",
    "os.makedirs(CENTERLINE_FOLDER_PATH, exist_ok=True)\n",
    "centerlining_tree_selections = get_centerlining_sets(CENTERLINE_FOLDER_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57b82c71-8a24-46ad-81f4-e62f8b70d21d",
   "metadata": {},
   "source": [
    "# App (UI) Layout / Components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d62df8df-8405-4bd3-b6d3-4832f015084a",
   "metadata": {},
   "source": [
    "## Main Page"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c36b496-b1c2-4d21-8e24-7831e7580fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "#App Header\n",
    "header = v.ToolbarTitle( children=['Seeq Centerline App'])\n",
    "\n",
    "first_text = v.Html(tag='tr', children=['Please select a grade to view Centerline Results.'])\n",
    "table_title = v.Html(tag='h2', children=['Selected grade will display here.'])\n",
    "table_row = v.Flex(xs12=True, class_='flex-grow-1', style_='min-height: 500px;', children=[first_text])\n",
    "\n",
    "select_grade_button = v.Btn(class_=\"white--text\",color=app_color, children=['Select Grade'])\n",
    "view_tag_in_wb_button = v.Btn(class_=\"white--text\",color=app_color, children=['View Tag/Limits'])\n",
    "create_or_manage_tree_button = v.Btn(class_=\"white--text\",color=app_color, children=['Create or Manage Centerline Tree'])\n",
    "\n",
    "# Top table that shows previous month run information\n",
    "current_grade_metrics_datatable = v.DataTable(\n",
    "        headers=[{\"text\": col, \"value\": col} for col in current_data.columns],\n",
    "        items=current_data.to_dict('records')\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d51fb1de-cf91-4f00-9621-7b2c6e51515d",
   "metadata": {},
   "source": [
    "### Primary Centerline Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6418b524-9646-42a7-96f9-e2f6650606e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_options = {'defaultColDef': {'sortable': 'true', 'filter': 'true', 'resizable': 'true', 'editable': True},\n",
    "               'columnDefs' : [{'field': c, 'cellStyle': cell_style if c == 'Priority' else None} for c in centerlining_table.columns]}\n",
    "\n",
    "css_rules = \"\"\"\n",
    ".priority-high {\n",
    "    background-color: red;\n",
    "}\n",
    ".priority-medium {\n",
    "    background-color: orange;\n",
    "}\n",
    "\"\"\"\n",
    "\n",
    "ccf = \"\"\"function(params) { \n",
    "    if (params.value >= 2) {\n",
    "        return 'priority-high'; \n",
    "    } else if (params.value >= 1) {\n",
    "        return 'priority-medium';\n",
    "    }\n",
    "    return '';\n",
    "}\"\"\"\n",
    "\n",
    "grid_options['columnDefs'] = [{'field': c, 'cellClass': ccf if c == 'Priority' else ''} for c in centerlining_table.columns]\n",
    "\n",
    "g = Grid(width='100%',\n",
    "         height = 5000,\n",
    "         grid_data=centerlining_table,\n",
    "         grid_options=grid_options,\n",
    "         theme='ag-theme-balham',\n",
    "         quick_filter=True,\n",
    "         css_rules=css_rules,  # add css_rules\n",
    "         sync_grid=True,\n",
    "         export_csv=True,\n",
    "         export_excel=True,\n",
    "         show_toggle_delete=False,\n",
    "         columns_fit= 'size_to_fit',\n",
    "         index=False,\n",
    "         keep_multiindex=False\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dccc79a-8922-4cb2-b3ef-562eb6b1b2e1",
   "metadata": {},
   "source": [
    "## Misc UI Components"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16ceee65-07da-4bd0-a6dc-29a5ac4727f1",
   "metadata": {},
   "source": [
    "### Pop Up Messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "566419cb-efe3-4d0e-ad08-08c27c95cfd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "error_card = v.Card(children=[])\n",
    "error_dialog = v.Dialog(\n",
    "    max_width='300',\n",
    "    v_model = None,\n",
    "    children=[error_card],\n",
    ")\n",
    "\n",
    "card = v.Card(children=[])\n",
    "dialog = v.Dialog(\n",
    "    max_width='300',\n",
    "    v_model = None,\n",
    "    children=[card],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2806c5fe-52d4-4ee1-9f74-e8faaebc2af2",
   "metadata": {},
   "source": [
    "### Outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d86b68cc-f08c-4164-bf7f-e4129d1109ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Output for URL Hyperlink, CSV Uplodad, and delete tree\n",
    "output = Output()\n",
    "csv_output = Output()\n",
    "delete_tree_output = Output()\n",
    "\n",
    "# Outputs for tree creation\n",
    "output_grades = Output()\n",
    "output_downtimes = Output()\n",
    "output_speed_tag = Output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0629e5e6-d546-4fd5-9a54-44b6c04a539a",
   "metadata": {},
   "source": [
    "## Dialog for \"Select Grade\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69b6b129-67b1-449f-8a47-97a3ebf0133a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_selection_input = v.Combobox(label='Select Centerlining Set', items=centerlining_tree_selections, v_model=None)\n",
    "grade_selection_input = v.Combobox(label='Select Grade', items=grades, v_model=None)\n",
    "\n",
    "execute_grade_selection_button = v.Btn(class_=\"white--text\",color=app_color, children=['Execute'])\n",
    "\n",
    "#Loading Message\n",
    "please_wait = v.Html(tag='p', children=['Loading... This may take a moment to collect the relevant data.'], style_='display: none')\n",
    "\n",
    "dialog_grade_selection = v.Dialog(v_model=False, children=[\n",
    "    v.Card(children=[\n",
    "        v.CardTitle(children=['Select Centerline Tree & Grade']),\n",
    "        v.CardText(children=[tree_selection_input,\n",
    "            grade_selection_input,\n",
    "            please_wait\n",
    "        ]),\n",
    "        v.CardActions(children=[execute_grade_selection_button])\n",
    "    ])\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "059816ff-2492-4a90-b823-5c7433caadda",
   "metadata": {},
   "source": [
    "## Dialog for \"Create or Manage Cenerline Tree\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81a76e36-7827-4d75-a305-ab0aa73225b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "upload_or_manage_selector = v.Combobox(label='Upload or Manage', items=['Upload', 'Manage'], v_model='Upload')\n",
    "upload_or_manage_selector_col = v.Col(children=[upload_or_manage_selector])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dec88daa-d85d-4c72-92c0-65e984b231e3",
   "metadata": {},
   "source": [
    "### Create Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de09d9fa-110d-4282-87cf-c313635c9180",
   "metadata": {},
   "outputs": [],
   "source": [
    "asset_tree_name_input= v.TextField(label='Enter the name for this Centerlining Data Set; e.g., Plant A Paper Machine 1', v_model='', disabled=False, class_='ma-10')\n",
    "\n",
    "help_csv_format_button = v.Btn(class_=\"white--text\",color=app_color, children=['CSV Formatting Guidelines'])\n",
    "execute_new_tree_button = v.Btn(class_=\"white--text\",color=GREEN, children=['Create Centerline Tree'], style_='width: auto', disabled = True)\n",
    "find_all_grades_button = v.Btn(class_=\"white--text\",color=app_color, children=['Find All Grades']) \n",
    "find_all_modes_button = v.Btn(class_=\"white--text\",color=app_color, children=['Find All Tag Values'])        \n",
    "find_speed_tag_button = v.Btn(class_=\"white--text\",color=app_color, children=['Find Speed Tag']) \n",
    "\n",
    "help_dialog = v.Dialog(#width='300', \n",
    "                       v_model=False, children=[\n",
    "    v.Card(children=[\n",
    "        v.CardTitle(children=['Help Information']),\n",
    "        v.CardText(children=['Required Columns: \"Tag Name\", \"Friendly Name\", \"Category\"\\nOptional Columns: \"Path\", \"Asset\", \"Datasource Name\", \"Datasource Class\", \"Datasource ID\"']),\n",
    "    ])\n",
    "])\n",
    "\n",
    "# File Upload Widget\n",
    "file_upload = widgets.FileUpload(\n",
    "    accept='.csv',  # Accepted file extension\n",
    "    multiple=False,  # True to accept multiple files upload else False\n",
    "    description='Upload CSV',  # Add title to the button\n",
    "    layout= widgets.Layout(width='auto')\n",
    ")\n",
    "\n",
    "# Creation Widgets\n",
    "string_or_number_selector = v.Combobox(label='Value Represents', items=['String', 'Number'], v_model='String')\n",
    "input_value_uptime = v.TextField(\n",
    "            label=f'Enter the exact value that represents UPTIME.',\n",
    "            outlined=True,\n",
    "            v_model=None,\n",
    "            disabled = True\n",
    "        )\n",
    "\n",
    "grade_tag_item_selector = spy.widgets.SeeqItemSelect(\n",
    "                    title = '<H5>Click Find All Grades after you have selected your grade signal.</H5>',\n",
    "                    show_fields=['Name', 'Datasource Dropdown'],\n",
    "                    multi_select=False,\n",
    "                    type_options=['Signal'],\n",
    "                    item_type='Signal',\n",
    "                    )\n",
    "\n",
    "downtime_tag_item_selector = spy.widgets.SeeqItemSelect(\n",
    "                    title = '<H5>Click Find All Tag Values after you have selected your Uptime/Downtime signal.</H5>',\n",
    "                    show_fields=['Name', 'Datasource Dropdown'],\n",
    "                    multi_select=False,\n",
    "                    type_options=['Signal'],\n",
    "                    item_type='Signal',\n",
    "                    )\n",
    "\n",
    "speed_tag_item_selector = spy.widgets.SeeqItemSelect(\n",
    "                    title = '<H5>Click Find Speed Tag after you have selected the tag that measures process/machine speed.</H5>',\n",
    "                    show_fields=['Name', 'Datasource Dropdown'],\n",
    "                    multi_select=False,\n",
    "                    type_options=['Signal'],\n",
    "                    item_type='Signal',\n",
    "                    )\n",
    "grade_tag_item_selector.layout.width='500px'\n",
    "downtime_tag_item_selector.layout.width='500px'\n",
    "speed_tag_item_selector.layout.width='500px'\n",
    "\n",
    "\n",
    "\n",
    "def create_attribute_panel(name, description, default, input_type='text'):\n",
    "    # Choose the correct vuetify component based on the input_type\n",
    "    if input_type == 'integer':\n",
    "        input_widget = v.TextField(\n",
    "            label=f'Enter a number (e.g., {default})',\n",
    "            type='number',\n",
    "            outlined=True,\n",
    "            v_model=None  # Initialize the v_model to None\n",
    "        )\n",
    "    elif input_type == 'string':\n",
    "        input_widget = v.TextField(\n",
    "            label=f'Enter text (e.g., {default})',\n",
    "            outlined=True,\n",
    "            v_model=None  # Initialize the v_model to None\n",
    "        )\n",
    "    elif input_type == 'grade_tag_selector':\n",
    "        input_widget= v.Container(fluid=True, class_='pt-10', children=[\n",
    "            v.Row(children=[grade_tag_item_selector]),\n",
    "            v.Row(children=[output_grades]),\n",
    "            v.Row(children=[find_all_grades_button])\n",
    "        ])\n",
    "    elif input_type == 'downtime_tag_selector':\n",
    "        input_widget= v.Container(fluid=True, class_='pt-10', children=[\n",
    "            v.Row(children=[downtime_tag_item_selector]),\n",
    "            v.Row(children=[output_downtimes]),\n",
    "            v.Col(cols = \"6\", children=[find_all_modes_button]),\n",
    "            v.Col(cols = \"6\", children = [input_value_uptime]), \n",
    "            v.Col(cols = \"6\", children = [string_or_number_selector])\n",
    "        ])\n",
    "    elif input_type == 'speed_tag_selector':\n",
    "        input_widget= v.Container(fluid=True, class_='pt-10', children=[\n",
    "            v.Row(children=[speed_tag_item_selector]),\n",
    "            v.Row(children=[output_speed_tag]),\n",
    "            v.Row(children=[find_speed_tag_button])\n",
    "        ])\n",
    "    else:\n",
    "        raise ValueError(\"input_type must be 'integer' or 'string' or 'grade_selector', 'downtime_selector'\")\n",
    "    \n",
    "    panel = v.ExpansionPanel(children=[\n",
    "        v.ExpansionPanelHeader(children=[name]),\n",
    "        v.ExpansionPanelContent(children=[\n",
    "            v.CardText(children=[description]),\n",
    "            input_widget\n",
    "        ])\n",
    "    ])\n",
    "    \n",
    "    return panel, input_widget\n",
    "\n",
    "\n",
    "\n",
    "# List of attributes with their attribute_types\n",
    "# ('Simple Name', 'Description', 'example default value', 'attribute_type')\n",
    "attributes = [\n",
    "    ('Specify Grade Tag', 'Search for and select the Grade tag; must be a step signal.', 0, 'grade_tag_selector'),\n",
    "    ('Specify Uptime/Downtime Tag', 'Search for and select the uptime/downtime tag; must be a step signal.', 0, 'downtime_tag_selector'),\n",
    "    ('Specify Speed Tag', 'Search for and select the Speed tag.', 0, 'speed_tag_selector'),\n",
    "    ('Upper Speed Limit Filter', 'Only data within the Upper and Lower Speed Limit Filter limits will be considered for limit creation.', 3500, 'integer'),\n",
    "    ('Lower Speed Limit Filter', 'Only data within the Upper and Lower Speed Limit Filter limits will be considered for limit creation.', 2800, 'integer'),\n",
    "    ('% Uptime Filter', 'Only grade runs with % Uptime greater than this threshold will be considered for limit creation', 90,'integer'),\n",
    "    ('StdDev Multiplier (Inner)', 'StdDev Inner Multiplier', 1, 'integer'),\n",
    "    ('StdDev Multiplier (Outer)', 'StdDev Outer Multiplier', 3, 'integer'),\n",
    "    ('Remove Shorter Than (Shortest Grade Run)', 'Shortest expected grade run', '30 min', 'string'),\n",
    "    ('Remove Longer Than (Longest Grade Run)', 'Longest expected grade run', '100 d', 'string'),\n",
    "    ('Number of Previous Grade Runs for Limit Creation', 'Number of previous grade runs to consider', 3, 'integer'),\n",
    "    ('Lookback Range for Previous Grade Runs', 'How far to look back for previous grade runs', '100 d', 'string'),\n",
    "    ('Sampling Rate', 'Sampling rate to calculate limits', '30 min', 'string')\n",
    "]\n",
    "\n",
    "# Create the UI elements for each attribute and store the input widgets\n",
    "attribute_panels = []\n",
    "for attr in attributes:\n",
    "    panel, input_widget = create_attribute_panel(*attr)\n",
    "    attribute_panels.append(panel)\n",
    "    input_widgets[attr[0]] = input_widget  # Store the widget with the name as the key\n",
    "\n",
    "\n",
    "# Combine all attribute panels into one expansion panels group\n",
    "attributes_expansion_panels = v.ExpansionPanels(children=attribute_panels, accordion=True)\n",
    "\n",
    "# Create the higher-level panel to contain all the attribute panels\n",
    "configuration_panel = v.ExpansionPanel(children=[\n",
    "    v.ExpansionPanelHeader(children=['Centerlining Configuration']),\n",
    "    v.ExpansionPanelContent(children=[attributes_expansion_panels])\n",
    "])\n",
    "\n",
    "# Combine the high-level panel into an Expansion Panels group\n",
    "configuration_panels_group = v.ExpansionPanels(children=[\n",
    "    configuration_panel\n",
    "], accordion=True)\n",
    "\n",
    "\n",
    "dialog_tree_upload_view_Title = v.CardTitle(children=['Upload a CSV with Centerlining Tags'], class_='ma-10')\n",
    "dialog_tree_upload_view_Text = v.CardText(children=[v.Col(children = [v.Row(children = [asset_tree_name_input]),\n",
    "                                                                     v.Row(children = [ csv_output])])])\n",
    "dialog_tree_upload_view_Actions = v.CardActions(children=[\n",
    "                                                    v.Row(children = [\n",
    "                                                        v.Col(cols=\"2\", children=[file_upload]),  # Assign half the width of the row to file_upload\n",
    "                                                        v.Col(cols = \"6\", children = [configuration_panels_group]),\n",
    "                                                        v.Col(cols=\"2\", children=[execute_new_tree_button]),  # Assign the other half to execute_new_tree_button\n",
    "                                                    ], class_='ma-10')\n",
    "                                                ])\n",
    "\n",
    "dialog_tree_upload = v.Dialog(v_model=False, children=[\n",
    "    v.Card(children=[\n",
    "        help_dialog,\n",
    "        v.Row(justify='center',children = [upload_or_manage_selector_col,\n",
    "        v.Col(children = [help_csv_format_button])], class_='ma-10'),\n",
    "        dialog_tree_upload_view_Title,\n",
    "        dialog_tree_upload_view_Text,\n",
    "        dialog_tree_upload_view_Actions\n",
    "    ])\n",
    "])\n",
    "\n",
    "\n",
    "\n",
    "dialog_tree_upload_or_manage = v.Dialog(v_model=False, children=[ #dialog_tree_upload\n",
    "    v.Card(children=[\n",
    "        help_dialog,\n",
    "        v.Row(justify='center',children = [upload_or_manage_selector_col,\n",
    "        v.Col(children = [help_csv_format_button])], class_='ma-10'),\n",
    "        dialog_tree_upload_view_Title,\n",
    "        dialog_tree_upload_view_Text,\n",
    "        dialog_tree_upload_view_Actions\n",
    "    ])\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5415b59d-9d6e-4499-ae85-6d3a8ac176e7",
   "metadata": {},
   "source": [
    "### Manage Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8730fa1-1056-4aa5-84e7-456e9758a404",
   "metadata": {},
   "outputs": [],
   "source": [
    "delete_tree_selection_input = v.Combobox(label='Select Centerlining Set to Delete', items=centerlining_tree_selections, v_model=None)\n",
    "\n",
    "execute_delete_tree_button = v.Btn(class_=\"white--text\",color=RED, children=['Delete Centerline Tree'], style_='width: auto', disabled = True)\n",
    "\n",
    "dialog_tree_manage_view_Title = v.CardTitle(children=['Delete Existing Centerline Trees'], class_='ma-10')\n",
    "dialog_tree_manage_view_Text = v.CardText(children=[delete_tree_selection_input, delete_tree_output], class_='ma-10')\n",
    "dialog_tree_manage_view_Actions = v.CardActions(children=[v.Row(children = [v.Col(cols = '6', children = [execute_delete_tree_button])], class_='ma-10')])\n",
    "dialog_tree_manage = v.Dialog(v_model=False, children=[\n",
    "    v.Card(children=[\n",
    "        upload_or_manage_selector_col,\n",
    "        dialog_tree_manage_view_Title,\n",
    "        dialog_tree_manage_view_Text,\n",
    "        dialog_tree_manage_view_Actions\n",
    "    ])\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f78e81f8-cd78-43a4-9a20-03faae3a2bc6",
   "metadata": {},
   "source": [
    "## Dialog for \"View Tag/Limits\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4d43b9b-5e09-48bc-8c09-c554ed988275",
   "metadata": {},
   "outputs": [],
   "source": [
    "tag_selection_input = v.Combobox(label='Select Tag', items=tags, v_model=None)\n",
    "\n",
    "execute_view_tag_button = v.Btn(class_=\"white--text\",color=app_color, children=['Execute'])\n",
    "\n",
    "dialog_view_tag = v.Dialog(v_model=False, children=[\n",
    "    v.Card(children=[\n",
    "        v.CardTitle(children=['Select a tag to generate link. Limits will be viewed against the selected grade.']),\n",
    "        v.CardText(children=[tag_selection_input, output]),\n",
    "        v.CardActions(children=[execute_view_tag_button])\n",
    "    ])\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f56f94ac-0dc6-42b7-af02-e08746612477",
   "metadata": {},
   "source": [
    "## App Layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdc7f65c-2282-4ef9-b7f9-bfae2ff427b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "top_table_container = v.Container(fluid=True, class_='pt-10', children=[\n",
    "            v.Row(children=[current_grade_metrics_datatable]),\n",
    "        ])\n",
    "\n",
    "\n",
    "main_container = v.Container(fluid=True, class_='pt-10', children=[\n",
    "            v.Row(children=[\n",
    "                v.Col(children=[select_grade_button]),\n",
    "                v.Col(children=[view_tag_in_wb_button]),\n",
    "                v.Col(children=[create_or_manage_tree_button]),\n",
    "                top_table_container\n",
    "            ]),\n",
    "            v.Row(children=[table_title]),\n",
    "            table_row,\n",
    "            dialog_view_tag,\n",
    "            dialog_grade_selection,\n",
    "            dialog_tree_upload_or_manage\n",
    "        ])\n",
    "\n",
    "\n",
    "app = v.Layout(\n",
    "    _metadata={'mount_id': 'content-main'},\n",
    "    children=[\n",
    "        v.AppBar(app=True, dark=True, color=app_color, children=[\n",
    "            header\n",
    "        ]),\n",
    "        main_container,\n",
    "        error_dialog,\n",
    "        dialog\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acfcb2f3-aada-4f8e-a9f5-881ece3b3860",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e8afcb8-0ff2-4a27-9e39-a4fd3bb497ce",
   "metadata": {},
   "source": [
    "## Utility / Misc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c199a44f-600e-42eb-b8c6-80b7e127fe75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pop up with an error. Best used with a try: except:\n",
    "def show_error_message(message):\n",
    "    error_card.children = [\n",
    "            v.CardTitle(class_='headline gray lighten-2', primary_title=True, children=['Error']),\n",
    "            v.CardText(children=[message]), \n",
    "    ]\n",
    "    \n",
    "    error_dialog.v_model = True  # Show the dialog\n",
    "    \n",
    "def show_message(title, message):\n",
    "    card.children = [\n",
    "            v.CardTitle(class_='headline gray lighten-2', primary_title=True, children=[title]),\n",
    "            v.CardText(children=[message]), \n",
    "    ]\n",
    "    \n",
    "    dialog.v_model = True  # Show the dialog\n",
    "    \n",
    "    \n",
    "def validate_columns(df):\n",
    "    \"\"\" Validate the columns of the DataFrame and return a tuple (is_valid, message) \"\"\"\n",
    "    missing_required = [col for col in required_columns if col not in df.columns]\n",
    "    invalid_columns = [col for col in df.columns if col not in required_columns + optional_columns]\n",
    "\n",
    "    if missing_required or invalid_columns:\n",
    "        message_parts = []\n",
    "        if missing_required:\n",
    "            message_parts.append(f\"Missing required columns: {', '.join(missing_required)}\")\n",
    "        if invalid_columns:\n",
    "            message_parts.append(f\"Invalid columns: {', '.join(invalid_columns)}\")\n",
    "        message_parts.append(f\"Allowed columns are: {', '.join(required_columns + optional_columns)}\")\n",
    "        return False, \"; \".join(message_parts)\n",
    "\n",
    "    return True, \"Columns are valid.\"\n",
    "\n",
    "def check_all_inputs_specified(input_widgets):\n",
    "    global speed_tag_df\n",
    "    for widget in input_widgets.values():\n",
    "        if isinstance(widget, v.TextField):\n",
    "            # Check v.TextFields for non-empty input\n",
    "            if widget.v_model is None or widget.v_model == '':\n",
    "                return False\n",
    "        elif isinstance(widget, v.Container):\n",
    "            if not grade_tag_item_selector.selected_value:\n",
    "                #show_error_message(f'You must search for and select a single Grade tag.')\n",
    "                return False\n",
    "            if not downtime_tag_item_selector.selected_value:\n",
    "                #show_error_message(f'You must search for and select a single Uptime / Downtime tag.')\n",
    "                return False\n",
    "            if input_value_uptime is None or input_value_uptime.v_model == '':\n",
    "                return False\n",
    "            if len(speed_tag_df) == 0:\n",
    "                return False\n",
    "        else:\n",
    "            # Handle other widget types or raise an error\n",
    "            raise ValueError(f\"Unhandled widget type: {type(widget)}\")\n",
    "    return True\n",
    "\n",
    "def get_all_input_values(input_widgets):\n",
    "    values = {}\n",
    "    for name, widget in input_widgets.items():\n",
    "        if isinstance(widget, v.TextField):  # Check if the widget is a v.TextField\n",
    "            values[name] = widget.v_model  # Store the user-input value\n",
    "    return values\n",
    "\n",
    "def create_centerlining_tree():\n",
    "    global unique_grades_list\n",
    "    global csv_file_upload\n",
    "    global speed_tag_df\n",
    "    global input_widgets\n",
    "    global created_trees\n",
    "    with csv_output:\n",
    "        name_of_tree = asset_tree_name_input.v_model\n",
    "        \n",
    "        display(f\"Beginning to build centerlining Set: {name_of_tree}... Please keep this app open until complete.\")\n",
    "        \n",
    "        tags_df = csv_file_upload\n",
    "        grade_tag_df = pd.DataFrame([grade_tag_item_selector.selected_value])\n",
    "        downtime_tag_df = pd.DataFrame([downtime_tag_item_selector.selected_value])\n",
    "        uptime_value = input_value_uptime.v_model\n",
    "        input_config_values = get_all_input_values(input_widgets)\n",
    "        string_or_number = string_or_number_selector.v_model\n",
    "        try:\n",
    "            create_tree(name_of_tree, tags_df, speed_tag_df, input_config_values, unique_grades_list, grade_tag_df, downtime_tag_df, string_or_number, uptime_value, centerlining_workbook, centerlining_datasource, CENTERLINE_FOLDER_PATH)\n",
    "            show_message('Congrats!', 'Your Centerlining Dataset has been successfully processed. You may now select it to view the limits.')\n",
    "\n",
    "            ## UPDATE THE DROPDOWN SO THAT USER CAN SEE NEW TREE IMMEDIATELY.\n",
    "            # Get the latest sets\n",
    "            centerlining_tree_selections = get_centerlining_sets(CENTERLINE_FOLDER_PATH)\n",
    "\n",
    "            # Directly update the tree_selection_input element's items\n",
    "            tree_selection_input.items = centerlining_tree_selections\n",
    "            delete_tree_selection_input.items = centerlining_tree_selections\n",
    "\n",
    "\n",
    "        except Exception as e:\n",
    "            show_error_message(f\"Error occurred while creating Centerline Tree: {e}\")\n",
    "            \n",
    "    csv_output.clear_output()\n",
    "    \n",
    "def execute_view_tag(widget, event, data):\n",
    "    global centerlining_table\n",
    "    global current\n",
    "    global previous\n",
    "    global selected_grade\n",
    "    global tree\n",
    "    global base_url\n",
    "    global centerlining_workbook\n",
    "    \n",
    "    tag_name = tag_selection_input.v_model\n",
    "    url = build_url(current, previous, selected_grade, tag_name, tree, base_url, centerlining_workbook)\n",
    "    \n",
    "    output.clear_output()\n",
    "    with output:\n",
    "        display(HTML(f'<a href=\"{url}\" target=\"_blank\">Click here to investigate {tag_name} in Workbench</a>'))\n",
    "\n",
    "def update_top_table():\n",
    "    global current_data\n",
    "    global current_grade_metrics_datatable\n",
    "    current_grade_metrics_datatable.headers = [{\"text\": col, \"value\": col} for col in current_data.columns]\n",
    "    current_grade_metrics_datatable.items = current_data.to_dict('records')\n",
    "    return\n",
    "\n",
    "def update_table():\n",
    "    global centerlining_table\n",
    "    global current\n",
    "    global previous\n",
    "    global selected_grade\n",
    "    global update_frequency\n",
    "    global last_updated\n",
    "    global g\n",
    "    global dialog_grade_selection\n",
    "    global tag_search_df\n",
    "    global tree\n",
    "    global current_grade_metrics_datatable\n",
    "    global running_metrics\n",
    "    global centerline_metadata\n",
    "    \n",
    "    while True:\n",
    "        # If the table has been updated already and the other dialogs are closed, update both tables\n",
    "        if len(centerlining_table) > 0 and dialog_grade_selection.v_model == False and dialog_tree_upload_or_manage.v_model == False and selected_grade != '':\n",
    "            try:\n",
    "                results = find_current_values(tag_search_df)\n",
    "                current = results[0]\n",
    "                last_updated = convert_date_format(results[1])\n",
    "                centerlining_table = add_priority(current, previous, selected_grade)\n",
    "                main_container.children[1].children = [f\"Viewing Tree: {tree}. Viewing Grade: {selected_grade}. Last updated: {last_updated}\"]\n",
    "                g.update_grid_data(centerlining_table)\n",
    "                current_data = find_current_metrics(running_metrics, centerline_metadata)\n",
    "                current_data = current_data.applymap(replace_non_json_compliant_floats)\n",
    "                update_top_table()\n",
    "                \n",
    "\n",
    "            except Exception as e:\n",
    "                app_log.error(f'Error occurred in update_table 1: {e}')\n",
    "                \n",
    "        # If the table has NOT been updated already and the other dialogs are closed, update the current data table    \n",
    "        elif len(centerlining_table) == 0 and dialog_grade_selection.v_model == False and dialog_tree_upload_or_manage.v_model == False and selected_grade != '':\n",
    "            try:\n",
    "                current_data = find_current_metrics(running_metrics, centerline_metadata)\n",
    "                current_data = current_data.applymap(replace_non_json_compliant_floats)\n",
    "                update_top_table()\n",
    "                \n",
    "            except Exception as e:\n",
    "                app_log.error(f'Error occurred in update_table 2: {e}')\n",
    "        # Otherwise, don't update anything... I.e. if select grade dialog is open\n",
    "        else:\n",
    "            pass\n",
    "        \n",
    "        # Wait for a specified period of time\n",
    "        time.sleep(update_frequency)  \n",
    "\n",
    "def execute_grade_selection(widget, event, data):\n",
    "    global centerlining_table\n",
    "    global current\n",
    "    global previous\n",
    "    global selected_grade\n",
    "    global table_row\n",
    "    global last_updated\n",
    "    global g\n",
    "    global first_text\n",
    "    global grades\n",
    "    global tag_search_df\n",
    "    global tree\n",
    "    global current_data\n",
    "    global current_grade_metrics_datatable\n",
    "    global centerline_metadata\n",
    "    global running_metrics\n",
    "    \n",
    "    \n",
    "    app_log.info('execute_grade_selection function started')\n",
    "    please_wait.style_ = 'display: block'  # Make the please_wait visible when executing\n",
    "\n",
    "    try:\n",
    "        selected_grade = grade_selection_input.v_model\n",
    "        results = find_current_values(tag_search_df)\n",
    "        #app_log.info(f\"Here are my Results: {results}\")\n",
    "        \n",
    "        current = results[0]\n",
    "        app_log.info(f\"Current Results: {current}\")\n",
    "        \n",
    "        last_updated = convert_date_format(results[1])\n",
    "        previous = find_previous_run_data(selected_grade, centerline_metadata)\n",
    "        app_log.info(f\"Previous Results: {previous}\")\n",
    "        \n",
    "        centerlining_table = add_priority(current, previous, selected_grade)\n",
    "\n",
    "        g.update_grid_data(centerlining_table)\n",
    "\n",
    "        \n",
    "        main_container.children[1].children = [f\"Viewing Tree: {tree}. Viewing Grade: {selected_grade}. Last updated: {last_updated}\"]\n",
    "        if isinstance(table_row.children[0], v.Html):\n",
    "            table_row = v.Flex(xs12=True, class_='flex-grow-1', style_='min-height: 500px;', children=[g])\n",
    "            main_container.children[2].children = [table_row]\n",
    "        current_data = find_current_metrics(running_metrics, centerline_metadata)\n",
    "        current_data = current_data.applymap(replace_non_json_compliant_floats)\n",
    "        update_top_table()\n",
    "\n",
    "    except Exception as e:\n",
    "        app_log.error(f'Error occurred in execute_grade_selection: {e}')\n",
    "        show_error_message(f\"An error occurred: {e}\")\n",
    "    \n",
    "    please_wait.style_ = 'display: none'\n",
    "    dialog_grade_selection.v_model = False\n",
    "    \n",
    "def find_current_metrics(running_metrics, centerline_metadata):\n",
    "    grade = grade_selection_input.v_model\n",
    "    grade_condition = centerline_metadata['Name'] == 'Grade Keep Condition with Uptime Property'\n",
    "    specific_grade = centerline_metadata['Path'].str.contains(f'.*{grade}', regex = True) \n",
    "    grade_condition_df = centerline_metadata[(grade_condition) & (specific_grade)].iloc[0]\n",
    "\n",
    "    days = 31\n",
    "    now_dt = datetime.now(timezone('US/Central'))\n",
    "    start_date_dt = now_dt - timedelta(days=days)\n",
    "    now_str = datetime.isoformat(now_dt, timespec='minutes')\n",
    "    start_date_str = datetime.isoformat(start_date_dt, timespec='minutes')\n",
    "    end_date_str = now_str\n",
    "\n",
    "    calculation = f\"$condition.keep('Grade Code', isEqualTo('{grade}')).removeShorterThan(30min).removeLongerThan(100d)\"\n",
    "    # Get previous run information\n",
    "    data = spy.pull(items = grade_condition_df, \n",
    "                    calculation = calculation, \n",
    "                    start = start_date_str, \n",
    "                    end = end_date_str, \n",
    "                    quiet = True, \n",
    "                    shape = 'capsules',\n",
    "                    #capsule_properties = ['Duration', 'Grade Code']\n",
    "                   )\n",
    "    \n",
    "    # Convert 'Capsule Start' and 'Capsule End' to datetime objects in US/Central timezone\n",
    "    data['Capsule Start'] = pd.to_datetime(data['Capsule Start']).dt.tz_convert('US/Central')\n",
    "    data['Capsule End'] = pd.to_datetime(data['Capsule End']).dt.tz_convert('US/Central')\n",
    "\n",
    "    # Calculate Duration\n",
    "    data['Duration'] = data['Capsule End'] - data['Capsule Start']\n",
    "    data['Duration'] = data['Duration'].apply(lambda x: f\"{x.components.days} days {x.components.hours:02d}:{x.components.minutes:02d}\")\n",
    "\n",
    "    # Combine 'Capsule Start' and 'Capsule End' into a single column 'Start / End'\n",
    "    data['Start / End; Results for Past Month'] = data['Capsule Start'].dt.strftime('%-m/%-d/%y %-I:%M %p') + ' - ' + data['Capsule End'].dt.strftime('%-m/%-d/%y %-I:%M %p')\n",
    "    \n",
    "    columns = ['Start / End; Results for Past Month', 'Duration', '% Uptime']\n",
    "\n",
    "    \n",
    "    data = data[columns]\n",
    "\n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b278900a-825a-4016-8d16-3422a8ff215c",
   "metadata": {},
   "source": [
    "## On Event Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8831fcd1-5376-429c-bf08-aa935c01e64b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_all_grades_from_tag(widget, event, data):\n",
    "    global unique_grades_list\n",
    "    if grade_tag_item_selector.selected_value:\n",
    "        pass\n",
    "    else:\n",
    "        show_error_message(f'You must search for and select a single tag.')\n",
    "        return\n",
    "    \n",
    "    try:\n",
    "        tag_df = pd.DataFrame([grade_tag_item_selector.selected_value])\n",
    "        # Get the current timestamp (current time)\n",
    "        current_time = datetime.now() - timedelta(minutes = 30)\n",
    "\n",
    "        # Calculate the timestamp for one year ago\n",
    "        one_year_ago = current_time - timedelta(days=365)\n",
    "        one_year_pull = spy.pull(tag_df, start = one_year_ago, end = current_time, quiet = True)\n",
    "        unique_grade_values = one_year_pull.iloc[:, 0].unique()\n",
    "        unique_grades_list = [grade for grade in unique_grade_values if pd.notna(grade)]\n",
    "        unique_grades_str = \", \".join([str(grade) for grade in unique_grade_values if pd.notna(grade)])\n",
    "        final_sentence = f\"You may proceed. Centerlining limits will be created for the following grades: {unique_grades_str}.\"\n",
    "        with output_grades:\n",
    "            display(final_sentence)\n",
    "    except Exception as e:\n",
    "        show_error_message(f'Error finding all unique Grades: {e}')\n",
    "        \n",
    "def find_all_values_from_tag(widget, event, data):\n",
    "    if downtime_tag_item_selector.selected_value:\n",
    "        pass\n",
    "    else:\n",
    "        show_error_message(f'You must search for and select a single tag.')\n",
    "        return\n",
    "    \n",
    "    try:\n",
    "        tag_df = pd.DataFrame([downtime_tag_item_selector.selected_value])\n",
    "        # Get the current timestamp (current time)\n",
    "        current_time = datetime.now() - timedelta(minutes = 30)\n",
    "\n",
    "        # Calculate the timestamp for one year ago\n",
    "        one_year_ago = current_time - timedelta(days=365)\n",
    "        one_year_pull = spy.pull(tag_df, start = one_year_ago, end = current_time, quiet = True)\n",
    "        unique_values = one_year_pull.iloc[:, 0].unique()\n",
    "        unique_str = \", \".join([str(value) for value in unique_values if pd.notna(value)])\n",
    "        final_sentence = f\"You must specify the exact value below for what represents UPTIME. After entering the value, you may proceed. Found values: {unique_str}\"\n",
    "        with output_downtimes:\n",
    "            display(final_sentence)\n",
    "        input_value_uptime.disabled = False\n",
    "    except Exception as e:\n",
    "        show_error_message(f'Error finding all unique Grades: {e}')\n",
    "        \n",
    "def find_speed_tag(widget, event, data):\n",
    "    global speed_tag_df\n",
    "    if speed_tag_item_selector.selected_value:\n",
    "        pass\n",
    "    else:\n",
    "        show_error_message(f'You must search for and select a single tag.')\n",
    "        return\n",
    "    \n",
    "    try:\n",
    "        tag_df = pd.DataFrame([speed_tag_item_selector.selected_value])\n",
    "        \n",
    "        speed_tag_df = spy.search(tag_df, quiet = True)\n",
    "        final_sentence = f\"Speed tag has been found. You may proceed.\"\n",
    "        with output_speed_tag:\n",
    "            display(final_sentence)\n",
    "    except Exception as e:\n",
    "        show_error_message(f'Error finding speed tag: {e}')\n",
    "\n",
    "def update_grades_and_tags(widget, event, data):\n",
    "    global grades\n",
    "    global tags\n",
    "    global tag_search_df\n",
    "    global centerline_metadata\n",
    "    global tree\n",
    "    \n",
    "    tree = tree_selection_input.v_model\n",
    "    tag_search_path_raw_file = os.path.join(CENTERLINE_FOLDER_PATH, tree+'_centerline_tag_search.csv')\n",
    "    metadata_path_raw_file = os.path.join(CENTERLINE_FOLDER_PATH, tree+'_centerline_metadata.csv')\n",
    "    raw_upload_path = os.path.join(CENTERLINE_FOLDER_PATH, tree+'_raw_upload.csv')\n",
    "    \n",
    "    tag_search_df = pd.read_csv(tag_search_path_raw_file, usecols=lambda column: column not in ['Unnamed: 0'])\n",
    "    centerline_metadata = pd.read_csv(metadata_path_raw_file, usecols=lambda column: column not in ['Unnamed: 0'])\n",
    "    centerline_data = pd.read_csv(raw_upload_path, usecols=lambda column: column not in ['Unnamed: 0'])\n",
    "    grades = list(centerline_metadata['Grade'].dropna().unique())\n",
    "    \n",
    "    # Filter rows where 'Path' column has 3 or more values split by '>>'\n",
    "    filtered_df = centerline_metadata[centerline_metadata['Path'].str.count('>>') >= 2]\n",
    "\n",
    "    # Get the unique values from the 'Asset' column\n",
    "    unique_assets = filtered_df['Asset'].unique().tolist()\n",
    "    \n",
    "    tags = unique_assets # list(centerline_data['Tag Name'])\n",
    "\n",
    "    grade_selection_input.items = grades\n",
    "    tag_selection_input.items = tags\n",
    "\n",
    "def select_grade_click(widget, event, data):\n",
    "    dialog_grade_selection.v_model = True\n",
    "\n",
    "\n",
    "def view_tag_click(widget, event, data):\n",
    "    dialog_view_tag.v_model = True\n",
    "    \n",
    "def create_or_manage_click(widget, event, data):\n",
    "    dialog_tree_upload_or_manage.v_model = True\n",
    "    \n",
    "def help_csv_format_click(widget, event, data):\n",
    "    help_dialog.v_model = True\n",
    "    \n",
    "def change_view_upload_or_manage(widget, event, data):\n",
    "    selection = upload_or_manage_selector.v_model\n",
    "    if selection == 'Manage':\n",
    "        dialog_tree_upload_or_manage.children = dialog_tree_manage.children\n",
    "    else:\n",
    "        dialog_tree_upload_or_manage.children = dialog_tree_upload.children\n",
    "        \n",
    "def delete_tree_select(widget, event, data):\n",
    "    execute_delete_tree_button.disabled = False\n",
    "\n",
    "def delete_tree_click(widget, event, data):\n",
    "    delete_tree_output.clear_output()\n",
    "    \n",
    "    tree_to_delete = delete_tree_selection_input.v_model\n",
    "    try:\n",
    "        with delete_tree_output:\n",
    "            print(f\"Deleting tree: {tree_to_delete}\")\n",
    "            delete_tree(tree_to_delete)\n",
    "        execute_delete_tree_button.disabled = True\n",
    "        centerlining_tree_selections = get_centerlining_sets(CENTERLINE_FOLDER_PATH)\n",
    "        tree_selection_input.items = centerlining_tree_selections\n",
    "        delete_tree_selection_input.items = centerlining_tree_selections\n",
    "        \n",
    "    except Exception as e:\n",
    "        show_error_message(f\"Error deleting Tree: {e}\")\n",
    "    \n",
    "# Create a function to handle file upload\n",
    "def on_upload_change(change):\n",
    "    global csv_file_upload\n",
    "    try:\n",
    "        \n",
    "        # Get the name of the first (and only) uploaded file\n",
    "        file_name = list(change['new'].keys())[0]\n",
    "        \n",
    "        # Get the content of the uploaded file\n",
    "        content = change['new'][file_name]['content']\n",
    "\n",
    "        # Convert the bytes to a string\n",
    "        content_str = content.decode()\n",
    "\n",
    "        # Convert the string to a pandas DataFrame\n",
    "        upload = pd.read_csv(StringIO(content_str))\n",
    "        \n",
    "        # Validate columns\n",
    "        is_valid, validation_message = validate_columns(upload)\n",
    "        if not is_valid:\n",
    "            show_error_message(validation_message)\n",
    "            file_upload.value = {}\n",
    "            \n",
    "            return\n",
    "            \n",
    "        csv_file_upload = pd.read_csv(StringIO(content_str))\n",
    "\n",
    "        # Display the DataFrame\n",
    "        csv_output.clear_output()\n",
    "        with csv_output:\n",
    "            display(csv_file_upload)\n",
    "        execute_new_tree_button.disabled = False\n",
    "            \n",
    "    except Exception as e:\n",
    "        file_upload.value = {}\n",
    "        csv_output.clear_output()\n",
    "        with csv_output:\n",
    "            display(f\"An error occurred: {e}\")\n",
    "        \n",
    "def execute_new_tree_click(widget, event, data):\n",
    "    name_of_tree = asset_tree_name_input.v_model\n",
    "    if name_of_tree == '':\n",
    "        show_error_message('Name for the Centerlining Dataset needs to be set.')\n",
    "    elif not check_all_inputs_specified(input_widgets):\n",
    "        show_error_message('All configuration items must be set.')\n",
    "    else:\n",
    "\n",
    "        create_centerlining_tree()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9ea74e6-34c9-48eb-8c1b-64138c67e4bc",
   "metadata": {},
   "source": [
    "# Event Handlers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a0bcb0f-5f12-4e21-8836-b39402a976ab",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "execute_view_tag_button.on_event('click', execute_view_tag)\n",
    "view_tag_in_wb_button.on_event('click', view_tag_click)\n",
    "create_or_manage_tree_button.on_event('click', create_or_manage_click)\n",
    "select_grade_button.on_event('click', select_grade_click)\n",
    "execute_grade_selection_button.on_event('click', execute_grade_selection)\n",
    "tree_selection_input.on_event('change', update_grades_and_tags)\n",
    "file_upload.observe(on_upload_change, names='value')\n",
    "execute_new_tree_button.on_event('click', execute_new_tree_click)\n",
    "execute_delete_tree_button.on_event('click', delete_tree_click)\n",
    "upload_or_manage_selector.on_event('change', change_view_upload_or_manage)\n",
    "help_csv_format_button.on_event('click', help_csv_format_click)\n",
    "delete_tree_selection_input.on_event('change', delete_tree_select)\n",
    "find_all_modes_button.on_event('click', find_all_values_from_tag)\n",
    "find_all_grades_button.on_event('click', find_all_grades_from_tag)\n",
    "find_speed_tag_button.on_event('click', find_speed_tag)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efe4c84e-856a-4c74-8a15-4312da6a5877",
   "metadata": {},
   "source": [
    "# Display App & Create Thread"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0e79661-b1a8-43de-97b3-f6ac58cdb734",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# To update the table\n",
    "if update:\n",
    "    # Create a thread to run the update_table function in the background\n",
    "    update_thread = threading.Thread(target=update_table)\n",
    "\n",
    "    # Start the thread\n",
    "    update_thread.start()\n",
    "\n",
    "display(app)"
   ]
  }
 ],
 "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}