cubevis 1.0.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

cubevis/bokeh/state/_initialize.py

@@ -1,6 +1,6 @@
 ########################################################################
 #
-# Copyright (C) 2021,2022,2023
+# Copyright (C) 2021,2022,2023,2025
 # Associated Universities, Inc. Washington DC, USA.
 #
 # This script is free software; you can redistribute it and/or modify it
@@ -30,135 +30,301 @@ generated HTML that is used to display the Bokeh plots that ``casagui``'s
 applications produce'''
 import os
 import re
+import logging
 from os import path
+from enum import Enum
 from os.path import dirname, join, basename, abspath
 from urllib.parse import urlparse
 from bokeh import resources
+from bokeh.settings import settings
 from ...utils import path_to_url, static_vars, have_network
 
+logger = logging.getLogger(__name__)
 
-@static_vars( initialized=False,
-              do_local_subst=not have_network( ) )
-def initialize_bokeh( bokehjs_subst=None ):
+_CUBEVIS_LIBS = {}
+# Selector for which source to prefer for JavaScript files. Bokeh's Python
+# package comes with static versions of the Bokeh JavaScript libraries.
+# cubevis libraries are available both as static versions contained within
+# the Python package and from an NRAO website.
+#
+# None = auto-detect, 'local' = prefer local, 'network' = prefer network
+class JsLoading(Enum):
+    AUTO = 'auto'
+    LOCAL = 'local'
+    NETWORK = 'network'
+
+_JS_STRATEGY = JsLoading.AUTO
+
+# Package-level registry
+_JUPYTER_STATE = {
+    'models_registered': set()
+}
+
+def get_cubevis_libs( ):
+    """Get the package-level default cubevis paths"""
+    return _CUBEVIS_LIBS
+
+def set_cubevis_lib(**kw):
+    """Set custom paths for cubevis JavaScript libraries"""
+    libs = get_cubevis_libs()
+    for lib in ['bokeh', 'bokeh_widgets', 'bokeh_tables', 'casalib', 'cubevisjs']:
+        if lib in kw:
+            libs[lib] = kw[lib]
+    return libs
+
+def get_js_loading( ):
+    """Get JavaScript loading strategy.
+    """
+    return _JS_STRATEGY
+
+def set_js_loading(strategy):
+    """Set JavaScript loading strategy.
+
+    Args:
+        strategy (JsLoading or str):
+            - 'auto': Smart selection based on environment
+            - 'local': Always prefer local static files when available
+            - 'network': Always prefer network CDN when available
+    """
+    global _JS_STRATEGY
+    if isinstance(strategy, str):
+        _JS_STRATEGY = JsLoading(strategy)
+    elif isinstance(strategy, JsLoading):
+        _JS_STRATEGY = strategy
+    else:
+        raise TypeError("'strategy' must be a valid JsLoading string or enum member")
+
+def get_js_loading_selection( ):
+    # Check for user override
+    global _JS_STRATEGY
+
+    prefer_network = False
+    prefer_local = False
+
+    in_jupyter = is_jupyter()
+    use_network = have_network()
+
+    if _JS_STRATEGY is JsLoading.LOCAL:
+        prefer_network = False
+        prefer_local = True
+        logger.debug("Strategy: User override -> prefer local")
+    elif _JS_STRATEGY is JsLoading.NETWORK:
+        prefer_network = True
+        prefer_local = False
+        logger.debug("Strategy: User override -> prefer network")
+    else:
+        # Auto-detect optimal strategy
+        if in_jupyter and use_network:
+            # Jupyter notebooks work best with CDN versions
+            prefer_network = True
+            prefer_local = False
+            logger.debug("Strategy: Jupyter + network -> prefer CDN")
+        elif not use_network:
+            # No choice - must use local
+            prefer_network = False
+            prefer_local = True
+            logger.debug("Strategy: No network -> local only")
+        else:
+            # Standalone application with network -> prefer local for speed/reliability
+            prefer_network = False
+            prefer_local = True
+            logger.debug("Strategy: Standalone + network -> prefer local static")
+
+    return prefer_local, prefer_network
+
+def is_jupyter():
+    """Check if running in Jupyter environment"""
+    try:
+        from IPython import get_ipython
+        return get_ipython() is not None
+    except ImportError:
+        return False
+
+def resolve_js_library_paths():
+    """Resolve paths to all required JavaScript libraries based on environment and availability.
+
+    Strategy:
+    - Jupyter notebooks: Prefer network CDN (required for proper functionality)
+    - Standalone apps with network: Prefer local static (faster, more reliable)
+    - No network: Use local static (only option)
+    - Corporate/restricted networks: Prefer local static (firewall bypass)
+
+    Returns:
+        dict: Dictionary with resolved paths for 'casalib', 'bokeh', 'bokeh_widgets',
+              'bokeh_tables', and 'cubevisjs'
+    """
+    ### These functions also select remote/local based on Jupyter or
+    ### no network because these URLs also are included in the
+    ### __javascript__ variables for Bokeh model derived member variables.
+    from . import casalib_url as get_casalib_url
+    from . import cubevisjs_url as get_cubevisjs_url
+
+    # Start with user-defined overrides
+    result = get_cubevis_libs().copy()
+
+    # Handle {JSLIB}/ substitution for user paths
+    for key, value in result.items():
+        if value and value.startswith("{JSLIB}/"):
+            result[key] = path_to_url(value[8:])
+
+    prefer_local, prefer_network = get_js_loading_selection( )
+
+    # Get available sources
+    bokeh_static_js = {}
+    bokeh_static_available = False
+
+    try:
+        bokeh_static_path = settings.bokehjs_path()
+        js_dir = join(bokeh_static_path, 'js')
+        logger.debug( f"Bokeh static pat: {js_dir}" )
+
+        if path.exists(js_dir):
+            for filename in os.listdir(js_dir):
+                if filename.endswith('.js'):
+                    file_path = f"file://{abspath(join(js_dir, filename))}"
+
+                    ## js_dir seems to contain both minified and non minified versions of
+                    ## the bokeh librarys. If we ever want to allow for non-minified
+                    ## versions, e.g. for debugging, we'll need to look here
+                    if re.match(r'.*bokeh(?:-\d+\.\d+\.\d+)?\.min\.js$', filename):
+                        bokeh_static_js['bokeh'] = file_path
+                    elif re.match(r'.*bokeh-widgets(?:-\d+\.\d+\.\d+)?\.min\.js$', filename):
+                        bokeh_static_js['bokeh_widgets'] = file_path
+                    elif re.match(r'.*bokeh-tables(?:-\d+\.\d+\.\d+)?\.min\.js$', filename):
+                        bokeh_static_js['bokeh_tables'] = file_path
+
+            bokeh_static_available = len(bokeh_static_js) > 0
+
+    except Exception as e:
+        logger.warning(f"Could not access Bokeh static files: {e}")
+
+    # Network connection available
+    use_network = have_network()
+
+    # Fill in missing Bokeh libraries using the selected strategy
+    for lib in ['bokeh', 'bokeh_widgets', 'bokeh_tables']:
+        if lib not in result or result[lib] is None:
+            if prefer_local and bokeh_static_available and lib in bokeh_static_js:
+                result[lib] = bokeh_static_js[lib]
+                logger.debug(f"Using local static for {lib}")
+            elif prefer_network and use_network:
+                # Let Bokeh handle CDN URLs - return None to use defaults
+                result[lib] = None
+                logger.debug(f"Using CDN for {lib}")
+            elif bokeh_static_available and lib in bokeh_static_js:
+                # Fallback to local if network preference fails
+                result[lib] = bokeh_static_js[lib]
+                logger.debug(f"Fallback to local static for {lib}")
+            else:
+                # Last resort - try local cache
+                try:
+                    cached_path = path_to_url(f"{lib}.min.js")
+                    if cached_path != f"{lib}.min.js":  # Found in cache
+                        result[lib] = cached_path
+                        logger.debug(f"Using local cache for {lib}")
+                    else:
+                        result[lib] = None
+                        logger.debug(f"No source found for {lib}")
+                except:
+                    result[lib] = None
+
+    # Fill in cubevis-specific libraries
+    if 'casalib' not in result or result['casalib'] is None:
+        result['casalib'] = get_casalib_url( )
+
+    if 'cubevisjs' not in result or result['cubevisjs'] is None:
+        result['cubevisjs'] = get_cubevisjs_url( )
+
+    logger.debug(f"Resolved JS library paths: {result}")
+    logger.debug(f"Environment: jupyter={is_jupyter( )}, network={use_network}, strategy={'network' if prefer_network else 'local'}")
+
+    return result
+
+@static_vars(initialized=False)
+def order_bokeh_js():
     """Initialize `bokeh` for use with the ``cubevisjs`` extensions.
 
-    The ``cubevisjs`` extensions for Bokeh are built into a stand-alone
-    external JavaScript file constructed for the specific version of
-    Bokeh that is being used. Previously the CASA minified JavaScript
-    libraries were loaded from the network. Now these libraries are
-    included in a ``__js__`` directory within the cubevis Python package.
-    If users need to debug JavaScript problems, non-minified versions
-    can be copied into the ``__js__`` directory to replace the existing
-    libraries. To debug within the bokehjs library, a URL or a path
-    can be supplied by the ``bokehjs_subst`` parameter and it will be
-    substituted for the standard Bokeh library.
-
-    Parameters
-    ----------
-    bokehjs_subst: None or str or list of str
-        Bokeh dependent javascript library which is loaded after all
-        other Bokeh libraries have been loaded. This path could be a
-        local path, a URL or None. None is the default in which case
-        it loads the published library for the current version of
-        ``cubevisjs`` and ``bokeh``
-
-    Example
-    -------
-    from cubevis.bokeh.state import initialize_bokeh
-    initialize_bokeh( bokehjs_subst="/tmp/bokeh-3.2.2.js" )
+    This function injects the cubevis JavaScript libraries into Bokeh's resource
+    loading system in the proper order: casalib → bokeh core → bokeh widgets →
+    bokeh tables → cubevisjs.
+
+    The function automatically determines the best source for JavaScript libraries
+    based on the current environment (Jupyter vs standalone, network availability, etc.).
     """
 
-    if initialize_bokeh.initialized:
-        ### only initialize once...
+    if order_bokeh_js.initialized:
         return
 
-    initialize_bokeh.initialized = True
+    # Get all resolved library paths
+    js_paths = resolve_js_library_paths()
+
+    logger.debug(f"order_bokeh_js() initializing with paths: {js_paths}")
+    order_bokeh_js.initialized = True
+
+    # Store original Bokeh js_files function
     resources.Resources._old_js_files = resources.Resources.js_files
-    def js_files( self ):
-        ########################################################################
-        ### Function that will replace the member function within Bokeh that ###
-        ### returns the URLs for Bokeh initialization...                     ###
-        ########################################################################
-        def expand_paths( replacement ):
-            ### turn all paths into URLs
-            ### turn a single string into a list with one string
-            if replacement is None:
-                return [ ]
-            if type(replacement) == str:
-                if path.isfile(replacement):
-                    return [ f'''file://{abspath(replacement)}''' ]
-                elif replacement.startswith('http'):
-                    return [ replacement ]
-                else:
-                    raise RuntimeError( f'''debugging bokehjs substitution ('{replacement}') does not exist''' )
-            if type(replacement) == list:
-                result = [ ]
-                for u in replacement:
-                    if path.isfile(u):
-                        result.append( f'''file://{abspath(u)}''' )
-                    elif u.startswith('http'):
-                        result.append( u )
-                    else:
-                        raise RuntimeError( f'''debugging bokehjs substitution ('{u}') does not exist''' )
-                return result
-            return [ ]
-        def cubevisjs_predicate( s ):
-            ### detect cubevisjs library URL
-            return basename(s).startswith('cubevisjs')
-        def replace_bokehjs( urls, replacement ):
-            ### substitute replacement list for the bokehjs library URL
-            result = [ ]
-            for url in urls:
-                if re.match( r'.*/bokeh-\d+\.\d+\.\d+(?:\.min)?\.js$', url ):
-                    result += replacement
-                else:
-                    result.append(url)
-            return result
-
-        def include_all_bokehjs( urls ):
-            result = urls.copy( )
-            bokeh_path=None
-            has_bokeh_widgets=False
-            has_bokeh_tables=False
-            for url in urls:
-                if re.match( r'.*/bokeh-\d+\.\d+\.\d+(?:\.min)?\.js$', url ):
-                    bokeh_path = url
-                if re.match( r'.*/bokeh-widgets-\d+\.\d+\.\d+(?:\.min)?\.js$', url ):
-                    has_bokeh_widgets = True
-                if re.match( r'.*/bokeh-tables-\d+\.\d+\.\d+(?:\.min)?\.js$', url ):
-                    has_bokeh_tables = True
-
-            if bokeh_path:
-                if not has_bokeh_widgets:
-                    result.append( bokeh_path.replace('/bokeh-','/bokeh-widgets-') )
-                if not has_bokeh_tables:
-                    result.append( bokeh_path.replace('/bokeh-','/bokeh-tables-') )
-
-            return result
-
-        user_bokehjs_replacement = expand_paths(bokehjs_subst)
-        sys_urls = include_all_bokehjs( resources.Resources._old_js_files.fget(self) )
-        if initialize_bokeh.do_local_subst:
-            local_urls = [ ]
-            for url in sys_urls:
-                pieces = urlparse(url)
-                if pieces.scheme != 'file':
-                    lib = basename(pieces.path)
-                    url = path_to_url(lib)
-                    if lib != url:
-                        local_urls.append(url)
-                    else:
-                        raise RuntimeError( '''Cannot confirm internet access and could not find local cached versions of Bokeh's libraries''' )
-                else:
-                    local_urls.append(url)
-            sys_urls = local_urls
-
-        if len(user_bokehjs_replacement) == 0:
-            ### move cubevisjs library after Bokeh libraries
-            return [x for x in sys_urls if not cubevisjs_predicate(x)] + [x for x in sys_urls if cubevisjs_predicate(x)]
-        else:
-            ### replace bokehjs library with bokehjs_subst and move cubevisjs library after Bokeh libraries
-            return replace_bokehjs( [x for x in sys_urls if not cubevisjs_predicate(x)], user_bokehjs_replacement ) + [x for x in sys_urls if cubevisjs_predicate(x)]
 
