cubevis 0.5.19__py3-none-any.whl → 0.5.20__py3-none-any.whl

cubevis/private/apps/_interactiveclean.mustache

@@ -1,7 +1,7 @@
 ########################################################################
 #
 #TASK XML> tclean -argfilter=interactive,fullsummary -argfilter:initParams=vis,imagename
-# Copyright (C) 2022,2023,2024
+# Copyright (C) 2022,2023,2024,2025
 # Associated Universities, Inc. Washington DC, USA.
 #
 # This script is free software; you can redistribute it and/or modify it
@@ -29,137 +29,24 @@
 '''implementation of the ``InteractiveClean`` application for interactive control
 of tclean'''
 
-###
-### Useful for debugging
-###
-###from cubevis.bokeh.state import initialize_bokeh
-###initialize_bokeh( bokehjs_subst=".../bokeh-3.2.2.js" )
-###
-import os
-import copy
-import asyncio
-import shutil
-import websockets
-from os.path import basename, abspath, exists
-from uuid import uuid4
-from html import escape as html_escape
-from contextlib import asynccontextmanager
-from bokeh.models import Button, TextInput, Checkbox, Div, LinearAxis, CustomJS, Spacer, Span, HoverTool, DataRange1d, Step, InlineStyleSheet
-from bokeh.events import ModelEvent, MouseEnter
-from bokeh.models import TabPanel, Tabs
-from bokeh.plotting import ColumnDataSource, figure, show
-from bokeh.layouts import column, row, layout
-from bokeh.io import reset_output as reset_bokeh_output, output_notebook
-from bokeh.models.dom import HTML
-
-from bokeh.models.ui.tooltips import Tooltip
-from cubevis.bokeh.models import TipButton, Tip, EvTextInput
-from cubevis.utils import resource_manager, reset_resource_manager, is_interactive_jupyter, find_pkg, load_pkg
-from cubevis.utils import ContextMgrChain as CMC
-
-# pylint: disable=no-name-in-module
-from casatasks.private.imagerhelpers.imager_return_dict import ImagingDict
+from pprint import pprint
 
+import sys
+from os.path import exists
 from casatasks.private.imagerhelpers.input_parameters import ImagerParameters
-# pylint: enable=no-name-in-module
-
-from cubevis.utils import find_ws_address, convert_masks
-from cubevis.toolbox import CubeMask, AppContext
-from cubevis.bokeh.utils import svg_icon
-from cubevis.bokeh.sources import DataPipe
-from cubevis.utils import DocEnum
-
-from ._interactiveclean_wrappers import SharedWidgets
 
-USE_MULTIPLE_GCLEAN_HACK=False
+from cubevis.utils import find_pkg, load_pkg
+from cubevis.toolbox import InteractiveCleanUI
+from cubevis import exe
 
 class InteractiveClean:
     '''InteractiveClean(...) implements interactive clean using Bokeh
     {{docstring}}
     '''
