pandas_GUI.fit_Pandas_GUI

   1import sys
   2
   3import numpy as np
   4
   5def calcresid(result):
   6    '''
   7    lmfit has empty values for residuals where the weighting is infinite or not defined.
   8    This calculates all the residuals based on the actual data and fit results.
   9
  10    :param ModelResult result: An lmfit ModelResult.
  11
  12    :return np.array residuals: The residuals.
  13    '''
  14    import numpy as np
  15    import lmfit as lmfit
  16    resid = []
  17    for i in range(0, len(results.data)):
  18        resid.append(results.data[i] - results.best_fit[i])
  19    return np.array(resid)
  20
  21def fit_pandas_GUI(df_info=None, show_text_col = False, **kwargs):
  22    """
  23    If passed no parameters this will look for all the dataframes in the user
  24    namespace and make them available for plotting. Once a
  25    dataframe is chosen only the numerical columns from that dataframe will
  26    be available for inclusion in the plotting expression.
  27
  28    This GUI produces code to use the lmfit package to fit data and the plotly
  29    interactive plotting package to display the results.
  30
  31    If you wish to allow only certain dataframes or have them show up as
  32    user friendly names in the menus provide that information in the first
  33    paramater df_info.
  34
  35    To allow inclusion of text columns pass True for show_text_col.
  36
  37    :param bool show_text_col: (default = False). When True columns
  38    containing text will be shown.
  39
  40    :param list df_info: List of Lists [[object,globalname,
  41    userfriendly]],..]
  42      * object -- pandas.DataFrame
  43      * globalname -- string name of the object in the user global name space.
  44      * userfriendly -- string name to display for user selection.
  45      
  46    :keyword string figname: string used to override default python name for
  47    figure.
  48
  49    :keyword string fitname: string used to override default python name for
  50    fit.
  51    
  52    :keyword bool findframes: default = True. If set to false and dataframes
  53    are passed in dfs_info, will not search for dataframes in the user
  54    namespace.
  55    """
  56    from ipywidgets import Layout, Box, HBox, VBox, GridBox, Tab, \
  57        Accordion, Dropdown, Label, Text, Button, Checkbox, FloatText, \
  58        RadioButtons, BoundedIntText, Output
  59    from ipywidgets import HTML as richLabel
  60    from ipywidgets import HTMLMath as texLabel
  61    from IPython.display import display, HTML
  62    from IPython.display import Javascript as JS
  63    from IPython import get_ipython
  64    from JPSLUtils.utils import new_cell_immediately_below,\
  65        select_cell_immediately_below, move_cursor_in_current_cell, \
  66        insert_text_into_next_cell, insert_text_at_beginning_of_current_cell, \
  67        insert_newline_at_end_of_current_cell, select_containing_cell, \
  68        delete_selected_cell, iconselector, notice_group, \
  69        replace_text_of_current_cell, pseudoLatexToLatex
  70    from lmfit import models
  71
  72    from .utils import find_pandas_dataframe_names, build_run_snip_widget
  73    from IPython import get_ipython
  74    global_dict = get_ipython().user_ns
  75    JPSLUtils = global_dict["JPSLUtils"]
  76    if JPSLUtils.notebookenv != 'colab':
  77        import plotly.graph_objects as go
  78    dfs_info = []
  79    if isinstance(df_info,list):
  80        for k in df_info:
  81            dfs_info.append(k)
  82    findframes = kwargs.pop('findframes',True)
  83    if findframes:
  84        for k in find_pandas_dataframe_names():
  85            dfs_info.append([global_dict[k],k,k])
  86    friendly_to_globalname = {k[2]:k[1] for k in dfs_info}
  87    friendly_to_object = {k[2]:k[0] for k in dfs_info}
  88
  89    fitname = kwargs.pop('fitname',None)
  90    from .utils import find_fit_names
  91    fitlst = find_fit_names()
  92    if fitname in fitlst:
  93        raise UserWarning (str(fitname) + ' already exists. Choose a '
  94                                          'different name for the fit.')
  95    if fitname == None:
  96        fitname = 'Fit_'+str(len(fitlst)+1)
  97
  98    figname = kwargs.pop('figname',None)
  99    from .utils import find_figure_names
 100    figlst = find_figure_names()
 101    if figname in figlst:
 102        raise UserWarning (str(figname) + ' already exists. Choose a '
 103                                          'different name for the figure.')
 104    if figname == None:
 105        figname = str(fitname) + '_Figure'
 106
 107    fitmodels = ['LinearModel','PolynomialModel','ExponentialModel',
 108                 'GaussianModel','SineModel', 'OffsetExpModel']
 109    fitmodeleqns = {
 110    'LinearModel':r'$fit ={\color{red}{a}}x+{\color{red}{b}}$, where $\color{'
 111                  r'red}{a}$ = slope, $\color{red}{b}$ = intercept',
 112    'PolynomialModel': r'$fit = \sum_{n=0}^{\le7}{{\color{red}{c_n}}x^n} = ' \
 113                       r'{\color{red}{c_0}} + {\color{red}{c_1}}x + {\color{' \
 114                       r'red}{c_2}}x^2 + ...$',
 115    'ExponentialModel': r'$fit ={\color{red}{A}} {\exp \left( \frac{-x} ' \
 116                        r'{\color{red}{\tau}}\right)}$, where $\color{red}{A}$ '
 117                        r'= amplitude, $ \color{red}{\tau}$ = decay',
 118    'GaussianModel': r'$fit = \frac{{\color{red}{A}}}{{\color{red}{\sigma}}' \
 119                     r'\sqrt{2 \pi}} \exp \left( \frac{-(x-{\color{red}' \
 120                     r'{\mu}})^2}{2 \color{red}{\sigma}^2} \right)$, where ' \
 121                     r'$\color{red}{A}$ = amplitude, $\color{red}{\sigma}$ = sigma, '
 122                     r'$\color{red}{\mu}$ = center',
 123        'SineModel': r'$fit = {\color{red}{A}} \sin \left ({\color{red}{f}}x+' \
 124                     r'{\color{red}{\phi}} \right)$, '
 125                     r'where $\color{red}{A}$ = ' \
 126                     r'amplitude, $\color{red}{f}$ = frequency, '\
 127                     r'$\color{red}{\phi}$ = shift',
 128    'OffsetExpModel': r'$fit = {\color{red}{y_o}} + {\color{red}{A}}{\exp ' \
 129                      r'\left( '\
 130                      r'\frac{-(x - {\color{red}{x_o}})} ' \
 131                      r'{\color{red}{\tau}}\right)}$, '\
 132                      r'where $\color{red}{y_o}$ = y-offset, $\color{red}{A}$ '
 133                      r'= amplitude, $\color{red}{x_o}$ = x-offset, ' \
 134                      r'$\color{red}{\tau}$ = decay',
 135    }
 136
 137    def polymodelresultstr(resultname):
 138        template = '' \
 139          'fitstr = r\'$fit = \'\n' \
 140          'termcount = int(0)\n' \
 141          'for k in %result.params.keys():\n' \
 142          '    pwr = int(str(k)[int(-1):])\n' \
 143          '    if %result.params[k].vary:\n' \
 144          '        if termcount > int(0):\n' \
 145          '            fitstr += \' + \'\n' \
 146          '        fitstr += r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 147                                         '%result.params[k].value,\n' \
 148          '                               %result.params[k].stderr, \n' \
 149          '                                errdig=int(1), \n' \
 150          '                                lowmag=-int(3))+\'}})\'\n' \
 151          '        if pwr == int(1):\n' \
 152          '            fitstr += \'x\'\n' \
 153          '        if pwr > int(1):\n' \
 154          '            fitstr += \'x^\'+str(pwr)\n' \
 155          '        termcount+=int(1)\n' \
 156          '    else:\n' \
 157          '        if %result.params[k].value!=0.0:\n' \
 158          '            if termcount > int(0):\n' \
 159          '                fitstr += \'+\'\n' \
 160          '            fitstr += r\'({%COLOR{blue}{\'+str(' \
 161                                         '%result.params[k].value)+\'}})\'\n' \
 162          '            termcount +=int(1)\n' \
 163          '            if pwr == int(1):\n' \
 164          '                fitstr += \'x\'\n' \
 165          '            if pwr > int(1):\n' \
 166          '                fitstr += \'x^\'+str(pwr)\n' \
 167          'fitstr+=\'$\'\n' \
 168          'captionstr=r\'<p>Use the command <code>%result</code> as the ' \
 169          'last line of a code cell for more details.</p>\'\n' \
 170          'display(Math(fitstr))\n' \
 171          'display(HTML(captionstr))'
 172        return template.replace('%result', str(resultname))
 173
 174    def linmodelresultstr(resultname):
 175        template = '' \
 176       'slopestr = ''\'\'\n' \
 177       'interceptstr = ''\'\'\n' \
 178       'for k in %results.params.keys():\n' \
 179       '    if %results.params[k].vary:\n' \
 180       '        paramstr = r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 181                   '%results.params[k].value,\n' \
 182       '                                       %results.params[k].stderr,\n' \
 183       '                                       errdig=int(1),\n' \
 184       '                                       lowmag=-int(3))+\'}})\'\n' \
 185       '    else:\n' \
 186       '        paramstr = r\'{%COLOR{blue}{\'+str(%results.params[' \
 187                   'k].value,' \
 188                   '\n' \
 189       '                                       )+\'}}\'\n' \
 190       '    if k == \'slope\':\n' \
 191       '        slopestr = paramstr\n' \
 192       '    if k == \'intercept\' and %results.params[k].value != 0:\n' \
 193       '        interceptstr = \' + \' + paramstr\n' \
 194       'fitstr = r\'$fit = \'+slopestr + \'x\' + interceptstr + \'$\'\n' \
 195       'captionstr = r\'<p>Use the command <code>%results</code> as the ' \
 196       'last line of a code cell for more details.</p>\'\n' \
 197       'display(Math(fitstr))\n' \
 198       'display(HTML(captionstr))'
 199        return template.replace('%results', resultname)
 200
 201    def expmodelresultstr(resultname):
 202        template = '' \
 203        'ampstr = ''\'\'\n' \
 204        'decaystr = ''\'\'\n' \
 205        'for k in %results.params.keys():\n' \
 206        '    if %results.params[k].vary:\n' \
 207        '        paramstr = r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 208        '%results.params[k].value,\n' \
 209        '                                 %results.params[k].stderr,\n' \
 210        '                                 errdig=int(1),\n' \
 211        '                                 lowmag=-int(3))+\'}})\'\n' \
 212        '    else:\n' \
 213        '        paramstr = r\'{%COLOR{blue}{\'+str(%results.params[' \
 214                                               'k].value, \n' \
 215        '                                       )+\'}}\'\n' \
 216        '    if k == \'amplitude\':\n' \
 217        '        ampstr = paramstr\n' \
 218        '    if k == \'decay\':\n' \
 219        '        decaystr = paramstr\n' \
 220        'fitstr = r\'$$fit = \'+ampstr+r\'%EXP %LEFT( %FRAC{-x}' \
 221                        '{\'+decaystr+r\'}%RIGHT)$$\'\n' \
 222        'captionstr = r\'<p>Use the command <code>%results</code> as the ' \
 223        'last line of a code cell for more details.</p>\'\n' \
 224        'display(Math(fitstr))\n' \
 225        'display(HTML(captionstr))'
 226        return template.replace('%results',resultname)
 227
 228    def gausmodelresultstr(resultname):
 229        template = '' \
 230        'ampstr = ''\'\'\n' \
 231        'centstr = ''\'\'\n' \
 232        'sigmastr = ''\'\'\n' \
 233        'for k in %results.params.keys():\n' \
 234        '    if %results.params[k].vary:\n' \
 235        '        paramstr = r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 236                                          '%results.params[k].value,\n' \
 237        '                                 %results.params[k].stderr,\n' \
 238        '                                 errdig=int(1),\n' \
 239        '                                 lowmag=-int(3))+\'}})\'\n' \
 240        '    else:\n' \
 241        '        paramstr = r\'{%COLOR{blue}{\'+str(%results.params[' \
 242                                               'k].value, \n' \
 243        '                                       )+\'}}\'\n' \
 244        '    if k == \'amplitude\':\n' \
 245        '        ampstr = paramstr\n' \
 246        '    if k == \'center\':\n' \
 247        '        centstr = paramstr\n' \
 248        '    if k == \'sigma\':\n' \
 249        '        sigmastr = paramstr\n' \
 250        'fitstr = r\'$$fit = %FRAC{\'+ampstr+\'}{' \
 251                   '\'+sigmastr+r\'%SQRT{2%PI}}%EXP %LEFT( %FRAC{' \
 252                   '-%LEFT[x-\'+centstr+r\'%RIGHT]^2}' \
 253                   '{2\'+sigmastr+r\'^2}%RIGHT)$$\'\n' \
 254        'captionstr = r\'<p>Use the command <code>%results</code> as the ' \
 255        'last line of a code cell for more details.</p>\'\n' \
 256        'display(Math(fitstr))\n' \
 257        'display(HTML(captionstr))'
 258        return template.replace('%results',resultname)
 259
 260    def sinmodelresultstr(resultname):
 261        template = '' \
 262       'ampstr = \'\'\n' \
 263       'freqstr = \'\'\n' \
 264       'shiftstr = \'\'\n' \
 265       'for k in %results.params.keys():\n' \
 266       '    if %results.params[k].vary:\n' \
 267       '        if %results.params[k].stderr:\n' \
 268       '            paramstr = r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 269                   '%results.params[k].value,\n' \
 270       '                                       %results.params[k].stderr,\n' \
 271       '                                       errdig=int(1),\n' \
 272       '                                       lowmag=-int(3))+\'}})\'\n' \
 273       '        else:\n' \
 274       '            paramstr = r\'{%COLOR{red}{\'+' \
 275                   'str(%results.params[k].value)+\'}}\'\n' \
 276       '    else:\n' \
 277       '        paramstr = r\'{%COLOR{blue}{\'+str(%results.params[k].value' \
 278                   ')+\'}}\'\n' \
 279       '    if k == \'amplitude\':\n' \
 280       '        ampstr = paramstr\n' \
 281       '    if k == \'frequency\':\n' \
 282       '        freqstr = paramstr\n' \
 283       '    if k == \'shift\' and %results.params[k].value != 0.0:\n' \
 284       '        shiftstr = \' + \' + paramstr\n' \
 285       'fitstr = r\'$fit = \'+ampstr + \'sin[\' + freqstr + \'x\' + shiftstr + \']$\'\n' \
 286       'captionstr = r\'<p>Use the command <code>%results</code> as the ' \
 287       'last line of a code cell for more details.</p>\'\n' \
 288       'display(Math(fitstr))\n' \
 289       'display(HTML(captionstr))'
 290        return template.replace('%results', resultname)
 291
 292    def offsetexpmodelresultstr(resultname):
 293        from .custom_fit_models import OffsetExpModel
 294        import sympy as sp
 295        # overrides immediately below not necessary for this function
 296        #  but for a generic function might be necessary
 297        sp.I = sp.Symbol('I') # override of sqrt(-1) sorthand
 298        sp.E = sp.Symbol('E') # override of exp(1) shorthand
 299        spexpr = sp.sympify(OffsetExpModel().expr)
 300        rawlatex = sp.latex(spexpr)
 301        template = 'rawlatex = r\''+rawlatex+'\' # via sympy\n' \
 302        'from sympy import sympify, latex\n' \
 303        'for k in %results.params.keys():\n' \
 304        '    if %results.params[k].vary:\n' \
 305        '        paramstr = r\'({%COLOR{red}{\'+rue.latex_rndwitherr(' \
 306        '%results.params[k].value,\n' \
 307        '                                 %results.params[k].stderr,\n' \
 308        '                                 errdig=int(1),\n' \
 309        '                                 lowmag=-int(3))+\'}})\'\n' \
 310        '    else:\n' \
 311        '        paramstr = r\'{%COLOR{blue}{\'+str(%results.params[' \
 312                                               'k].value, \n' \
 313        '                                       )+\'}}\'\n' \
 314        '    rawlatex = rawlatex.replace(latex(sympify(k)),paramstr)\n' \
 315        'fitstr = r\'$$fit = \'+rawlatex+\'$$\'\n' \
 316        'captionstr = r\'<p>Use the command <code>%results</code> as the ' \
 317        'last line of a code cell for more details.</p>\'\n' \
 318        'display(Math(fitstr))\n' \
 319        'display(HTML(captionstr))'
 320        return template.replace('%results',resultname)
 321
 322    fitresultstrs = {
 323    'LinearModel': linmodelresultstr,
 324    'PolynomialModel': polymodelresultstr,
 325    'ExponentialModel': expmodelresultstr,
 326    'GaussianModel': gausmodelresultstr,
 327    'SineModel': sinmodelresultstr,
 328    'OffsetExpModel': offsetexpmodelresultstr
 329    }
 330
 331    importstr = '# CODE BLOCK generated using fit_pandas_GUI().\n# See '\
 332                'https://jupyterphysscilab.github.io/jupyter_Pandas_GUI.\n' \
 333                '# Integers wrapped in `int()` to avoid having them cast \n' \
 334                '# as other types by interactive preparsers. \n' \
 335                '# Imports (no effect if already imported)\n' \
 336                'import numpy as np\n' \
 337                'import lmfit as lmfit\n' \
 338                'from pandas_GUI import custom_fit_models\n' \
 339                'import round_using_error as rue\n' \
 340                'import copy as copy\n' \
 341                'from plotly import graph_objects as go\n' \
 342                'from IPython.display import HTML, Math\n\n'
 343    step1str = ''
 344    step2str = ''
 345    step3str = ''
 346    step4str = ''
 347    step5str = ''
 348    step6str = ''
 349    range_chosen = False
 350    #### Define GUI Elements ####
 351    # Those followed by a * are required.
 352    output = Output()
 353    with output:
 354        display(HTML(
 355            "<h3 id ='pandasfitGUI' style='text-align:center;'>Pandas Fit "
 356            "Composer</h3> <div style='text-align:center;'>"
 357            "<span style='color:green;'>Steps with a * are required.</span> The "
 358            "code that will generate the fit is being "
 359            "built in the textbox or cell immediately below.</div><div "
 360            "style='text-align:center;'>This composer uses a subset of "
 361            "<a href ='https://lmfit.github.io/lmfit-py/'> the lmfit package</a>"
 362            " and <a href ='https://plotly.com/python/line-and-scatter/#'> "
 363            "the plotly scatter plot</a> capabilities.</div>"))
 364
 365    longdesc = {'description_width':'initial'}
 366
 367    # Notices for the Final Check Tab.
 368    makeplot_notices = notice_group(['Need data to fit',
 369                                     'Need a fit model',
 370                                     'Axes must have labels.'],
 371                                    'Notices:','','red')
 372    makeplot_notices.set_active([0,1,2])
 373
 374    # 1. Pick and variables to fit and fit model
 375    #   a. Select Y vs. X (DataFrame, X and Y, which must be from single
 376    #       frame.
 377    # Notices for the Pick Trace(s) tab.
 378    notice_list = [
 379        'Data set (DataFrame) required.',
 380        'X- and Y-values required.',
 381    ]
 382    trace_notices = notice_group(notice_list, 'Notices:','','red')
 383    trace_notices.set_active([0,1])
 384    step1instr = richLabel(value = '<ol><li>Select a DataFrame (Data '
 385                                   'set);</li>'
 386                                   '<li>Select the column containing the X '
 387                                   'values;</li>'
 388                                   '<li>Select the column containing the Y '
 389                                   'values (what is being fit);</li>'
 390                                   '<li>Provide a name for the trace if you do'
 391                                   ' not like the default. This text will be '
 392                                   'used for the legend;</li></ol>'
 393                           )
 394    step1instracc = Accordion(children = [step1instr])
 395    step1instracc.set_title(0,'Instructions')
 396    step1instracc.selected_index = None
 397
 398    # DataFrame selection
 399    tempopts = []
 400    tempopts.append('Choose data set.')
 401    for k in dfs_info:
 402        tempopts.append(k[2])
 403    whichframe = Dropdown(options=tempopts,
 404                                description='DataFrame: ',)
 405
 406    def update_columns(change):
 407        if change['new'] == 'Choose data set.':
 408            Xcoord.disabled = True
 409            Ycoord.disabled = True
 410            trace_notices.activate_notice(0)
 411            trace_notices.activate_notice(1)
 412            trace_notices.activate_notice(2)
 413            add_trace_notices.value = trace_notices.notice_html()
 414            return
 415        df = friendly_to_object[change['new']]
 416        tempcols = df.columns.values
 417        tempopt = ['Choose column for coordinate.']
 418        for k in tempcols:
 419            if show_text_col:
 420                tempopt.append(k)
 421            else:
 422                if df[k].dtype != 'O':
 423                    tempopt.append(k)
 424        Xcoord.options = tempopt
 425        Xcoord.value = tempopt[0]
 426        Ycoord.options = tempopt
 427        Ycoord.value = tempopt[0]
 428        Xcoord.disabled = False
 429        Ycoord.disabled = False
 430        trace_notices.activate_notice(1)
 431        trace_notices.deactivate_notice(0)
 432        add_trace_notices.value =trace_notices.notice_html()
 433        pass
 434    whichframe.observe(update_columns, names='value')
 435
 436    # Data selection
 437    Xcoord = Dropdown(options=['Choose X-coordinate.'],
 438                           description='X: ',
 439                           disabled = True)
 440    Ycoord = Dropdown(options=['Choose Y-coordinate.'],
 441                           description='Y: ',
 442                           disabled = True)
 443    def trace_name_update(change):
 444        if change['new'] != 'Choose column for coordinate.':
 445            trace_name.value = Ycoord.value
 446        if Xcoord.value != 'Choose column for coordinate.' and Ycoord.value \
 447                != 'Choose column for coordinate.':
 448            yerrtype.disabled = False
 449            trace_name.disabled = False
 450            trace_notices.deactivate_notice(1)
 451            add_trace_notices.value = trace_notices.notice_html()
 452        else:
 453            yerrtype.disabled = True
 454            trace_name.disabled = True
 455            trace_notices.activate_notice(1)
 456            add_trace_notices.value = trace_notices.notice_html()
 457        pass
 458    Xcoord.observe(trace_name_update,names='value')
 459    Ycoord.observe(trace_name_update,names='value')
 460
 461    # Trace name
 462    trace_name = Text(placeholder = 'Trace name for legend',
 463                      description = 'Trace name: ',
 464                      disabled = True)
 465
 466    trace_notices.set_active([0,1])
 467    add_trace_notices = richLabel(value = trace_notices.notice_html())
 468    step1tracebox =  VBox(children=[whichframe,Xcoord,Ycoord,trace_name])
 469    step1actionbox =  VBox(children=[add_trace_notices])
 470    step1hbox =  HBox(children=[step1tracebox,step1actionbox])
 471    step1 =  VBox(children=[step1instracc, step1hbox])
 472
 473    # 2. Set data uncertainty
 474    step2instr = richLabel(value = 'If you know the uncertainty in your data '
 475                                   'values (Y-values)you should '
 476                                   'specify it, as the uncertainty impacts '
 477                                   'the final uncertainty in the fit '
 478                                   'parameters. '
 479                                   'If you do not know the uncertainty of '
 480                                   'your data leave the "Error Type" as '
 481                                   '"none". In this case all the data values '
 482                                   'will be equally weighted during the fit. '
 483                                   'Alternatives are: a constant uncertainty '
 484                                   'that is the same for every data point; a '
 485                                   'percentage of each value; data (a '
 486                                   'column) specifying the uncertainty for '
 487                                   'every data point.')
 488
 489    yerrtype = Dropdown(options = ['none','percent','constant','data'],
 490                        description = 'Error Type: ',
 491                        disabled = True)
 492
 493    def error_settings_OK():
 494        check = True
 495        if (yerrtype.value == 'data') and (yerrdata.value == 'Choose error '
 496                                                        'column.'):
 497            check = False
 498        return check
 499
 500    def yerr_change(change):
 501        df = friendly_to_object[whichframe.value]
 502        if change['new'] == 'percent' or change['new'] == 'constant':
 503            yerrvalue.disabled = False
 504            yerrdata.disabled = True
 505        if change['new'] == 'data':
 506            yerrvalue.disabled = True
 507            tempopts = ['Choose error column.']
 508            tempcols = df.columns.values
 509            for k in tempcols:
 510                if df[k].dtype != 'O':
 511                    tempopts.append(k)
 512            yerrdata.options=tempopts
 513            yerrdata.disabled = False
 514        if change['new'] == 'none':
 515            yerrvalue.disabled = True
 516            yerrdata.disabled = True
 517        add_trace_notices.value = trace_notices.notice_html()
 518        pass
 519
 520    yerrtype.observe(yerr_change, names = 'value')
 521
 522    yerrvalue = FloatText(description = '% or constant: ', disabled = True,
 523                          style=longdesc, value=1.0)
 524    yerrdata = Dropdown(options = ['Choose error column.'],
 525                        description = 'Error values: ',
 526                        disabled = True)
 527
 528    def errdata_change(change):
 529        if error_settings_OK():
 530            #trace_notices.deactivate_notice(2)
 531            pass
 532        else:
 533            #trace_notices.activate_notice(2)
 534            pass
 535        add_trace_notices.value = trace_notices.notice_html()
 536        pass
 537
 538    yerrdata.observe(errdata_change, names = 'value')
 539    yerrrow1 =  HBox(children=[yerrtype,yerrvalue])
 540    yerror =  VBox(children=[yerrrow1,yerrdata])
 541    step2instracc = Accordion(children=[step2instr])
 542    step2instracc.selected_index = None
 543    step2 =  VBox(children=[step2instr,yerror])
 544
 545    # 3. Set fit parameters
 546    step3instr = richLabel(value = '<ol><li>Choose the fit type ('
 547                                   'functional form). <span '
 548                                   'style="color:red">Red symbols are '
 549                                   'the fit parameters.</span></li>'
 550                                   '<li>You may use the default settings for '
 551                                   'the '
 552                                   'initial guesses and parameter ranges or '
 553                                   'you may set them.</li>'
 554                                   '<li>To fix a value at the '
 555                                   'initial guess select the "fix" checkbox. '
 556                                   'You must provide an initial guess if you '
 557                                   'fix a parameter.</li></ol>')
 558    step3instracc = Accordion(children = [step3instr])
 559    step3instracc.set_title(0,'Instructions')
 560    step3instracc.selected_index = None
 561    # get selected fit model and update parameters list.
 562    modeldrop = Dropdown(options=fitmodels)
 563    modeleqn = texLabel(value = fitmodeleqns[modeldrop.value])
 564    def getcurrmodel_param(modelname, params_set):
 565        '''
 566        Using the model name return ipywidgets for setting the fit 
 567        parameters and constraints, populated with the default values.
 568        :param string modelname: The string name for the lmfit model.
 569        :param VBox params_set: The VBox containing the HBoxes for parameter
 570            guesses and constraints.
 571        :return VBox: params_set with fields reset and those available visible.
 572        '''
 573        currmodel = None
 574        try:
 575            currmodel = getattr(models,modelname)()
 576        except:
 577            import pandas_GUI.custom_fit_models as custfitmod
 578            currmodel = getattr(custfitmod, modelname)()
 579        currmodel_param = []
 580        labeltext = ''
 581        fix = False
 582        value = 0
 583        min = -sys.float_info.max
 584        max = sys.float_info.max
 585        expr = None  # Not used, maybe for arbitrary functions.
 586        if hasattr(currmodel,'guess') and (modelname !='PolynomialModel') and (
 587                modelname != 'SineModel') and (
 588                whichframe.value != 'Choose data set.'):
 589            df = friendly_to_object[whichframe.value]
 590            xvals = df[Xcoord.value]
 591            yvals = df[Ycoord.value]
 592            try:
 593                pars = currmodel.guess(yvals,xvals)
 594                for k in pars:
 595                    currmodel.set_param_hint(k,value = pars[k].value)
 596            except NotImplementedError:
 597                pass
 598        for i in range(0,8):
 599            fix = False
 600            if i < len(currmodel.param_names):
 601                labeltext = str(currmodel.param_names[i])
 602                hints = currmodel.param_hints.get(labeltext,None)
 603                if isinstance(hints,dict):
 604                    fix = not(hints.get('vary',True))
 605                    value = hints.get('value', 0)
 606                    min = hints.get('min', -sys.float_info.max)
 607                    max = hints.get('max', sys.float_info.max)
 608                    expr = hints.get('expr',None)
 609                params_set.children[i].layout.display=''
 610                if modelname == 'SineModel':
 611                    df = friendly_to_object[whichframe.value]
 612                    xvals = df[Xcoord.value]
 613                    yvals = df[Ycoord.value]
 614                    if labeltext == 'amplitude':
 615                        value = np.max(yvals)
 616                    if labeltext == 'frequency':
 617                        # Looking for the most prominent frequency component
 618                        # to fit.
 619                        temprange = np.max(xvals) - np.min(xvals)
 620                        npts = len(xvals)
 621                        tempfft = np.fft.fft(yvals)[:int(npts/2)]
 622                        maxloc = np.argmax(np.absolute(tempfft))
 623                        value = maxloc*temprange/npts
 624            else:
 625                labeltext = str(i)
 626                params_set.children[i].layout.display='none'
 627            params_set.children[i].children[0].value = labeltext+':'
 628            params_set.children[i].children[1].children[0].value = fix
 629            params_set.children[i].children[1].children[1].value = value
 630            params_set.children[i].children[1].children[2].value = min
 631            params_set.children[i].children[1].children[3].value = max
 632        pass
 633
 634    def make_param_set():
 635        '''
 636        Creates a VBox with 7 parameters each having fields in an HBox:
 637        1. fixcheck (checkbox for fixing the value)
 638        2. valuefield (floatText for setting the value)
 639        3. minfield (floatText for setting the minimum allowed value)
 640        4. maxfield (floatText for setting the maximum allowed value)
 641        By default the all VBox components have their `layout.display=none`.
 642        :return: VBox
 643        '''
 644        import sys
 645        currmodel_param=[]
 646        for i in range (0,8):
 647            fixcheck = Checkbox(value=False,
 648                                description='Fix (hold)',
 649                                disabled=False,
 650                                style=longdesc)
 651            valuefield = FloatText(value=0,
 652                                   description='Value: ',
 653                                   disabled=False,
 654                                   style=longdesc)
 655            minfield = FloatText(value=-sys.float_info.max,
 656                                 description='Min: ',
 657                                 disabled=False,
 658                                 style=longdesc)
 659            maxfield = FloatText(value=sys.float_info.max,
 660                                 description='Max: ',
 661                                 disabled=False,
 662                                 style=longdesc)
 663            paramlabel = Label(value = str(i)+':',style=longdesc)
 664            parambox =  VBox(children=[paramlabel, HBox(children=[fixcheck,valuefield,minfield,
 665                                    maxfield])])
 666            parambox.layout.display = 'none'
 667            currmodel_param.append(parambox)
 668        params_set = VBox(currmodel_param)
 669        return params_set
 670
 671    def modeldrop_change(change):
 672        modeleqn.value=fitmodeleqns[modeldrop.value]
 673        getcurrmodel_param(modeldrop.value,params_set)
 674        pass
 675    modeldrop.observe(modeldrop_change, names = 'value')
 676    params_set = make_param_set()
 677    getcurrmodel_param(modeldrop.value, params_set)
 678    step3 =  VBox(children=[step3instracc, HBox(children=[modeldrop,modeleqn]),params_set])
 679
 680    # 5.Title, Axes, Format ...
 681    step5instr = richLabel(value = '<ul><li><span '
 682                                   'style="font-weight:bold;">You '
 683                                   'must set the axes labels to something '
 684                           'appropriate.</span> For example if the X - values '
 685                           'represent time in seconds "Time (s)" is a good '
 686                           'choice. Likewise, choose an appropriate label '
 687                           'for the Y - axis.</li>'
 688                           '<li>If the Aspect Ratio is set to `auto` the '
 689                           'figure will fill the default output region. '
 690                           'Other choices will allow you to pick the Plot '
 691                                   'Size. `Large` will use about 2/3 of an HD '
 692                                   '(1920X1080) screen.</li></ul>')
 693    plot_title = Text(value = figname,
 694                       description = 'Plot title: ',
 695                      layout = Layout(width='80%'))
 696    X_label = Text(placeholder = 'Provide an X-axis label (usually has units)',
 697                   description = 'X-axis label: ',
 698                   style = longdesc,
 699                   layout=Layout(width='45%'))
 700    Y_label = Text(placeholder = 'Provide a Y-axis label (usually has units)',
 701                   description = 'Y-axis label: ',
 702                   style = longdesc,
 703                   layout=Layout(width='45%'))
 704    def mirror_axes_change(change):
 705        if change['new']:
 706            mirror_ticks.disabled= False
 707        else:
 708            mirror_ticks.disabled= True
 709            mirror_ticks.value = False
 710        pass
 711
 712    mirror_axes = Checkbox(value = False,
 713                           description = 'Display Mirror Axes',
 714                           style = longdesc)
 715    mirror_axes.observe(mirror_axes_change, names = 'value')
 716    mirror_ticks = Checkbox(value = False,
 717                            description = 'Mirror Tick Marks',
 718                            disabled = True)
 719
 720    def aspect_change(change):
 721        if change['new'] != 'auto':
 722            plot_size.disabled=False
 723        else:
 724            plot_size.disabled=True
 725        pass
 726
 727    plot_aspect = Dropdown(options = ['auto', '16:9', '5:3', '7:5', '4:3',
 728                                     '10:8', '1:1'],
 729                      value = 'auto',
 730                      description = 'Aspect Ratio: ',
 731                      style = longdesc)
 732    plot_aspect.observe(aspect_change, names = 'value')
 733    plot_size = Dropdown(options = ['tiny', 'small', 'medium', 'large',
 734                                    'huge'],
 735                         value = 'large',
 736                         description = 'Plot Size: ',
 737                         style = longdesc,
 738                         disabled = True)
 739    plot_template = Dropdown(options=['none','simple_white', 'ggplot2',
 740                                    'seaborn',
 741                                 'plotly', 'plotly_white', 'plotly_dark',
 742                                 'presentation', 'xgridoff', 'ygridoff',
 743                                 'gridon', 'simple_white+presentation',
 744                                      'simple_white+gridon', 
 745                                      'simple_white+presentation+gridon'],
 746                        value='simple_white',
 747                        description = 'Plot Styling: ',
 748                        style = longdesc)
 749    step5hbox1 =  HBox(children=[X_label, Y_label])
 750    step5hbox2 =  HBox(children=[mirror_axes,mirror_ticks, plot_template,
 751                                 plot_aspect, plot_size])
 752    step5 =  VBox(children=[step5instr, plot_title, step5hbox1, step5hbox2])
 753
 754    # 4. Pick Fit Range(s)
 755    step4instr = richLabel(value ='This step is optional. '
 756                                  'If you define no range(s) all data '
 757                                  'points will be used in the fit. <ul>'
 758                                  '<li> Click on points to select the '
 759                                  'beginning and ending of each range of '
 760                                  'data to include in the fit.</li>'
 761                                  '<li> Click again on '
 762                                  'a point to deselect it.</li>'
 763                                  '<li> Nearest neighbor pairs of points '
 764                                  'starting with the lowest point index '
 765                                  'number are used to define each range. If '
 766                                  'you select an odd number of points, '
 767                                  'the last point will be ignored.</li>'
 768                                  '<li> Check the `Extend fitted function '
 769                                  'plot` box if you want to display '
 770                                  'calculations of the fitted function and '
 771                                  'residuals in regions that were not fit '
 772                                  'to.</li></ul>')
 773    extend_fit = Checkbox(value=False,
 774                           description='Extend fitted function plot',
 775                           style=longdesc)
 776    range_plot = None
 777    if JPSLUtils.notebookenv == 'colab':
 778        range_plot = richLabel(value = '<span style="color:blue;">' \
 779                               'Unfortunately, defining a range by clicking ' \
 780                               'on the graph is not yet supported in Google' \
 781                               'Colab.</span>')
 782    else:
 783        range_plot =  go.FigureWidget(layout_template='simple_white')
 784        range_plot_line_color = 'blue'
 785        range_plot_hilight = 'cyan'
 786        range_plot_marker_size = 6
 787        range_plot_hilight_size = 20
 788        ranges=[]
 789        
 790    def update_range_point(trace, points, selector):
 791        # size and color must be done separately as they may not be updated
 792        # in sync.
 793        try:
 794            from collections.abc import Iterable
 795        except ImportError(e):
 796            from collections import Iterable            
 797        if not isinstance(trace['marker']['size'],Iterable):
 798            s = [range_plot_marker_size]*len(trace['x'])
 799        else:
 800            s = list(trace['marker']['size'])
 801        if (not isinstance(trace['marker']['color'],Iterable)) or isinstance(
 802                trace['marker']['color'],str):
 803            c = [range_plot_line_color]*len(trace['x'])
 804        else:
 805            c = list(trace['marker']['color'])
 806        for i in points.point_inds:
 807            if c[i]==range_plot_line_color:
 808                c[i] = range_plot_hilight
 809                s[i] = range_plot_hilight_size
 810            else:
 811                c[i] = range_plot_line_color
 812                s[i] = range_plot_marker_size
 813        with range_plot.batch_update():
 814            trace.marker.color = c
 815            trace.marker.size = s
 816        pass
 817    step4instacc = Accordion(children =[step4instr])
 818    step4instacc.set_title(0,'Instructions (optional step)')
 819    step4instacc.selected_index = None
 820    step4 =  VBox(children=[step4instacc,extend_fit,range_plot])
 821
 822    # 6. Final Check*
 823    step6instr = richLabel(value = 'Things to check before running the fit:' \
 824                                   '<ul><li>Fix any problems listed in ' \
 825                                   '"Notices".</li>' \
 826                                   '<li>Check for any unpaired parentheses, ' \
 827                                   'brackets or braces.</li>' \
 828                                   '<li>Check that all single and double ' \
 829                                   'quotes are paired.</li>' \
 830                                   '<li>If you did any manual editing ' \
 831                                   'double-check for typos.</li>')
 832    step6noticebox = richLabel(value = makeplot_notices.notice_html())
 833
 834    def dofit_click(change):
 835        if JPSLUtils.notebookenv == 'NBClassic':
 836            # Commented out do nothing because of timing issues
 837            #text = '\n# Force save widget states so that graph will still be\n'
 838            #text += '# available when notebook next opened in trusted state.\n'
 839            #text += 'import time\ntime.sleep(5)'
 840            select_containing_cell('pandasfitGUI')
 841            select_cell_immediately_below()
 842            #insert_newline_at_end_of_current_cell(text)
 843            #jscode = 'Jupyter.actions.call("widgets:save-with-widgets");'
 844            #text = 'JPSLUtils.OTJS(\''+jscode+'\')'
 845            #insert_newline_at_end_of_current_cell(text)
 846            # run the cell to build the plot
 847            JPSLUtils.OTJS('Jupyter.notebook.get_selected_cell().execute()')
 848            # remove the GUI cell
 849            select_containing_cell('pandasfitGUI')
 850            delete_selected_cell()
 851        pass
 852
 853    dofitbut_lay = Layout(visibility = "hidden")
 854    if JPSLUtils.notebookenv == 'NBClassic':
 855        dofitbut_lay = Layout(visibility="visible")
 856    dofitbut = Button(description = 'Do Fit',
 857                      disabled = True,
 858                      layout = dofitbut_lay)
 859    dofitbut.on_click(dofit_click)
 860    step6vbox =  VBox(children=[dofitbut,step6noticebox])
 861    step6 =  HBox(children=[step6instr,step6vbox])
 862
 863
 864    steps =  Tab(children=[step1, step2, step3, step4, step5, step6])
 865    steps.set_title(0,'1. Pick Data*')
 866    steps.set_title(1,'2. Data Uncertainty*')
 867    steps.set_title(2,'3. Set up Model*')
 868    steps.set_title(3,'4. Pick Fit Range(s)')
 869    steps.set_title(4, '5. Axes & Format*')
 870    steps.set_title(5, '6. Final Check*')
 871
 872    def tab_changed(change):
 873        nonlocal importstr, step1str, step2str, step3str, step4str, step5str, \
 874            range_chosen
 875        dfname = friendly_to_globalname[whichframe.value]
 876        if change['old'] == 0:
 877            # Update step 1 string
 878            step1str = '# Define data and trace name\n'
 879            step1str += 'Xvals = '+dfname+'[\"'
 880            step1str += str(Xcoord.value)+'\"]\n'
 881            step1str += 'Yvals = ' + dfname +'[\"'
 882            step1str += str(Ycoord.value)+'\"]\n'
 883            step1str += 'tracename = \"'+str(trace_name.value)+'\"\n\n'
 884            pass
 885        if change['old'] == 1:
 886            # TODO need do something in case  tab is changed before a click
 887            # occurs outside a box that was just change. blur things will
 888            # require ipywidgets v8+
 889            # update step 2 string
 890            step2str = '# Define error (uncertainty)\n'
 891            if yerrtype.value == 'none':
 892                step2str += 'Yerr = ' + dfname + '[\"'
 893                step2str += str(Ycoord.value) + '\"]*0.0 + 1.0\n\n'
 894            if yerrtype.value=='constant':
 895                step2str += 'Yerr = ' + dfname +'[\"'
 896                step2str += str(Ycoord.value)+'\"]*0.0 + ' + str(
 897                    yerrvalue.value) + '\n\n'
 898            if yerrtype.value == 'percent':
 899                step2str += 'Yerr = np.fabs('+ dfname +'[\"'
 900                step2str += str(Ycoord.value)+'\"])*0.01*' + str(
 901                    yerrvalue.value) + '\n\n'
 902            if yerrtype.value == 'data':
 903                step2str += 'Yerr = ' + dfname +'[\"'
 904                step2str += str(yerrdata.value)+'\"]\n\n'
 905            pass
 906        if change['old']== 2:
 907            # update step 3 string
 908            step3str = '# Define the fit model, initial guesses, ' \
 909                       'and constraints\n'
 910            currmodel = None
 911            modelname = modeldrop.value
 912            try:
 913                currmodel = getattr(models, modelname)()
 914                step3str += 'fitmod = lmfit.models.'
 915                step3str += str(modeldrop.value) + '()\n'
 916            except:
 917                import pandas_GUI.custom_fit_models as custfitmod
 918                currmodel = getattr(custfitmod, modelname)()
 919                step3str += 'fitmod = custom_fit_models.'
 920                step3str += str(modeldrop.value)+'()\n'
 921            for k in params_set.children:
 922                param_name = str(k.children[0].value.split(':')[0])
 923                if param_name in currmodel.param_names:
 924                    step3str += 'fitmod.set_param_hint(\"'+param_name+'\",'
 925                    step3str += ' vary = '+str(not(k.children[1].children[
 926                        0].value))
 927                    temp_val = k.children[1].children[1].value
 928                    def tst_temp_val(temp_val):
 929                        if (temp_val != np.nan) and (temp_val != np.inf) and\
 930                                (temp_val != -np.inf) and (temp_val != \
 931                                -sys.float_info.max) and (temp_val != \
 932                                sys.float_info.max):
 933                            return True
 934                        else:
 935                            return False
 936                    if tst_temp_val(temp_val):
 937                        step3str += ', value = ' + str(temp_val)
 938                    temp_val = k.children[1].children[2].value
 939                    if tst_temp_val(temp_val):
 940                        step3str += ', min = ' + str(temp_val)
 941                    temp_val = k.children[1].children[3].value
 942                    if tst_temp_val(temp_val):
 943                        step3str += ', max = ' + str(temp_val)
 944                    step3str += ')\n'
 945            step3str +='\n'
 946            pass
 947        if change['new']>=4:
 948            ranges = []
 949            if JPSLUtils.notebookenv != 'colab':
 950                # update ranges
 951                range_start = True
 952                new_range = []
 953                if len(range_plot.data)>0:
 954                    for i in range(len(range_plot.data[0].marker.color)):
 955                        if range_plot.data[0].marker.color[i] == range_plot_hilight:
 956                            new_range.append(i)
 957                            if not range_start:
 958                                ranges.append(new_range)
 959                                new_range = []
 960                            range_start = not range_start
 961            # update step 4 string
 962            covscalestr = 'False'
 963            if yerrtype.value == 'none':
 964                covscalestr = 'True'
 965            if len(ranges) > 0:
 966                range_chosen = True
 967                step4str = '# Define fit ranges\n'
 968                step4str += 'Yfiterr = copy.deepcopy(Yerr) # ranges not to ' \
 969                            'fit = np.inf\n'
 970                step4str += 'Xfitdata = copy.deepcopy(Xvals) # ranges where ' \
 971                            'fit not displayed = np.nan\n'
 972                for i in range(len(ranges)):
 973                    if i == 0 and ranges[0][0]>0:
 974                        step4str += 'Yfiterr[int(0):int('+str(ranges[0][0])+ \
 975                                    ')] = np.inf\n'
 976                        step4str += 'Xfitdata[int(0):int('+str(ranges[0][0])+\
 977                                    ')] = np.nan\n'
 978                    if (i + 1) < len(ranges):
 979                        step4str += 'Yfiterr[int('+str(ranges[i][1]+1)+\
 980                                    '):int('+str(ranges[i+1][0])+')] = np.inf\n'
 981                        step4str += 'Xfitdata[int('+str(ranges[i][1]+1)+ \
 982                                    '):int('+str(ranges[i+1][0])+')] = np.nan\n'
 983                    if i+1 == len(ranges):
 984                        step4str += 'Yfiterr[int('+str(ranges[i][1]+1)+\
 985                                    '):int('+str(len(range_plot.data[0].marker.
 986                                                color))+')] = np.inf\n'
 987                        step4str += 'Xfitdata[int('+str(ranges[i][1]+1)+\
 988                                '):int('+str(len(range_plot.data[0].marker.
 989                                            color))+')] = np.nan\n'
 990                step4str += '\n'
 991                step4str += '# Do fit\n'
 992                step4str += str(fitname)+' = fitmod.fit(Yvals, x=Xvals, ' \
 993                    'weights = 1/Yfiterr, scale_covar = '+covscalestr+', ' \
 994                    'nan_policy = \"omit\")\n\n'
 995            else:
 996                range_chosen = False
 997                step4str = '# Do fit\n'
 998                step4str += str(fitname)+' = fitmod.fit(Yvals, x=Xvals, ' \
 999                    'weights = 1/Yerr, scale_covar = '+covscalestr+', ' \