+    def js_files(self):
+        """Replacement function that returns JavaScript files in the correct order"""
+
+        # Get original Bokeh URLs as fallback
+        original_urls = resources.Resources._old_js_files.fget(self)
+        logger.debug( f"Original Bokeh JavaScript: {original_urls}" )
+
+        def get_url_or_fallback(lib_key, fallback_pattern=None):
+            """Get resolved URL or find fallback from original Bokeh URLs"""
+            resolved_path = js_paths.get(lib_key)
+
+            if resolved_path:
+                return resolved_path
+
+            # Look for fallback in original URLs
+            if fallback_pattern:
+                for url in original_urls:
+                    if re.match(fallback_pattern, url):
+                        return url
+
+            return None
+
+        # Build the ordered list
+        ordered_js = []
+
+        # 1. casalib (always first)
+        casalib_url = get_url_or_fallback('casalib')
+        if casalib_url:
+            ordered_js.append(casalib_url)
+
+        # 2. bokeh core
+        bokeh_url = get_url_or_fallback('bokeh', r'.*/bokeh-\d+\.\d+\.\d+(?:\.min)?\.js$')
+        if bokeh_url:
+            ordered_js.append(bokeh_url)
+
+        # 3. bokeh widgets
+        widgets_url = get_url_or_fallback('bokeh_widgets', r'.*/bokeh-widgets-\d+\.\d+\.\d+(?:\.min)?\.js$')
+        if widgets_url:
+            ordered_js.append(widgets_url)
+
+        # 4. bokeh tables
+        tables_url = get_url_or_fallback('bokeh_tables', r'.*/bokeh-tables-\d+\.\d+\.\d+(?:\.min)?\.js$')
+        if tables_url:
+            ordered_js.append(tables_url)
+
+        # 5. cubevisjs (always last)
+        cubevisjs_url = get_url_or_fallback('cubevisjs')
+        if cubevisjs_url:
+            ordered_js.append(cubevisjs_url)
+
+        logger.debug(f"Final JS load order: {ordered_js}")
+        return ordered_js
+
+    # Replace Bokeh's js_files property
     resources.Resources.js_files = property(js_files)
     return