-    def __stop( self, _=None ):
-        self.__result_future.set_result(self.__retrieve_result( ))
-
-    def _abort_handler( self, err ):
-        self._error_result = err
-        self.__stop( )
-
-    def __reset( self ):
-        if self.__pipes_initialized:
-            self._pipe = { 'control': None }
-            self._clean = { 'converge': { 'state': { } }, 'last-success': None }
-            reset_bokeh_output( )
-            reset_resource_manager( )
-
-        ###
-        ### reset asyncio result future
-        ###
-        self.__result_future = None
-
-        ###
-        ### used by data pipe (websocket) initialization function
-        ###
-        self.__pipes_initialized = False
-
-        ###
-        ### error or exception result
-        ###
-        self._error_result = None
-
-        ###
-        ### iclean results
-        ###
-        self.__result = None
-        self.__result_from_gui = None
-
-    '''
-        _gen_port_fwd_cmd()
-
-    Create an SSH port-forwarding command to create the tunnels necessary for remote connection.
-    NOTE: This assumes that the same remote ports are also available locally - which may
-        NOT always be true.
-    '''
-    def _gen_port_fwd_cmd(self):
-        hostname = os.uname()[1]
-
-        ###
-        ### need to add extra cube ports here for multifield imaging
-        ###
-        ports = [ self._pipe['control'].address[1], self._clean['converge']['pipe'].address[1] ]
-
-        for imid, imdetails in self._clean_targets.items( ):
-            ports.append( imdetails['gui']['cube']._pipe['image'].address[1] )
-            ports.append( imdetails['gui']['cube']._pipe['control'].address[1] )
-
-        # Also forward http port if serving webpage
-        if not self._is_notebook:
-            ports.append(self._http_port)
-
-        cmd = 'ssh'
-        for port in ports:
-            cmd += (' -L ' + str(port) + ':localhost:' + str(port))
-
-        cmd += ' ' + str(hostname)
-        return cmd
-
-    def _residual_path( self, gclean, imid ):
-        if self._clean['gclean_paths'] is None:
-            raise RuntimeError( f'''gclean paths are not available for {imid}''' )
-        for p in self._clean['gclean_paths']:
-            if p['name'] == imid:
-                return f"{p['imagepath']}/{p['residualname']}"
-        raise RuntimeError( f'''gclean residual path not found for {imid}''' )
-
-    def _mask_path( self, gclean, imid ):
-        if self._clean['gclean_paths'] is None:
-            raise RuntimeError( f'''gclean paths are not available for {imid}''' )
-        for p in self._clean['gclean_paths']:
-            if p['name'] == imid:
-                return f"{p['imagepath']}/{p['maskname']}"
-        raise RuntimeError( f'''gclean mask path not found for {imid}''' )
 
     def __init__( self, vis, imagename{{# initParams}}, {{name}}={{default}}{{/ initParams}}, iclean_backend="PROD" ):
 
+
         ###
         ### iclean_backend can be used to select alternate backends for interactive clean. This could be used
         ### to enable a backend with extended features or it could be used to select a stub backend designed
@@ -177,815 +64,14 @@ class InteractiveClean:
         else:
             raise ImportError(f"Could not locate {iclean_backend} kind of iclean backend")
 
-        ###
-        ### With Bokeh 3.2.2, the spectrum and convergence plots extend beyond the edge of the
-        ### browser window (requiring scrolling) if a width is not specified. It could be that
-        ### this should be computed from the width of the tabbed control area at the right of
-        ### the image display.
-        ###
-        self._conv_spect_plot_width = 450
-        ###
-        ### Create application context (which includes a temporary directory).
-        ### This sets the title of the plot.
-        ###
-        self._app_state = AppContext( 'Interactive Clean' )
-
-        ###
-        ### Whether or not the Interactive Clean session is running remotely
-        ###
-        #self._is_remote = remote
-        self._is_remote = False
-
-        ###
-        ### whether or not the session is being run from a jupyter notebook or script
-        ###
-        self._is_notebook = is_interactive_jupyter()
-
-        ##
-        ## the http port for serving GUI in webpage if not running in script
-        ##
-        self._http_port = None
-
-        ###
-        ### the asyncio future that is used to transmit the result from interactive clean
-        ###
-        self.__result_future = None
-
-        ###
-        ### This is used to tell whether the websockets have been initialized, but also to
-        ### indicate if __call__ is being called multiple times to allow for resetting Bokeh
-        ###
-        self.__pipes_initialized = False
-
-        ###
-        ### State required to manage iteration control
-        ###
-        self._control = { 'iteration': { } }
-
-        ###
-        ### color specs
-        ###
-        self._converge_color = { 'residual': 'black',
-                                 'flux':     'forestgreen' }
-
-        ###
-        ### widgets shared across image tabs (multifield imaging)
-        ###
-        self._cube_palette = None
-        self._image_bitmask_controls = None
-
-        ###
-        ### String which indicates the changes applied to the mask to indicte when
-        ### the mask has changed... however, THIS IS NO LONGER USED
-        ### It could be removed, but it adds minor overhead and would be
-        ### DIFFICULT to add back in the future
-        ###
-        self._last_mask_breadcrumbs = ''
-
-        ###
-        ### Set up dictionary of javascript code snippets
-        ###
-        self._initialize_javascript( )
-
-        # Create folder for the generated html webpage - needs its own folder to not name conflict (must be 'index.html')
-        webpage_dirname = imagename + '_webpage'
-        ### Directory is created when an HTTP server is running
-        ### (MAX)
-#       if not os.path.isdir(webpage_dirname):
-#          os.makedirs(webpage_dirname)
-        self._webpage_path = os.path.abspath(webpage_dirname)
-
-        self._pipe = { 'control': None }
-        self._clean = { 'converge': { 'state': { } }, 'last-success': None }
-
-        self._clean_targets = { imagename: { 'args': {{forwDict}} } }
-        self._initial_clean_params = { }
-
-        self._parameters = ImagerParameters( **{ k:v for k,v in self._clean_targets[imagename]['args'].items( )
-                                                 if k in ImagerParameters.__init__.__code__.co_varnames[1:] } )
-
-        ###
-        ### For 6.6.5, outliers are not yet completely implemented so the
-        ### 'outlierfile' parameter may not be present.
-        ###
-        if 'outlierfile' in locals( ) and outlierfile and exists(outlierfile):
-            outliers, err = self._parameters.parseOutlierFile(outlierfile)
-            if err: raise RuntimeError( f'''outlierfile error: {err}''' )
-            for image in outliers:
-                if 'impars' in image and 'imagename' in image['impars']:
-                    name = image['impars']['imagename']
-                    self._clean_targets[name] = { }
-                    args = {{forwDict}}
-                    args['outlierfile'] = ''					### >>HERE>> outlierfile TEMPORARILY handled in _interactiveclean.py
-                    for _,arg_mods in image.items( ):
-                        for k,v in arg_mods.items( ):
-                            if k in args:
-                                args[k] = v
-                    self._clean_targets[name]['args'] = args
-
-        ###
-        ### create clean interface -- final version will have only one gclean object
-        ###
-        self._init_values = { "deconvolver": deconvolver,                       ### used by _residual_path( )
-                              "cycleniter": cycleniter,                         ### used by _setup( )
-                              "threshold": threshold,                           ### used by _setup( )
-                              "cyclefactor": cyclefactor,                       ### used by _setup( )
-                              "gain": gain,                                     ### used by _setup( )
-                              "nsigma": nsigma,                                 ### used by _setup( )
-                              "convergence_state": { 'convergence': {},         ### shares state between
-                                                     'cyclethreshold': {} } }   ### __init__( ) and _setup( )
-
-        self._clean['gclean'] = None
-        self._clean['gclean_paths'] = None
-        self._clean['imid'] = [ ]
-        self._clean['gclean_rest'] = [ ]
-        for imid, imdetails in self._clean_targets.items( ):
-            self._clean['imid'].append(imid)
-
-            ###
-            ### Residual path...
-            ###
-            if 'path' not in imdetails: imdetails['path'] = { }
-            if self._clean['gclean'] is None:
-
-                self._clean['gclean'] = self._gclean_module.gclean( **imdetails['args'] )
-                self._clean['gclean_paths'] = self._clean['gclean'].image_products( )
-
-                imdetails['path']['residual'] = self._residual_path(self._clean['gclean'],imid)
-                imdetails['path']['mask'] = self._mask_path(self._clean['gclean'],imid)
-
-            else:
-
-                imdetails['path']['residual'] = self._residual_path(self._clean['gclean'],imid)
-                imdetails['path']['mask'] = self._mask_path(self._clean['gclean'],imid)
-
-        for idx, (imid, imdetails) in enumerate(self._clean_targets.items( )):
-            imdetails['gui'] = { }
-
-            imdetails['gui'] = { 'params': { 'iteration': { }, 'automask': { } },
-                                 'image': { },
-                                 'image-adjust': { } }
-
-            ###
-            ### Only the first image should initialize the initial convergence state
-            ###
-            imdetails['gui']['cube'] = CubeMask( imdetails['path']['residual'], mask=imdetails['path']['mask'], abort=self._abort_handler,
-                                                 init_script=CustomJS( args=dict( initial_convergence_state=self._init_values["convergence_state"],
-                                                                                  name=imid ),
-                                                                       code='''document._casa_convergence_data = initial_convergence_state''' )
-                                                             if idx == 0 else None )
-
-            ###
-            ### Auto Masking Parameters
-            ###
-            imdetails['params'] = { }
-            imdetails['params']['am'] = { }
-            imdetails['params']['am']['usemask'] = usemask
-            imdetails['params']['am']['noisethreshold'] = noisethreshold
-            imdetails['params']['am']['sidelobethreshold'] = sidelobethreshold
-            imdetails['params']['am']['lownoisethreshold'] = lownoisethreshold
-            imdetails['params']['am']['minbeamfrac'] = minbeamfrac
-            imdetails['params']['am']['negativethreshold'] = negativethreshold
-            imdetails['params']['am']['dogrowprune'] = dogrowprune
-            imdetails['params']['am']['fastnoise'] = fastnoise
-
-    def _init_pipes( self ):
-        if not self.__pipes_initialized:
-            self.__pipes_initialized = True
-            self._pipe['control'] = DataPipe( address=find_ws_address( ), abort=self._abort_handler )
-            ###
-            ### One pipe for updating the convergence plots.
-            ###
-            self._clean['converge'] = { 'state': None }
-            self._clean['converge']['pipe'] = DataPipe( address=find_ws_address( ), abort=self._abort_handler )
-            self._clean['converge']['id'] = str(uuid4( ))
-
-
-
-            # Get port for serving HTTP server if running in script
-            self._http_port = find_ws_address("")[1]
-        for imid, imdetails in self._clean_targets.items( ):
-            imdetails['gui']['cube']._init_pipes( )
-
-    def _create_convergence_gui( self, imdetails, orient='horizontal', sizing_mode='stretch_width', **kw ):
-        TOOLTIPS='''<div>
-                        <div>
-                            <span style="font-weight: bold;">@type</span>
-                            <span>@values</span>
-                        </div>
-                        <div>
-                            <span style="font-weight: bold; font-size: 10px">cycle threshold</span>
-                            <span>@cyclethreshold</span>
-                        </div>
-                        <div>
-                            <span style="font-weight: bold; font-size: 10px">stop</span>
-                            <span>@stopDesc</span>
-                        </div>
-                    </div>'''
-
-        hover = HoverTool( tooltips=TOOLTIPS )
-        imdetails['gui']['convergence'] = figure( sizing_mode=sizing_mode, y_axis_location="right",
-                                                  tools=[ hover ], toolbar_location=None, **kw )
-
-        if orient == 'vertical':
-            imdetails['gui']['convergence'].yaxis.axis_label='Iteration (cycle threshold dotted red)'
-            imdetails['gui']['convergence'].xaxis.axis_label='Peak Residual'
-            imdetails['gui']['convergence'].extra_x_ranges = { 'residual_range': DataRange1d( follow='end' ),
-                                                               'flux_range': DataRange1d( follow='end' ) }
-
-            imdetails['gui']['convergence'].step( 'values', 'iterations', source=imdetails['converge-data']['cyclethreshold'],
-                                                  line_color='red', x_range_name='residual_range', line_dash='dotted', line_width=2 )
-            imdetails['gui']['convergence'].line(   'values', 'iterations',   source=imdetails['converge-data']['residual'],
-                                                    line_color=self._converge_color['residual'], x_range_name='residual_range' )
-            imdetails['gui']['convergence'].scatter( 'values', 'iterations',   source=imdetails['converge-data']['residual'],
-                                                     color=self._converge_color['residual'], x_range_name='residual_range',size=10 )
-            imdetails['gui']['convergence'].line(   'values', 'iterations', source=imdetails['converge-data']['flux'],
-                                                    line_color=self._converge_color['flux'], x_range_name='flux_range' )
-            imdetails['gui']['convergence'].scatter( 'values', 'iterations', source=imdetails['converge-data']['flux'],
-                                                     color=self._converge_color['flux'], x_range_name='flux_range', size=10 )
-
-            imdetails['gui']['convergence'].add_layout( LinearAxis( x_range_name='flux_range', axis_label='Total Flux',
-                                                        axis_line_color=self._converge_color['flux'],
-                                                        major_label_text_color=self._converge_color['flux'],
-                                                        axis_label_text_color=self._converge_color['flux'],
-                                                        major_tick_line_color=self._converge_color['flux'],
-                                                        minor_tick_line_color=self._converge_color['flux'] ), 'above')
-
-        else:
-            imdetails['gui']['convergence'].xaxis.axis_label='Iteration (cycle threshold dotted red)'
-            imdetails['gui']['convergence'].yaxis.axis_label='Peak Residual'
-            imdetails['gui']['convergence'].extra_y_ranges = { 'residual_range': DataRange1d( follow='end' ),
-                                                               'flux_range': DataRange1d( follow='end' ) }
-
-            imdetails['gui']['convergence'].step( 'iterations', 'values', source=imdetails['converge-data']['cyclethreshold'],
-                                                  line_color='red', y_range_name='residual_range', line_dash='dotted', line_width=2 )
-            imdetails['gui']['convergence'].line(   'iterations', 'values',   source=imdetails['converge-data']['residual'],
-                                                    line_color=self._converge_color['residual'], y_range_name='residual_range' )
-            imdetails['gui']['convergence'].scatter( 'iterations', 'values',   source=imdetails['converge-data']['residual'],
-                                                     color=self._converge_color['residual'], y_range_name='residual_range',size=10 )
-            imdetails['gui']['convergence'].line(   'iterations', 'values', source=imdetails['converge-data']['flux'],
-                                                    line_color=self._converge_color['flux'], y_range_name='flux_range' )
-            imdetails['gui']['convergence'].scatter( 'iterations', 'values', source=imdetails['converge-data']['flux'],
-                                                     color=self._converge_color['flux'], y_range_name='flux_range', size=10 )
-
-            imdetails['gui']['convergence'].add_layout( LinearAxis( y_range_name='flux_range', axis_label='Total Flux',
-                                                        axis_line_color=self._converge_color['flux'],
-                                                        major_label_text_color=self._converge_color['flux'],
-                                                        axis_label_text_color=self._converge_color['flux'],
-                                                        major_tick_line_color=self._converge_color['flux'],
-                                                        minor_tick_line_color=self._converge_color['flux'] ), 'right')
-
-
-    def _launch_gui( self ):
-        '''create and show GUI
-        '''
-        ###
-        ### Will contain the top level GUI
-        ###
-        self._fig = { }
-
-        ###
-        ### Python-side handler for events from the interactive clean control buttons
-        ###
-        async def clean_handler( msg, self=self ):
-            if msg['action'] == 'next' or msg['action'] == 'finish':
-
-                if 'mask' in msg['value']:
-                    ###
-                    ### >>HERE>> breadcrumbs must be specific to the field they are related to...
-                    ###
-                    if 'breadcrumbs' in msg['value'] and msg['value']['breadcrumbs'] is not None and msg['value']['breadcrumbs'] != self._last_mask_breadcrumbs:
-                        self._last_mask_breadcrumbs = msg['value']['breadcrumbs']
-                        mask_dir = "%s.mask" % self._imagename
-                        shutil.rmtree(mask_dir)
-                        new_mask = imdetails['gui']['cube'].jsmask_to_raw(msg['value']['mask'])
-                        self._mask_history.append(new_mask)
-
-                        msg['value']['mask'] = convert_masks(masks=new_mask, coord='pixel', cdesc=imdetails['gui']['cube'].coorddesc())
-
-                    else:
-                        ##### seemingly the mask path used to be spliced in?
-                        #msg['value']['mask'] = self._mask_path
-                        pass
-                else:
-                    ##### seemingly the mask path used to be spliced in?
-                    #msg['value']['mask'] = self._mask_path
-                    pass
-
-                ###
-                ### In the final implementation, there will only be one gclean object...
-                ###
-                convergence_state={ 'convergence': {}, 'cyclethreshold': {} }
-                err,errmsg = self._clean['gclean'].update( dict( **msg['value']['iteration'],
-                                                                 **msg['value']['automask'] ) )
-
-                iteration_limit = int(msg['value']['iteration']['niter'])
-                stopdesc, stopcode, majordone, majorleft, iterleft, self._convergence_data = await self._clean['gclean'].__anext__( )
-
-                clean_cmds = self._clean['gclean']._log( )
-
-                for key, value in self._convergence_data.items( ):
-
-                    if len(value['chan']) == 0 or stopcode[0] == -1:
-                        ### stopcode[0] == -1 indicates an error condition within gclean
-                        return dict( result='error', stopcode=stopcode, cmd=clean_cmds,
-                                     convergence=None, majordone=majordone,
-                                     majorleft=majorleft, iterleft=iterleft, stopdesc=stopdesc )
-
-                    convergence_state['convergence'][key] = value['chan']
-                    convergence_state['cyclethreshold'][key] = value['major']['cyclethreshold']
-
-                ### stopcode[0] != 0 indicates that some stopping criteria has been reached
-                ###               this will also catch errors as well as convergence
-                ###               (so 'converged' isn't quite right...)
-                self._clean['last-success'] = dict( result='converged' if stopcode[0] else 'update', stopcode=stopcode, cmd=clean_cmds,
-                                                   convergence=convergence_state['convergence'],
-                                                   iterdone=iteration_limit - iterleft, iterleft=iterleft,
-                                                   majordone=majordone, majorleft=majorleft, cyclethreshold=convergence_state['cyclethreshold'], stopdesc=stopdesc )
-                return self._clean['last-success']
-
-            elif msg['action'] == 'stop':
-                self.__stop( )
-                return dict( result='stopped', update=dict( ) )
-            elif msg['action'] == 'status':
-                return dict( result="ok", update=dict( ) )
-            else:
-                print( "got something else: '%s'" % msg['action'] )
-
-        ###
-        ### set up websockets which will be used for control and convergence updates
-        ###
-        self._init_pipes( )
-
-        ###
-        ### Setup id that will be used for messages from each button
-        ###
-        self._clean_ids = { }
-        for btn in "continue", 'finish', 'stop':
-            self._clean_ids[btn] = str(uuid4( ))
-            #print("%s: %s" % ( btn, self._clean_ids[btn] ) )
-            self._pipe['control'].register( self._clean_ids[btn], clean_handler )
-
-
-        ###
-        ### There is one set of tclean controls for all images/outlier/etc. because
-        ### in the final version gclean will handle the iterations for all fields...
-        ###
-        cwidth = 64
-        cheight = 40
-        self._control['iteration'] = { }
-        self._control['iteration']['continue'] = TipButton( max_width=cwidth, max_height=cheight, name='continue',
-                                                        icon=svg_icon(icon_name="iclean-continue", size=18),
-                                                        tooltip=Tooltip( content=HTML( '''Stop after <b>one major cycle</b> or when any stopping criteria is met.''' ), position='left') )
-        self._control['iteration']['finish'] = TipButton( max_width=cwidth, max_height=cheight, name='finish',
-                                                      icon=svg_icon(icon_name="iclean-finish", size=18),
-                                                      tooltip=Tooltip( content=HTML( '''<b>Continue</b> until some stopping criteria is met.''' ), position='left') )
-        self._control['iteration']['stop'] = TipButton( button_type="danger", max_width=cwidth, max_height=cheight, name='stop',
-                                                    icon=svg_icon(icon_name="iclean-stop", size=18),
-                                                    tooltip=Tooltip( content=HTML( '''<p>Clicking a <font color="red">red</font> stop button will cause this tab to close and control will return to Python.<p>Clicking an <font color="orange">orange</font> stop button will cause <tt>tclean</tt> to stop after the current major cycle.''' ), position='left' ) )
-
-        ###
-        ### The single SHARED help button will be supplied by the first CubeMask...
-        ###
-        help_button = None
-        ###
-        ### First status line will be reused...
-        ###
-        status_line = None
-
-        ###
-        ### Manage the widgets which are shared between tabs...
-        ###
-        icw = SharedWidgets( )
-        toolbars = [ ]
-        for imid, imdetails in self._clean_targets.items( ):
-            imdetails['gui']['stats'] = imdetails['gui']['cube'].statistics( )
-            imdetails['image-channels'] = imdetails['gui']['cube'].shape( )[3]
-
-            status_line = imdetails['gui']['stopcode'] = imdetails['gui']['cube'].status_text( "<p>initial residual image</p>" if imdetails['image-channels'] > 1 else "<p>initial <b>single-channel</b> residual image</p>", width=230, reuse=status_line )
-
-            ###
-            ### Retrieve convergence information
-            ###
-            def convergence_handler( msg, self=self, imid=imid ):
-                if msg['action'] == 'retrieve':
-                    return { 'result': self._clean['last-success'] }
-                else:
-                    return { 'result': None, 'error': 'unrecognized action' }
-
-            self._clean['converge']['pipe'].register( self._clean['converge']['id'], convergence_handler )
-
-            ###
-            ### Data source that will be used for updating the convergence plot
-            ###
-            stokes = 0
-            convergence = imdetails['converge']['chan'][0][stokes]
-            imdetails['converge-data'] = { }
-            imdetails['converge-data']['flux']     = ColumnDataSource( data=dict( values=convergence['modelFlux'], iterations=convergence['iterations'],
-                                                               cyclethreshold=convergence['cycleThresh'],
-                                                               stopDesc=list( map( ImagingDict.get_summaryminor_stopdesc, convergence['stopCode'] ) ),
-                                                               type=['flux'] * len(convergence['iterations']) ) )
-            imdetails['converge-data']['residual'] = ColumnDataSource( data=dict( values=convergence['peakRes'],   iterations=convergence['iterations'],
-                                                               cyclethreshold=convergence['cycleThresh'],
-                                                               stopDesc=list( map( ImagingDict.get_summaryminor_stopdesc, convergence['stopCode'] ) ),
-                                                               type=['residual'] * len(convergence['iterations'])) )
-            imdetails['converge-data']['cyclethreshold'] = ColumnDataSource( data=dict( values=convergence['cycleThresh'], iterations=convergence['iterations'] ) )
-
-
-            ###
-            ### help page for cube interactions
-            ###
-            if help_button is None:
-                help_button = imdetails['gui']['cube'].help( rows=[ '<tr><td><i><b>red</b> stop button</i></td><td>clicking the stop button (when red) will close the dialog and control to python</td></tr>',
-                                                                    '<tr><td><i><b>orange</b> stop button</i></td><td>clicking the stop button (when orange) will return control to the GUI after the currently executing tclean run completes</td></tr>' ], position='right' )
-
-            self._create_convergence_gui( imdetails, orient='horizontal', sizing_mode='stretch_height', width=self._conv_spect_plot_width )
-
-            imdetails['gui']['params']['iteration']['nmajor'] = icw.nmajor( title='nmajor', value="%s" % self._initial_clean_params['nmajor'], width=90 )
-            imdetails['gui']['params']['iteration']['niter'] = icw.niter( title='niter', value="%s" % self._initial_clean_params['niter'], width=90 )
-            imdetails['gui']['params']['iteration']['cycleniter'] = icw.cycleniter( title="cycleniter", value="%s" % self._initial_clean_params['cycleniter'], width=90 )
-            imdetails['gui']['params']['iteration']['threshold'] = icw.threshold( title="threshold", value="%s" % self._initial_clean_params['threshold'], width=90 )
-            imdetails['gui']['params']['iteration']['cyclefactor'] = icw.cyclefactor( value="%s" % self._initial_clean_params['cyclefactor'], title="cyclefactor", width=90 )
-            imdetails['gui']['params']['iteration']['gain'] = icw.gain( title='gain', value="%s" % self._initial_clean_params['gain'], width=90 )
-            imdetails['gui']['params']['iteration']['nsigma'] = icw.nsigma( title='nsigma', value="%s" % self._initial_clean_params['nsigma'], width=90 )
-
-            if imdetails['params']['am']['usemask'] == 'auto-multithresh':
-                ###
-                ### Currently automasking tab is only available when the user selects 'auto-multithresh'
-                ###
-                imdetails['gui']['params']['automask']['active'] = True
-                imdetails['gui']['params']['automask']['noisethreshold'] = icw.noisethreshold( title='noisethreshold', value="%s" % imdetails['params']['am']['noisethreshold'], margin=( 5, 25, 5, 5 ), width=90 )
-                imdetails['gui']['params']['automask']['sidelobethreshold'] = icw.sidelobethreshold( title='sidelobethreshold', value="%s" % imdetails['params']['am']['sidelobethreshold'], margin=( 5, 25, 5, 5 ), width=90 )
-                imdetails['gui']['params']['automask']['lownoisethreshold'] = icw.lownoisethreshold( title='lownoisethreshold', value="%s" % imdetails['params']['am']['lownoisethreshold'], margin=( 5, 25, 5, 5 ), width=90 )
-                imdetails['gui']['params']['automask']['minbeamfrac'] = icw.minbeamfrac( title='minbeamfrac', value="%s" % imdetails['params']['am']['minbeamfrac'], width=90 )
-                imdetails['gui']['params']['automask']['negativethreshold'] = icw.negativethreshold( title='negativethreshold', value="%s" % imdetails['params']['am']['negativethreshold'], margin=( 5, 25, 5, 5 ), width=90 )
-                imdetails['gui']['params']['automask']['dogrowprune'] = icw.dogrowprune( label='dogrowprune', active=imdetails['params']['am']['dogrowprune'], margin=( 15, 25, 5, 5 ) )
-                imdetails['gui']['params']['automask']['fastnoise'] = icw.fastnoise( label='fastnoise', active=imdetails['params']['am']['fastnoise'], margin=( 15, 25, 5, 5 ) )
-
-
-            imdetails['gui']['image']['src'] = imdetails['gui']['cube'].js_obj( )
-            imdetails['gui']['image']['fig'] = imdetails['gui']['cube'].image( grid=False, height_policy='max', width_policy='max',
-                                                                               channelcb=CustomJS( args=dict( img_state={ 'src': imdetails['gui']['image']['src'],
-                                                                                                                          'flux': imdetails['converge-data']['flux'],
-                                                                                                                          'residual': imdetails['converge-data']['residual'],
-                                                                                                                          'cyclethreshold': imdetails['converge-data']['cyclethreshold'] },
-                                                                                                              imid=imid,
-                                                                                                              ctrl={ 'converge': self._clean['converge'] },
-                                                                                                              stopdescmap=ImagingDict.get_summaryminor_stopdesc( ) ),
-                                                                                                   code=self._js['update-converge'] +
-                                                                                                        '''update_convergence_single( img_state, document._casa_convergence_data.convergence[imid] )''' ) )
-
-            ###
-            ### collect toolbars for syncing selection
-            ###
-            toolbars.append(imdetails['gui']['image']['fig'].toolbar)
-
-            ###
-            ### spectrum plot must be disabled during iteration due to "tap to change channel" functionality
-            ###
-            if imdetails['image-channels'] > 1:
-                imdetails['gui']['spectrum'] = imdetails['gui']['cube'].spectrum( orient='vertical', sizing_mode='stretch_height', width=self._conv_spect_plot_width )
-                imdetails['gui']['slider'] = imdetails['gui']['cube'].slider( show_value=False, title='', margin=(14,5,5,5), sizing_mode="scale_width" )
-                imdetails['gui']['goto'] = imdetails['gui']['cube'].goto( )
-            else:
-                imdetails['gui']['spectrum'] = None
-                imdetails['gui']['slider'] = None
-                imdetails['gui']['goto'] = None
-
-            imdetails['gui']['channel-ctrl'] = imdetails['gui']['cube'].channel_ctrl( )
-
-            imdetails['gui']['cursor-pixel-text'] = imdetails['gui']['cube'].pixel_tracking_text( margin=(-3, 5, 3, 30) )
-
-            self._image_bitmask_controls = imdetails['gui']['cube'].bitmask_ctrl( reuse=self._image_bitmask_controls, button_type='light' )
-
-            if imdetails['params']['am']['usemask'] == 'auto-multithresh':
-                imdetails['gui']['auto-masking-panel'] = [ TabPanel( child=column( row( Tip( imdetails['gui']['params']['automask']['noisethreshold'],
-                                                                                             tooltip=Tooltip( content=HTML( 'sets the signal-to-noise threshold above which significant emission is masked during the initial round of mask creation' ),
-                                                                                                              position='bottom' ) ),
-                                                                                        Tip( imdetails['gui']['params']['automask']['sidelobethreshold'],
-                                                                                             tooltip=Tooltip( content=HTML( 'sets a threshold based on the sidelobe level above which significant emission is masked during the initial round of mask creation' ),
-                                                                                                              position='bottom' ) ),
-                                                                                        Tip( imdetails['gui']['params']['automask']['minbeamfrac'],
-                                                                                             tooltip=Tooltip( content=HTML( 'sets the minimum size a region must be to be retained in the mask' ),
-                                                                                                              position='bottom' ) ) ),
-                                                                                   row( Tip( imdetails['gui']['params']['automask']['lownoisethreshold'],
-                                                                                             tooltip=Tooltip( content=HTML( 'sets the threshold into which the initial mask (which is determined by either noisethreshold or sidelobethreshold) is expanded in order to include low signal-to-noise regions in the mask' ),
-                                                                                                              position='bottom' ) ),
-                                                                                        Tip( imdetails['gui']['params']['automask']['negativethreshold'],
-                                                                                             tooltip=Tooltip( content=HTML( 'sets the signal-to-noise threshold for absorption features to be masked' ),
-                                                                                                              position='bottom' ) ) ),
-                                                                                   row( Tip( imdetails['gui']['params']['automask']['dogrowprune'],
-                                                                                             tooltip=Tooltip( content=HTML( 'allows you to turn off the pruning of the low signal-to-noise mask, which speeds up masking for images and cubes with complex low signal-to-noise emission' ),
-                                                                                                              position='bottom' ) ),
-                                                                                        Tip( imdetails['gui']['params']['automask']['fastnoise'],
-                                                                                             tooltip=Tooltip( content=HTML( 'When set to True, a simpler but faster noise calucation is used' ),
-                                                                                                              position='bottom' ) ) ) ),
-                                                                                   title='Automask' ) ]
-            else:
-                imdetails['gui']['auto-masking-panel'] = [ ]
-
-
-        ###
-        ### synchronize toolbar selections among figures
-        ###
-        if toolbars:
-            for tb in toolbars:
-                tb.js_on_change( 'active_changed',
-                                 ###
-                                 ### toolbars must filter out 'tb' to avoid circular references
-                                 ###
-                                 CustomJS( args=dict(toolbars=[t for t in toolbars if t.id != tb.id]),
-                                           code='''casalib.map( (gest,tool) => {
-                                                                    if ( tool.active ) {
-                                                                        // a tool which belongs to the toolbar that signaled a change
-                                                                        // is active for this gesture...
-                                                                        toolbars.forEach( (other_tb) => {
-                                                                            let new_active = other_tb.gestures[gest].tools.find(
-                                                                                                 (t) => t.name == tool.active.name )
-                                                                            if ( ! other_tb.gestures[gest].active ) {
-                                                                                if ( new_active ) {
-                                                                                    other_tb.gestures[gest].active = new_active
-                                                                                    new_active.active = true
-                                                                                }
-                                                                            } else if ( other_tb.gestures[gest].active.name != tool.active.name ) {
-                                                                                if ( new_active ) {
-                                                                                    other_tb.gestures[gest].active.active = false
-                                                                                    new_active.active = true
-                                                                                    other_tb.gestures[gest].active = new_active
-                                                                                }
-                                                                            }
-                                                                        } )
-                                                                    } else {
-                                                                        // a tool which belongs to the toolbar that signaled a change
-                                                                        // is NOT active for this gesture...
-                                                                        toolbars.forEach( (other_tb) => {
-                                                                            if ( other_tb.gestures[gest] && other_tb.gestures[gest].active ) {
-                                                                                other_tb.gestures[gest].active.active = false
-                                                                                other_tb.gestures[gest].active = null
-                                                                            }
-                                                                        } )
-                                                                    }
-                                                                }, cb_obj.gestures )''' ) )
+        self._args = {{forwDict}}
+        self._gclean = self._gclean_module.gclean( **self._args )
+        self._gclean_paths = self._gclean.image_products( )
+        #self._residual_path = self._residual_path(self._clean['gclean'],imid)
+        #self._mask_path = self._mask_path(self._clean['gclean'],imid)
 
-        ###
-        ### button to display the tclean log -- in the final implmentation, outliers and other multifield imaging should be handled by gclean
-        ###
-        self._log_button = TipButton( max_width=help_button.width, max_height=help_button.height, name='log',
-                                      icon=svg_icon(icon_name="bp-application-sm", size=25),
-                                      tooltip=Tooltip( content=HTML('''click here to see the <pre>tclean</pre> execution log'''), position="right" ),
-                                      margin=(-1, 0, -10, 0), button_type='light',
-                                      stylesheets=[ InlineStyleSheet( css='''.bk-btn { border: 0px solid #ccc;  padding: 0 var(--padding-vertical) var(--padding-horizontal); margin-top: 3px; }''' ) ] )
-
-        self._control['iteration']['cb'] = CustomJS( args=dict( images_state={ k: { 'status': v['gui']['stopcode'],
-                                                                                    'automask': v['gui']['params']['automask'],
-                                                                                    'iteration': v['gui']['params']['iteration'],
-                                                                                    'img': v['gui']['image']['fig'],
-                                                                                    'src': v['gui']['cube'].js_obj( ),
-                                                                                    'spectrum': v['gui']['spectrum'],
-                                                                                    'src': v['gui']['image']['src'],
-                                                                                    'flux': v['converge-data']['flux'],
-                                                                                    'cyclethreshold': v['converge-data']['cyclethreshold'],
-                                                                                    'residual': v['converge-data']['residual'],
-                                                                                    'navi': { 'slider': v['gui']['slider'],
-                                                                                              'goto': v['gui']['goto'],
-                                                                                              ## it doesn't seem like pixel tracking must be disabled
-                                                                                              ##'tracking': v['gui']['cursor-pixel-text'],
-                                                                                              'stokes': v['gui']['channel-ctrl'][1] } }
-                                                                               for k,v in self._clean_targets.items( ) },
-                                                                ctrl={ 'converge': self._clean['converge'] },
-                                                                clean_ctrl=self._control['iteration'],
-                                                                state=dict( mode='interactive', stopped=False, awaiting_stop=False, mask="" ),
-                                                                ctrl_pipe=self._pipe['control'],
-                                                                ids=self._clean_ids,
-                                                                logbutton=self._log_button,
-                                                                stopdescmap=ImagingDict.get_summaryminor_stopdesc( )
-                                                              ),
-                                                 code=self._js['update-converge'] + self._js['clean-refresh'] + self._js['clean-disable'] +
-                                                      self._js['clean-enable'] + self._js['clean-status-update'] +
-                                                      self._js['iter-gui-update'] + self._js['clean-wait'] +
-                                                      '''function invalid_niter( s ) {
-                                                             let v = parseInt( s )
-                                                             if ( v > 0 ) return ''
-                                                             if ( v == 0 ) return 'niter is zero'
-                                                             if ( v < 0 ) return 'niter cannot be negative'
-                                                             if ( isNaN(v) ) return 'niter must be an integer'
-                                                         }
-                                                         const itobj = Object.entries(images_state)[0][1].iteration
-                                                         if ( ! state.stopped && cb_obj.origin.name == 'finish' ) {
-                                                             let invalid = invalid_niter(itobj.niter.value)
-                                                             if ( invalid ) update_status( invalid )
-                                                             else {
-                                                                 state.mode = 'continuous'
-                                                                 update_status( 'Running multiple iterations' )
-                                                                 disable( false )
-                                                                 clean_ctrl.stop.button_type = "warning"
-                                                                 const thevalue = get_update_dictionary( )
-                                                                 ctrl_pipe.send( ids[cb_obj.origin.name],
-                                                                                 { action: 'finish',
-                                                                                   value: thevalue },
-                                                                                 update_gui )
-                                                             }
-                                                         }
-                                                         if ( ! state.stopped && state.mode === 'interactive' &&
-                                                              cb_obj.origin.name === 'continue' ) {
-                                                             let invalid = invalid_niter(itobj.niter.value)
-                                                             if ( invalid ) update_status( invalid )
-                                                             else {
-                                                                 update_status( 'Running one set of deconvolution iterations' )
-                                                                 disable( true )
-                                                                 // only send message for button that was pressed
-                                                                 // it's unclear whether 'this.origin.' or 'cb_obj.origin.' should be used
-                                                                 // (or even if 'XXX.origin.' is public)...
-                                                                 ctrl_pipe.send( ids[cb_obj.origin.name],
-                                                                                 { action: 'next',
-                                                                                   value: get_update_dictionary( ) },
-                                                                                 update_gui )
-                                                             }
-                                                         }
-                                                         if ( state.mode === 'interactive' && cb_obj.origin.name === 'stop' ) {
-                                                             if ( confirm( "Are you sure you want to end this interactive clean session and close the GUI?" ) ) {
-                                                                 disable( true )
-                                                                 //ctrl_pipe.send( ids[cb_obj.origin.name],
-                                                                 //                { action: 'stop',
-                                                                 //                  value: { } },
-                                                                 //                update_gui )
-                                                                 document._casa_window_closed = true
-                                                                 /*** this will close the tab >>>>---------+   ***/
-                                                                 /***                                      |   ***/
-                                                                 /***     vvvvv----------------------------+   ***/
-                                                                 document._cube_done( Object.entries(images_state).reduce((acc,[k,v]) => ({ ...acc, [k]: v.src.masks( ) }),{ } ) )
-                                                             }
-                                                         } else if ( state.mode === 'continuous' &&
-                                                                     cb_obj.origin.name === 'stop' &&
-                                                                     ! state.awaiting_stop ) {
-                                                             disable( true )
-                                                             state.awaiting_stop = true
-                                                             ctrl_pipe.send( ids[cb_obj.origin.name],
-                                                                             { action: 'status',
-                                                                               value: { } },
-                                                                             wait_for_tclean_stop )
-                                                         }''' )
-
-
-        self._control['iteration']['continue'].js_on_click( self._control['iteration']['cb'] )
-        self._control['iteration']['finish'].js_on_click( self._control['iteration']['cb'] )
-        self._control['iteration']['stop'].js_on_click( self._control['iteration']['cb'] )
-
-        self._log_button.js_on_click( CustomJS( args=dict( logbutton=self._log_button ),
-                                                code='''function format_log( elem ) {
-                                                             return `<html>
-                                                                     <head>
-                                                                         <style type="text/css">
-                                                                             body {
-                                                                                 counter-reset: section;
-                                                                             }
-                                                                             p:not([no-num]):before {
-                                                                                 font-weight: bold;
-                                                                                 counter-increment: section;
-                                                                                 content: "" counter(section) ": ";
-                                                                             }
-                                                                         </style>
-                                                                     </head>
-                                                                     <body>
-                                                                         <h1>Interactive Clean History</h1>
-                                                                     ` + elem.map((x) => x.startsWith('#') ? `<p no-num>${x}</p>` : `<p>${x}</p>`).join('\\n') + '</body>\\n</html>'
-                                                         }
-                                                         let b = cb_obj.origin
-                                                         if ( ! b._window || b._window.closed ) {
-                                                             b._window = window.open("about:blank","Interactive Clean Log")
-                                                             b._window.document.write(format_log(b._log))
-                                                             b._window.document.close( )
-                                                         }''' ) )
-
-        ###
-        ### Setup script that will be called when the user closes the
-        ### browser tab that is running interactive clean
-        ###
-        initial_log = self._clean['gclean']._log( )
-
-        self._pipe['control'].init_script=CustomJS( args=dict( ctrl_pipe=self._pipe['control'],
-                                                               ids=self._clean_ids,
-                                                               logbutton=self._log_button,
-                                                               log=initial_log,
-                                                               initial_image=list(self._clean_targets.items( ))[0][0]
-                                                             ),
-                                                      code=self._js['initialize'] +
-                                                           '''if ( ! logbutton._log ) {
-                                                                  /*** store log list with log button for access in other callbacks ***/
-                                                                  logbutton._log = log
-                                                              }''' )
-
-        tab_panels = list( map( self._create_image_panel, self._clean_targets.items( ) ) )
-
-        for imid, imdetails in self._clean_targets.items( ):
-            imdetails['gui']['cube'].connect( )
+        self._ui = InteractiveCleanUI(self._gclean, self._args)
 
-        image_tabs = Tabs( tabs=tab_panels, tabs_location='below', height_policy='max', width_policy='max' )
-
-        self._fig['layout'] = column(
-                                  row( help_button,
-                                       self._log_button,
-                                       Spacer( height=self._control['iteration']['stop'].height, sizing_mode="scale_width" ),
-                                       Div( text="<div><b>status:</b></div>" ),
-                                       status_line,
-                                       self._control['iteration']['stop'], self._control['iteration']['continue'], self._control['iteration']['finish'], sizing_mode="scale_width" ),
-                                  row( image_tabs, height_policy='max', width_policy='max' ),
-                                  height_policy='max', width_policy='max' )
-
-        ###
-        ### Keep track of which image is currently active in document._casa_image_name (which is
-        ### initialized in self._js['initialize']). Also, update the current control sub-tab
-        ### when the field main-tab is changed. An attempt to manage this all within the
-        ### control sub-tabs using a reference to self._image_control_tab_groups from
-        ### each control sub-tab failed with:
-        ###
-        ###     bokeh.core.serialization.SerializationError: circular reference
-        ###
-        image_tabs.js_on_change( 'active', CustomJS( args=dict( names=[ t[0] for t in self._clean_targets.items( ) ],
-                                                                itergroups=self._image_control_tab_groups ),
-                                                     code='''if ( ! hasprop(document,'_casa_last_control_tab') ) {
-                                                                 document._casa_last_control_tab = 0
-                                                             }
-                                                             document._casa_image_name = names[cb_obj.active]
-                                                             itergroups[document._casa_image_name].active = document._casa_last_control_tab''' ) )
-
-        # Change display type depending on runtime environment
-        if self._is_notebook:
-            output_notebook()
-        else:
-            ### Directory is created when an HTTP server is running
-            ### (MAX)
-###         output_file(self._imagename+'_webpage/index.html')
-            pass
-
-        show(self._fig['layout'])
-
-    def _create_colormap_adjust( self, imdetails ):
-        palette = imdetails['gui']['cube'].palette( reuse=self._cube_palette )
-        return column( row( Div(text="<div><b>Colormap:</b></div>",margin=(5,2,5,25)), palette ),
-                       imdetails['gui']['cube'].colormap_adjust( ), sizing_mode='stretch_both' )
-
-
-    def _create_control_image_tab( self, imid, imdetails ):
-        result = Tabs( tabs=[ TabPanel(child=column( row( Tip( imdetails['gui']['params']['iteration']['nmajor'],
-                                                             tooltip=Tooltip( content=HTML( 'maximum number of major cycles to run before stopping'),
-                                                                              position='bottom' ) ),
-                                                        Tip( imdetails['gui']['params']['iteration']['niter'],
-                                                             tooltip=Tooltip( content=HTML( 'number of clean iterations to run' ),
-                                                                              position='bottom' ) ),
-                                                        Tip( imdetails['gui']['params']['iteration']['threshold'],
-                                                             tooltip=Tooltip( content=HTML( 'stopping threshold' ),
-                                                                              position='bottom' ) ) ),
-                                                   row( Tip( imdetails['gui']['params']['iteration']['nsigma'],
-                                                             tooltip=Tooltip( content=HTML( 'multiplicative factor for rms-based threshold stopping'),
-                                                                              position='bottom' ) ),
-                                                        Tip( imdetails['gui']['params']['iteration']['gain'],
-                                                             tooltip=Tooltip( content=HTML( 'fraction of the source flux to subtract out of the residual image'),
-                                                                              position='bottom' ) ) ),
-                                                   row( Tip( imdetails['gui']['params']['iteration']['cycleniter'],
-                                                             tooltip=Tooltip( content=HTML( 'maximum number of <b>minor-cycle</b> iterations' ),
-                                                                              position='bottom' ) ),
-                                                        Tip( imdetails['gui']['params']['iteration']['cyclefactor'],
-                                                             tooltip=Tooltip( content=HTML( 'scaling on PSF sidelobe level to compute the minor-cycle stopping threshold' ),
-                                                                              position='bottom_left' ) ), background="lightgray" ),
-                                                   imdetails['gui']['convergence'], sizing_mode='stretch_height' ),
-                                     title='Iteration' ) ] +
-                          ( [ TabPanel( child=imdetails['gui']['spectrum'],
-                                        title='Spectrum' ) ] if imdetails['image-channels'] > 1 else [ ] ) +
-                          [ TabPanel( child=self._create_colormap_adjust(imdetails),
-                                      title='Colormap' ),
-                            TabPanel( child=column( *imdetails['gui']['stats'] ),
-                                      title='Statistics' ) ] + imdetails['gui']['auto-masking-panel'],
-                     width=500, sizing_mode='stretch_height', tabs_location='below' )
-
-        if not hasattr(self,'_image_control_tab_groups'):
-            self._image_control_tab_groups = { }
-
-        self._image_control_tab_groups[imid] = result
-        result.js_on_change( 'active', CustomJS( args=dict( ),
-                                                 code='''document._casa_last_control_tab = cb_obj.active''' ) )
-        return result
-
-    def _create_image_panel( self, imagetuple ):
-        imid, imdetails = imagetuple
-
-
-
-        return TabPanel( child=column( row( *imdetails['gui']['channel-ctrl'], imdetails['gui']['cube'].coord_ctrl( ),
-                                            *self._image_bitmask_controls,
-                                            #Spacer( height=5, height_policy="fixed", sizing_mode="scale_width" ),
-                                            imdetails['gui']['cursor-pixel-text'],
-                                            row( Spacer( sizing_mode='stretch_width' ),
-                                                 imdetails['gui']['cube'].tapedeck( size='20px' ) if imdetails['image-channels'] > 1 else Div( ),
-                                                 Spacer( height=5, width=350 ), width_policy='max' ),
-                                            width_policy='max' ),
-                                       row( imdetails['gui']['image']['fig'],
-                                            column( row( imdetails['gui']['goto'],
-                                                         imdetails['gui']['slider'],
-                                                         width_policy='max' ) if imdetails['image-channels'] > 1 else Div( ),
-                                                    self._create_control_image_tab(imid, imdetails), height_policy='max' ),
-                                            height_policy='max', width_policy='max' ),
-                                       height_policy='max', width_policy='max' ), title=imid )
 
     def __call__( self ):
         '''Display GUI and process events until the user stops the application.
@@ -998,510 +84,6 @@ class InteractiveClean:
                                cell='12.0arcsec', specmode='cube',
                                interpolation='nearest', ... )( ) )
         '''
-
-        self._setup()
-
-        # If Interactive Clean is being run remotely, print helper info for port tunneling
-        if self._is_remote:
-            # Tunnel ports for Jupyter kernel connection
-            print("\nImportant: Copy the following line and run in your local terminal to establish port forwarding.\
-                You may need to change the last argument to align with your ssh config.\n")
-            print(self._gen_port_fwd_cmd())
-
-            # TODO: Include?
-            # VSCode will auto-forward ports that appear in well-formatted addresses.
-            # Printing this line will cause VSCode to autoforward the ports
-            # print("Cmd: " + str(repr(self.auto_fwd_ports_vscode())))
-            input("\nPress enter when port forwarding is setup...")
-
-        async def _run_( ):
-            async with self.serve( ) as s:
-                await s
-
-        if self._is_notebook:
-            ic_task = asyncio.create_task(_run_())
-        else:
-            asyncio.run(_run_( ))
-            return self.result( )
-
-    def _setup( self ):
-        self.__reset( )
-
-        def initialize_tclean( gclean ):
-
-            stopdesc, stopcode, majordone, majorleft, iterleft, all_converge = next(gclean)
-
-            for imid, converge  in all_converge.items( ):
-                #######################################################################################################
-                ### gclean seems to return its internal state making it succeptable to modification... so we'll at  ###
-                ### least start out with unique dictionaries.                                                       ###
-                #######################################################################################################
-                converge = copy.deepcopy(converge)
-
-                imdetails = self._clean_targets[imid]
-                imdetails['converge'] = converge
-
-                if imdetails['converge'] is None or len(imdetails['converge'].keys()) == 0 or \
-                    imdetails['converge']['major'] is None or imdetails['converge']['chan'] is None:
-                    ###
-                    ### gclean should provide argument checking (https://github.com/casangi/casagui/issues/33)
-                    ### but currently gclean can be initialized with bad arguments and it is not known until
-                    ### the initial calls to tclean/deconvolve
-                    ###
-                    raise RuntimeError(f'''gclean failure "%s" not returned: {imdetails["converge"]}''' % ('major' if imdetails['converge']['major'] is None else 'chan'))
-
-            self._clean['cmds'].extend(self._clean['gclean']._log( ))
-
-            self._initial_clean_params['nmajor'] = majorleft
-            self._initial_clean_params['niter'] = iterleft
-            self._initial_clean_params['cycleniter'] = self._init_values["cycleniter"]
-            self._initial_clean_params['threshold'] = self._init_values["threshold"]
-            self._initial_clean_params['cyclefactor'] = self._init_values["cyclefactor"]
-            self._initial_clean_params['gain'] = self._init_values["gain"]
-            self._initial_clean_params['nsigma'] = self._init_values["nsigma"]
-
-            self._init_values["convergence_state"]['convergence'][imid] = imdetails['converge']['chan']
-            self._init_values["convergence_state"]['cyclethreshold'][imid] = imdetails['converge']['major']['cyclethreshold']
-
-            return (stopdesc, stopcode, majordone, majorleft, iterleft)
-
-
-        self._clean['cmds'] = []
-
-        stopdesc, stopcode, majordone, majorleft, iterleft = initialize_tclean(self._clean['gclean'])
-
-
-        self._clean['last-success'] = dict( result='converged' if stopcode[0] else 'update', stopcode=stopcode, cmd=self._clean['cmds'],
-                                            convergence=self._init_values["convergence_state"]['convergence'],
-                                            iterdone=0, iterleft=iterleft,
-                                            majordone=majordone, majorleft=majorleft,
-                                            cyclethreshold=self._init_values["convergence_state"]['cyclethreshold'],
-                                            stopdesc=stopdesc )
-
-        ### Must occur AFTER initial "next" call to gclean(s)
-        self._init_pipes()
-
-    @asynccontextmanager
-    async def serve( self ):
-        '''This function is intended for developers who would like to embed interactive
-        clean as a part of a larger GUI. This embedded use of interactive clean is not
-        currently supported and would require the addition of parameters to this function
-        as well as changes to the interactive clean implementation. However, this function
-        does expose the ``asyncio.Future`` that is used to signal completion of the
-        interactive cleaning operation, and it provides the coroutines which must be
-        managed by asyncio to make the interactive clean GUI responsive.
-
-        Example:
-            Create ``iclean`` object, process events and retrieve result::
-
-                ic = iclean( vis='refim_point_withline.ms', imagename='test', imsize=512,
-                             cell='12.0arcsec', specmode='cube', interpolation='nearest', ... )
-                async def process_events( ):
-                    async with ic.serve( ) as state:
-                        await state[0]
-
-                asyncio.run(process_events( ))
-                print( "Result:", ic.result( ) )
-
-
-        Returns
-        -------
-        (asyncio.Future, dictionary of coroutines)
-        '''
-        def start_http_server():
-            import http.server
-            import socketserver
-            PORT = self._http_port
-            DIRECTORY=self._webpage_path
-
-            class Handler(http.server.SimpleHTTPRequestHandler):
-                def __init__(self, *args, **kwargs):
-                    super().__init__(*args, directory=DIRECTORY, **kwargs)
-
-            with socketserver.TCPServer(("", PORT), Handler) as httpd:
-                print("\nServing Interactive Clean webpage from local directory: ", DIRECTORY)
-                print("Use Control-C to stop Interactive clean.\n")
-                print("Copy and paste one of the below URLs into your browser (Chrome or Firefox) to view:")
-                print("http://localhost:"+str(PORT))
-                print("http://127.0.0.1:"+str(PORT))
-
-                httpd.serve_forever()
-
-        self._launch_gui( )
-
-        async with CMC( *( [ ctx for img in self._clean_targets.keys( ) for ctx in
-                             [
-                                 self._clean_targets[img]['gui']['cube'].serve(self.__stop),
-                             ]
-                           ] + [ websockets.serve( self._pipe['control'].process_messages,
-                                                   self._pipe['control'].address[0],
-                                                   self._pipe['control'].address[1] ),
-                                 websockets.serve( self._clean['converge']['pipe'].process_messages,
-                                                   self._clean['converge']['pipe'].address[0],
-                                                   self._clean['converge']['pipe'].address[1] ) ]
-                          ) ):
-            self.__result_future = asyncio.Future( )
-            yield self.__result_future
-
-    def __retrieve_result( self ):
-        '''If InteractiveClean had a return value, it would be filled in as part of the
-        GUI dialog between Python and JavaScript and this function would return it'''
-        if isinstance(self._error_result,Exception):
-            raise self._error_result
-        elif self._error_result is not None:
-            return self._error_result
-        return { k: v['converge'] for k,v in self._clean_targets.items( ) }
-
-    def result( self ):
-        '''If InteractiveClean had a return value, it would be filled in as part of the
-        GUI dialog between Python and JavaScript and this function would return it'''
-        if self.__result_future is None:
-            raise RuntimeError( 'no interactive clean result is available' )
-
-        if self.__result is None:
-            ### restore returns full return dictionary
-            self.__result_from_gui = self.__result_future.result( )
-            self.__result = self._clean['gclean'].restore( )
-
-        return self.__result
-
-    def masks( self ):
-        '''Retrieves the masks which were used with interactive clean.
-
-        Returns
-        -------
-        The standard ``cubevis`` cube region dictionary which contains two elements
-        ``masks`` and ``polys``.
-
-        The value of the ``masks`` element is a dictionary that is indexed by
-        tuples of ``(stokes,chan)`` and the value of each element is a list
-        whose elements describe the polygons drawn on the channel represented
-        by ``(stokes,chan)``. Each polygon description in this list has a
-        polygon index (``p``) and a x/y translation (``d``).
-
-        The value of the ``polys`` element is a dictionary that is indexed by
-        polygon indexes. The value of each polygon index is a dictionary containing
-        ``type`` (whose value is either ``'rect'`` or ``'poly``) and ``geometry``
-        (whose value is a dictionary containing ``'xs'`` and ``'ys'`` (which are
-        the x and y coordinates that define the polygon).
-
-        This can be converted to other formats with ``cubevis.utils.convert_masks``.
-        '''
-        return copy.deepcopy(self._mask_history)    ## don't allow users to change history
-
-    def history( self ):
-        '''Retrieves the commands used during the interactive clean session.
-
-        Returns
-        -------
-        list[str]  tclean calls made during the interactive clean session.
-        '''
-        return self._clean['gclean']._log( True )
-
-    def _initialize_javascript( self ):
-        self._js = { ### initialize state
-                     ### --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-                     ### -- document is used storing state                                                        --
-                     ### --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-                     'initialize':      '''if ( ! document._casa_initialized ) {
-                                               document._casa_image_name = initial_image
-                                               document._casa_initialized = true
-                                               document._casa_window_closed = false
-                                               window.addEventListener( 'beforeunload',
-                                                                        function (e) {
-                                                                            // if the window is already closed this message is never
-                                                                            // delivered (unless interactive clean is called again then
-                                                                            // the event shows up in the newly created control pipe
-                                                                            if ( document._casa_window_closed == false ) {
-                                                                                ctrl_pipe.send( ids['stop'],
-                                                                                                { action: 'stop', value: { } },
-                                                                                                  undefined ) } } )
-                                           }''',
-
-                     ### --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-                     ### -- flux_src._convergence_data is used to store the complete                              --
-                     ### --                                                                                       --
-                     ### -- The "Insert here ..." code seems to be called when when the stokes plane is changed   --
-                     ### -- but there have been no tclean iterations yet...                                       --
-                     ### --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
-                     'update-converge': '''function update_convergence_single( target, data ) {
-                                               const pos = target.src.cur_chan
-                                               const imdata = data.get(pos[1]).get(pos[0])
-                                               //  chan----------------^^^^^^      ^^^^^^----stokes
-                                               const iterations = imdata.iterations
-                                               const peakRes = imdata.peakRes
-                                               const cyclethreshold = imdata.cycleThresh
-                                               const modelFlux = imdata.modelFlux
-                                               const stopCode = imdata.stopCode
-                                               const stopDesc = imdata.stopCode.map( code => stopdescmap.has(code) ? stopdescmap.get(code): "" )
-                                               target.residual.data = { iterations, cyclethreshold, stopDesc, values: peakRes, type: Array(iterations.length).fill('residual') }
-                                               target.flux.data = { iterations, cyclethreshold, stopDesc, values: modelFlux, type: Array(iterations.length).fill('flux') }
-                                               target.cyclethreshold.data = { iterations, values: cyclethreshold }
-                                           }
-
-                                           function update_convergence( recurse=false ) {
-                                               let convdata
-                                               if ( hasprop(document,'_casa_convergence_data') ) {
-                                                   convdata = document._casa_convergence_data
-                                               } else {
-                                                   if ( ! recurse ) {
-                                                       ctrl.converge.pipe.send( ctrl.converge.id, { action: 'retrieve' },
-                                                                                (msg) => { if ( hasprop( msg.result, 'convergence' ) ) {
-                                                                                               document._casa_convergence_data = { convergence: msg.result.convergence,
-                                                                                                                                   cyclethreshold: msg.result.cyclethreshold }
-                                                                                               update_convergence(true)
-                                                                                           } } )
-                                                   } else { console.log( 'INTERNAL ERROR: fetching convergence data failed' ) }
-                                                   return
-                                               }
-
-                                               Object.entries(images_state).map(
-                                                   ([k,v],i) => { update_convergence_single(v,convdata.convergence[k]) } )
-                                           }''',
-
-                     'clean-refresh':   '''function refresh( clean_msg ) {
-                                               const itobj = Object.entries(images_state)[0][1].iteration
-                                               let stokes = 0    // later we will receive the polarity
-                                                                 // from some widget mechanism...
-                                               if ( clean_msg !== undefined ) {
-                                                   if ( 'iterleft' in clean_msg ) {
-                                                       itobj.niter.value = '' + clean_msg['iterleft']
-                                                   } else if ( clean_msg !== undefined && 'iterdone' in clean_msg ) {
-                                                       const remaining = parseInt(itobj.niter.value) - parseInt(clean_msg['iterdone'])
-                                                       itobj.niter.value = '' + (remaining < 0 ? 0 : remaining)
-                                                   }
-
-                                                   if ( 'majorleft' in clean_msg ) {
-                                                       itobj.nmajor.value = '' + clean_msg['majorleft']
-                                                   } else if ( 'majordone' in clean_msg ) {
-                                                       const nm = parseInt(itobj.nmajor.value)
-                                                       if ( nm != -1 ) {
-                                                           const remaining = nm - parseInt(clean_msg['majordone'])
-                                                           itobj.nmajor.value = '' + (remaining < 0 ? 0 : remaining)
-                                                       } else itobj.nmajor.value = '' + nm          // nmajor == -1 implies do not consider nmajor in stop decision
-                                                   }
-
-                                                   if ( hasprop(clean_msg,'convergence') && clean_msg.convergence != null ) {
-                                                       document._casa_convergence_data = { convergence: clean_msg.convergence,
-                                                                                           cyclethreshold: clean_msg.cyclethreshold }
-                                                   }
-                                               }
-
-                                               // All images must be updated... without this no images are updated
-                                               casalib.map( (im,state) => state.src.refresh( msg => {
-                                                   if ( 'stats' in msg ) state.src.update_statistics( msg.stats )
-                                               } ), images_state )
-                                               // Update convergence plot...
-                                               update_convergence( )
-                                           }''',
-
-                       ###
-                       ### enabling/disabling tools in imdetails['gui']['image']['fig'].toolbar.tools does not seem to not work
-                       ###     imdetails['gui']['image']['fig'].toolbar.tools.tool_name (e.g. "Box Select", "Lasso Select")
-                       ###
-                       ### By design, images_state[*].automask.*/images_state[*].iteration.* are singletons which only need
-                       ### to be disabled once...
-                       ###
-                       'clean-disable': '''function disable( with_stop ) {
-                                               const amobj = Object.entries(images_state)[0][1].automask
-                                               Object.entries(amobj).map(
-                                                   ([k,v],i) => { if ( hasprop(v,'disabled') ) v.disabled = true } )
-                                               const itobj = Object.entries(images_state)[0][1].iteration
-                                               Object.entries(itobj).map(
-                                                   ([k,v],i) => { if ( hasprop(v,'disabled') ) v.disabled = true } )
-                                               Object.entries(images_state).map(
-                                                   ([k,v],i) => {
-                                                       v.img.disabled = true
-                                                       if ( v.spectrum ) v.spectrum.disabled = true
-                                                       v.src.disable_masking( )
-                                                       v.src.disable_pixel_update( )
-                                                       Object.entries(v.navi).map(
-                                                           ([k1,v1],i1) => { if ( hasprop(v1,'disabled') ) v1.disabled = true }
-                                                       )
-                                                   }
-                                               )
-                                               clean_ctrl.continue.disabled = true
-                                               clean_ctrl.finish.disabled = true
-                                               clean_ctrl.stop.disabled = with_stop
-                                           }''',
-
-                       'clean-enable':  '''function enable( only_stop ) {
-                                               const amobj = Object.entries(images_state)[0][1].automask
-                                               Object.entries(amobj).map(
-                                                   ([k,v],i) => { if ( hasprop(v,'disabled') ) v.disabled = false } )
-                                               const itobj = Object.entries(images_state)[0][1].iteration
-                                               Object.entries(itobj).map(
-                                                   ([k,v],i) => { if ( hasprop(v,'disabled') ) v.disabled = false } )
-                                               Object.entries(images_state).map(
-                                                   ([k,v],i) => {
-                                                       v.img.disabled = false
-                                                       if ( v.spectrum ) v.spectrum.disabled = false
-                                                       v.src.enable_masking( )
-                                                       v.src.enable_pixel_update( )
-                                                       Object.entries(v.navi).map(
-                                                           ([k1,v1],i) => { if ( hasprop(v1,'disabled') ) v1.disabled = false } )
-                                                   } )
-
-                                               clean_ctrl.stop.disabled = false
-                                               if ( ! only_stop ) {
-                                                   clean_ctrl.continue.disabled = false
-                                                   clean_ctrl.finish.disabled = false
-                                               }
-                                           }''',
-
-
-                       'clean-status-update': '''function update_status( status ) {
-                                               const stopstr = [ 'Zero stop code',
-                                                                 'Iteration limit hit',
-                                                                 'Force stop',
-                                                                 'No change in peak residual across two major cycles',
-                                                                 'Peak residual increased by 3x from last major cycle',
-                                                                 'Peak residual increased by 3x from the minimum',
-                                                                 'Zero mask found',
-                                                                 'No mask found',
-                                                                 'N-sigma or other valid exit criterion',
-                                                                 'Stopping criteria encountered',
-                                                                 'Unrecognized stop code' ]
-                                               if ( typeof status === 'number' ) {
-                                                   images_state[document._casa_image_name]['status'].text =
-                                                       '<p>' +
-                                                       stopstr[ status < 0 || status >= stopstr.length ?
-                                                                stopstr.length - 1 : status ] +
-                                                       '</p>'
-                                               } else {
-                                                   images_state[document._casa_image_name]['status'].text = `<p>${status}</p>`
-                                               }
-                                           }''',
-
-                       'iter-gui-update': '''function get_update_dictionary( ) {
-                                                  //const amste = images_state[document._casa_image_name]['automask']
-                                                  //const clste = images_state[document._casa_image_name]['iteration']
-                                                  // Assumption is that there is ONE set of iteration and automask updates
-                                                  // for ALL imaging fields...
-                                                  const amobj = Object.entries(images_state)[0][1].automask
-                                                  const automask = amobj.active ?
-                                                                   Object.entries(amobj).reduce(
-                                                                       (acc,[k1,v1]) => { if ( hasprop(v1,'value') ) acc[k1] = v1.value; return acc },
-                                                                       { dogrowprune: amobj.dogrowprune.active,
-                                                                         fastnoise: amobj.fastnoise.active,
-                                                                         active: true }
-                                                                   ) : { }
-                                                  const itobj = Object.entries(images_state)[0][1].iteration
-                                                  const iteration = Object.entries(itobj).reduce(
-                                                                        (acc,[k1,v1]) => { if ( hasprop(v1,'value') ) acc[k1] = v1.value; return acc },
-                                                                        { }
-                                                                    )
-
-                                                  const masks = Object.entries(images_state).reduce( (acc,[k,v]) => { acc[k] = v.src.masks( ); return acc }, { } )
-                                                  const breadcrumbs = Object.entries(images_state).reduce( (acc,[k,v]) => { acc[k] = v.src.breadcrumbs( ); return acc }, { } )
-                                                  return { iteration, automask, masks, breadcrumbs, current_image: document._casa_image_name }
-                                           }
-                                           function update_log( log_lines ) {
-                                               let b = logbutton
-                                               b._log = b._log.concat( log_lines )
-                                               if ( b._window && ! b._window.closed ) {
-                                                   for ( const line of log_lines ) {
-                                                       const p = b._window.document.createElement('p')
-                                                       p.appendChild( b._window.document.createTextNode(line) )
-                                                       b._window.document.body.appendChild(p)
-                                                   }
-                                               }
-                                           }
-                                           function update_gui( msg ) {
-                                               const itobj = Object.entries(images_state)[0][1].iteration
-                                               if ( msg.result === 'error' ) {
-                                                   // ************************************************************************************
-                                                   // ******** error occurs and is signaled by _gclean, e.g. exception in gclean  ********
-                                                   // ************************************************************************************
-                                                   state.mode = 'interactive'
-                                                   clean_ctrl.stop.button_type = "danger"
-                                                   enable(false)
-                                                   state.stopped = false
-                                                   update_status( msg.stopdesc ? msg.stopdesc : 'An internal error has occurred' )
-                                                   if ( 'cmd' in msg ) {
-                                                       update_log( msg.cmd )
-                                                   }
-                                               } else if ( msg.result === 'no-action' ) {
-                                                   update_status( msg.stopdesc ? msg.stopdesc : 'nothing done' )
-                                                   enable( false )
-                                                   if ( 'cmd' in msg ) {
-                                                       update_log( msg.cmd )
-                                                   }
-                                               } else if ( msg.result == 'converged' ) {
-                                                   state.mode = 'interactive'
-                                                   clean_ctrl.stop.button_type = "danger"
-                                                   enable(false)
-                                                   state.stopped = false
-                                                   update_status( msg.stopdesc ? msg.stopdesc : 'stopping criteria reached' )
-                                                   if ( 'cmd' in msg ) {
-                                                       update_log( msg.cmd )
-                                                   }
-                                                   refresh( msg )
-                                               } else if ( msg.result === 'update' ) {
-                                                   if ( 'cmd' in msg ) {
-                                                       update_log( msg.cmd )
-                                                   }
-                                                   refresh( msg )
-                                                   // stopcode[0] == 1: iteration limit hit
-                                                   // stopcode[0] == 9: major cycle limit hit
-                                                   // *******************************************************************************************
-                                                   // ******** perhaps the user should not be locked into exiting after the limit is hit ********
-                                                   // *******************************************************************************************
-                                                   //state.stopped = state.stopped || (msg.stopcode[0] > 1 && msg.stopcode[0] < 9) || msg.stopcode[0] == 0
-                                                   state.stopped = false
-                                                   if ( state.mode === 'interactive' && ! state.awaiting_stop ) {
-                                                       clean_ctrl.stop.button_type = "danger"
-                                                       update_status( msg.stopdesc ? msg.stopdesc : 'stopcode' in msg ? msg.stopcode[0] : -1 )
-                                                       if ( ! state.stopped ) {
-                                                           enable( false )
-                                                       } else {
-                                                           disable( false )
-                                                       }
-                                                   } else if ( state.mode === 'continuous' && ! state.awaiting_stop ) {
-                                                       if ( ! state.stopped && itobj.niter.value > 0 && (itobj.nmajor.value > 0 || itobj.nmajor.value == -1) ) {
-                                                           // *******************************************************************************************
-                                                           // ******** 'niter.value > 0 so continue with one more iteration                      ********
-                                                           // ******** 'nmajor.value' == -1 implies do not consider nmajor in stop consideration ********
-                                                           // *******************************************************************************************
-                                                           ctrl_pipe.send( ids[cb_obj.origin.name],
-                                                                           { action: 'finish',
-                                                                             value: get_update_dictionary( ) },
-                                                                           update_gui )
-                                                       } else if ( ! state.stopped  ) {
-                                                           // *******************************************************************************************
-                                                           // ******** 'niter.value <= 0 so iteration should stop                                ********
-                                                           // *******************************************************************************************
-                                                           state.mode = 'interactive'
-                                                           clean_ctrl.stop.button_type = "danger"
-                                                           enable(false)
-                                                           state.stopped = false
-                                                           update_status( msg.stopdesc ? msg.stopdesc : 'stopping criteria reached' )
-                                                       } else {
-                                                           state.mode = 'interactive'
-                                                           clean_ctrl.stop.button_type = "danger"
-                                                           enable(false)
-                                                           state.stopped = false
-                                                           update_status( msg.stopdesc ? msg.stopdesc : 'stopcode' in msg ? msg.stopcode[0] : -1 )
-                                                       }
-                                                   }
-                                               } else if ( msg.result === 'error' ) {
-                                                   img_src.drop_breadcrumb('E')
-                                                   if ( 'cmd' in msg ) {
-                                                       update_log( msg.cmd )
-                                                   }
-                                                   state.mode = 'interactive'
-                                                   clean_ctrl.stop.button_type = "danger"
-                                                   state.stopped = false
-                                                   update_status( 'stopcode' in msg ? msg.stopcode[0] : -1 )
-                                                   enable( false )
-                                               }
-                                           }''',
-
-                       'clean-wait':    '''function wait_for_tclean_stop( msg ) {
-                                               state.mode = 'interactive'
-                                               clean_ctrl.stop.button_type = "danger"
-                                               enable( false )
-                                               state.awaiting_stop = false
-                                               update_status( 'user requested stop' )
-                                           }''',
-        }
+        context = exe.Context( exe.Mode.SYNC )
+        exec_task = self._ui( exe.Setting.CLI, context, "interactive-clean" )
+        return context.execute( exec_task, "interactive-clean" )