cubevis 1.0.14__py3-none-any.whl → 1.0.21__py3-none-any.whl

cubevis/bokeh/models/_bokeh_app_context.py

@@ -2,7 +2,13 @@ import logging
 from bokeh.core.properties import String, Dict, Any, Nullable, Instance
 from bokeh.models.layouts import LayoutDOM
 from bokeh.models.ui import UIElement
+from bokeh.resources import CDN
+from tempfile import TemporaryDirectory
 from uuid import uuid4
+import unicodedata
+import webbrowser
+import os
+import re
 
 logger = logging.getLogger(__name__)
 
@@ -29,9 +35,34 @@ class BokehAppContext(LayoutDOM):
             cls._session_id = str(uuid4())
         return cls._session_id
 
-    def __init__( self, ui=None, **kwargs ):
+    def _slugify(self, value, allow_unicode=False):
+        """
+        Taken from https://github.com/django/django/blob/master/django/utils/text.py
+        Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
+        dashes to single dashes. Remove characters that aren't alphanumerics,
+        underscores, or hyphens. Convert to lowercase. Also strip leading and
+        trailing whitespace, dashes, and underscores.
+        https://stackoverflow.com/a/295466/2903943
+        """
+        value = str(value)
+        if allow_unicode:
+            value = unicodedata.normalize('NFKC', value)
+        else:
+            value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii')
+        value = re.sub(r'[^\w\s-]', '', value.lower())
+        return re.sub(r'[-\s]+', '-', value).strip('-_')
+
+    def __init__( self, ui=None, title=str(uuid4( )), prefix=None, **kwargs ):
         logger.debug(f"\tBokehAppContext::__init__(ui={type(ui).__name__ if ui else None}, {kwargs}): {id(self)}")
 
+        if prefix is None:
+            ## create a prefix from the title
+            prefix = self._slugify(title)[:10]
+
+        self.__title = title
+        self.__workdir = TemporaryDirectory(prefix=prefix)
+        self.__htmlpath = os.path.join( self.__workdir.name, f'''{self._slugify(self.__title)}.html''' )
+
         if ui is not None and 'ui' in kwargs:
             raise RuntimeError( "'ui' supplied as both a positional parameter and a keyword parameter" )
 
@@ -61,3 +92,19 @@ class BokehAppContext(LayoutDOM):
         current_state = dict(self.app_state)
         current_state.update(state_updates)
         self.app_state = current_state
+
+    def show( self ):
+        """Always show plot in a new browser tab without changing output settings.
+           Jupyter display is handled by the Showable class. However, at some
+           point this function might need to support more than just independent
+           browser tab display.
+        """
+        logger.debug(f"\tBokehAppContext::show( ): {id(self)}")
+
+        from bokeh.plotting import save
+
+        # Save the plot
+        save( self, filename=self.__htmlpath, resources=CDN, title=self.__title)
+
+        # Open in browser
+        webbrowser.open('file://' + os.path.abspath(self.__htmlpath))

cubevis/bokeh/models/_showable.py

@@ -1,7 +1,8 @@
 import logging
 from bokeh.models.layouts import LayoutDOM
 from bokeh.models.ui import UIElement
-from bokeh.core.properties import Instance
+from bokeh.core.properties import Instance, String
+
 from bokeh.io import curdoc
 from .. import BokehInit
 
@@ -9,12 +10,20 @@ logger = logging.getLogger(__name__)
 
 class Showable(LayoutDOM,BokehInit):
     """Wrap a UIElement to make any Bokeh UI component showable with show()
-    
+
     This class works by acting as a simple container that delegates to its UI element.
     For Jupyter notebook display, use show(showable) - automatic display via _repr_mimebundle_
     is not reliably supported by Bokeh's architecture.
     """
 
+    ### _usage_mode is needed to prevent mixing "bokeh.plotting.show(showable)" with
+    ### "showable.show( )" or just evaluating "showable". This is required because the
+    ### latter use "bokeh.embed.components" to create the HTML that is rendered while
+    ### "bokeh.plotting.show(showable)" uses internal Bokeh rendering that is
+    ### incompatable with "bokeh.embed.components" usage. For this reason, the user
+    ### can use either one, but not both.
+    _usage_mode = None
+
     @property
     def document(self):
         """Get the document this model is attached to."""
