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

cubevis/bokeh/models/_bokeh_app_context.py

@@ -0,0 +1,110 @@
+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__)
+
+class BokehAppContext(LayoutDOM):
+    """
+    Custom Bokeh model that bridges Python AppContext with JavaScript.
+    Initializes session-level data structure and app-specific state.
+    """
+    ui = Nullable(Instance(UIElement), help="""
+    A UI element, which can be plots, layouts, widgets, or any other UIElement.
+    """)
+
+    app_id = String(default="")
+    session_id = String(default="")
+    app_state = Dict(String, Any, default={})
+
+    # Class-level session ID shared across all apps in the same Python session
+    _session_id = None
+    
+    @classmethod
+    def get_session_id(cls):
+        """Get or create a session ID for this Python session"""
+        if cls._session_id is None:
+            cls._session_id = str(uuid4())
+        return cls._session_id
+
+    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" )
+
+        kwargs['session_id'] = self.get_session_id( )
+
+        if 'ui' not in kwargs:
+            kwargs['ui'] = ui
+        if 'app_id' not in kwargs:
+            kwargs['app_id'] = str(uuid4())
+        
+        super().__init__(**kwargs)
+
+    def _sphinx_height_hint(self):
+        """Delegate height hint to the wrapped UI element"""
+        logger.debug(f"\tShowable::_sphinx_height_hint(): {id(self)}")
+        if self.ui and hasattr(self.ui, '_sphinx_height_hint'):
+            return self.ui._sphinx_height_hint()
+        return None
+
+    def update_app_state(self, state_updates):
+        """
+        Update the application state (will be in the generated HTML/JS)
+
+        Args:
+            state_updates: dict of state key-value pairs to update
+        """
+        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/bokeh/sources/_data_pipe.py

@@ -36,13 +36,14 @@ import asyncio
 import traceback
 import time
 import json
+from uuid import uuid4
 
 from bokeh.models.sources import DataSource
 from bokeh.util.compiler import TypeScript
-from bokeh.core.properties import Tuple, String, Int, Instance, Nullable
+from bokeh.core.properties import Tuple, String, Int, Instance, Nullable, Bool
 from bokeh.models.callbacks import Callback
 
-from ...utils import serialize, deserialize
+from ...utils import serialize, deserialize, is_interactive_jupyter
 from ..state import casalib_url, cubevisjs_url
 from .. import BokehInit
 
@@ -72,6 +73,10 @@ class DataPipe(DataSource,BokehInit):
 
     address = Tuple( String, Int, help="two integer sequence representing the address and port to use for the websocket" )
 
+    instance_id = String( help="Unique ID for each DataPipe object" )
+
+    conflict_check = Bool( default=True, help="Perform check to avoid reuse of URL for GUI. Not needed in the Jupyter context" )
+
     # Class-level session tracking to prevent multiple connections
     _active_sessions = {}  # session_id -> {'websocket': ws, 'timestamp': time, 'datapipe': instance}
     _session_lock = threading.Lock()
@@ -82,7 +87,14 @@ class DataPipe(DataSource,BokehInit):
     #__javascript__ = [ casalib_url( ), cubevisjs_url( ) ]
 
     def __init__( self, *args, abort=None, **kwargs ):
+
+        if 'conflict_check' not in kwargs:
+            kwargs['conflict_check'] = not is_interactive_jupyter( )
+        if 'instance_id' not in kwargs:
+            kwargs['instance_id'] = str(uuid4( ))
+
         super( ).__init__( *args, **kwargs )
+
         self.__send_queue = { }
         self.__pending = { }
         self.__incoming_callbacks = { }

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