1000                    'nan_policy = \"omit\")\n\n'
1001            step4str += '# Calculate residuals (data - fit) because lmfit\n'
1002            step4str += '#  does not calculate for all points under all ' \
1003                        'conditions\n'
1004            step4str += 'resid = []\n'
1005            step4str += ('# explicit int(0) below avoids collisions with some '
1006                         'preparsers.\n')
1007            step4str += 'for i in range(int(0),len('+str(fitname)+'.data)):\n'
1008            step4str += '    resid.append('+str(fitname)+'.data[' \
1009                                        'i]-'+str(fitname)+'.best_fit[i])\n\n'
1010            pass
1011        if change['old'] == 4:
1012                # update step 5 string
1013                step5str = ''
1014                if range_chosen:
1015                    xstr = 'Xfitdata'
1016                    if not(extend_fit.value):
1017                        step5str += '# Delete residuals in ranges not fit\n'
1018                        step5str += '# and fit values that are not ' \
1019                                    'displayed.\n'
1020                        step5str += 'for i in range(len(resid)):\n'
1021                        step5str += '    if np.isnan(Xfitdata[i]):\n'
1022                        step5str += '        resid[i] = None\n'
1023                        step5str += '        '+str(fitname)+'.best_fit[i] = ' \
1024                                                   'None\n\n'
1025                else:
1026                    xstr = 'Xvals'
1027                errbarstr = ''
1028                if yerrtype.value!='none':
1029                    errbarstr = ', error_y_type=\"data\", error_y_array=Yerr'
1030                xresidstr = xstr
1031                if extend_fit.value:
1032                    xresidstr = 'Xvals'
1033                mirrorstr = ''
1034                if mirror_axes.value:
1035                    mirrorstr = ', mirror = True'
1036                    if mirror_ticks.value:
1037                        mirrorstr = ', mirror = \"ticks\"'
1038                # the plot
1039                step5str += '# Plot Results\n'
1040                step5str += ('# explicit int(..) below avoids collisions with '
1041                             'some preparsers.\n')
1042                step5str += str(figname) + ' = go.FigureWidget(' \
1043                                    'layout_template=\"'+str(
1044                                    plot_template.value)+'\")\n'
1045                step5str += str(figname)+ '.update_layout(title = \"'+ \
1046                                    str(plot_title.value)+'\",'
1047                text = ''
1048                if plot_aspect.value == 'auto':
1049                    text += 'autosize=True)\n'
1050                else:
1051                    if plot_size.value == 'tiny':
1052                        plot_width = 300
1053                    elif plot_size.value == 'small':
1054                        plot_width = 450
1055                    elif plot_size.value == 'medium':
1056                        plot_width = 800
1057                    elif plot_size.value == 'large':
1058                        plot_width = 1200
1059                    elif plot_size.value == 'huge':
1060                        plot_width = 2400
1061                    if plot_aspect.value == '16:9':
1062                        plot_height = int(9 * plot_width / 16)
1063                    elif plot_aspect.value == '5:3':
1064                        plot_height = int(3 * plot_width / 5)
1065                    elif plot_aspect.value == '7:5':
1066                        plot_height = int(5 * plot_width / 7)
1067                    elif plot_aspect.value == '4:3':
1068                        plot_height = int(3 * plot_width / 4)
1069                    elif plot_aspect.value == '10:8':
1070                        plot_height = int(8 * plot_width / 10)
1071                    elif plot_aspect.value == '1:1':
1072                        plot_height = plot_width
1073                    text += 'autosize=False, width = int('
1074                    text += str(plot_width) + '), height=int('
1075                    text += str(plot_height) + '))\n'
1076                step5str += text
1077                step5str += str(figname) + '.set_subplots(rows=int(2), cols=int(1), ' \
1078                                           'row_heights=[0.2,0.8], ' \
1079                                           'shared_xaxes=True)\n'
1080                step5str += 'scat = go.Scatter(y=resid,x='+xresidstr+', ' \
1081                                    'mode=\"markers\",' \
1082                                    'name = \"residuals\"'+errbarstr+')\n'
1083                step5str += str(figname) + '.update_yaxes(title = ' \
1084                                        '\"Residuals\", ' \
1085                            'row=int(1), col=int(1), zeroline=True, zerolinecolor = ' \
1086                            '\"lightgrey\"'+str(mirrorstr)+')\n'
1087                if mirror_axes.value:
1088                    step5str += str(figname) + '.update_xaxes(' \
1089                                           'row=int(1), col=int(1)'+str(mirrorstr)+')\n'
1090                step5str += str(figname) + '.add_trace(scat,col=int(1),row=int(1))\n'
1091                step5str += 'scat = go.Scatter(x=Xvals, y=Yvals, ' \
1092                            'mode=\"markers\", name=tracename'+errbarstr+')\n'
1093                step5str += str(figname) + '.add_trace(scat, col=int(1), ' \
1094                                           'row=int(2))\n'
1095                step5str += str(figname) + '.update_yaxes(title = ' \
1096                                           '\"'+Y_label.value+'\", ' \
1097                                           'row=int(2), col=int(1)'+str(mirrorstr)+')\n'
1098                step5str += str(figname) + '.update_xaxes(title = ' \
1099                                           '\"'+X_label.value+'\", ' \
1100                                           'row=int(2), col=int(1)'+str(mirrorstr)+')\n'
1101                if extend_fit.value:
1102                    step5str += 'scat = go.Scatter(y='+str(
1103                        fitname)+'.best_fit, x=Xvals, mode=\"lines\", '\
1104                                'line_color = \"black\", ' \
1105                                'name=\"extrapolated\",' \
1106                                 'line_dash=\"dash\")\n'
1107                    step5str += str(figname) + '.add_trace(scat, col=int(1), ' \
1108                                               'row=int(2))\n'
1109                step5str += 'scat = go.Scatter(y='+str(fitname)+'.best_fit,' \
1110                                    'x='+xstr+', mode=\"lines\", ' \
1111                                    'name=\"fit\", line_color = ' \
1112                                    '\"black\", line_dash=\"solid\")\n'
1113                step5str += str(figname) + '.add_trace(scat,col=int(1),row=int(2))\n'
1114                step5str += 'display('+str(figname)+')\n\n'
1115                pass
1116        if change['new'] == 3 and JPSLUtils.notebookenv != 'colab':
1117            df = friendly_to_object[whichframe.value]
1118            rangex = df[Xcoord.value]
1119            rangey = df[Ycoord.value]
1120            c =[]
1121            s = []
1122            if len(range_plot.data)> 0 and len(range_plot.data[
1123                0].marker.color) == len(range_plot.data[0]['x']):
1124                c = list(range_plot.data[0].marker.color)
1125                s = list(range_plot.data[0].marker.size)
1126            range_plot.data=[]
1127            range_plot.add_scatter(x=rangex,y=rangey, mode = 'markers',
1128                                   line_color = range_plot_line_color,
1129                                   marker_size = range_plot_marker_size)
1130            if len(range_plot.data[0]['x']) == len(c):
1131                with range_plot.batch_update():
1132                    range_plot.data[0].marker.color = c
1133                    range_plot.data[0].marker.size = s
1134            range_plot.data[0].on_click(update_range_point)
1135        if change['new'] ==5:
1136            if X_label.value == '' or Y_label.value == '':
1137                makeplot_notices.activate_notice(2)
1138                dofitbut.disabled = True
1139                dofitbut.button_style = ''
1140            else:
1141                makeplot_notices.deactivate_notice(2)
1142            if Xcoord.value == 'Choose X-coordinate.' or \
1143                    Ycoord.value == 'Choose X-coordinate.':
1144                makeplot_notices.activate_notice(0)
1145                dofitbut.disabled = True
1146                dofitbut.button_style = ''
1147            else:
1148                makeplot_notices.deactivate_notice(0)
1149            if modeldrop.value == '':
1150                makeplot_notices.activate_notice(1)
1151                dofitbut.disabled = True
1152                dofitbut.button_style = ''
1153            else:
1154                makeplot_notices.deactivate_notice(1)
1155            step6noticebox.value = makeplot_notices.notice_html()
1156        if len(makeplot_notices.get_active()) == 0:
1157            dofitbut.disabled = False
1158            dofitbut.button_style = 'success'
1159        # the best fit equation
1160        step6str = '# Display best fit equation\n'
1161        step6str += fitresultstrs[modeldrop.value](fitname)
1162        if JPSLUtils.notebookenv == 'NBClassic':
1163            JPSLUtils.select_containing_cell('pandasfitGUI')
1164            JPSLUtils.replace_text_of_next_cell(importstr + step1str + \
1165                                                step2str + step3str + \
1166                                                step4str + step5str + step6str)
1167        else:
1168            codearea.sniptext.value = importstr + step1str + step2str + \
1169                                      step3str + step4str + step5str + \
1170                                      pseudoLatexToLatex(step6str)
1171        pass
1172
1173    steps.observe(tab_changed, names = 'selected_index')
1174    with output:
1175        display(steps)
1176    if JPSLUtils.notebookenv == 'NBClassic':
1177        display(output)
1178        select_containing_cell('pandasfitGUI')
1179        new_cell_immediately_below()
1180    else:
1181        codearea = build_run_snip_widget('', output)
1182        with output:
1183            display(codearea)
1184        display(output)
1185    pass