Widgets.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<style>a{text-decoration: none !important;color:lightkblue;font-weight:bold;}\n",
       "                a:focus,a:active,a:hover{color:hotpink !important;}</style>\n",
       "> [&nbsp;`▶` Index&nbsp;](https://massgh.github.io/pivotpy/)  \n",
       "> [&nbsp;`▶` Example&nbsp;](https://massgh.github.io/pivotpy/Example)  \n",
       "> [&nbsp;`▶` StaticPlots&nbsp;](https://massgh.github.io/pivotpy/StaticPlots)  \n",
       "> [&nbsp;`▶` InteractivePlots&nbsp;](https://massgh.github.io/pivotpy/InteractivePlots)  \n",
       "> [&nbsp;`▶` SpinProjectedSurfaces&nbsp;](https://massgh.github.io/pivotpy/SpinProjectedSurfaces)  \n",
       "> [&nbsp;`▶` StructureIO&nbsp;](https://massgh.github.io/pivotpy/StructureIO)  \n",
       "> [&nbsp;`▶` Widgets●&nbsp;](https://massgh.github.io/pivotpy/Widgets)  \n",
       "> [&nbsp;`▶` MainAPI&nbsp;](https://massgh.github.io/pivotpy/MainAPI)  \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide_input\n",
    "from pivotpy.utils import nav_links \n",
    "nav_links(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Widgets\n",
    "> This module contains widgets to perform selected tasks such as viewing/modifying plots interactively. Use Jupyterlab>=3, Notebook or VS Code, Google Colab may not work! For troubleshooting plotly's FigureWidget see [Plotly's help](https://plotly.com/python/troubleshooting/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "import os, textwrap\n",
    "import json\n",
    "from time import sleep\n",
    "\n",
    "# Widgets Imports\n",
    "from IPython.display import display, Markdown\n",
    "from IPython import get_ipython #For SLides\n",
    "import ipywidgets as ipw\n",
    "from ipywidgets import Layout,Label,Button,Box,HBox,VBox,Dropdown,Text,Checkbox, SelectMultiple\n",
    "from ipywidgets.embed import embed_minimal_html, dependency_state\n",
    "\n",
    "# More exports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import plotly.graph_objects as go\n",
    "\n",
    "# Inside packages import to work both with package and jupyter notebook.\n",
    "try:\n",
    "    from pivotpy import utils as gu\n",
    "    from pivotpy import parser as vp\n",
    "    from pivotpy import iplots as ip\n",
    "    from pivotpy import splots as sp\n",
    "    from pivotpy import sio\n",
    "    from pivotpy import serializer\n",
    "except:\n",
    "    import pivotpy.utils as gu\n",
    "    import pivotpy.parser as vp\n",
    "    import pivotpy.iplots as ip\n",
    "    import pivotpy.splots as sp\n",
    "    import pivotpy.sio as sio\n",
    "    import pivotpy.serializer as serializer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[HTML STYLES REFERENCE](https://github.com/jupyter-widgets/ipywidgets/blob/master/packages/controls/css/widgets-base.css)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def css_style(colors_dict,_class = 'main_wrapper'):\n",
    "    \"\"\"Return style based on colors_dict available as pp.light_colors, pp.dark_colors etc\"\"\"\n",
    "    return \"\"\"<style>\n",
    "    .{_class} h1,h2,h3,h4,h5,h6 {{\n",
    "        color: {accent} !important;\n",
    "    }}\n",
    "    .{_class} .widget-label-basic {{\n",
    "        background-color: transparent !important;\n",
    "        color: {main_fg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-text input {{\n",
    "        background-color: {next_bg} !important;\n",
    "        border-radius:20px !important;\n",
    "        padding: 0px 10px 0px 10px !important;\n",
    "        border: 1px solid {next_bg} !important;\n",
    "        color: {main_fg} !important;\n",
    "        }}\n",
    "    .{_class} .widget-text input:focus {{\n",
    "        border: 1px solid {hover_bg} !important;\n",
    "        }}\n",
    "    .{_class} .widget-text input:hover {{\n",
    "        border: 1px solid {hover_bg} !important;\n",
    "        }}\n",
    "    .{_class} .widget-dropdown > select {{\n",
    "        background-color: {next_bg} !important;\n",
    "        border:none !important;\n",
    "        border-bottom: 1px solid {hover_bg} !important;\n",
    "        box-shadow: inset 0 -20px 10px -20px {hover_bg};\n",
    "        color: {main_fg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-dropdown > select:hover {{\n",
    "        background-color: {hover_bg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-dropdown > select > option {{\n",
    "        color: {main_fg} !important;\n",
    "        background-color: {next_bg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-dropdown > select > option:focus {{\n",
    "        background-color: {hover_bg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-label {{\n",
    "        color: {main_fg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-html {{\n",
    "        color: {main_fg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-box, .{_class}.widget-box {{\n",
    "        background-color: {main_bg} !important;\n",
    "        border-radius:5px !important;\n",
    "        padding:1px !important;\n",
    "        border: 1px solid {next_bg} !important;\n",
    "        box-shadow: 1px 1px 1px 1px {next_bg} !important;\n",
    "    }}\n",
    "    .{_class} .borderless, .{_class}.borderless {{\n",
    "        border: 1px solid transparent !important;\n",
    "        box-shadow: none !important;\n",
    "        border-radius: 4px !important;\n",
    "        margin:4px !important;\n",
    "    }}\n",
    "    .{_class} .marginless, .{_class}.marginless {{\n",
    "        margin: 0px !important;\n",
    "        border-radius: 0px !important;\n",
    "    }}\n",
    "    .{_class} .output, .{_class}.output {{\n",
    "        color: {main_fg} !important;\n",
    "        background-color: inherit !important;\n",
    "    }}\n",
    "    .{_class} .widget-tab, .{_class}.widget-tab {{\n",
    "        background-color: {main_bg} !important;\n",
    "        border: none !important;\n",
    "        box-shadow: 1px 1px 1px 1px {next_bg} !important;\n",
    "        padding: 0px 2px 2px 2px !important;\n",
    "    }}\n",
    "    .{_class} .widget-tab-contents, .{_class}.widget-tab > .widget-tab-contents {{\n",
    "        width: 100%;\n",
    "        box-sizing: border-box;\n",
    "        margin: 0px !important;\n",
    "        padding: 0px !important;\n",
    "        flex-grow: 1;\n",
    "        overflow: auto;\n",
    "        border: none !important;\n",
    "        background-color: {main_bg} !important;\n",
    "    }}\n",
    "    .{_class} .widget-tab > .p-TabBar .p-TabBar-tab, .{_class}.widget-tab > .p-TabBar .p-TabBar-tab {{\n",
    "        background-color:{main_bg} !important;\n",
    "        border: none !important;\n",
    "        color: {accent} !important;\n",
    "        font-weight: bold !important;\n",
    "        font-size: 16px !important;\n",
    "        font-family: \"Times\",\"serif\" !important;\n",
    "        text-align: center !important;\n",
    "    }}\n",
    "    .{_class} table {{\n",
    "        color: {main_fg} !important;\n",
    "        }}\n",
    "    .{_class} tr:nth-child(odd) {{\n",
    "        background-color: {next_bg} !important;\n",
    "        }}\n",
    "    .{_class} tr:nth-child(even) {{\n",
    "        background-color: {main_bg} !important;\n",
    "        }}\n",
    "    .{_class} .widget-button,.widget-toggle-button {{\n",
    "        color:  {accent} !important;\n",
    "        min-width: max-content !important;\n",
    "        background-color: {next_bg};\n",
    "        border-radius: 5px !important;\n",
    "    }}\n",
    "    .{_class} tr:hover {{\n",
    "        background-color: {hover_bg} !important;\n",
    "        }}\n",
    "    </style>\n",
    "    \"\"\".format(**colors_dict,_class= _class)\n",
    "\n",
    "dark_colors = {\n",
    " 'main_fg'  : '#ABB2BF',\n",
    " 'main_bg'  : '#21252B',\n",
    " 'next_bg'  : '#282C34',\n",
    " 'hover_bg' : '#414855',\n",
    " 'accent'   : '#61AFEF'\n",
    "}\n",
    "\n",
    "light_colors = {\n",
    " 'next_bg'  : 'white',\n",
    " 'hover_bg' : '#abe4ff',\n",
    " 'accent'   : 'navy',\n",
    " 'main_bg'  : '#F3F3F3',\n",
    " 'main_fg'  : 'black'\n",
    "}\n",
    "simple_colors = {\n",
    " 'hover_bg' : 'lightgray',\n",
    " 'accent'   : 'black',\n",
    " 'main_bg'  : 'white',\n",
    " 'main_fg'  : 'black',\n",
    " 'next_bg'  : 'whitesmoke'\n",
    "}\n",
    "default_colors = {  # Adopt Jupyterlab theme\n",
    " 'main_fg' : 'var(--jp-inverse-layout-color0,black)',\n",
    " 'main_bg' : 'var(--jp-layout-color0,#F3F3F3)',\n",
    " 'next_bg' : 'var(--jp-layout-color2,white)',\n",
    " 'hover_bg': 'var(--jp-border-color1,lightblue)',\n",
    " 'accent'  : 'var(--jp-brand-color2,navy)'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def get_files_gui(auto_fill = 'vasprun.xml', theme_colors = None, height=320):\n",
    "    \"\"\"\n",
    "    - Creates a GUI interface for files/folders filtering.\n",
    "    - **Parmeters**\n",
    "        - auto_fill  : Default is `vasprun.xml`, any file/folder.\n",
    "        - theme_colors : None,Any of pivotpy.[dark,light,simple]_colors.\n",
    "        - height     : Height of Grid box.\n",
    "    - **Returns**\n",
    "        - Tuple(GUI_gridbox,Files_Dropdown). Access second one by item itself.\n",
    "    \"\"\"\n",
    "    files_w = ipw.Dropdown(continuous_update=False)\n",
    "    pw = ipw.Text(value=os.getcwd())\n",
    "\n",
    "    incldue_w = ipw.Text(value=auto_fill)\n",
    "\n",
    "    excldue_w = ipw.Text()\n",
    "    d_layout = Layout(width='30%')\n",
    "    l_layout = Layout(width='19%')\n",
    "    depth_w = ipw.Dropdown(options=[None,1,2,3,4,5],value=4,layout=d_layout)\n",
    "    item_w = ipw.Dropdown(options=['Both','Files','Folders'],value='Files',layout=d_layout)\n",
    "    item_box = ipw.HBox([ipw.Label('Depth: ',layout=l_layout),depth_w,ipw.Label('Type: ',layout=l_layout),item_w])\n",
    "    item_box.add_class('borderless').add_class('marginless')\n",
    "\n",
    "    applybtn_w = ipw.Button(description='Apply Filters')\n",
    "    gci_output = ipw.Output(layout=Layout(height='{}px'.format(height-70)))\n",
    "    label_head = ipw.HTML(\"<h3>Your Filtered Files List</h3>\")\n",
    "\n",
    "\n",
    "    def filter_gci(applybtn_w):\n",
    "        applybtn_w.description = 'Applying...'\n",
    "        applybtn_w.disabled = True\n",
    "        if os.path.isdir(pw.value):\n",
    "            path = pw.value\n",
    "        else:\n",
    "            with gci_output:\n",
    "                print(\"Given path does not exists.\")\n",
    "                print(\"Falling back to PWD: {}\".format(os.getcwd()))\n",
    "            path = os.getcwd()\n",
    "            pw.value = path\n",
    "        gci = serializer.Dict2Data({'children':[],'parent':path})\n",
    "\n",
    "        if 'Files' in item_w.value:\n",
    "            file_type = dict(filesOnly=True)\n",
    "        elif 'Folders' in item_w.value:\n",
    "            file_type = dict(dirsOnly=True)\n",
    "        else:\n",
    "            file_type = {}\n",
    "        try:\n",
    "            gci = gu.get_child_items(path=path, **file_type,\n",
    "                           include= incldue_w.value,\n",
    "                           exclude= excldue_w.value,\n",
    "                           depth=depth_w.value)\n",
    "        except:\n",
    "            with gci_output:\n",
    "                print('Something went wrong')\n",
    "        # Enable before any error occur.\n",
    "        applybtn_w.disabled = False\n",
    "        files_w.options = [(name, os.path.join(gci.parent,name)) for name in gci.children]\n",
    "\n",
    "        applybtn_w.description = 'Successful!'\n",
    "        label_head.value = \"<h3>From: {}</h3>\".format(gci.parent)\n",
    "        with gci_output:\n",
    "            display(ipw.HTML(\"<h4>{} files found.</h4>\".format(len(gci.children))))\n",
    "            display(ipw.HTML(\"<ol>{}<ol>\".format(''.join(['<li>{}</li>'.format(i) for i in gci.children]))))\n",
    "\n",
    "\n",
    "        applybtn_w.description = 'Apply Filters'\n",
    "        gci_output.clear_output(wait=True)\n",
    "\n",
    "    applybtn_w.on_click(filter_gci)\n",
    "    out_box = ipw.Box([gci_output])\n",
    "    right_box = ipw.VBox([label_head,out_box])\n",
    "    out_box.add_class('borderless')\n",
    "    right_box.add_class('borderless')\n",
    "    i_layout = Layout(width='99%')\n",
    "    incldue_w.layout = i_layout\n",
    "    excldue_w.layout = i_layout\n",
    "    pw.layout = i_layout\n",
    "    input_box = ipw.VBox([\n",
    "        ipw.Label('Path to Project Folder',layout=i_layout),pw,\n",
    "        ipw.Label('Items to Include (separate by |)',layout=i_layout),incldue_w,\n",
    "        ipw.Label('Items to Exclude (separate by |)',layout=i_layout),excldue_w,\n",
    "        item_box,\n",
    "        applybtn_w],layout=Layout(width='330px'))\n",
    "\n",
    "    _class = 'custom-'+''.join(np.random.randint(9,size=(23,)).astype(str)) #Random class\n",
    "    html_style = css_style(theme_colors,_class = _class) if theme_colors else ''\n",
    "    full_box = ipw.HBox([ipw.HTML(html_style),input_box, right_box],\n",
    "                        layout=Layout(height='{}px'.format(height))).add_class(_class)\n",
    "\n",
    "    full_box.add_class('borderless').add_class('marginless')\n",
    "    return full_box, files_w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_box,files_w = get_files_gui(theme_colors=light_colors,height=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class InputGui:\n",
    "    def __init__(self,sys_info=None,theme_colors = None,height=400):\n",
    "        \"\"\"\n",
    "        - Creates a GUI interface for input/selection of orbitals/elms projection.\n",
    "        - **Parmeters**\n",
    "            - theme_colors : None,Any of pivotpy.[dark,light,simple]_colors.\n",
    "            - height     : Height of Grid box, Can set to None for auto-resizing.\n",
    "            - sys_info   : `export_vasprun().sys_info`. Can change later using `self.update_options` mthod.\n",
    "        - **Output Parameters**\n",
    "            - output: Dictionary that contains kwargs for plot functions.\n",
    "            - html  : A widget which can be used to bserve change in output, used in `VasprunApp`.\n",
    "        \"\"\"\n",
    "        self.sys_info = sys_info if sys_info else serializer.Dict2Data({'fields':['s'],\n",
    "                                                'ElemIndex':[0,1],'ElemName':['A']})\n",
    "        self.output = dict(elements = [[],[],[]],orbs = [[],[],[]],labels = ['','',''])\n",
    "\n",
    "        layout = Layout(width='30%')\n",
    "        l_width = Layout(width='20%')\n",
    "        self.html = ipw.HTML() # For Display in Big App as well. Very important\n",
    "        self._dds = {\n",
    "            'elms': Dropdown(layout=layout),\n",
    "            'orbs': Dropdown(layout=layout),\n",
    "            'rgb' : Dropdown(options=[('Red',0),('Green',1),('Blue',2)],value=0,layout=layout)\n",
    "            }\n",
    "        self._texts = {\n",
    "            'orbs' : Text(layout=layout,continuous_update=False),\n",
    "            'elms' : Text(layout=layout,continuous_update=False),\n",
    "            'label': Text(layout=layout,continuous_update=False)\n",
    "            }\n",
    "        self.update_options(self.sys_info) # In start if given\n",
    "\n",
    "        _class = 'custom-'+''.join(np.random.randint(9,size=(23,)).astype(str)) #Random class\n",
    "        html_style = css_style(theme_colors,_class = _class) if theme_colors else ''\n",
    "        self.box = VBox([ipw.HTML(html_style),\n",
    "                self.html,\n",
    "                HBox([Label('Color: ',layout=l_width), self._dds['rgb'],\n",
    "                      Label('Label: ',layout=l_width),self._texts['label']\n",
    "                    ]).add_class('borderless').add_class('marginless'),\n",
    "                HBox([Label('Ions: ',layout=l_width),self._dds['elms'],\n",
    "                      Label('::>>:: ',layout=l_width),self._texts['elms']\n",
    "                    ]).add_class('borderless').add_class('marginless'),\n",
    "                HBox([Label('Orbs: ',layout=l_width),self._dds['orbs'],\n",
    "                      Label('::>>:: ',layout=l_width),self._texts['orbs']\n",
    "                    ]).add_class('borderless').add_class('marginless')\n",
    "                ],layout=Layout(height=\"{}px\".format(height))\n",
    "                ).add_class(_class).add_class('marginless')\n",
    "\n",
    "\n",
    "        #Obsever\n",
    "        self._dds['rgb'].observe(self.__see_input,'value')\n",
    "        self._texts['label'].observe(self.__read_pro,'value')\n",
    "        self._texts['orbs'].observe(self.__read_pro,'value')\n",
    "        self._texts['elms'].observe(self.__read_pro,'value')\n",
    "        # Link\n",
    "        ipw.dlink((self._dds['elms'],'value'),(self._texts['elms'],'value'))\n",
    "        ipw.dlink((self._dds['orbs'],'value'),(self._texts['orbs'],'value'))\n",
    "    \n",
    "\n",
    "    def update_options(self,sys_info=None):\n",
    "        if sys_info:\n",
    "            orbs_opts = [(str(i)+': '+item,str(i)) for i,item in enumerate(sys_info.fields)]\n",
    "            if len(sys_info.fields) == 9:\n",
    "                orbs_opts = [*orbs_opts,('1-3: p','1-3'),('4-8: d','4-8')]\n",
    "            if len(sys_info.fields) == 16:\n",
    "                orbs_opts = [*orbs_opts,('9-15: f','9-15')]\n",
    "            max_ind = len(sys_info.fields)-1\n",
    "            orbs_opts = [('0-{}: All'.format(max_ind), \"0-{}\".format(max_ind)),*orbs_opts]\n",
    "            inds = sys_info.ElemIndex\n",
    "            ions_opts = [(\"{}-{}: {}\".format(inds[i],inds[i+1]-1,item),\"{}-{}\".format(\n",
    "                                    inds[i],inds[i+1]-1)) for i,item in enumerate(sys_info.ElemName)]\n",
    "            self._dds['elms'].options = [*ions_opts,('0-{}: All'.format(inds[-1]-1),'0-{}'.format(inds[-1]-1))]\n",
    "            self._dds['orbs'].options = orbs_opts\n",
    "            self.sys_info = sys_info # Update it as well.\n",
    "\n",
    "    def __read_pro(self,btn):\n",
    "        def read(cell_value):\n",
    "            _out = []\n",
    "            for v in (cell_value.split(\",\") if cell_value else ''):\n",
    "                if v and '-' in v:\n",
    "                    i, f = [int(k) for k in v.split(\"-\")]\n",
    "                    _out = [*_out,*list(range(i,f+1))]\n",
    "                elif v:\n",
    "                    _out = [*_out,int(v)]\n",
    "            return _out\n",
    "        \n",
    "        index = self._dds['rgb'].value\n",
    "        self.output['elements'][index] = read(self._texts['elms'].value)\n",
    "        self.output['orbs'][index] = read(self._texts['orbs'].value)\n",
    "        _text,_ion,_orb = self._texts['label'].value,self._texts['elms'].value,self._texts['orbs'].value\n",
    "        self.output['labels'][index] = _text if _text else \"{}:{}\".format(_ion,_orb)\n",
    "        self.html.value = \"\"\"<div style='border: 2px solid {0}!important;\n",
    "                             background-color:{0} !important;'> </div>\n",
    "                             \"\"\".format(self._dds['rgb'].label.lower())\n",
    "        sleep(0.3)\n",
    "        self.html.value = ''\n",
    "\n",
    "    def __see_input(self,change):\n",
    "        # Unobserve first to avoid overwriting\n",
    "        self._texts['label'].unobserve(self.__read_pro,'value')\n",
    "        self._texts['orbs'].unobserve(self.__read_pro,'value')\n",
    "        self._texts['elms'].unobserve(self.__read_pro,'value')\n",
    "\n",
    "        # Look up while not observing\n",
    "        x = self._dds['rgb'].value\n",
    "        self._texts['elms'].value = ','.join([str(i) for i in self.output['elements'][x]])\n",
    "        self._texts['orbs'].value = ','.join([str(i) for i in self.output['orbs'][x]])\n",
    "        self._texts['label'].value = self.output['labels'][x]\n",
    "        # Observe Back Again\n",
    "        self._texts['label'].observe(self.__read_pro,'value')\n",
    "        self._texts['orbs'].observe(self.__read_pro,'value')\n",
    "        self._texts['elms'].observe(self.__read_pro,'value')\n",
    "\n",
    "    def show(self):\n",
    "        return self.box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "#mouse event handler\n",
    "def _click_data(sel_en_w,Fermi,data_dict,fig,bd_w):\n",
    "    def handle_click(trace, points, state):\n",
    "        if points.ys != []:\n",
    "            v_clicked = points.ys[0] if bd_w.value=='Bands' else points.xs[0]\n",
    "            val = np.round(float(v_clicked) + Fermi,4) #exact value\n",
    "            \n",
    "            for key in sel_en_w.options:\n",
    "                if key in sel_en_w.value and key != 'None':\n",
    "                    data_dict[key] = val # Assign value back\n",
    "            \n",
    "            # Update E_gap, SO etc\n",
    "            if data_dict['VBM'] and data_dict['CBM']:\n",
    "                data_dict['E_gap'] = np.round(data_dict['CBM'] - data_dict['VBM'], 4)\n",
    "            if data_dict['so_max'] and data_dict['so_min']:\n",
    "                data_dict['Δ_SO'] = np.round(data_dict['so_max'] - data_dict['so_min'], 4)\n",
    "            # Cycle energy types on graph click and chnage table as well unless it is None.\n",
    "            if sel_en_w.value == 'CBM': # Avoid accidental SO calculation\n",
    "                sel_en_w.value = 'None'\n",
    "            if sel_en_w.value != 'None': # Keep usually as None\n",
    "                _this = sel_en_w.options.index(sel_en_w.value)\n",
    "                _next = _this + 1 if _this < len(sel_en_w.options) - 1 else 0\n",
    "                sel_en_w.value = sel_en_w.options[_next] #To simulate as it changes\n",
    "\n",
    "    for trace in fig.data:\n",
    "        trace.on_click(handle_click)\n",
    "\n",
    "# Display Table\n",
    "def _tabulate_data(data_dict):\n",
    "    new_dict = {k:v for k,v in data_dict.items() if v != '' and k not in ['sys','so_max','so_min']}\n",
    "    ls = list(new_dict.keys())\n",
    "    ds = list(new_dict.values())\n",
    "\n",
    "    if len(ls) % 2 != 0:\n",
    "        ls.append('')\n",
    "        ds.append('')\n",
    "\n",
    "    tab_data = [ls[:int(len(ls)/2)],ds[:int(len(ls)/2)],ls[int(len(ls)/2):],ds[int(len(ls)/2):]]\n",
    "\n",
    "    htm_string = \"\"\"<style>table {border-collapse: collapse !important;\n",
    "      min-width: 100% !important;\n",
    "      margin: 1px 1px 1px 1px !important;\n",
    "      font-size: small !important;\n",
    "      font-family: \"Times New Roman\", \"Times\", \"serif\" !important;}\n",
    "      th, td {text-align: center !important;\n",
    "      padding: 0px 8px 0px 8px !important;}\n",
    "      tr { width: 100% !important;}\n",
    "      tr:nth-child(odd) {font-weight:bold !important;}\n",
    "      </style>\"\"\"\n",
    "    htm_string += \"<table><tr>{}</tr></table>\".format( '</tr><tr>'.join(\n",
    "                   '<td>{}</td>'.format('</td><td>'.join(str(_) for _ in row)) for row in tab_data) )\n",
    "    return htm_string\n",
    "\n",
    "# Send Data\n",
    "def _save_data(out_w1,data_dict):\n",
    "    out_f = os.path.join(os.path.split(out_w1.value)[0],'result.json')\n",
    "    serializer.dump(data_dict,dump_to='json',outfile=out_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def generate_summary(paths_list=None):\n",
    "    # Make Data Frame\n",
    "    result_paths = []\n",
    "    if paths_list:\n",
    "        for item in paths_list:\n",
    "            if item and os.path.isdir(item):\n",
    "                result_paths.append(os.path.join(item,'result.json'))\n",
    "            elif item and os.path.isfile(item):\n",
    "                result_paths.append(os.path.join(os.path.split(item)[0],'result.json'))\n",
    "    result_dicts = []\n",
    "    for path in result_paths:\n",
    "        try:\n",
    "            data = serializer.load(path)\n",
    "            data.update({'path':path})\n",
    "            result_dicts.append(data)\n",
    "        except: pass\n",
    "        \n",
    "    out_dict = {} # placeholder\n",
    "    if result_dicts:\n",
    "        out_dict.update({k:[v] if v != '' else [np.nan] for k,v in result_dicts[0].items()})\n",
    "        for i,d in enumerate(result_dicts, start = 1):\n",
    "            for k,v in d.items():\n",
    "                v = np.nan if v == '' else v\n",
    "                try: \n",
    "                    out_dict[k].append(v)\n",
    "                except:\n",
    "                    out_dict.update({k:[np.nan for l in range(i)]}) #if not key before, add to all previous\n",
    "                    out_dict[k].append(v) # Then append for current value\n",
    "            # If next dictionary does not have key\n",
    "            for k in out_dict.keys():\n",
    "                if k not in d.keys():\n",
    "                    out_dict[k].append(np.nan)\n",
    "\n",
    "    return pd.DataFrame(out_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#export\n",
    "class VasprunApp:\n",
    "    \"\"\"\n",
    "    Display a GUI for vasp output analysis. `self.theme_colors` can be used to edit custom theme.\n",
    "    \n",
    "    **Usage Example**\n",
    "    ```python\n",
    "    import pivotpy as pp\n",
    "    va = pp.VasprunApp()\n",
    "    va.set_options(\n",
    "        cache_data = False, #Turn off cache globally.\n",
    "        mode = 'bands', #Change graph mode from 'markers' to 'bands'. Setting it to 'lines' is not recommended in live graph, it could hang all UI.\n",
    "        interp_nk = dict(n = 2, k = 2), #Add 2 points between data points with quadratic interpolation.\n",
    "    )\n",
    "    va.show() #Displays App and do work!\n",
    "    va.theme_colors = pp.dark_colors #Set theme to dark externally and edit dictionary values to make your own theme\n",
    "    va.splot(**kwargs) #Get matplotlib plot of current data.\n",
    "    va.df #After you do some analysis and hit `Project Summary` button, get DataFrame or directly by.df\n",
    "    va.fig #Get current fig in Notebook cell.\n",
    "    ```\n",
    "    \"\"\"\n",
    "    _output = ipw.Output().add_class('output')\n",
    "    def __init__(self,height = 610):\n",
    "        self.height = height\n",
    "        tab = ipw.Tab(layout = ipw.Layout(min_height=f'{height}px', max_height='100vh',\n",
    "                                           min_width='700px', max_width='100vw')\n",
    "            ).add_class('marginless').add_class('borderless') # Main Tab\n",
    "        try:\n",
    "            for i,item in enumerate(['Home','Graphs','STD(out/err)']):\n",
    "                tab.set_title(i,item)\n",
    "        except:\n",
    "            tab.titles = ['Home','Graphs','STD(out/err)']\n",
    "        self._main_class = 'custom-'+''.join(np.random.randint(9,size=(22,)).astype(str)) #Random class\n",
    "        self._tab     = tab.add_class(self._main_class) # Main layout\n",
    "        self._data   = None # Export vasprun object.\n",
    "        self._path = None # current path\n",
    "        self._fig    = go.FigureWidget() # plotly's figure widget\n",
    "        self._fig.update_layout(autosize=True)\n",
    "        self._result = {'sys':'','V':'','a':'','b':'','c':'',\n",
    "                     'VBM':'','CBM':'','so_max':'','so_min':''} # Table widget value\n",
    "\n",
    "        self._files_gui,self._files_dd = get_files_gui(height=300)\n",
    "        self._InGui  = InputGui(height=None)\n",
    "        self._input  = {'Fermi': 0} # Dictionary for input Should be zero, not None\n",
    "        self._fig_gui = HBox() # Middle Tab\n",
    "        self.theme_colors = light_colors.copy() # Avoid Modification\n",
    "        # Permeannet Parameters\n",
    "        self._idos_kws   = dict(colormap='RGB',tdos_color=(0.5, 0.95, 0),linewidth=2,fill_area=True,\n",
    "                               spin='both',interp_nk={},title=None)\n",
    "        self._ibands_kws = dict(mode='bands',skipk=None,max_width=6,title=None,interp_nk={})\n",
    "        self._evr_kws = dict(skipk=None,elim=[])\n",
    "        self._cache_data = True\n",
    "\n",
    "        l_btn = ipw.Layout(width='max-content')\n",
    "        self._buttons = {'load_data' : Button(description='Load Data',layout=l_btn,tooltip='Load and Cache Data'),\n",
    "                        'load_graph': Button(description='Update Graph',layout=l_btn,tooltip='Create Graph'),\n",
    "                        'confirm'   : Button(description='Confirm Delete',layout=l_btn,icon='trash'),\n",
    "                        'summary'   : Button(description='Project Summary',layout=l_btn,tootltip='Make DataFrame'),\n",
    "                        'expand'    : Button(icon = \"fa-expand\",layout=l_btn,tooltip='Expand Fig'),\n",
    "                        'save_fig'  : Button(description='Save Fig',icon='download',layout=l_btn,tooltip='')\n",
    "                        }\n",
    "\n",
    "        b_out = Layout(width='30%')\n",
    "        en_options = ['VBM','CBM','so_max','so_min','None']\n",
    "        self._dds   = {'band_dos': Dropdown(options=['Bands','DOS'],value='Bands',\n",
    "                                                layout= Layout(width='80px')),\n",
    "                      'en_type' : Dropdown(options = en_options,value='None',layout=b_out),\n",
    "                      'cache'   : Dropdown(options=['Table Data','PWD Cache','All Cache','None'],\n",
    "                                            value='None',layout=b_out),\n",
    "                      'theme'   : Dropdown(options=['Default','Light','Dark','Custom'],\n",
    "                                            value='Default',layout=l_btn),\n",
    "                      'style'   : Dropdown(options=[\"plotly\", \"plotly_white\", \"plotly_dark\",\n",
    "                                    \"ggplot2\", \"seaborn\", \"simple_white\", \"none\"],layout=l_btn),\n",
    "                                    }\n",
    "\n",
    "        self._texts = {'kticks': Text(value='',layout=b_out,continuous_update=False),\n",
    "                      'ktickv': Text(value='',layout=b_out,continuous_update=False),\n",
    "                      'kjoin' : Text(value='',layout=b_out,continuous_update=False),\n",
    "                      'elim'  : Text(value='',layout=b_out,continuous_update=False),\n",
    "                      'xyt'   : Text(value='',continuous_update=False),\n",
    "                      'load_elim'  : Text(value='-5,5',layout = Layout(width='5em'),continuous_update=False)\n",
    "                      }\n",
    "        self._htmls = {'theme': ipw.HTML(css_style(light_colors,_class = self._main_class)),\n",
    "                      'table': ipw.HTML()}\n",
    "\n",
    "        # Observing\n",
    "        self._InGui.html.observe(self.__update_input,\"value\")\n",
    "        self._InGui.html.observe(self._warn_to_load_graph,\"value\")\n",
    "        self._files_dd.observe(self._warn_to_load_graph,\"value\")\n",
    "        self._texts['kjoin'].observe(self._warn_to_load_graph,\"value\")\n",
    "        self._dds['band_dos'].observe(self._warn_to_load_graph,\"value\")\n",
    "        self._dds['band_dos'].observe(self.__update_input,\"value\")\n",
    "        self._texts['kjoin'].observe(self.__update_input,\"value\")\n",
    "        self._texts['kticks'].observe(self.__update_xyt,\"value\")\n",
    "        self._texts['ktickv'].observe(self.__update_xyt,\"value\")\n",
    "        self._texts['elim'].observe(self.__update_xyt,\"value\")\n",
    "        self._texts['xyt'].observe(self.__update_xyt)\n",
    "        self._dds['theme'].observe(self.__update_theme,\"value\")\n",
    "        self._dds['style'].observe(self.__update_plot_style,\"value\")\n",
    "        self._files_dd.observe(self.__load_previous,\"value\")\n",
    "        self._buttons['load_graph'].on_click(self.__load_previous,\"value\")\n",
    "        self._buttons['load_data'].on_click(self.__on_load)\n",
    "        self._dds['band_dos'].observe(self.__figure_tab,\"value\")\n",
    "        self._files_dd.observe(self.__update_table,'value')\n",
    "        self._buttons['load_data'].observe(self.__update_table,'value')\n",
    "        self._dds['en_type'].observe(self.__update_table,\"value\") # This works from _click_data\n",
    "        self._buttons['summary'].on_click(self.__df_out)\n",
    "        self._buttons['confirm'].on_click(self.__deleter)\n",
    "        self._buttons['save_fig'].on_click(self.__save_connected)\n",
    "        self._buttons['expand'].on_click(self.__expand_fig)\n",
    "        self._buttons['load_graph'].on_click(self.__update_graph)\n",
    "        self._texts['load_elim'].observe(self.__elim_changed,\"value\")\n",
    "        # Build Layout\n",
    "        self.__build()\n",
    "        self._tab.on_displayed(self._on_displayed)\n",
    "    \n",
    "    @property\n",
    "    def data(self): return self._data\n",
    "    \n",
    "    @property\n",
    "    def fig(self): return self._fig\n",
    "    \n",
    "    @property\n",
    "    def result(self): return self._result\n",
    "    \n",
    "    @property\n",
    "    def input(self): return self._input\n",
    "    \n",
    "    @property\n",
    "    def htmls(self): return self._htmls\n",
    "    \n",
    "    @property\n",
    "    def texts(self): return self._texts\n",
    "    \n",
    "    @property\n",
    "    def dds(self): return self._dds\n",
    "    \n",
    "    @property\n",
    "    def buttons(self): return self._buttons\n",
    "    \n",
    "    @property\n",
    "    def files_dd(self): return self._files_dd\n",
    "    \n",
    "    @property\n",
    "    def path(self): return self._path\n",
    "    \n",
    "    @property\n",
    "    def output(self): return self.__class__._output\n",
    "    \n",
    "    def set_options(self, cache_data = True, # general options\n",
    "        mode = 'bands', max_width = 6, skipk = None, # bands only keywords\n",
    "        interp_nk = {}, title = None, # Mixed keywords\n",
    "        colormap='RGB',tdos_color=(0.5, 0.95, 0),linewidth=2,fill_area=True, spin='both' # DOS only keywords\n",
    "        ):\n",
    "        self._cache_data = cache_data\n",
    "        if mode not in ['bands','markers','lines']:\n",
    "            raise ValueError(\"mode must be 'bands','markers','lines'\")\n",
    "        # bands only keywords\n",
    "        self._ibands_kws['mode'] = mode\n",
    "        self._ibands_kws['max_width'] = max_width\n",
    "        self._ibands_kws['skipk'] = skipk\n",
    "        \n",
    "        if ''.join(interp_nk.keys()) not in 'nk':\n",
    "            raise ValueError(\"interp_nk must be be of the form {'n': int, 'k': int}\")\n",
    "        # Mixed keywords\n",
    "        self._ibands_kws['interp_nk'] = interp_nk\n",
    "        self._idos_kws['interp_nk'] = interp_nk\n",
    "        self._idos_kws['title'] = title\n",
    "        self._ibands_kws['title'] = title\n",
    "        \n",
    "        if spin not in 'updownboth':\n",
    "            raise ValueError(\"spin must be in ('up','down','both')\")\n",
    "        # DOS only keywords\n",
    "        self._idos_kws['colormap'] = colormap\n",
    "        self._idos_kws['tdos_color'] = tdos_color\n",
    "        self._idos_kws['linewidth'] = linewidth\n",
    "        self._idos_kws['fill_area'] = fill_area\n",
    "        self._idos_kws['spin'] = spin\n",
    "        \n",
    "        self._evr_kws['skipk'] = skipk # Useful\n",
    "        \n",
    "    \n",
    "    def _on_displayed(self, change = None):\n",
    "        self._tab.selected_index = 1\n",
    "        self._fig_gui.layout.width = '95%' # Just to send a signal to resize the graph\n",
    "        self._fig_gui.layout.width = '100%' # Just to send another signal for figure size\n",
    "        self._tab.selected_index = 0 \n",
    "        \n",
    "    def __elim_changed(self,change):\n",
    "        # Delete Cache and Data to make user reload data \n",
    "        self._dds['cache'].value = 'PWD Cache' \n",
    "        self._buttons['confirm'].click()\n",
    "    \n",
    "    def __check_lsorbit(self):\n",
    "        if self._data:\n",
    "            lsorbit = self._data.sys_info.incar.to_dict().get('LSORBIT','F')\n",
    "            options = ['VBM','CBM','None'] \n",
    "            if lsorbit in 'T':\n",
    "                options = ['VBM','CBM','so_max','so_min','None']\n",
    "            self._dds['en_type'].options = options\n",
    "            self._dds['en_type'].value = 'None'\n",
    "            \n",
    "    def _warn_to_load_graph(self, change = None):\n",
    "        self._buttons['load_graph'].icon = 'refresh'\n",
    "        self._buttons['load_graph'].style.button_color = 'yellow'\n",
    "        self._buttons['load_graph'].description = 'Update Graph'\n",
    "            \n",
    "    def set_theme_colors(self,theme_colors):\n",
    "        \"Get self.theme_colors and after edit set back\"\n",
    "        if 'dds' in self.__dict__.keys():\n",
    "            self._dds['theme'].value = 'Custom'\n",
    "        if 'htmls' in self.__dict__.keys():\n",
    "            self._htmls['theme'].value = css_style(theme_colors)\n",
    "\n",
    "    def __figure_tab(self,change):\n",
    "        l_out = Layout(width='20%')\n",
    "        cache_box = HBox([Label('Delete Cache:'),self._dds['cache'],self._buttons['confirm']]\n",
    "                        ).add_class('marginless')\n",
    "        upper_box = VBox([\n",
    "                HBox([Label('File:',layout=Layout(width='50px')),self._files_dd\n",
    "                    ]).add_class('borderless').add_class('marginless'),\n",
    "                HBox([Label('View:',layout=Layout(width='50px')),\n",
    "                        self._dds['band_dos'],\n",
    "                        Label('elim:',layout=Layout(width='3em')),\n",
    "                        self._texts['load_elim'],\n",
    "                        self._buttons['load_data'],\n",
    "                    ]).add_class('borderless').add_class('marginless')\n",
    "                ]).add_class('marginless').add_class('borderless')\n",
    "\n",
    "        points_box = HBox([Box([Label('E Type:',layout=Layout(min_width='5em')),\n",
    "                                self._dds['en_type'],\n",
    "                    ],layout = Layout(min_width='50%')).add_class('marginless').add_class('borderless'),\n",
    "                    self._buttons['load_graph']\n",
    "                    ],layout=Layout(width='100%')).add_class('marginless')\n",
    "        in_box = VBox([self._InGui.box,\n",
    "                    ]).add_class('marginless').add_class('borderless')\n",
    "        top_right = HBox([self._buttons['load_graph'],\n",
    "                          Label('Style:'),\n",
    "                          self._dds['style'],\n",
    "                          Label('Theme:'),\n",
    "                          self._dds['theme'],\n",
    "                          self._buttons['expand']\n",
    "                    ]).add_class('marginless')\n",
    "        fig_box = Box([self._fig],layout=Layout(min_height='380px')).add_class('marginless')\n",
    "        right_box = VBox([top_right,fig_box,self._htmls['table']\n",
    "                 ],layout=Layout(min_width='60%')).add_class('marginless').add_class('borderless')\n",
    "\n",
    "\n",
    "        if 'Bands' in self._dds['band_dos'].value:\n",
    "            in_box.children = [Label('---------- Projections ----------'),self._InGui.box,\n",
    "                               Label('---- Other Arguments/Options ----'),\n",
    "                      VBox([HBox([Label('Ticks At: ',layout=l_out),\n",
    "                                  self._texts['kticks'],\n",
    "                                  Label('Labels: ',layout=l_out),\n",
    "                                  self._texts['ktickv']\n",
    "                                 ]).add_class('borderless').add_class('marginless'),\n",
    "                      HBox([Label('Join At: ',layout=l_out),\n",
    "                            self._texts['kjoin'],\n",
    "                            Label('E Range: ',layout=l_out),\n",
    "                            self._texts['elim']\n",
    "                           ]).add_class('marginless').add_class('borderless')\n",
    "                      ]).add_class('marginless')]\n",
    "            right_box.children = [top_right,fig_box,points_box]\n",
    "            \n",
    "        else:\n",
    "            in_box.children = [Label('---------- Projections ----------'),self._InGui.box,\n",
    "                               Label('---- Other Arguments/Options ----'),\n",
    "                      HBox([Label('E Range:',layout=l_out),\n",
    "                      self._texts['elim'],\n",
    "                      ]).add_class('marginless')]\n",
    "            right_box.children = [top_right,fig_box,points_box]\n",
    "            self._dds['en_type'].value = 'None' # no scatter collection in DOS.\n",
    "\n",
    "        left_box = VBox([upper_box,\n",
    "                        in_box,\n",
    "                        HBox([Label('X, Y, Title'),self._texts['xyt']]).add_class('borderless'),\n",
    "                        HBox([Label('Options:'),self._buttons['summary'],self._buttons['save_fig']]),\n",
    "                        cache_box,\n",
    "                        self._htmls['table']],layout=Layout(max_width='40%'),\n",
    "                        ).add_class('marginless').add_class('borderless')\n",
    "        self._fig_gui.children = (left_box,right_box)\n",
    "        return self._fig_gui # Return for use in show\n",
    "\n",
    "    @_output.capture()\n",
    "    def __build(self):\n",
    "        intro_html = ipw.HTML((\"<h2>Pivotpy</h2><p>Filter files here and switch tab to Graphs. \" \n",
    "                               \"You can create cache ahead of time to load quickly while working. \" \n",
    "                               \"If anything does not seem to work, see the error in STD(out/err) tab. \" \n",
    "                               \"<a href=https://massgh.github.io/pivotpy/Widgets.html#VasprunApp target='_blank'> See More</a> \"\n",
    "                               \"</p><marquee style='color:blue'>Pivotpy GUI based on ipywidgets!</marquee>\"))\n",
    "        header_box = HBox([intro_html,\n",
    "                           Label('Theme:',layout=Layout(width='80px')),\n",
    "                           self._dds['theme']\n",
    "                    ]).add_class('marginless').add_class('borderless')\n",
    "        summary_gui = HBox([ipw.Label(),\n",
    "                            self._buttons['summary']]\n",
    "                            ).add_class('borderless')\n",
    "        intro_box = VBox([self._htmls['theme'],\n",
    "                      header_box,\n",
    "                      self._files_gui,\n",
    "                      summary_gui]\n",
    "                      ).add_class('marginless').add_class('borderless').add_class('marginless')\n",
    "        self._fig_gui = self.__figure_tab(1) #Start\n",
    "        self._tab.children = (intro_box,\n",
    "                             self._fig_gui,\n",
    "                             VBox([HBox([ipw.HTML(\"<h3>Functions Logging/Output</h3>\"),\n",
    "                                          Box([\n",
    "                                          Label('Theme:',layout=Layout(width='80px')),\n",
    "                                          self._dds['theme']],layout=Layout(left='50%')).add_class('borderless')\n",
    "                                          ]).add_class('borderless').add_class('marginless'),\n",
    "                                    self.__class__._output])\n",
    "                             )\n",
    "        self._dds['style'].value = 'plotly' # to trigger first callback on graph.\n",
    "        self.app = self._tab #Need to access it\n",
    "        self.__update_theme(True) #Good option in jupyterlab for following theme.\n",
    "\n",
    "    def show(self):\n",
    "        return display(self._tab)\n",
    "\n",
    "    def _ipython_display_(self):\n",
    "        self.show()\n",
    "\n",
    "    def __fill_ticks(self):\n",
    "        kpath = os.path.join(os.path.split(self._files_dd.value)[0],'KPOINTS')\n",
    "        tvs = sio.read_ticks(kpath) #ticks values segments\n",
    "        if tvs['ktick_inds']: #If is must, if not present, avoid overwritting custom input\n",
    "            self._texts['kticks'].value = ','.join([str(v) for v in tvs['ktick_inds']])\n",
    "        if tvs['ktick_vals']:\n",
    "            self._texts['ktickv'].value = ','.join(tvs['ktick_vals'])\n",
    "        if tvs['kseg_inds']:\n",
    "            self._texts['kjoin'].value = ','.join([str(v) for v in tvs['kseg_inds']])\n",
    "\n",
    "    def __update_theme(self,change):\n",
    "        if self._dds['theme'].value == 'Dark':\n",
    "            self._htmls['theme'].value = css_style(dark_colors,_class=self._main_class)\n",
    "            self._fig.update_layout(template='plotly_dark')\n",
    "            self._dds['style'].value = 'plotly_dark'\n",
    "        elif self._dds['theme'].value == 'Light':\n",
    "            self._htmls['theme'].value = css_style(light_colors,_class=self._main_class)\n",
    "            self._fig.update_layout(template='ggplot2')\n",
    "            self._dds['style'].value = 'ggplot2'\n",
    "        elif self._dds['theme'].value == 'Custom':\n",
    "            self._htmls['theme'].value = css_style(simple_colors,_class=self._main_class)\n",
    "            self._fig.update_layout(template='none')\n",
    "            self._dds['style'].value = 'none'\n",
    "        else:\n",
    "            self._htmls['theme'].value = css_style(default_colors,_class=self._main_class)\n",
    "            self._fig.update_layout(template='plotly')\n",
    "            self._dds['style'].value = 'plotly'\n",
    "\n",
    "    def __update_plot_style(self,change):\n",
    "        self._fig.update_layout(template = self._dds['style'].value)\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __load_previous(self,change):\n",
    "        path = self._files_dd.value\n",
    "        try:\n",
    "            _dir = os.path.split(path)[0]\n",
    "            r_f = os.path.join(_dir,'result.json')\n",
    "            self._result = serializer.load(r_f)\n",
    "            self.__update_table(change = None)\n",
    "            print('Previous Analysis loaded in Table for {}'.format(path))\n",
    "        except:\n",
    "            print('Previous Analysis does not exist for {}'.format(path))\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __read_data(self,poscar=None,sys_info=None):\n",
    "        if sys_info != None:\n",
    "            self._result[\"sys\"] = sys_info.SYSTEM\n",
    "        if poscar != None:\n",
    "            self._result[\"V\"] = np.round(poscar.volume,5)\n",
    "            a,b,c = np.round(np.linalg.norm(poscar.basis,axis=1),5)\n",
    "            self._result[\"a\"] = a\n",
    "            self._result[\"b\"] = b\n",
    "            self._result[\"c\"] = c\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __on_load(self,button):\n",
    "        if self._data and self._files_dd.value == self._path: # Same load and data exists, keeps in fast\n",
    "            print('Data already loaded')\n",
    "            self._buttons['load_data'].description = 'Data already loaded'\n",
    "            sleep(1)\n",
    "            self._buttons['load_data'].description = 'Load Data'\n",
    "            return None\n",
    "            \n",
    "        self.__fill_ticks() # First fill ticks, then update input\n",
    "        self.__update_input(change=None) # Fix input right here.\n",
    "        self.__load_previous(change=button) # previous calculations.\n",
    "        self._tab.selected_index = 2\n",
    "        self._buttons['load_data'].description='Loading ...'\n",
    "        _dir = os.path.split(self._files_dd.value)[0] # directory\n",
    "        try:\n",
    "            sys_info = serializer.load(os.path.join(_dir,'sys_info.pickle'))\n",
    "            self._data = serializer.load(os.path.join(_dir,'vasprun.pickle'))\n",
    "            print('Cache Loaded')\n",
    "        except:\n",
    "            print('Trying Loading from Python ...')\n",
    "            elim = self._texts['load_elim'].value.split(',')[:2] # First two elements\n",
    "            if len(elim) == 2:\n",
    "                self._evr_kws['elim'] = [float(e) for e in elim]\n",
    "            self._data = vp.export_vasprun(self._files_dd.value, **self._evr_kws)\n",
    "            if self._cache_data:\n",
    "                print('Caching From: {}'.format(self._files_dd.value)) #Cache result\n",
    "                serializer.dump(self._data.sys_info,outfile=os.path.join(_dir,'sys_info.pickle'))\n",
    "                serializer.dump(self._data,outfile=os.path.join(_dir,'vasprun.pickle'))\n",
    "\n",
    "            sys_info = self._data.sys_info # required here.\n",
    "            print('Done')\n",
    "\n",
    "        _ = self.__read_data(self._data.poscar,sys_info) # Update Table data on load\n",
    "        self._tab.selected_index = 1\n",
    "        # Revamp input dropdowns on load  ==========\n",
    "        self._InGui.update_options(sys_info=sys_info) #Upadate elements/orbs/labels\n",
    "        #===========================================\n",
    "        self._buttons['load_data'].description='Load Data'\n",
    "        self._path = self._files_dd.value # Update in __on_load or graph to make sure data loads once\n",
    "        self._buttons['load_data'].tooltip = \"Current System\\n{!r}\".format(self._data.sys_info)\n",
    "        self.__update_input(change=None) # Update to have new Fermi value\n",
    "        self._warn_to_load_graph()\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_input(self,change):\n",
    "        self._input.update(self._InGui.output)\n",
    "        elim_str  = [v for v in self._texts['elim'].value.split(',') if v!='']\n",
    "        if self._data:\n",
    "            self._input['Fermi'] = float(self._data.fermi)\n",
    "        self._input['elim'] = [float(v) for v in elim_str if v!='-'][:2] if len(elim_str) >= 2 else None\n",
    "        if self._dds['band_dos'].value == 'Bands':\n",
    "            kjoin_str  = [v for v in self._texts['kjoin'].value.split(',') if v!='']\n",
    "            kticks_str = [v for v in self._texts['kticks'].value.split(',') if v!='']\n",
    "            ktickv_str = [v for v in self._texts['ktickv'].value.split(',') if v!='']\n",
    "            self._input['kseg_inds'] = [int(v) for v in kjoin_str if v!='-'] if kjoin_str else None\n",
    "            self._input['ktick_inds'] = [int(v) for v in kticks_str if v!='-'] if kticks_str else [0,-1]\n",
    "            self._input['ktick_vals'] = [v for v in ktickv_str if v!=''] if ktickv_str else ['A','B']      \n",
    "        \n",
    "        else:\n",
    "            self._input = {k:v for k,v in self._input.items() if k not in ['ktick_inds','ktick_vals','kseg_inds']}\n",
    "        #Update at last\n",
    "        self._InGui.output = self._input\n",
    "        self._buttons['load_graph'].tooltip = \"Current Input\\n{!r}\".format(serializer.Dict2Data(self._input))\n",
    "        \n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_table(self,change):\n",
    "        self._htmls['table'].value = _tabulate_data(self._result)\n",
    "        _save_data(self._files_dd,self._result) # save data as well.\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __df_out(self,btn):\n",
    "        self._tab.selected_index = 2\n",
    "        self._buttons['summary'].description = 'See STD(out/err) Tab'\n",
    "        paths = [v for (k,v) in self._files_dd.options]\n",
    "        display(generate_summary(paths_list=paths))\n",
    "        print('Get above DataFrame by app_name.df\\nNote: app_name is variable name assigned to VasprunApp()')\n",
    "        self._buttons['summary'].description = 'Project Summary'\n",
    "    \n",
    "    @property\n",
    "    def df(self):\n",
    "        \"Access Results of all calculations as DataFrame\"\n",
    "        paths = [v for (k,v) in self._files_dd.options]\n",
    "        return generate_summary(paths_list=paths)\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __deleter(self,btn):\n",
    "        self._buttons['confirm'].description = 'Deleting ...'\n",
    "        if self._files_dd.value:\n",
    "            print('Deleting Selected Cache...')\n",
    "            self.__clear_cache() # Deleting\n",
    "            print('Done')\n",
    "        self.__update_table(1) #Update when delete data\n",
    "        self._buttons['confirm'].description='Confirm Delete'\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_xyt(self,change):\n",
    "        if self._texts['xyt'].value:\n",
    "            xyt_text = self._texts['xyt'].value.split(',')\n",
    "            try:\n",
    "                self._fig.update_xaxes(title=xyt_text[0])\n",
    "                self._fig.update_yaxes(title=xyt_text[1])\n",
    "                self._fig.update_layout(title=xyt_text[2])\n",
    "            except: pass #do nothing else\n",
    "\n",
    "        if self._texts['ktickv'].value or self._texts['kticks'].value or self._texts['elim'].value:\n",
    "            self.__update_input(change=None)\n",
    "        if self._dds['band_dos'].value == 'Bands' and self._data:\n",
    "            tickvals = [self._data.kpath[i] for i in self._input['ktick_inds']]\n",
    "            self._fig.update_xaxes(ticktext=self._input['ktick_vals'], tickvals=tickvals)\n",
    "        if self._texts['elim'].value and self._input['elim'] != None and len(self._input['elim']) == 2:\n",
    "            if self._dds['band_dos'].value == 'Bands':\n",
    "                self._fig.update_yaxes(range = self._input['elim'])\n",
    "            else:\n",
    "                self._fig.update_xaxes(range = self._input['elim'])\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __save_connected(self,btn):\n",
    "        s_p = os.path.split(self._files_dd.value)[0]\n",
    "        filename = os.path.join(s_p,'ConnectedFig.html')\n",
    "        filename = gu.prevent_overwrite(filename)\n",
    "        self._buttons['save_fig'].description = 'Saving...'\n",
    "        theme = self._htmls['theme'].value.replace(f'.{self._main_class}','')\n",
    "        views = VBox([ipw.HTML(theme),self._fig,self._htmls['table']],\n",
    "                layout=Layout(width='500px',height='490px')).add_class('borderless')\n",
    "        embed_minimal_html(filename, views=[views], state=dependency_state([views]))\n",
    "        self._buttons['save_fig'].description = 'Save Fig'\n",
    "        self._buttons['save_fig'].tooltip = 'Recently Saved\\n{!r}'.format(filename)\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __expand_fig(self,btn):\n",
    "        self._tab.selected_index = 2\n",
    "        self._dds['en_type'].value = 'None' # To avoid accidental clicks\n",
    "        display(self._fig)\n",
    "    # Garph\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_graph(self,btn):\n",
    "        if (self._buttons['load_graph'].icon == 'check') and (self._data and self._files_dd.value == self._path):\n",
    "            print('Graph is already updated with latest input!')\n",
    "            self._buttons['load_graph'].description = 'Graph Already Updated'\n",
    "            sleep(1)\n",
    "            self._buttons['load_graph'].description = 'Latest Graph'\n",
    "            return None\n",
    "        \n",
    "        path = self._files_dd.value\n",
    "        if path:\n",
    "            self.__fill_ticks() # First fill ticks, then update input\n",
    "            self.__update_input(change=None) # Update input here as well\n",
    "            self._tab.selected_index = 2\n",
    "            self._fig.data = []\n",
    "            if self._data and path == self._path: # Same load and data exists, keeps in fast\n",
    "                print('Data already loaded')\n",
    "            else:\n",
    "                self._buttons['load_graph'].description = 'Loading Data...'\n",
    "                try:\n",
    "                    print('Trying to Load Cache for Graph ...')\n",
    "                    file = os.path.join(os.path.split(path)[0],'vasprun.pickle')\n",
    "                    self._buttons['load_graph'].description = file\n",
    "                    self._data = serializer.load(file)\n",
    "                except:\n",
    "                    print('No cache found. Loading from file {} ...'.format(path))\n",
    "                    elim = self._texts['load_elim'].value.split(',')[:2] # First two elements\n",
    "                    if len(elim) == 2:\n",
    "                        self._evr_kws['elim'] = [float(e) for e in elim]\n",
    "                    self._data = vp.export_vasprun(path, **self._evr_kws)\n",
    "\n",
    "            self._buttons['load_graph'].description = 'Updating Graph...'\n",
    "            print('Done')\n",
    "\n",
    "            self._path  = self._files_dd.value #update here or __on_load. Useful to match things\n",
    "            _ = self.__read_data(self._data.poscar,self._data.sys_info) # Update Table data\n",
    "            self.__check_lsorbit() # Check if LSORBIT is on, then set options accordingly\n",
    "            \n",
    "            self._input['Fermi'] = float(self._data.fermi) # Update Fermi before plot\n",
    "            if self._dds['band_dos'].value == 'Bands':\n",
    "                fig_data = ip.iplot_rgb_lines(path_evr=self._data,**self._input,**self._ibands_kws)\n",
    "            else:\n",
    "                self._dds['en_type'].value = 'None' # Avoid random clicks\n",
    "                fig_data = ip.iplot_dos_lines(path_evr=self._data,**self._input,**self._idos_kws) # input auto-modified\n",
    "\n",
    "            self._tab.selected_index = 1\n",
    "            with self._fig.batch_animate():\n",
    "                for d in fig_data.data:\n",
    "                    self._fig.add_trace(d)\n",
    "                fig_data.layout.template = self._dds['style'].value # before layout to avoid color blink\n",
    "                self._fig.layout = fig_data.layout\n",
    "\n",
    "            _click_data(self._dds['en_type'],self._input['Fermi'],self._result,self._fig,self._dds['band_dos']) # click after updating fermi\n",
    "            \n",
    "            self._buttons['load_graph'].icon = 'check'\n",
    "            self._buttons['load_graph'].description = 'Latest Graph'\n",
    "            self._buttons['load_graph'].style.button_color = 'transparent'\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __clear_cache(self):\n",
    "        self._tab.selected_index = 2\n",
    "        _dir = os.path.split(self._files_dd.value)[0]\n",
    "        if 'Table' in self._dds['cache'].value:\n",
    "            for k in self._result.keys(): # Avoid deleting V,a,b,Fermi\n",
    "                if k not in ['sys','V','a','b','c']:\n",
    "                    self._result[k] = ''\n",
    "        if 'PWD' in self._dds['cache'].value:\n",
    "            _files = [os.path.join(_dir,f) for f in ['sys_info.pickle','vasprun.pickle']]\n",
    "            _ = [[print(\"Deleting\", _file),os.remove(_file)] for _file in _files if os.path.isfile(_file)]\n",
    "            self._data =  None\n",
    "            self._warn_to_load_graph(change=None)\n",
    "        if 'All' in self._dds['cache'].value:\n",
    "            for (key, value) in self._files_dd.options:\n",
    "                _dir = os.path.split(value)[0]\n",
    "                _files = [os.path.join(_dir,f) for f in ['sys_info.pickle','vasprun.pickle']]\n",
    "                _ = [[print(\"Deleting\", _file),os.remove(_file)] for _file in _files if os.path.isfile(_file)]\n",
    "            self._data =  None\n",
    "            self._warn_to_load_graph(change=None)\n",
    "            \n",
    "        self._tab.selected_index = 1\n",
    "\n",
    "    def iplot(self,**kwargs):\n",
    "        \"Returns a detached interactive Figure. `kwargs` are passed to `iplot_rgb_lines` or `iplot_dos_lines` based on current figure. `kwargs` should exclude whatever inside `self._input` and `path_evr`\"\n",
    "        kwargs = {k:v for k,v in kwargs.items() if k not in self._input.keys() or k!='path_evr'}\n",
    "        if self._dds['band_dos'].value == 'Bands':\n",
    "            return ip.iplot_rgb_lines(path_evr=self._data,**self._input,**kwargs)\n",
    "        else:\n",
    "            return ip.iplot_dos_lines(path_evr=self._data,**self._input,**kwargs)\n",
    "\n",
    "    def splot(self,**kwargs):\n",
    "        \"Returns matplotlib Axes.`kwargs` are passed to `splot_rgb_lines` or `splot_dos_lines` based on current figure. `kwargs` should exclude whatever inside `self._input` and `path_evr`\"\n",
    "        kwargs = {k:v for k,v in kwargs.items() if k not in self._input.keys() or k!='path_evr'}\n",
    "        if self._dds['band_dos'].value == 'Bands':\n",
    "            return sp.splot_rgb_lines(path_evr=self._data,**self._input,**kwargs)\n",
    "        else:\n",
    "            return sp.splot_dos_lines(path_evr=self._data,**self._input,**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "va = VasprunApp()\n",
    "# va.set_options(cache_data = False, mode= 'markers')  \n",
    "# va.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Edit valuse and run cell to change theme. Used valid CSS colors\n",
    "va.set_theme_colors({'next_bg': 'whitesmoke',\n",
    " 'hover_bg': 'skyblue',\n",
    " 'accent': 'black',\n",
    " 'main_bg': 'white',\n",
    " 'main_fg': 'black'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### App Attributes\n",
    "Note: If you used pivotpy.sio.get_kpath for generating KPOINTS file, your kticks will be automatically filled. If not, you can still add this example string at end of first line of first KPOINTS file with your own values, (not required in all KPOINST files, one time fill is enough if whole project is based on same kpath) [Do not modify names of variables!].        \n",
    "`HSK-INDS = [0, 29, -1], LABELS = ['M', 'Γ|M', 'L'], SEG-INDS = [21, 29]`  \n",
    "\n",
    "```python\n",
    "va = VasprunApp()\n",
    "va.input # is dictionary which is unpacked in plot arguments.\n",
    "va.result # is what you see in table. \n",
    "va.fig # is current figure.  \n",
    "va.set_options(\n",
    "    cache_data = False, #Turn off cache globally.\n",
    "    mode = 'bands', #Change graph mode from 'markers' to 'bands'. Setting it to'lines' is not recommended in live graph, it could hang all UI.\n",
    "    interp_nk = dict(n = 2, k = 2), #Add 2 points between data points withquadratic interpolation.\n",
    "    **kwargs\n",
    ") \n",
    "va.iplot # and \n",
    "va.splot # give current figure(detached) and its matplotlib figure respectively. Their `kwargs` correspond to current figure's command e.g if `Bands` figure is there, `kwargs` are passed to `iplot_rgb_lines` for `va.iplot` and to `splot_rgb_lines` for `va.splot`. \n",
    "```\n",
    "\n",
    "Almost every other attribute is a gui or collection of widgets. E.g. `va.dds` is dictionary that contains all dropdowns in app. Make sure to not change any key in any dictionary, if done by mistake use, `dictionary.pop(key,None)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Edit Custom Theme\n",
    "You can set `va.set_theme_colors(<va.theme_colors after edit>)` and then apply `Custom` from theme dropdown to display theme of your choice. Used CSS-compatible color values only.  \n",
    "\n",
    "### Extend Functionality (Example: Save Matplotlib's figure on clicking `Update/Latest Graph`)\n",
    "You can extend app as you choose, see how it saves a figure on button(within app) click.\n",
    "\n",
    "```python\n",
    "import pivotpy as pp\n",
    "import ipywidgets as ipw, os\n",
    "\n",
    "va = pp.VasprunApp()\n",
    "va.show() \n",
    "\n",
    "#Create Additional Functionality \n",
    "out = ipw.Output()\n",
    "\n",
    "@out.capture(clear_output=True, wait=True)\n",
    "def update_mpl(change): \n",
    "    if change:\n",
    "        va.splot(colorbar=False)\n",
    "        path = os.path.join(os.path.dirname(va.path),'mpl_plot.png')\n",
    "        pp.savefig(path,transparent=True,dpi=600) #Prevents overwiting existing files\n",
    "        pp._show()\n",
    "        print(va.data.sys_info.incar)\n",
    "va.buttons['load_graph'].on_click(update_mpl)   \n",
    "out\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class KPathApp:\n",
    "    \"\"\"View and trace path on BZ.\n",
    "    - **Usage**\n",
    "        > ka = KPathApp()\n",
    "        > ka.show() #Display app\n",
    "        > ka.splot() #get matplotlib figure\n",
    "    \"\"\"\n",
    "    _output = ipw.Output().add_class('output')\n",
    "    def __init__(self,path='POSCAR'):\n",
    "        self.path = path\n",
    "        self._files_gui, self._files_dd = get_files_gui(auto_fill='POSCAR')\n",
    "        self._files_dd.layout.width = '50%'\n",
    "        self._main_class = 'custom-'+''.join(np.random.randint(9,size=(21,)).astype(str)) #Random class\n",
    "        self._tab = ipw.Tab(children=[self._files_gui,Box([]),self.__class__._output]).add_class(self._main_class)\n",
    "        self._tab.add_class('marginless').add_class('borderless')\n",
    "        self._tab.layout = Layout(width='100%',min_width='600px',height='450px',min_height='450px')\n",
    "        try:\n",
    "            for i,title in enumerate(['Home','Main','STDERR']):\n",
    "                self._tab.set_title(i,title)\n",
    "        except:\n",
    "            self._tab.titles = ['Home','Main','STDERR']\n",
    "        self.app = self._tab\n",
    "        self._fig = go.FigureWidget()\n",
    "        self._fig.layout.template = 'plotly_white' #Forces to avoid colored patch in background\n",
    "        self.bz = None\n",
    "        self.kcsn = [] #KPOINTS, COORDS,SYMBOLS, N_per_interval and box symbol in dictionary per item\n",
    "        self._buttons = {'delete':Button(description='Delete Selection'),\n",
    "                        'add':Button(description='Add Point'),\n",
    "                        'patch':Button(description='Split Path'),\n",
    "                        'fig_up': Button(description='Update Figure'),\n",
    "                        'theme': Button(description='Dark Theme')}\n",
    "        self.sm = SelectMultiple(layout=Layout(width='100%'))\n",
    "        self._texts = {'label':Text(description='Label, N',indent=False),\n",
    "                      'kxyz':Text(description='kx, ky, kz',indent=False)}\n",
    "        self.theme_html = ipw.HTML(css_style(light_colors,_class=self._main_class))\n",
    "\n",
    "        self._buttons['delete'].on_click(self.__delete)\n",
    "        self._buttons['add'].on_click(self.__add)\n",
    "        self._buttons['patch'].on_click(self.__add_patch)\n",
    "        self._buttons['theme'].on_click(self.__toggle_theme)\n",
    "        self._buttons['fig_up'].on_click(self.__update_fig)\n",
    "        self._texts['label'].on_submit(self.__label)\n",
    "        self._texts['kxyz'].on_submit(self.__manual_k)\n",
    "\n",
    "        self.__update_fig()\n",
    "        self.__build()\n",
    "        \n",
    "    @property\n",
    "    def fig(self):\n",
    "        return self._fig\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __toggle_theme(self,change):\n",
    "        _style = '''<style>.widget-select-multiple>select {{\n",
    "            font-family: \"Cascadia Code\",\"Ubuntu Mono\",\"SimSun-ExtB\",\"Courier New\";\n",
    "            background:{next_bg};border-radius:0;color:{accent};border:none;\n",
    "            height:auto;min-height:160px;padding:5px;margin:0px;overflow:auto;}}\n",
    "        .widget-select-multiple>select>option:hover,\n",
    "        .widget-select-multiple>select>option:focus{{background:{hover_bg};}}</style>'''\n",
    "        if self._buttons['theme'].description == 'Dark Theme':\n",
    "            self.theme_html.value = css_style(dark_colors,_class = self._main_class) + _style.format(**dark_colors)\n",
    "            self._fig.layout.template = 'plotly_dark'\n",
    "            self._fig.layout.paper_bgcolor = dark_colors['main_bg'] #important\n",
    "            self._buttons['theme'].description = 'Light Theme'\n",
    "        else:\n",
    "            self.theme_html.value = css_style(light_colors,_class=self._main_class) + _style.format(**light_colors)\n",
    "            self._fig.layout.template = 'plotly_white'\n",
    "            self._fig.layout.paper_bgcolor = light_colors['main_bg']\n",
    "            self._buttons['theme'].description = 'Dark Theme'\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __manual_k(self,change):\n",
    "        for i in self.sm.value:\n",
    "            self.kcsn[i]['k'] = [float(v) for v in self._texts['kxyz'].value.split(',') if v != ''][:3]\n",
    "\n",
    "        self._texts['kxyz'].value = '' # clean it\n",
    "        self.__update_label()\n",
    "        self.__update_selection() #Change on graph too\n",
    "\n",
    "    def __label_at(self,i):\n",
    "        self.kcsn[0]['b'], self.kcsn[-1]['b'] = '┌', '└'  #Avoid clashes\n",
    "        _ln_ = f\"─ {self.kcsn[i]['n']}\" if self.kcsn[i]['n'] and i < (len(self.sm.options) - 1) else \"\"\n",
    "        if self.kcsn[i]['k']:\n",
    "            return \"{0} {1} {2:>8.4f}{3:>8.4f}{4:>8.4f} {5}\".format(self.kcsn[i]['b'],self.kcsn[i]['s'],*self.kcsn[i]['k'],_ln_)\n",
    "        return f\"{self.kcsn[i]['b']} {self.kcsn[i]['s']} {_ln_}\"\n",
    "\n",
    "    def __update_label(self):\n",
    "        opt = list(self.sm.options)\n",
    "        vs = self.sm.value # get before it goes away\n",
    "        for i in vs:\n",
    "            opt[i] = (self.__label_at(i),i)\n",
    "\n",
    "        self.sm.options = tuple(opt)\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __build(self):\n",
    "        for k,b in self._buttons.items():\n",
    "            b.layout.width = 'max-content'\n",
    "        for k,t in self._texts.items():\n",
    "            t.layout.width='85%'\n",
    "        top_row = HBox([self._files_dd,self._buttons['fig_up']]).add_class('borderless')\n",
    "        _buttons1 = HBox([self._buttons[b] for b in ['add','delete']]).add_class('borderless')\n",
    "        _buttons2 = HBox([self._buttons[b] for b in ['patch','theme']]).add_class('borderless')\n",
    "        self._tab.children = [self._tab.children[0],\n",
    "                            HBox([\n",
    "                                  VBox([self.theme_html,\n",
    "                                        VBox([top_row,_buttons1,_buttons2],\n",
    "                                        layout = Layout(min_height='140px')),\n",
    "                                        Box([self.sm]).add_class('marginless').add_class('borderless'),\n",
    "                                        *self._texts.values()],\n",
    "                                  layout=Layout(min_width='320px')).add_class('borderless'),\n",
    "                                  Box([self._fig]).add_class('borderless')],\n",
    "                            layout=Layout(height='400px',width='auto')).add_class('borderless'),\n",
    "                            self._tab.children[-1]]\n",
    "\n",
    "    def show(self):\n",
    "        return display(self._tab)\n",
    "\n",
    "    def _ipython_display_(self):\n",
    "        self.show()\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __delete(self,change):\n",
    "        v = self.sm.value\n",
    "        for i, kp in enumerate(self.kcsn):\n",
    "            self.kcsn[i]['b'] = '├' #Break Path Retrieve first\n",
    "        self.kcsn = [k for i,k in enumerate(self.kcsn) if i not in v]\n",
    "        self.sm.options = [(self.__label_at(i),i) for i,op in enumerate(self.kcsn)]\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __add(self,change):\n",
    "        if self.kcsn:\n",
    "            self.kcsn.append({'k':[],'c':[],'s':'','n':'', 'b': '└'})\n",
    "        else:\n",
    "            self.kcsn.append({'k':[],'c':[],'s':'','n':'', 'b': '┌'})\n",
    "        for i, kp in enumerate(self.kcsn[1:-1]):\n",
    "            self.kcsn[i+1]['b'] = '├'\n",
    "\n",
    "        self.sm.options = [*self.sm.options,('You just added me',len(self.sm.options))]\n",
    "        self.sm.value = (len(self.sm.options) - 1,) # make available\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __add_patch(self,change):\n",
    "        vs = [v for v in self.sm.value if v > 1 and v < len(self.sm.options) - 1]\n",
    "        opts = list(self.sm.options)\n",
    "        for i,v in enumerate(self.sm.options):\n",
    "            # Clean previous action\n",
    "            if i > 0 and i < len(opts) - 1: #Avoid end points\n",
    "                self.kcsn[i]['b'] = '├'\n",
    "                opts[i] = (self.__label_at(i),i)\n",
    "            #Patch before selection\n",
    "            if i in vs:\n",
    "                self.kcsn[i]['b'] = '┌'\n",
    "                self.kcsn[i-1]['b'] = '└'\n",
    "                opts[i] = (self.__label_at(i),i)\n",
    "                opts[i-1] = (self.__label_at(i-1),i-1)\n",
    "\n",
    "        self.sm.options = opts\n",
    "        self.__update_selection()\n",
    "\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def get_coords_labels(self):\n",
    "        \"`coords` are calculated for current `bz` even if `kpoints` were from other one. Useful in case of same kind of Zones with just basis changed.\"\n",
    "        if self.bz:\n",
    "            for i, kp in enumerate(self.kcsn):\n",
    "                self.kcsn[i]['c'] = sio.to_R3(self.bz.basis,kp['k']).tolist() if kp['k'] else []\n",
    "\n",
    "        coords = [kp['c'] for kp in self.kcsn]\n",
    "        labels = [kp['s'] for kp in self.kcsn]\n",
    "        j = 0\n",
    "        for p in self.get_patches()[:-1]:\n",
    "            labels.insert(p.stop+j,'NaN')\n",
    "            coords.insert(p.stop+j,[np.nan,np.nan,np.nan])\n",
    "            j += 1\n",
    "\n",
    "        coords = np.array([c for c in coords if c])\n",
    "        labels = [l for l in labels if l]\n",
    "        return coords,labels\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_selection(self):\n",
    "        coords,labels = self.get_coords_labels()\n",
    "        with self._fig.batch_animate():\n",
    "            for trace in self._fig.data:\n",
    "                if 'path' in trace.name and coords.any():\n",
    "                    trace.x = coords[:,0]\n",
    "                    trace.y = coords[:,1]\n",
    "                    trace.z = coords[:,2]\n",
    "                    trace.text = labels\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __click(self):\n",
    "        def handle_click(trace, points, state):\n",
    "            if points.ys != []:\n",
    "                index = points.point_inds[0]\n",
    "                kp = trace.hovertext[index]\n",
    "                kp = [float(k) for k in kp.split('[')[1].split(']')[0].split()]\n",
    "                cp = [trace.x[index],trace.y[index],trace.z[index]]\n",
    "                for i in self.sm.value:\n",
    "                    self.kcsn[i]['k'] = kp\n",
    "                    self.kcsn[i]['c'] = cp\n",
    "\n",
    "                self.__update_label()\n",
    "                self.__update_selection()\n",
    "\n",
    "        for trace in self._fig.data:\n",
    "            if 'HSK' in trace.name:\n",
    "                trace.on_click(handle_click)\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __update_fig(self,change=None):\n",
    "        if self._files_dd.value:\n",
    "            self.path = self._files_dd.value\n",
    "            self.bz = sio.get_bz(self.path)\n",
    "            fig_data = sio.iplot_bz(self.bz,fill=False,color='red',background='rgba(1,1,1,0)')\n",
    "            self._fig.data = []\n",
    "            with self._fig.batch_animate():\n",
    "                self._fig.add_trace(go.Scatter3d(x = [],y = [],z = [],\n",
    "                    mode='lines+text+markers',name='path',text=[],\n",
    "                    textfont_size=18))\n",
    "                self.__update_selection() #Show previous path on current fig.\n",
    "                for trace in fig_data.data:\n",
    "                    self._fig.add_trace(trace)\n",
    "\n",
    "                self._fig.layout = fig_data.layout\n",
    "                self._fig.layout.autosize=True\n",
    "                self._fig.layout.scene.aspectmode = 'data' #very important\n",
    "\n",
    "            self.__click()\n",
    "\n",
    "\n",
    "    @_output.capture(clear_output=True,wait=True)\n",
    "    def __label(self,change):\n",
    "        for i in self.sm.value:\n",
    "            inbox = self._texts['label'].value.split(',')\n",
    "            self.kcsn[i]['s'] = 'Γ' if 'am' in inbox[0] else inbox[0] #fix gamma\n",
    "            try: self.kcsn[i]['n'] = int(inbox[1])\n",
    "            except: pass\n",
    "            self._texts['label'].value = '' # Clear it\n",
    "        self.__update_label()\n",
    "        self.__update_selection()\n",
    "\n",
    "    def get_patches(self):\n",
    "        bs = [kp['b'] for kp in self.kcsn]\n",
    "        patches = [*[i for i,b in enumerate(bs) if '┌' in b],len(self.kcsn)]\n",
    "        _patches = [range(i,j) for i,j in zip(patches[:-1],patches[1:])]\n",
    "        if _patches and len(_patches) <= 1:\n",
    "            return []\n",
    "        return _patches\n",
    "\n",
    "    def get_data(self):\n",
    "        obj = [{k:v for k,v in kp.items() if k != 'b'} for kp in self.kcsn]\n",
    "        patches = self.get_patches()\n",
    "        fmt_str = \"{0:>16.10f}{1:>16.10f}{2:>16.10f} !{3} {4}\"\n",
    "        if patches:\n",
    "            p_strs = ['\\n'.join([fmt_str.format(\n",
    "                                *self.kcsn[p]['k'],self.kcsn[p]['s'],self.kcsn[p]['n']\n",
    "                                               ) for p in ps]) for ps in patches]\n",
    "            return obj, '\\n\\n'.join(p_strs)\n",
    "        else:\n",
    "            return obj,'\\n'.join([fmt_str.format(*kp['k'],kp['s'],kp['n']) for kp in self.kcsn])\n",
    "\n",
    "    def get_kpath(self,n=5,weight=None,ibzkpt=None,outfile=None):\n",
    "        \"See Docs of pp.str2kpath for details.\"\n",
    "        from pivotpy import POSCAR\n",
    "        kws = dict(n=n,weight=weight,ibzkpt=ibzkpt,outfile=outfile)\n",
    "        _, k_str = self.get_data()\n",
    "        return POSCAR(self.path).str2kpath(k_str,**kws)\n",
    "\n",
    "    def splot(self,text_kws = {}, plot_kws ={}, **kwargs):\n",
    "        \"\"\"Same as `pp.splot_bz` except it also plots path on BZ.    \n",
    "        \n",
    "        - text_kws: dict of keyword arguments for `plt.text`\n",
    "        - plot_kws: dict of keyword arguments for `plt.plot`\n",
    "        `kwargs` are passed to `pp.splot_bz`\"\"\"\n",
    "        ax = sio.splot_bz(self.bz,**kwargs)\n",
    "        coords,labels = self.get_coords_labels()\n",
    "        plane = kwargs.get('plane',None)\n",
    "        if plane != None and plane in 'xyzxzyx':\n",
    "            ind = 'xyzxzyx'.index(plane)\n",
    "            arr = [0,1,2,0,2,1,0]\n",
    "            ix,iy = arr[ind],arr[ind+1]\n",
    "            coords = coords[:,[ix,iy]]\n",
    "        if coords.any(): #To avoid errors if not coords\n",
    "            ax.plot(*coords.T,'-o',**plot_kws)\n",
    "            _ = [ax.text(*vs,lab, **text_kws) for vs,lab in zip(coords,labels) if lab!='NaN']\n",
    "        return ax\n",
    "    def iplot(self):\n",
    "        \"Returns disconnected current plotly figure\"\n",
    "        return go.Figure(data=self._fig.data, layout=self._fig.layout)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ka = KPathApp()\n",
    "#ka.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interactive Rich Slides in Jupyter Notebook\n",
    "Navigate to  [ipyslides](https://github.com/massgh/ipyslides) or do `pip install ipyslides` to create beautiful data driven presentation in Jupyter Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<style>a{text-decoration: none !important;color:lightkblue;font-weight:bold;}\n",
       "                a:focus,a:active,a:hover{color:hotpink !important;}</style>\n",
       "> [&nbsp;`▶` Index&nbsp;](https://massgh.github.io/pivotpy/)  \n",
       "> [&nbsp;`▶` Example&nbsp;](https://massgh.github.io/pivotpy/Example)  \n",
       "> [&nbsp;`▶` StaticPlots&nbsp;](https://massgh.github.io/pivotpy/StaticPlots)  \n",
       "> [&nbsp;`▶` InteractivePlots&nbsp;](https://massgh.github.io/pivotpy/InteractivePlots)  \n",
       "> [&nbsp;`▶` SpinProjectedSurfaces&nbsp;](https://massgh.github.io/pivotpy/SpinProjectedSurfaces)  \n",
       "> [&nbsp;`▶` StructureIO&nbsp;](https://massgh.github.io/pivotpy/StructureIO)  \n",
       "> [&nbsp;`▶` Widgets●&nbsp;](https://massgh.github.io/pivotpy/Widgets)  \n",
       "> [&nbsp;`▶` MainAPI&nbsp;](https://massgh.github.io/pivotpy/MainAPI)  \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#hide_input\n",
    "import pivotpy as pp \n",
    "pp.nav_links(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.6 64-bit",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}