+
+def get_jupyter_state( ):
+    """Get the package-level Jupyter state"""
+    return _JUPYTER_STATE
+
+def register_model(model_class):
+    """Register a model class that needs dependencies"""
+    _JUPYTER_STATE['models_registered'].add(model_class.__name__)

cubevis/bokeh/state/_javascript.py

@@ -1,6 +1,6 @@
 ########################################################################
 #
-# Copyright (C) 2023
+# Copyright (C) 2023,2025
 # Associated Universities, Inc. Washington DC, USA.
 #
 # This script is free software; you can redistribute it and/or modify it
@@ -28,26 +28,100 @@
 '''This contains functions which return the URLs to the ``cubevis``
 JavaScript libraries. The ``casalib`` library has Bokeh independent
 functions while the `cubevisjs` library has the Bokeh extensions'''
-from ...utils import static_vars
-from ._initialize import initialize_bokeh
-from os import path
+from os import path, environ
+from pathlib import Path
+from packaging import version
+from bokeh import __version__ as bokeh_version
+from . import get_js_loading_selection
+from ...utils import max_git_version as _max_git_version
 
-@static_vars( library_path=None )
+_local_library_path = None
+_bokeh_major_minor = None
+
+_CUBEVIS_RELEASE_VERSION = None
+_CUBEVIS_GITHUB_VERSION = None
+_BOKEH_MAJOR_MINOR = None
+_CUBEVIS_JS_TAG = None
+
+def bokeh_major_minor( ):
+    global _BOKEH_MAJOR_MINOR
+    if _BOKEH_MAJOR_MINOR is None:
+        from bokeh import __version__ as bokeh_version
+        v = version.parse(bokeh_version)
+        _BOKEH_MAJOR_MINOR = f"{v.major}.{v.minor}"
+    return _BOKEH_MAJOR_MINOR
+
+def github_js_tag( ):
+    global _CUBEVIS_JS_TAG
+    if _CUBEVIS_JS_TAG is None:
+        release = cubevis_release_version( )
+        if release is not None:
+            _CUBEVIS_JS_TAG = f"v{release}"
+        else:
+            if 'CUBEVIS_JS_TAG' in environ:
+                _CUBEVIS_JS_TAG = environ['CUBEVIS_JS_TAG']
+            else:
+                _CUBEVIS_JS_TAG = f"v{cubevis_github_version( )}"
+    return _CUBEVIS_JS_TAG
+
+def cubevis_github_version( ):
+    global _CUBEVIS_GITHUB_VERSION
+    if _CUBEVIS_GITHUB_VERSION is None:
+        _CUBEVIS_GITHUB_VERSION = _max_git_version( )
+    return _CUBEVIS_GITHUB_VERSION
+
+def cubevis_release_version( ):
+    global _CUBEVIS_RELEASE_VERSION
+    if _CUBEVIS_RELEASE_VERSION is None:
+        try:
+            ###
+            ### __version__.py is generated as part of the build, but if the source tree
+            ### for cubevis is used directly for development, no __version__.py will be
+            ### available...
+            ###
+            from ...__version__ import __version__ as package_version
+            _CUBEVIS_RELEASE_VERSION = package_version
+        except ModuleNotFoundError: pass
+    return _CUBEVIS_RELEASE_VERSION
+
+def casalib_path( ):
+    global _local_library_path
+    if _local_library_path is None:
+        _local_library_path = path.join( path.dirname(path.dirname(path.dirname(__file__))), '__js__' )
+    casalib_path = path.join( _local_library_path, 'casalib.min.js' )
+    if not path.isfile( casalib_path ):
+        raise RuntimeError( f''''casalib' JavaScript library not found at '{casalib_path}\'''' )
+    return casalib_path
+
+def cubevisjs_path( ):
+    global _local_library_path
+    global _bokeh_major_minor
+    if _local_library_path is None:
+        _local_library_path = path.join( path.dirname(path.dirname(path.dirname(__file__))), '__js__' )
+    if _bokeh_major_minor is None:
+        version = bokeh_version.split('.')
+        _bokeh_major_minor = f"{version[0]}.{version[1]}"
+    cubevisjs_path = path.join( _local_library_path, f"bokeh-{_bokeh_major_minor}", 'cubevisjs.min.js' )
+    if not path.isfile(cubevisjs_path):
+        raise RuntimeError( f''''cubevisjs' JavaScript library not found at '{cubevisjs_path}\'''' )
+    return cubevisjs_path
+
+### These functions MUST also select remote/local based on Jupyter or
+### no network because these URLs also are included in the
+### __javascript__ variables for Bokeh model derived member variables.
+### These paths are then included in the Bokeh list of JavaScript
+### libraries loaded when the GUI is loaded. However, the ordering is
+### not correct because cubevisjs.min.js must appear AFTER all of the
+### Bokeh files.
 def casalib_url( ):