@@ -26,58 +35,52 @@ class Showable(LayoutDOM,BokehInit):
         Intercept when Bokeh tries to attach us to a document.
         This is called by bokeh.plotting.show() when it adds us to a document.
         """
-        from bokeh.io.state import curstate
-        import traceback
 
-        # Allow None (detaching from document)
+        def get_caller_class_name(frame):
+            """Attempt to find the name of the class the calling method belongs to."""
+            # Check if 'self' is in the caller's local variables (conventional for instance methods)
+            if 'self' in frame.f_locals:
+                return frame.f_locals['self'].__class__.__name__
+            # Check for 'cls' (conventional for class methods)
+            elif 'cls' in frame.f_locals:
+                return frame.f_locals['cls'].__name__
+            else:
+                # It might be a regular function or static method without explicit 'self'/'cls'
+                return None
+
+        # Allow None (detaching from document) without any further checking
         if doc is None:
             self._document = None
             return
 
-        state = curstate()
-
-        # Check calling context
-        stack = traceback.extract_stack()
-
-        # Detect if called from bokeh.plotting.show or bokeh.io.show
-        called_from_bokeh_show = any(
-            ('bokeh/io/' in frame.filename or 'bokeh\\io\\' in frame.filename or
-             'bokeh/plotting/' in frame.filename or 'bokeh\\plotting\\' in frame.filename)
-            for frame in stack[:-2]  # Exclude the last 2 frames (this setter and __setattr__)
-        )
-
-        # Check if called from our own methods
-        called_from_our_methods = any(
-            'Showable' in str(frame.line) or frame.filename.endswith('showable.py')
-            for frame in stack[-5:-2]  # Check recent frames
-        )
+        from bokeh.io.state import curstate
+        state = curstate( )
 
-        if state.file and called_from_bokeh_show and not called_from_our_methods:
-            raise RuntimeError(
-                f"\n{'='*70}\n"
-                f"❌ Cannot use bokeh.plotting.show() with {self.__class__.__name__}\n\n"
-                f"Please use one of these methods instead:\n"
-                f"  • my_showable.show()     # Custom show method\n"
-                f"  • my_showable            # Automatic display (evaluate in cell)\n\n"
-                f"Reason: bokeh.plotting.show() doesn't properly handle the custom\n"
-                f"sizing and backend requirements of Showable objects.\n"
-                f"{'='*70}\n"
-            )
+        # Validate environment (only one OUTPUT mode)
+        active_modes = []
+        if state.file: active_modes.append('file')
+        if state.notebook: active_modes.append('notebook')
 
-        # Validate environment
-        if not state.notebook:
+        # only allow a single GUI to be displayed since there is a backend
+        # this could be relaxed if the backend can manage events from two
+        # different GUIs
+        if len(active_modes) > 1:
             raise RuntimeError(
-                f"{self.__class__.__name__} can only be displayed in Jupyter notebooks.\n"
-                f"Please run:\n"
-                f"  from bokeh.io import output_notebook\n"
-                f"  output_notebook()"
+                f"{self.__class__.__name__} can only be displayed in a single Bokeh\n"
+                f"display mode. Either file or notebook, but not both."
             )
 
-        # Apply notebook sizing before attaching to document
-        if self._notebook_sizing == 'fixed':
+        # For notebook display, fixed sizing is required. This selects between the
+        # fixed, notebook dimensions and the default browser dimensions based on
+        # the Bokeh output that has been selected.
+        if 'notebook' in active_modes and self._display_config['notebook']['mode'] == 'fixed':
             self.sizing_mode = None
-            self.width = self._notebook_width
-            self.height = self._notebook_height
+            self.width = self._display_config['notebook']['width']
+            self.height = self._display_config['notebook']['height']
+        else:
+            self.sizing_mode = self._display_config['browser']['mode']
+            self.width = self._display_config['browser']['width']
+            self.height = self._display_config['browser']['height']
 
         # Now set the document
         self._document = doc
@@ -87,12 +90,23 @@ class Showable(LayoutDOM,BokehInit):
             self._start_backend()
             self._backend_started = True
 
+    def to_serializable(self, *args, **kwargs):
+        if self._display_context:
+            self._display_context.on_to_serializable( )
+
+        # Call parent's to_serializable
+        return super().to_serializable(*args, **kwargs)
+
     def __init__( self, ui_element=None, backend_func=None,
                   result_retrieval=None,
                   notebook_width=1200, notebook_height=800,
-                  notebook_sizing='fixed', **kwargs):
+                  notebook_sizing='fixed',
+                  display_context=None,
+                  **kwargs ):
         logger.debug(f"\tShowable::__init__(ui_element={type(ui_element).__name__ if ui_element else None}, {kwargs}): {id(self)}")
-        
+
+        self._display_context = display_context
+
         # Set default sizing if not provided
         sizing_params = {'sizing_mode', 'width', 'height'}
         provided_sizing_params = set(kwargs.keys()) & sizing_params
@@ -102,11 +116,20 @@ class Showable(LayoutDOM,BokehInit):
         # CRITICAL FIX: Don't call _ensure_in_document during __init__
         # Let Bokeh handle document management through the normal flow
         super().__init__(**kwargs)
-        
+
         # Set the UI element
         if ui_element is not None:
             self.ui = ui_element
 
+        # Keep track of defaults based on display mode
+        ### self._notebook_width = notebook_width
+        ### self._notebook_height = notebook_height
+        ### self._notebook_sizing = notebook_sizing  # 'fixed' or 'stretch'
+        self._display_config = {
+            'notebook': { 'mode': notebook_sizing, 'width': notebook_width, 'height': notebook_height },
+            'browser': { 'mode': self.sizing_mode, 'width': self.width, 'height': self.height }
+        }
+
         # Set the function to be called upon display
         if backend_func is not None:
             self._backend_startup_callback = backend_func
@@ -114,14 +137,35 @@ class Showable(LayoutDOM,BokehInit):
         # result (if one is/will be available)...
         self._result_retrieval = result_retrieval
 
-        self._notebook_width = notebook_width
-        self._notebook_height = notebook_height
-        self._notebook_sizing = notebook_sizing  # 'fixed' or 'stretch'
         self._notebook_rendering = None
 
     ui = Instance(UIElement, help="""
     A UI element, which can be plots, layouts, widgets, or any other UIElement.
     """)
+    ###
+    ### when 'disabled' is set to true, this message should be displayed over
+    ### a grey-obscured GUI...
+    ###
+    ### May need to adjust message formatting to allow for more flexiblity,
+    ### i.e. all of the message does not need to be in big green print. May
+    ### need to allow something like:
+    ###
+    ###   <div style="font-size: 24px; font-weight: bold; color: #4CAF50; margin-bottom: 10px;">
+    ###      Interaction Complete ✓
+    ###   </div>
+    ###   <div style="font-size: 14px; color: #666;">
+    ###      You can now close this GUI or continue working in your notebook
+    ###   </div>
+    ###
+    ### currently the message is displayed in showable.ts like:
+    ###
+    ###   <div style="font-size: 24px; font-weight: bold; color: #4CAF50; margin-bottom: 10px;">
+    ###      ${this.model.disabled_message}
+    ###   </div>
+    ###
+    disabled_message = String(default="Interaction Complete ✓", help="""
+    Message to show when disabled
+    """)
 
     # FIXED: Remove the children property override
     # Let LayoutDOM handle its own children management
@@ -138,7 +182,7 @@ class Showable(LayoutDOM,BokehInit):
         """Ensure this Showable is in the current document"""
         from bokeh.io import curdoc
         current_doc = curdoc()
-        
+
         # FIXED: More careful document management
         # Only add to document if we're not already in the right one
         if self.document is None:
@@ -239,6 +283,9 @@ class Showable(LayoutDOM,BokehInit):
         if self.ui is None:
             return '<div style="color: red; padding: 10px; border: 1px solid red;">Showable object with no UI set</div>'
 
+        if self._display_context:
+            self._display_context.on_show( )
+
         if self._notebook_rendering:
             # Return a lightweight reference instead of re-rendering the full GUI
             return f'''
@@ -251,10 +298,10 @@ class Showable(LayoutDOM,BokehInit):
             '''
 
         # Apply notebook sizing for Jupyter context
-        if self._notebook_sizing == 'fixed':
-            self.sizing_mode = None
-            self.width = self._notebook_width
-            self.height = self._notebook_height
+        ###if self._notebook_sizing == 'fixed':
+        ###    self.sizing_mode = None
+        ###    self.width = self._notebook_width
+        ###    self.height = self._notebook_height
 
         script, div = components(self)
         if start_backend:
@@ -263,32 +310,6 @@ class Showable(LayoutDOM,BokehInit):
         self._notebook_rendering = f'{script}\n{div}'
         return self._notebook_rendering
 
-    def _repr_html_(self, start_backend=True):
-        """
-        HTML representation for Jupyter display.
-
-        Note: Bokeh doesn't reliably support automatic display via _repr_mimebundle_.
-        This provides a helpful message directing users to use show().
-        """
-        html = self._get_notebook_html(start_backend)
-
-        if html is not None:
-            return html
-
-        # Not in notebook environment
-        return f"<!-- error: non-notebook environment{' in ' + self.name if self.name else ''} -->" + '''
-        <div style="padding: 15px; border: 2px solid #4CAF50; border-radius: 5px; background: #f9fff9; margin: 10px 0;">
-            <strong>📊 Showable Widget Ready</strong><br>
-            <em>Notebook display is not enabled, run:</em>
-                    <p><pre>
-from bokeh.io import output_notebook
-output_notebook()</pre>
-                    <p><em>and try again.</em>
-            <hr>
-            <small>Contains: {}</small>
-        </div>
-        '''.format(type(self.ui).__name__ if self.ui else "None")
-
     def _repr_mimebundle_(self, include=None, exclude=None):
         """
         MIME bundle representation for Jupyter display.
