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

cubevis/bokeh/__init__.py

@@ -30,6 +30,7 @@ provided by Bokeh'''
 
 from .state import order_bokeh_js as _order_bokeh_js
 from .state import register_model as _register_model
+from .state._initialize import get_bokeh_js_paths
 from .state import set_cubevis_lib
 
 class BokehInit:

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,20 +1,30 @@
 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
+from ...utils import is_colab
 
 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 +36,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 +91,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 +117,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 +138,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 +183,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:
@@ -228,8 +273,11 @@ class Showable(LayoutDOM,BokehInit):
         Common logic for generating HTML in notebook environments.
         Returns the HTML string to display, or None if not in a notebook.
         """
-        from bokeh.embed import components
+        from bokeh.embed import components, json_item
         from bokeh.io.state import curstate
+        from bokeh.resources import CDN
+        import sys
+        import json as json_lib
 
         state = curstate()
 
@@ -239,55 +287,93 @@ 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'''
             <div style="padding: 10px; background: #f0f8f0; border-left: 4px solid #4CAF50; margin: 5px 0;">
-                <strong>↑ iclean GUI active above</strong>
+                <strong>→ iclean GUI active above</strong>
                 <small style="color: #666; display: block; margin-top: 5px;">
                     Showable ID: {self.id[-8:]} | Backend: Running
                 </small>
             </div>
             '''
 
-        # 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
-
-        script, div = components(self)
-        if start_backend:
-            self._start_backend()
-
-        self._notebook_rendering = f'{script}\n{div}'
-        return self._notebook_rendering
+        if is_colab( ):
+            # Get all JS paths from the existing function
+            # This returns paths in the correct order:
+            # [casalib, bokeh-core, bokeh-widgets, bokeh-tables, cubevisjs]
+            from cubevis.bokeh import get_bokeh_js_paths
+            js_paths = get_bokeh_js_paths( )
+
+            # Build script tags for all libraries in order
+            all_scripts = '\n'.join([
+                f'<script type="text/javascript" src="{url}"></script>'
+                for url in js_paths
+            ])
+
+            # Use json_item approach which is more reliable in iframes
+            item = json_item(self, target=f"bokeh-{self.id}")
+            item_json = json_lib.dumps(item)
+
+            # Build complete HTML with proper loading sequence
+            # get_bokeh_js_paths() already returns libs in the correct order:
+            # 1. casalib (third-party libs for CustomJS)
+            # 2. bokeh-core
+            # 3. bokeh-widgets
+            # 4. bokeh-tables
+            # 5. cubevisjs (custom Bokeh models)
+            html = f'''
+            {f'<link href="{CDN.css_files[0]}" rel="stylesheet" type="text/css">' if CDN.css_files else ""}
+            <div id="bokeh-{self.id}" class="bk-root"></div>
+            {all_scripts}
+            <script type="text/javascript">
+            (function() {{
+                var item = {item_json};
+
+                function embedWhenReady() {{
+                    // Check if all required libraries are loaded
+                    if (typeof Bokeh !== 'undefined' && Bokeh.embed) {{
+                        var target = document.getElementById("bokeh-{self.id}");
+                        if (target) {{
+                            try {{
+                                Bokeh.embed.embed_item(item);
+                                console.log("Bokeh plot embedded successfully");
+                            }} catch(e) {{
+                                console.error("Error embedding Bokeh plot:", e);
+                            }}
+                        }} else {{
+                            console.error("Target element not found");
+                            setTimeout(embedWhenReady, 50);
+                        }}
+                    }} else {{
+                        setTimeout(embedWhenReady, 50);
+                    }}
+                }}
+
+                if (document.readyState === 'loading') {{
+                    document.addEventListener('DOMContentLoaded', embedWhenReady);
+                }} else {{
+                    embedWhenReady();
+                }}
+            }})();
+            </script>
+            '''
 
-    def _repr_html_(self, start_backend=True):
-        """
-        HTML representation for Jupyter display.
+            if start_backend:
+                self._start_backend()
 
-        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:
+            self._notebook_rendering = html
             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")
+        else:
+            # In Jupyter Lab/Classic, use components() as before
+            script, div = components(self)
+            if start_backend:
+                self._start_backend()
+            self._notebook_rendering = f'{script}\n{div}'
+            return self._notebook_rendering
 
     def _repr_mimebundle_(self, include=None, exclude=None):
         """
@@ -301,6 +387,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 +399,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 +418,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/bokeh/state/_initialize.py

@@ -321,6 +321,13 @@ def order_bokeh_js():
     resources.Resources.js_files = property(js_files)
     return
 
+#def get_bokeh_js_paths( ):
+#    modes = ['cdn','inline','server','server-dev','relative','relative-dev','absolute','absolute-dev']
+#    return { 'new': { mode: resources.Resources(mode=mode).js_files for mode in modes },
+#             'old': { mode: resources.Resources(mode=mode)._old_js_files for mode in modes } }
+def get_bokeh_js_paths( ):
+    return resources.Resources(mode='cdn').js_files
+
 def get_jupyter_state( ):
     """Get the package-level Jupyter state"""
     return _JUPYTER_STATE

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)
-