-    if casalib_url.library_path is None:
-        casalib_url.library_path = path.join(path.dirname(path.dirname(path.dirname(__file__))), '__js__', 'casalib.min.js')
-    if not path.isfile(casalib_url.library_path):
-        raise RuntimeError( f''''casalib' JavaScript library not found at '{casalib_url.library_path}\'''' )
-    if not initialize_bokeh.initialized:
-        initialize_bokeh( )
-    return f'''file://{casalib_url.library_path}'''
-
-@static_vars( library_path=None )
+    prefer_local, prefer_network = get_js_loading_selection( )
+    if prefer_network:
+        return f"https://cdn.jsdelivr.net/gh/casangi/cubevis@{github_js_tag( )}/cubevis/__js__/casalib.min.js"
+    else:
+        return f"file://{casalib_path( )}"
 def cubevisjs_url( ):
-    if cubevisjs_url.library_path is None:
-        cubevisjs_url.library_path = path.join(path.dirname(path.dirname(path.dirname(__file__))), '__js__', 'cubevisjs.min.js')
-    if not path.isfile(cubevisjs_url.library_path):
-        raise RuntimeError( f''''cubevisjs' JavaScript library not found at '{cubevisjs_url.library_path}\'''' )
-    if not initialize_bokeh.initialized:
-        initialize_bokeh( )
-    return f'''file://{cubevisjs_url.library_path}'''
+    prefer_local, prefer_network = get_js_loading_selection( )
+    if prefer_network:
+        return f"https://cdn.jsdelivr.net/gh/casangi/cubevis@{github_js_tag( )}/cubevis/__js__/bokeh-{bokeh_major_minor( )}/cubevisjs.min.js"
+    else:
+        return f"file://{cubevisjs_path( )}"