@@ -301,6 +322,8 @@ output_notebook()</pre>
         - Bokeh show(showable)
         - showable.show()
         """
+        if self.__class__._usage_mode is None:
+            self.__class__._usage_mode = "custom"
         from bokeh.io.state import curstate
 
         state = curstate()
@@ -311,13 +334,16 @@ output_notebook()</pre>
                 return {
                     'text/html': html
                 }
-    
+
         # Fall back to default Bokeh behavior for non-notebook environments
         # Return None to let Bokeh handle it
         return None
 
     def show(self, start_backend=True):
         """Explicitly show this Showable using inline display in Jupyter"""
+        if self.__class__._usage_mode is None:
+            self.__class__._usage_mode = "custom"
+
         from bokeh.io.state import curstate
 
         self._ensure_in_document()
@@ -327,7 +353,7 @@ output_notebook()</pre>
         if state.notebook:
             # In Jupyter, display directly using IPython.display
             from IPython.display import display, HTML
-    
+
             html = self._get_notebook_html(start_backend)
             if html:
                 display(HTML(html))

cubevis/exe/_task.py

@@ -67,31 +67,53 @@ class Task:
         
         return threading_event
 
+    def _run_coroutine_sync(self, coro):
+        """
+        Helper to run a coroutine synchronously, handling both CLI and Jupyter contexts.
+        """
+        try:
+            # Check if there's already a running event loop (Jupyter/IPython)
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running loop - safe to use asyncio.run() (CLI context)
+            return asyncio.run(coro)
+        else:
+            # Running loop exists (Jupyter context)
+            try:
+                import nest_asyncio
+                nest_asyncio.apply()
+                return asyncio.run(coro)
+            except ImportError:
+                # Fallback: run in a new thread with its own event loop
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                    return pool.submit(asyncio.run, coro).result()
+
     def run_sync(self) -> Any:
         """Run synchronously until completion or stop signal."""
         if self.stop_condition is None:
             # Handle async functions in sync context
             if asyncio.iscoroutinefunction(self.server_func):
-                logger.debug( f"\tTask::run_sync( ): {id(self)} - asyncio no stop condition {self.server_func}" )
-                return asyncio.run(self.server_func(*self.args, **self.kwargs))
+                logger.debug(f"\tTask::run_sync( ): {id(self)} - asyncio no stop condition {self.server_func}")
+                return self._run_coroutine_sync(self.server_func(*self.args, **self.kwargs))
             else:
-                logger.debug( f"\tTask::run_sync( ): {id(self)} - no stop condition {self.server_func}" )
+                logger.debug(f"\tTask::run_sync( ): {id(self)} - no stop condition {self.server_func}")
                 return self.server_func(*self.args, **self.kwargs)
 
         # Handle asyncio.Event in sync context by converting to threading.Event
         stop_condition = self.stop_condition
         if isinstance(self.stop_condition, asyncio.Event):
-            logger.debug( f"\tTask::run_sync( ): {id(self)} - asyncio bridge {self.server_func}" )
+            logger.debug(f"\tTask::run_sync( ): {id(self)} - asyncio bridge {self.server_func}")
             # Convert asyncio.Event to threading.Event for sync execution
             stop_condition = self._convert_asyncio_event_to_threading(self.stop_condition)
-        
+
         if callable(stop_condition):
             # Poll-based stopping
-            logger.debug( f"\tTask::run_sync( ): {id(self)} - polling {self.server_func}" )
+            logger.debug(f"\tTask::run_sync( ): {id(self)} - polling {self.server_func}")
             while not stop_condition():
                 try:
                     if asyncio.iscoroutinefunction(self.server_func):
-                        result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                        result = self._run_coroutine_sync(self.server_func(*self.args, **self.kwargs))
                     else:
                         result = self.server_func(*self.args, **self.kwargs)
                     if result is not None:  # Server function completed
@@ -102,12 +124,12 @@ class Task:
 
         elif isinstance(stop_condition, threading.Event):
             # Event-based stopping for threads
-            logger.debug( f"\tTask::run_sync( ): {id(self)} - threading event {self.server_func}" )
+            logger.debug(f"\tTask::run_sync( ): {id(self)} - threading event {self.server_func}")
             def run_with_check():
                 while not stop_condition.is_set():
                     try:
                         if asyncio.iscoroutinefunction(self.server_func):
-                            result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                            result = self._run_coroutine_sync(self.server_func(*self.args, **self.kwargs))
                         else:
                             result = self.server_func(*self.args, **self.kwargs)
                         if result is not None:
@@ -118,26 +140,25 @@ class Task:
             return run_with_check()
 
         elif isinstance(stop_condition, threading.Condition):
-            logger.debug( f"\tTask::run_sync( ): {id(self)} - threading condition {self.server_func}" )
+            logger.debug(f"\tTask::run_sync( ): {id(self)} - threading condition {self.server_func}")
             # Condition-based stopping - most flexible and efficient
             def run_with_condition():
                 with stop_condition:
                     while True:
-                        # Check if we should stop (condition should have a flag or predicate)
-                        # The condition object should be used by external code to signal stopping
-                        # We'll pass the condition to the server function so it can wait efficiently
                         try:
                             # Pass the condition to the server function if it accepts it
                             import inspect
                             sig = inspect.signature(self.server_func)
                             if 'stop_condition' in sig.parameters:
                                 if asyncio.iscoroutinefunction(self.server_func):
-                                    result = asyncio.run(self.server_func(*self.args, stop_condition=stop_condition, **self.kwargs))
+                                    result = self._run_coroutine_sync(
+                                        self.server_func(*self.args, stop_condition=stop_condition, **self.kwargs)
+                                    )
                                 else:
                                     result = self.server_func(*self.args, stop_condition=stop_condition, **self.kwargs)
                             else:
                                 if asyncio.iscoroutinefunction(self.server_func):
-                                    result = asyncio.run(self.server_func(*self.args, **self.kwargs))
+                                    result = self._run_coroutine_sync(self.server_func(*self.args, **self.kwargs))
                                 else:
                                     result = self.server_func(*self.args, **self.kwargs)
 
@@ -227,4 +248,3 @@ class Task:
             # Sync function in async context - run in thread pool
             loop = asyncio.get_event_loop()
             return await loop.run_in_executor(None, self.run_sync)
-

cubevis/private/apps/_createmask.py

@@ -35,7 +35,7 @@ from contextlib import asynccontextmanager
 from bokeh.layouts import row, column
 from bokeh.plotting import show
 from bokeh.models import Button, CustomJS, TabPanel, Tabs, Spacer, Div
-from cubevis.toolbox import CubeMask, AppContext
+from cubevis.toolbox import CubeMask
 from cubevis.bokeh.utils import svg_icon
 from bokeh.io import reset_output as reset_bokeh_output
 from bokeh.io import output_notebook
@@ -43,7 +43,7 @@ from bokeh.models.dom import HTML
 from bokeh.models.ui.tooltips import Tooltip
 from cubevis.utils import resource_manager, reset_resource_manager, is_interactive_jupyter
 from cubevis.data import casaimage
-from cubevis.bokeh.models import TipButton, Tip
+from cubevis.bokeh.models import TipButton, Tip, BokehAppContext
 from cubevis.utils import ContextMgrChain as CMC
 
 class CreateMask:
@@ -149,12 +149,6 @@ class CreateMask:
             if False a mask path which does not exist results in an exception
         '''
 
-        ###
-        ### Create application context (which includes a temporary directory).
-        ### This sets the title of the plot.
-        ###
-        self._app_state = AppContext( 'Create Mask' )
-
         ###
         ### widgets shared across image tabs (masking multiple images)
         ###
@@ -243,23 +237,7 @@ class CreateMask:
             ### If debugging this, make only a small change before confirming that exit from the
             ### Python asyncio loop continues to work... seems to be fiddly
             ###
-            imdetails['gui']['cube'] = CubeMask( paths[0], mask=paths[1],
-                                                 init_script = None if initialization_registered else \
-                                                               CustomJS( args={ }, code='''
-                                                                         window.addEventListener( 'beforeunload',
-                                                                                                  (event) => {
-                                                                                                      function donePromise( ) {
-
-                                                                                                          return new Promise( (resolve,reject) => {
-                                                                                                                                 // call by name does not work here:
-                                                                                                                                 //       document._cube_done(cb=resolve)  ???
-                                                                                                                                 if ( document._cube_done ) document._cube_done(null,resolve)
-                                                                                                                              } )
-                                                                                                      }
-                                                                                                      ( async () => { await donePromise( ) } )( )
-                                                                                                  } )''' ) )
-
-            initialization_registered = True
+            imdetails['gui']['cube'] = CubeMask( paths[0], mask=paths[1] )
             imdetails['image-channels'] = imdetails['gui']['cube'].shape( )[3]
 
 
@@ -276,6 +254,23 @@ class CreateMask:
             self._fig['status'] = imdetails['gui']['status'] = imdetails['gui']['cube'].status_text( "<p>initialization</p>" , width=230, reuse=self._fig['status'] )
             self._image_bitmask_controls = imdetails['gui']['cube'].bitmask_ctrl( reuse=self._image_bitmask_controls, button_type='light' )
 
+
+            ,
+            imdetails['gui']['cube'].init_script = None if initialization_registered else \
+                CustomJS( args={ 'status': self._fig['status'] },
+                          ### app state is found based on one of the GUI's models
+                          code='''const appstate = Bokeh.find.appState(status)
+                                  window.addEventListener( 'beforeunload',
+                                                           (event) => {
+                                                               function donePromise( ) {
+                                                                   return new Promise( (resolve,reject) => {
+                                                                       appstate?.cube_done?.(null,resolve)
+                                                                   } )
+                                                               }
+                                                               ( async () => { await donePromise( ) } )( )
+                                                           } )''' )
+            initialization_registered = True
+
             ###
             ### spectrum plot must be disabled during iteration due to "tap to change channel" functionality
             ###
@@ -319,7 +314,8 @@ class CreateMask:
 
         self._image_control_tab_groups[imid] = result
         result.js_on_change( 'active', CustomJS( args={ },
-                                                 code='''document._casa_last_control_tab = cb_obj.active''' ) )
+                                                 code='''const appstate = Bokeh.find.appState(cb_obj)
+                                                         appstate.last_control_tab = cb_obj.active''' ) )
         return result
 
     def _create_image_panel( self, imagetuple ):
@@ -356,7 +352,8 @@ class CreateMask:
 
         self._ctrl_state['stop'].js_on_click( CustomJS( args={ },
                                                         code='''if ( confirm( "Are you sure you want to end this mask creation session and close the GUI?" ) ) {
-                                                                    if ( document._cube_done ) document._cube_done( )
+                                                                    const appstate = Bokeh.find.appState(cb_obj)
+                                                                    appstate?.cube_done?.( )
                                                                 }''' ) )
 
 
@@ -368,17 +365,21 @@ class CreateMask:
 
         image_tabs = Tabs( tabs=tab_panels, tabs_location='below', height_policy='max', width_policy='max' )
 
-        self._fig['layout'] = column(
-                                  row( self._fig['help'],
-                                       Spacer( height=self._ctrl_state['stop'].height, sizing_mode="scale_width" ),
-                                       Div( text="<div><b>status:</b></div>" ),
-                                       self._fig['status'],
-                                       self._ctrl_state['stop'], sizing_mode="scale_width" ),
-                                  row( image_tabs, height_policy='max', width_policy='max' ),
-                                  height_policy='max', width_policy='max' )
+        self._fig['layout'] = BokehAppContext(
+            column( row( self._fig['help'],
+                         Spacer( height=self._ctrl_state['stop'].height, sizing_mode="scale_width" ),
+                         Div( text="<div><b>status:</b></div>" ),
+                         self._fig['status'],
+                         self._ctrl_state['stop'], sizing_mode="scale_width" ),
+                    row( image_tabs, height_policy='max', width_policy='max' ),
+                    height_policy='max', width_policy='max' ),
+            app_state={                         ### while the state dictionary itself
+                'name': 'create mask',          ### is used, these particular element
+                'initialized': True             ### are not currently used for anything
+            }, title='Create Mask' )
 
         ###
-        ### Keep track of which image is currently active in document._casa_image_name (which is
+        ### Keep track of which image is currently active in appstate.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
@@ -388,11 +389,12 @@ class CreateMask:
         ###
         image_tabs.js_on_change( 'active', CustomJS( args=dict( names=[ t[0] for t in self._mask_state.items( ) ],
                                                                 itergroups=self._image_control_tab_groups ),
-                                                     code='''if ( ! hasprop(document,'_casa_last_control_tab') ) {
-                                                                 document._casa_last_control_tab = 0
+                                                     code='''const appstate = Bokeh.find.appState(cb_obj)
+                                                             if ( ! hasprop(appstate,'last_control_tab') ) {
+                                                                 appstate.last_control_tab = 0
                                                              }
-                                                             document._casa_image_name = names[cb_obj.active]
-                                                             itergroups[document._casa_image_name].active = document._casa_last_control_tab''' ) )
+                                                             appstate.image_name = names[cb_obj.active]
+                                                             itergroups[appstate.image_name].active = appstate.last_control_tab''' ) )
 
         # Change display type depending on runtime environment
         if is_interactive_jupyter( ):
@@ -403,7 +405,7 @@ class CreateMask:
 ###         output_file(self._imagename+'_webpage/index.html')
             pass
 
-        show(self._fig['layout'])
+        self._fig['layout'].show( )
 
     def _asyncio_loop( self ):
         '''return the event loop which can be mixed in with an existing event loop