cubevis/bokeh/tools/_cbreset_tool.py

@@ -32,8 +32,9 @@
 from bokeh.models import ResetTool, Tool
 from bokeh.core.properties import Instance, Nullable
 from bokeh.models.callbacks import Callback
+from .. import BokehInit
 
-class CBResetTool(ResetTool):
+class CBResetTool(ResetTool,BokehInit):
     '''Tool that emits press and pressup events to signal start and end of drag'''
 
     precallback = Nullable(Instance(Callback), help="""

cubevis/bokeh/tools/_drag_tool.py

@@ -36,8 +36,9 @@ from bokeh.core.properties import Instance, Nullable
 from bokeh.models.callbacks import Callback
 from os.path import join,dirname
 from pathlib import Path
+from .. import BokehInit
 
-class DragTool(Drag):
+class DragTool(Drag,BokehInit):
     '''Tool that emits press and pressup events to signal start and end of drag'''
 
     start = Nullable(Instance(Callback), help="""

cubevis/bokeh/utils/__init__.py

@@ -28,7 +28,6 @@
 '''Functions use in the implementation of cubevis's Bokeh extensions.'''
 
 from ._svg_icon import svg_icon
-
 ###
 ### axes_labels has errors on import
 ###

cubevis/exe/_setting.py

@@ -2,3 +2,4 @@ from enum import Enum
 
 class Setting(Enum):
     CLI = "python_cli"
+    JPY = "jupyter_cell"

cubevis/private/apps/__init__.py

@@ -29,8 +29,8 @@
 '''End user applications supplied by ``cubevis``.'''
 import sys
 from cubevis.utils import copydoc, ImportProtectedModule
-from cubevis.bokeh.state import initialize_session
-initialize_session()
+#from cubevis.bokeh.state import initialize_session
+#initialize_session()
 
 ###
 ### This import roundabout was introduced when astroviper and casa6 apps were in the same
@@ -42,7 +42,9 @@ sys.modules[__name__].__class__ = ImportProtectedModule( __name__, { 'plotants':
                                                                      'CreateMask': '._createmask',
                                                                      'CreateRegion': '._createregion',
                                                                      'InteractiveClean': '._interactiveclean',
+                                                                     'InteractiveCleanNotebook': '._interactivecleannotebook',
                                                                      'iclean': '..casatasks.iclean',
+                                                                     'iclean_notebook': '..casatasks.iclean_notebook',
                                                                      'createmask': '..casatasks.createmask',
                                                                      'createregion': '..casatasks.createregion',
                                                                    } )

cubevis/private/apps/_interactiveclean.mustache

@@ -32,7 +32,9 @@ of tclean'''
 from pprint import pprint
 
 import sys
+from uuid import uuid4
 from os.path import exists
+from bokeh.plotting import show
 from casatasks.private.imagerhelpers.input_parameters import ImagerParameters
 
 from cubevis.utils import find_pkg, load_pkg
@@ -84,6 +86,8 @@ class InteractiveClean:
                                cell='12.0arcsec', specmode='cube',
                                interpolation='nearest', ... )( ) )
         '''
+        self._id = uuid4( )
         context = exe.Context( exe.Mode.SYNC )
-        exec_task = self._ui( exe.Setting.CLI, context, "interactive-clean" )
-        return context.execute( exec_task, "interactive-clean" )
+        bokeh_ui, exec_task = self._ui( context, self._id )
+        show(bokeh_ui)
+        return context.execute( exec_task, self._id )

cubevis/private/apps/_interactiveclean.py

@@ -31,7 +31,9 @@ of tclean'''
 from pprint import pprint
 
 import sys
+from uuid import uuid4
 from os.path import exists
+from bokeh.plotting import show
 from casatasks.private.imagerhelpers.input_parameters import ImagerParameters
 
 from cubevis.utils import find_pkg, load_pkg
@@ -1846,6 +1848,8 @@ class InteractiveClean:
                                cell='12.0arcsec', specmode='cube',
                                interpolation='nearest', ... )( ) )
         '''
+        self._id = uuid4( )
         context = exe.Context( exe.Mode.SYNC )
-        exec_task = self._ui( exe.Setting.CLI, context, "interactive-clean" )
-        return context.execute( exec_task, "interactive-clean" )
+        bokeh_ui, exec_task = self._ui( context, self._id )
+        show(bokeh_ui)
+        return context.execute( exec_task, self._id )