vidavis 0.0.14__tar.gz → 0.1.0__tar.gz

{vidavis-0.0.14 → vidavis-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vidavis
-Version: 0.0.14
+Version: 0.1.0
 Summary: Radio astronomy visibility data visualization
 License: LGPL
 Author-email: Darrell Schiebel <darrell@schiebel.us>,Pam Harris <pharris@nrao.edu>

{vidavis-0.0.14 → vidavis-0.1.0}/pyproject.toml

@@ -7,15 +7,16 @@ authors = [
     { name = "Pam Harris", email = "pharris@nrao.edu" },
 ]
 dependencies = [
-    "bokeh==3.6.1",
+    "bokeh>=3.7, <3.9",
     "matplotlib",
+    "panel==1.8.2",
     "hvplot",
     "graphviper",
     "selenium",
 ]
 requires-python = ">=3.11, <3.14"
 readme = "readme.rst"
-version = "0.0.14"
+version = "0.1.0"
 
 [project.license]
 text = "LGPL"

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/apps/_ms_raster.py

@@ -42,26 +42,30 @@ class MsRaster(MsPlot):
 
     def __init__(self, ms=None, log_level="info", log_to_file=True, show_gui=False):
         super().__init__(ms, log_level, log_to_file, show_gui, "MsRaster")
-        self._raster_plot = RasterPlot()
         self._plot_inputs = RasterPlotInputs()
         self._plot_inputs.set_input('ms', self._ms_info['ms'])
+        self._raster_plot = RasterPlot()
 
         # Calculations for color limits
         self._spw_stats = {}
         self._spw_color_limits = {}
 
         if show_gui:
-            # Return plot for gui DynamicMap: empty plot when ms not set or plot fails
-            self._empty_plot = self._create_empty_plot()
-
-            # Set default style and plot inputs to use when launching gui
+            # Set default style and plot inputs to use for empty plot and gui
             self.set_style_params()
             self.plot()
+
+            # Initial plot for gui
+            self._create_empty_plot()
+
+            # Create and show gui panel
             self._launch_gui()
 
-            # Set filename TextInput widget to input ms, which triggers default plot
+            # Set filename TextInput widget to input ms
             if 'ms' in self._ms_info and self._ms_info['ms']:
-                self._set_filename([self._ms_info['ms']]) # function expects list from FileBrowser widget
+                self._set_filename(self._ms_info['ms'])
+                self._update_gui_ms_options()
+                self._update_plot(do_plot=True)
 
     def colormaps(self):
         ''' List available colormap (Bokeh palettes). '''
@@ -179,6 +183,9 @@ class MsRaster(MsPlot):
 
         start = time.time()
 
+        # If previous plot was shown, unlink from data streams
+        super().unlink_plot_locate()
+
         # Clear for new plot
         self._reset_plot(clear_plots)
 
@@ -192,9 +199,6 @@ class MsRaster(MsPlot):
         if selection:
             self._logger.info("Create raster plot with selection: %s", selection)
 
-        # If previous plot was shown, unlink from data streams
-        super().unlink_plot_streams()
-
         if not self._show_gui:
             # Cannot plot if no MS
             if not self._ms_data or not self._ms_data.is_valid():
@@ -264,7 +268,7 @@ class MsRaster(MsPlot):
         # Show plot inputs in log
         super()._set_plot_params(plot_inputs | self._raster_plot.get_plot_params()['style'])
         plot_params = [f"{key}={value}" for key, value in self._plot_params.items()]
-        self._logger.info("MsRaster plot parameters: %s", ", ".join(plot_params))
+        self._logger.info("MsRaster plot inputs: %s", ", ".join(plot_params))
 
         # Make plot. Add data min/max if GUI is shown to update color limits range.
         return self._raster_plot.raster_plot(raster_data, self._logger, self._show_gui)
@@ -423,7 +427,8 @@ class MsRaster(MsPlot):
     def _launch_gui(self):
         ''' Use Holoviz Panel to create and show a dashboard for plot inputs. '''
         callbacks = {
-            'filename': self._set_filename,
+            'set_filename': self._set_filename,
+            'select_filename': self._select_filename,
             'style': self._set_style_params,
             'color': self._set_color_range,
             'axes': self._set_axes,
@@ -433,105 +438,97 @@ class MsRaster(MsPlot):
             'iter_values': self._set_iter_values,
             'iteration': self._set_iteration,
             'title': self._set_title,
-            'plot_updating': self._update_plot_spinner,
             'update_plot': self._update_plot,
         }
+
         data_dims = self._ms_info['data_dims'] if 'data_dims' in self._ms_info else None
-        x_axis = self._plot_inputs.get_input('x_axis')
-        y_axis = self._plot_inputs.get_input('y_axis')
-        self._gui_layout = create_raster_gui(callbacks, data_dims, x_axis, y_axis)
-        self._gui_layout.show(title=self._app_name, threaded=True)
+        plot_info = {
+            'ms': self._ms_info['ms'],
+            'data_dims': data_dims,
+            'x_axis': self._plot_inputs.get_input('x_axis'),
+            'y_axis': self._plot_inputs.get_input('y_axis'),
+        }
+
+        self._gui_panel = create_raster_gui(callbacks, plot_info, self._empty_plot)
+        self._gui_panel.show(title=self._app_name, threaded=True)
 
     ###
     ### Main callback to create plot if inputs changed
     ###
 # pylint: disable=too-many-arguments, too-many-positional-arguments
-    def _update_plot(self, ms, do_plot, x, y, data, bounds):
+    def _update_plot(self, do_plot):
         ''' Create plot with inputs from GUI, or update cursor/box location.
             Callbacks:
-                ms (first plot) - return plot with default inputs
                 do_plot (Plot button clicked) - return plot with inputs from GUI
-                x, y (PointerXY) - update cursor location box
-                data (PointDraw from point_draw tool) - update location of drawn points in tab and log
-                bounds (Bounds from box_select tool) - update location of points in box in tab and log
             This function *must* return plot, even if empty plot or last plot, for DynamicMap.
         '''
+        if not do_plot or not self._gui_panel:
+            return
+
         # Remove toast notification and collapse selection accordion
         if self._toast:
             self._toast.destroy()
         self._get_selector("selectors").active = []
-
-        if not ms:
-            # GUI launched with no MS, nothing to plot
-            return self._empty_plot
-
-        # User changed inputs without clicking Plot button, or callback for cursor/box.
-        if not do_plot and not self._first_gui_plot:
-            # Locate callbacks
-            super()._locate_cursor(x, y, self._gui_plot_data, self._gui_layout[0])
-            super()._locate_points(data, self._gui_plot_data, self._gui_layout[0])
-            super()._locate_box(bounds, self._gui_plot_data, self._gui_layout[0])
-            # Not ready to update plot yet, return last plot.
-            return self._last_plot
-
-        # First plot for input ms, or user clicked Plot button for new inputs
-        if (self._set_ms(ms) or self._first_gui_plot) and self._ms_data and self._ms_data.is_valid():
-            # New MS set and is valid
-            self._update_gui_axis_options()
-
-        # Add ms path to detect change and make new plot
-        self._plot_inputs.set_input('ms', ms)
-
-        # Do new plot or resend last plot
-        self._reset_plot()
-        self.clear_selection()
         gui_plot = None
 
-        # Make plot if first plot or changed plot
-        style_inputs = self._raster_plot.get_plot_params()['style']
-        plot_inputs = self._plot_inputs.get_inputs()
-        if inputs_changed(plot_inputs, self._last_plot_inputs) or inputs_changed(style_inputs, self._last_style_inputs):
-            try:
-                # Check inputs from GUI then plot
-                data_dims = self._ms_info['data_dims']
-                self._plot_inputs.set_input('data_dims', data_dims)
-                self._plot_inputs.check_inputs()
-                if 'ps_selection' in self._gui_selection or 'ms_selection' in self._gui_selection:
-                    self._do_gui_selection()
-                gui_plot = self._do_gui_plot()
-            except (ValueError, TypeError, KeyError, RuntimeError) as e:
-                # Clear plot, inputs invalid
-                self._notify(str(e), 'error', 0)
-                gui_plot = self._empty_plot
-        else:
-            # Subparam values changed but not applied to plot
-            gui_plot = self._last_plot
+        if self._plot_inputs.get_input('ms'):
+            # Start spinner
+            self._update_plot_status(True)
+            self._update_plot_spinner(True)
+
+            # Clear last plot
+            self._reset_plot()
+            self.clear_selection()
+            if 'ps_selection' in self._gui_selection or 'ms_selection' in self._gui_selection:
+                self._do_gui_selection()
+
+            # Make plot if first plot or changed plot
+            style_inputs = self._raster_plot.get_plot_params()['style']
+            plot_inputs = self._plot_inputs.get_inputs()
+            if inputs_changed(plot_inputs, self._last_plot_inputs) or inputs_changed(style_inputs, self._last_style_inputs):
+                try:
+                    # Check inputs from GUI then plot
+                    self._plot_inputs.set_input('data_dims', self._ms_info['data_dims'])
+                    self._plot_inputs.check_inputs()
+                    gui_plot = self._do_gui_plot()
+                    self._last_gui_plot = gui_plot # save plot for locate callback
+                    self._logger.info("Plot update complete")
+
+                    # Put plot with dmap for locate streams in gui panel
+                    dmap = self._get_locate_dmap(self._locate_gui_points)
+                    self._gui_panel[0][0][0].object = gui_plot * dmap
+                except (ValueError, TypeError, KeyError, RuntimeError) as e:
+                    # Clear plot, inputs invalid
+                    self._notify(str(e), 'error', 0)
 
-        # Update plot inputs for gui
+        # Update plot inputs for gui tab
         self._set_plot_params(plot_inputs | style_inputs)
+        self._show_plot_inputs()
 
-        # Save inputs to see if changed next time
+        # Save inputs to check if changed next time
         self._last_plot_inputs = plot_inputs.copy()
         self._last_style_inputs = style_inputs.copy()
 
-        # Save plot for return value if plot update not requested
-        self._last_plot = gui_plot
-        self._first_gui_plot = False
-
         # Add plot inputs to GUI, change plot button to outline, and stop spinner
-        self._show_plot_inputs()
         self._update_plot_status(False)
         self._update_plot_spinner(False)
 
-        return gui_plot
 # pylint: enable=too-many-arguments, too-many-positional-arguments
 
+    def _locate_gui_points(self, x, y, data, bounds):
+        ''' Callback for locate streams '''
+        if self._gui_plot_data:
+            super()._locate_cursor(x, y, self._gui_plot_data, self._gui_panel[0])
+            super()._locate_points(data, self._gui_plot_data, self._gui_panel[0])
+            super()._locate_box(bounds, self._gui_plot_data, self._gui_panel[0])
+        return self._last_gui_plot
+
     def _do_gui_selection(self):
         ''' Apply selections selected in GUI '''
         if self._gui_selection['ps_selection']:
             self.select_ps(**self._gui_selection['ps_selection'])
         if self._gui_selection['ms_selection']:
-            self.select_ms(**self._gui_selection['ms_selection'])
+            self.select_ms(**self._gui_selection['ms_selection'], drop=True)
 
     ###
     ### Create plot for DynamicMap
@@ -544,35 +541,22 @@ class MsRaster(MsPlot):
                     # Make iter plot (possibly with subplots layout)
                     self._do_iter_plot()
                     subplots = self._plot_inputs.get_input('subplots')
-                    layout_plot, is_layout = super()._layout_plots(subplots)
-                    if is_layout:
+                    layout_plot = super()._layout_plots(subplots)
+                    if self._plot_inputs.is_layout():
                         # Cannot show Layout in DynamicMap, show in new tab
                         super().show()
-                        self._logger.info("Plot update complete")
                         return self._last_plot
                     # Overlay raster plot for DynamicMap
-                    self._logger.info("Plot update complete")
                     return layout_plot
 
                 # Make single Overlay raster plot for DynamicMap
-                plot = self._do_plot(True)
-                plot_params = self._raster_plot.get_plot_params()
+                gui_plot = self._do_plot(True)
 
                 # Update color limits in gui with data range
+                plot_params = self._raster_plot.get_plot_params()
                 self._update_color_range(plot_params)
 
-                # Update colorbar labels and limits
-                plot.QuadMesh.I = self._set_plot_colorbar(plot.QuadMesh.I, plot_params, "flagged")
-                plot.QuadMesh.II = self._set_plot_colorbar(plot.QuadMesh.II, plot_params, "unflagged")
-
-                self._logger.info("Plot update complete")
-                return plot.opts(
-                    hv.opts.QuadMesh(
-                        tools=['hover', 'box_select'],
-                        selection_fill_alpha=0.2, # dim selected areas of plot
-                        nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
-                    )
-                )
+                return gui_plot
             except RuntimeError as e:
                 error = f"Plot failed: {str(e)}"
                 super()._notify(error, "error", 0)
@@ -583,7 +567,7 @@ class MsRaster(MsPlot):
     def _create_empty_plot(self):
         ''' Create empty Overlay plot for DynamicMap with colormap params and required tools enabled '''
         plot_params = self._raster_plot.get_plot_params()
-        plot = hv.Overlay(
+        self._empty_plot = hv.Overlay(
             hv.QuadMesh([]).opts(
                 colorbar=plot_params['style']['show_flagged_colorbar'],
                 cmap=plot_params['style']['flagged_cmap'],
@@ -595,51 +579,14 @@ class MsRaster(MsPlot):
                 responsive=True,
             )
         )
-        return plot.opts(
-            hv.opts.QuadMesh(
-                tools=['hover', 'box_select'],
-                selection_fill_alpha=0.5, # dim selected areas of plot
-                nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
-            )
-        )
-
-    def _set_plot_colorbar(self, plot, plot_params, plot_type):
-        ''' Update plot colorbar labels and limits
-                plot_type is "unflagged" or "flagged"
-        '''
-        # Update colorbar labels if shown, else hide
-        colorbar_key = plot_type + '_colorbar'
-        if plot_params['plot'][colorbar_key]:
-            c_label = plot_params['plot']['axis_labels']['c']['label']
-            cbar_title = "Flagged " + c_label if plot_type == "flagged" else c_label
-
-            plot = plot.opts(
-                colorbar=True,
-                backend_opts={
-                    "colorbar.title": cbar_title,
-                }
-            )
-        else:
-            plot = plot.opts(
-                colorbar=False,
-            )
-
-        # Update plot color limits
-        color_limits = plot_params['plot']['color_limits']
-        if color_limits:
-            plot = plot.opts(
-                clim=color_limits,
-            )
-
-        return plot
 
     def _update_color_range(self, plot_params):
         ''' Set the start/end range on the colorbar to min/max of plot data '''
-        if self._gui_layout and 'data' in plot_params and 'data_range' in plot_params['data']:
+        if self._gui_panel and 'data' in plot_params and 'data_range' in plot_params['data']:
             # Update range slider start and end to data min and max
             data_range = plot_params['data']['data_range']
             style_selectors = self._get_selector('style')
-            range_slider = style_selectors[3][1]
+            range_slider = style_selectors[2][1]
             range_slider.start = data_range[0]
             range_slider.end = data_range[1]
 
@@ -648,13 +595,17 @@ class MsRaster(MsPlot):
     ###
     def _get_selector(self, name):
         ''' Return selector group for name, for setting options '''
-        selectors = self._gui_layout[2][1]
-        selectors_index = {'file': 0, 'style': 1, 'sel': 2, 'axes': 3, 'agg': 4, 'iter': 5, 'title': 6}
+        if not self._gui_panel:
+            return None
+
+        selectors = self._gui_panel[2][1]
         if name == "selectors":
             return selectors
+
+        selectors_index = {'file': 0, 'style': 1, 'sel': 2, 'axes': 3, 'agg': 4, 'iter': 5, 'title': 6}
         return selectors[selectors_index[name]]
 
-    def _update_gui_axis_options(self):
+    def _update_gui_ms_options(self):
         ''' Set gui options from ms data '''
         if 'data_dims' in self._ms_info:
             data_dims = self._ms_info['data_dims']
@@ -721,7 +672,10 @@ class MsRaster(MsPlot):
                             options.extend(value)
                         else:
                             options.append(value)
-                    selector.options = sorted(list(set(options)))
+                    if options:
+                        selector.options = sorted(list(set(options)))
+                    else:
+                        selector.options = ['']
 
     def _update_ms_selection_options(self, ms_selectors):
         ''' Set MeasurementSet gui options from ms data '''
@@ -737,27 +691,22 @@ class MsRaster(MsPlot):
     ###
     ### Callbacks for widgets which update other widgets
     ###
-    def _set_filename(self, filename):
+    def _select_filename(self, filename):
         ''' Set filename in text box from file selector value (list) '''
-        if filename and self._gui_layout:
+        if filename and self._gui_panel:
             file_selectors = self._get_selector('file')
 
             # Collapse FileSelector card
             file_selectors[1].collapsed = True
 
-            # Change plot button color to indicate change unless ms path not set previously
+            # Set filename from last file in file selector
             filename_input = file_selectors[0][0]
-            if filename_input.value:
-                self._update_plot_status(True)
-
-            # Set filename from last file in file selector (triggers _update_plot())
-            #filename_input.width = len(filename[-1])
             filename_input.value = filename[-1]
 
     def _set_iter_values(self, iter_axis):
         ''' Set up player with values when iter_axis is selected '''
         iter_axis = None if iter_axis == 'None' else iter_axis
-        if iter_axis and self._gui_layout:
+        if iter_axis and self._gui_panel:
             iter_values = self._ms_data.get_dimension_values(iter_axis)
             if iter_values:
 
@@ -798,26 +747,37 @@ class MsRaster(MsPlot):
 
     def _update_plot_spinner(self, plot_clicked):
         ''' Callback to start spinner when Plot button clicked. '''
-        if self._gui_layout:
+        if self._gui_panel:
             # Start spinner
-            spinner = self._gui_layout[2][2][1]
+            spinner = self._gui_panel[2][2][1]
             spinner.value = plot_clicked
 
     def _update_plot_status(self, plot_changed):
         ''' Change button color when plot inputs change. '''
-        if self._gui_layout:
+        if self._gui_panel:
             # Set button color
-            button = self._gui_layout[2][2][0]
+            button = self._gui_panel[2][2][0]
             button.button_style = 'solid' if plot_changed else 'outline'
 
     def _show_plot_inputs(self):
         ''' Show inputs for raster plot in column in GUI tab '''
-        inputs_column = self._gui_layout[0][1]
+        inputs_column = self._gui_panel[0][1]
         super()._fill_inputs_column(inputs_column)
 
     ###
     ### Callbacks for widgets which update plot inputs
     ###
+    def _set_filename(self, filename):
+        ''' Set ms input from file text input '''
+        self._plot_inputs.set_input('ms', filename)
+        if self._set_ms(filename):
+            # New MS set, update gui input options
+            try:
+                self._update_gui_ms_options()
+                self._update_plot_status(True) # Change plot button to solid
+            except AttributeError:
+                self._update_plot_status(False)
+
     def _set_title(self, title):
         ''' Set title from gui text input '''
         self._plot_inputs.set_input('title', title)

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/data/measurement_set/processing_set/_ps_coords.py

@@ -15,6 +15,8 @@ def set_coordinates(ms_xdt):
 
 def set_datetime_coordinate(ms_xds):
     ''' Convert float time to datetime for plotting. '''
+    if 'time' not in ms_xds.coords:
+        return
     time_attrs = ms_xds.time.attrs
     try:
         ms_xds.coords['time'] = to_datetime(ms_xds.time, unit=time_attrs['units'], origin=time_attrs['format'])
@@ -47,6 +49,8 @@ def set_index_coordinates(ms_xds, coordinates):
 
 def _set_frequency_unit(ms_xdt):
     ''' Convert frequency to GHz. Note attrs (channel_width, reference_frequency) still have Hz units in dict '''
+    if 'frequency' not in ms_xdt.coords:
+        return
     if ms_xdt.frequency.attrs['units'] == "Hz":
         frequency_xda = ms_xdt.frequency / 1e9
         frequency_attrs = ms_xdt.frequency.attrs

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/data/measurement_set/processing_set/_ps_data.py

@@ -51,23 +51,28 @@ class PsData:
             print(ps_summary)
         elif columns == "by_ms":
             for row in ps_summary.itertuples(index=False):
-                print(f"MSv4 name: {row[0]}")
-                print(f"intent: {row[1]}")
+                print(f"name: {row[0]}")
+                print(f"scan_intents: {row[1]}")
                 shape = row[2]
                 print(f"shape: {shape[0]} times, {shape[1]} baselines, {shape[2]} channels, {shape[3]} polarizations")
-                print(f"polarization: {row[3]}")
-                scans = [str(scan) for scan in row[4]]
+                print(f"execution_block_UID: {row[3]}")
+                print(f"polarization: {row[4]}")
+                scans = [str(scan) for scan in row[5]]
                 print(f"scan_name: {scans}")
-                print(f"spw_name: {row[5]}")
-                fields = [str(field) for field in row[6]]
+                print(f"spw_name: {row[6]}")
+                print(f"spw_intents: {row[7]}")
+                fields = [str(field) for field in row[8]]
                 print(f"field_name: {fields}")
-                sources = [str(source) for source in row[7]]
+                sources = [str(source) for source in row[9]]
                 print(f"source_name: {sources}")
-                lines = [str(line) for line in row[8]]
+                lines = [str(line) for line in row[10]]
                 print(f"line_name: {lines}")
-                field_coords = row[9]
+                field_coords = row[11]
                 print(f"field_coords: ({field_coords[0]}) {field_coords[1]} {field_coords[2]}")
-                print(f"frequency range: {row[10]:e} - {row[11]:e}")
+                print(f"session_reference_UID: {row[12]}")
+                print(f"scheduling_block_UID: {row[13]}")
+                print(f"project_UID: {row[14]}")
+                print(f"frequency range: {row[15]:e} - {row[16]:e}")
                 print("-----")
         else:
             if isinstance(columns, str):

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/data/measurement_set/processing_set/_ps_raster_data.py

@@ -41,12 +41,12 @@ def raster_data(ps_xdt, plot_inputs, logger):
     # Apply aggregator
     raster_xds = aggregate_data(raster_xds, plot_inputs, logger)
 
-    logger.debug(f"Plotting visibility data with shape: {raster_xds[correlated_data].shape}")
+    logger.debug(f"Plotting visibility data with shape: {dict(raster_xds[correlated_data].sizes)}")
     return raster_xds
 
 def _select_ms(ps_xdt, logger, **selection):
-    ''' Select ProcessingSet MeasurementSets for raster data '''
-    return select_ms(ps_xdt, logger, indexers=None, method=None, tolerance=None, drop=False, **selection)
+    ''' Select ProcessingSet MeasurementSets for raster data. '''
+    return select_ms(ps_xdt, logger, indexers=None, method=None, tolerance=None, **selection)
 
 def _select_raster_dimensions(ps_xdt, plot_inputs, logger):
     ''' Select default dimensions if needed for raster data '''
@@ -64,6 +64,9 @@ def _select_raster_dimensions(ps_xdt, plot_inputs, logger):
             dim_selection[dim] = _get_first_dim_value(ps_xdt, dim, plot_inputs, logger)
         elif 'iter_axis' in plot_inputs and dim == plot_inputs['iter_axis']:
             dim_selection[dim] = selection[dim]
+        elif selection and dim in selection and isinstance(selection[dim], list):
+            dim_selection[dim] = selection[dim][0]
+
     if dim_selection:
         # Remove from selection for next plot
         if 'iter_axis' in plot_inputs and plot_inputs['iter_axis']:

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/data/measurement_set/processing_set/_ps_select.py

@@ -192,7 +192,7 @@ def _select_time(ms_xdt, selection, method, tolerance, drop):
     else:
         # Select str or slice
         ms_xdt = ms_xdt.xr_ms.sel(indexers=None, method=time_method, tolerance=time_tolerance, drop=drop, **selection)
-        if ms_xdt.time.size == 0:
+        if 'time' in ms_xdt.coords and ms_xdt.time.size == 0:
             return ms_xdt, False
     return ms_xdt, True
 

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_locate_points.py

@@ -259,7 +259,7 @@ def _layout_point_location(text_list):
             location_row.append(location_col)
             location_col = pn.Column()
 
-        static_text.margin = (0, 10) # default (5, 10)
+        static_text.margin = (0, 5) # default (5, 10)
         location_col.append(static_text)
 
     # Add last column

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_ms_plot.py

@@ -12,16 +12,11 @@ import holoviews as hv
 import numpy as np
 import panel as pn
 from selenium import webdriver
-
-try:
-    from toolviper.utils.logger import get_logger, setup_logger
-    _HAVE_TOOLVIPER = True
-except ImportError:
-    _HAVE_TOOLVIPER = False
+from toolviper.utils.logger import setup_logger
 
 from vidavis.data.measurement_set._ms_data import MsData
 from vidavis.plot.ms_plot._locate_points import cursor_changed, points_changed, box_changed, update_cursor_location, update_points_location, update_box_location
-from vidavis.toolbox import AppContext, get_logger
+from vidavis.toolbox import AppContext
 
 class MsPlot:
 
@@ -33,11 +28,8 @@ class MsPlot:
             raise RuntimeError("Must provide ms/zarr path if gui not shown.")
 
         # Set logger: use toolviper logger else casalog else python logger
-        if _HAVE_TOOLVIPER:
-            self._logger = setup_logger(app_name, log_to_term=True, log_to_file=log_to_file, log_file=app_name.lower(), log_level=log_level.upper())
-        else:
-            self._logger = get_logger()
-            self._logger.setLevel(log_level.upper())
+        self._logger = setup_logger(app_name, log_to_term=True, log_to_file=log_to_file, log_file=app_name.lower(), log_level=log_level.upper())
+        self._logger.propagate = False # avoid repeating unformatted log messages in console
 
         # Save parameters; ms set below
         self._show_gui = show_gui
@@ -63,21 +55,26 @@ class MsPlot:
             # Initialize gui panel for callbacks
             self._gui_plot_data = None
             self._gui_selection = {}
-            self._gui_layout = None
-            self._first_gui_plot = True
 
             # For _update_plot callback: check if inputs changed
             self._last_plot_inputs = None
             self._last_style_inputs = None
+            self._last_gui_plot = None # return value
 
         # For locate callback: check if points changed
         self._plot_axes = None
         self._last_cursor = None
         self._last_points = None
         self._last_box = None
-
-        # Initialize non-gui show() panel for callbacks
-        self._show_layout = None
+        self._locate_plot_options = {
+            'tools': ['hover', 'box_select'],
+            'selection_fill_alpha': 0.2,    # dim selected areas of plot
+            'nonselection_fill_alpha': 1.0, # do not dim unselected areas of plot
+        }
+
+        # Initialize panels for callbacks
+        self._gui_panel = None
+        self._show_panel = None
         self._plot_data = None
 
         # Set data (if ms)
@@ -144,34 +141,36 @@ class MsPlot:
         self._plots.clear()
         self._plot_params.clear()
         self._plot_axes = None
+        if self._gui_panel is not None:
+            self._gui_panel[0][2].clear() # locate points
+            self._gui_panel[0][3].clear() # locate box
 
-    def unlink_plot_streams(self):
+    def unlink_plot_locate(self):
         ''' Disconnect streams when plot data is going to be replaced '''
-        if self._show_layout and len(self._show_layout.objects) == 4:
+        if self._show_panel and len(self._show_panel.objects) == 4:
             # Remove dmap (streams with callback) from previous plot
-            self._show_layout[0][0] = self._last_plot.opts(tools=['hover'])
+            self._show_panel[0][0] = self._last_plot.opts(tools=['hover'])
             # Remove locate widgets
-            self._show_layout[0].pop(1) # cursor locate box
-            self._show_layout.pop(3)    # box locate tab
-            self._show_layout.pop(2)    # points locate tab
+            self._show_panel[0].pop(1) # cursor locate box
+            self._show_panel.pop(3)    # box locate tab
+            self._show_panel.pop(2)    # points locate tab
 
     def clear_selection(self):
         ''' Clear data selection and restore original ProcessingSet '''
         if self._ms_data:
             self._ms_data.clear_selection()
-
         self._plot_inputs.remove_input('selection')
 
     def show(self):
         ''' 
-        Show interactive Bokeh plots in a browser. Plot tools include pan, zoom, hover, and save.
+        Show interactive Bokeh plots in a browser.
         '''
         if not self._plots:
             raise RuntimeError("No plots to show.  Run plot() to create plot.")
 
         # Single plot or combine plots into layout using subplots (rows, columns)
         subplots = self._plot_inputs.get_input('subplots')
-        layout_plot = self._layout_plots(subplots)
+        plot = self._layout_plots(subplots)
 
         # Add plot inputs column tab
         inputs_column = None
@@ -179,52 +178,39 @@ class MsPlot:
             inputs_column = pn.Column()
             self._fill_inputs_column(inputs_column)
 
-        # Show plot and plot inputs in tabs
+        # Show plots and plot inputs in tabs
         if self._plot_inputs.is_layout():
-            self._show_layout = pn.Tabs(('Plot', layout_plot))
+            self._show_panel = pn.Tabs(('Plot', plot))
             if inputs_column:
-                self._show_layout.append(('Plot Inputs', inputs_column))
+                self._show_panel.append(('Plot Inputs', inputs_column))
         else:
-            plot = layout_plot.opts(
-                hv.opts.QuadMesh(
-                    tools=['hover', 'box_select'],
-                    selection_fill_alpha=0.2,    # dim selected areas of plot
-                    nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
-                )
+            plot = plot.opts(
+                hv.opts.QuadMesh(**self._locate_plot_options),
+                hv.opts.Scatter(**self._locate_plot_options)
             )
             # Add DynamicMap for streams for single plot
-            points = hv.Points([]).opts(
-                size=5,
-                fill_color='white'
-            )
-            dmap = hv.DynamicMap(
-                self._locate,
-                streams=[
-                    hv.streams.PointerXY(),              # cursor location (x, y)
-                    hv.streams.PointDraw(source=points), # fixed points location (data)
-                    hv.streams.BoundsXY()                # box location (bounds)
-                ]
-            )
+            dmap = self._get_locate_dmap(self._locate)
 
             # Create panel layout
-            self._show_layout = pn.Tabs(
-                ('Plot', pn.Column(
-                    plot * dmap * points,
-                    pn.WidgetBox(), # cursor info
+            self._show_panel = pn.Tabs(
+                ('Plot',
+                    pn.Column(
+                        plot * dmap,
+                        pn.WidgetBox(), # cursor info
                     )
                 ),
                 sizing_mode='stretch_width',
             )
             if inputs_column:
-                self._show_layout.append(('Plot Inputs', inputs_column))
-            self._show_layout.append(('Locate Selected Points', pn.Column()))
-            self._show_layout.append(('Locate Selected Box', pn.Column()))
+                self._show_panel.append(('Plot Inputs', inputs_column))
+            self._show_panel.append(('Locate Selected Points', pn.Column()))
+            self._show_panel.append(('Locate Selected Box', pn.Column()))
 
             # return value for locate callback
             self._last_plot = plot
 
         # Show panel layout
-        self._show_layout.show(title=self._app_name, threaded=True)
+        self._show_panel.show(title=self._app_name, threaded=True)
 
     def save(self, filename='ms_plot.png', fmt='auto', width=900, height=600):
         '''
@@ -245,10 +231,10 @@ class MsPlot:
         # Combine plots into layout using subplots (rows, columns) if not single plot.
         # Set fixed size for export.
         subplots = self._plot_inputs.get_input('subplots')
-        layout_plot = self._layout_plots(subplots, (width, height))
+        plot = self._layout_plots(subplots, (width, height))
 
         iter_axis = self._plot_inputs.get_input('iter_axis')
-        if not isinstance(layout_plot, hv.Layout) and iter_axis:
+        if not isinstance(plot, hv.Layout) and iter_axis:
             # Save iterated plots individually, with index appended to filename
             iter_range = self._plot_inputs.get_input('iter_range')
             plot_idx = 0 if iter_range is None else iter_range[0]
@@ -257,7 +243,7 @@ class MsPlot:
                 self._save_plot(plot, exportname, fmt)
                 plot_idx += 1
         else:
-            self._save_plot(layout_plot, filename, fmt)
+            self._save_plot(plot, filename, fmt)
         self._logger.debug("Save elapsed time: %.2fs.", time.time() - start_time)
 
     def _layout_plots(self, subplots, fixed_size=None):
@@ -398,6 +384,22 @@ class MsPlot:
                 str_pane.margin = (0, 10)
                 inputs_tab_column.append(str_pane)
 
+    def _get_locate_dmap(self, callback):
+        ''' Return DynamicMap with streams callback to locate points '''
+        points = hv.Points([]).opts(
+            size=5,
+            fill_color='white'
+        )
+        dmap = hv.DynamicMap(
+            callback,
+            streams=[
+                hv.streams.PointerXY(),              # cursor location (x, y)
+                hv.streams.PointDraw(source=points), # fixed points location (data)
+                hv.streams.BoundsXY()                # box location (bounds)
+            ]
+        )
+        return dmap * points
+
     def _get_plot_axes(self):
         ''' Return x, y, vis axes '''
         if not self._plot_axes:
@@ -409,9 +411,9 @@ class MsPlot:
 
     def _locate(self, x, y, data, bounds):
         ''' Callback for all show plot streams '''
-        self._locate_cursor(x, y, self._plot_data, self._show_layout)
-        self._locate_points(data, self._plot_data, self._show_layout)
-        self._locate_box(bounds, self._plot_data, self._show_layout)
+        self._locate_cursor(x, y, self._plot_data, self._show_panel)
+        self._locate_points(data, self._plot_data, self._show_panel)
+        self._locate_box(bounds, self._plot_data, self._show_panel)
         return self._last_plot
 
     def _locate_cursor(self, x, y, plot_data, tabs):

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_ms_plot_selectors.py

@@ -7,21 +7,23 @@ import panel as pn
 from vidavis.bokeh._palette import available_palettes
 from vidavis.plot.ms_plot._ms_plot_constants import VIS_AXIS_OPTIONS, AGGREGATOR_OPTIONS, PS_SELECTION_OPTIONS, MS_SELECTION_OPTIONS, DEFAULT_UNFLAGGED_CMAP, DEFAULT_FLAGGED_CMAP
 
-def file_selector(description, start_dir, callback):
+def file_selector(callbacks, ms):
     ''' Return a layout for file selection with input description and start directory.
         Includes a TextInput and a FileSelector, with a callback to set TextInput from FileSelector.
     '''
-    filename = pn.widgets.TextInput(
-        description=description,
+    input_filename = pn.widgets.TextInput(
+        description='Path to MeasurementSet (ms or zarr)',
         name="Filename",
         placeholder='Enter filename or use file browser below',
+        value=ms,
         sizing_mode='stretch_width',
     )
+    set_file = pn.bind(callbacks['set_filename'], input_filename)
 
     file_select = pn.widgets.FileSelector(
-        start_dir,
+        '~',
     )
-    select_file = pn.bind(callback, file_select)
+    select_file = pn.bind(callbacks['select_filename'], file_select)
 
     fs_card = pn.Card(
         file_select,
@@ -33,8 +35,9 @@ def file_selector(description, start_dir, callback):
 
     return pn.Column(
         pn.Row( # [0]
-            filename,   # [0]
-            select_file # [1]
+            input_filename,   # [0]
+            set_file,   # [1]
+            select_file # [2]
         ),
         fs_card, # [1]
         width_policy='min',
@@ -90,18 +93,22 @@ def style_selector(style_callback, color_range_callback):
         pn.Row( # [1]
             colorbar_checkbox,         # [0]
             flagged_colorbar_checkbox, # [1]
+            select_style,              # [2]
         ),
-        select_style, # [2]
-        pn.Row( # [3]
+        pn.Row( # [2]
             color_mode_selector, # [0]
             color_range_slider,  # [1]
+            select_color_range,  # [2]
         ),
-        select_color_range, # [4]
         width_policy='min',
     )
 
-def axis_selector(x_axis, y_axis, axis_options, include_vis, callback):
+def axis_selector(plot_info, include_vis, callback):
     ''' Return layout of selectors for x-axis, y-axis, and vis-axis '''
+    axis_options = plot_info['data_dims'] if 'data_dims' in plot_info else []
+    x_axis = plot_info['x_axis'] if 'x_axis' in plot_info else ''
+    y_axis = plot_info['y_axis'] if 'y_axis' in plot_info else ''
+
     x_options = axis_options if axis_options else [x_axis]
     x_selector = pn.widgets.Select(
         name="X Axis",

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_plot_inputs.py

@@ -2,7 +2,7 @@
 
 def inputs_changed(plot_inputs, last_plot_inputs):
     ''' Check if inputs changed and need new plot '''
-    if not last_plot_inputs:
+    if plot_inputs and not last_plot_inputs:
         return True
 
     for key, val in plot_inputs.items():

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_raster_plot.py

@@ -2,8 +2,6 @@
 Class to create a raster plot of visibility/spectrum data using plot parameters.
 '''
 
-import holoviews as hv
-
 # hvPlot extensions used to plot xarray DataArray and pandas DataFrame
 # pylint: disable=unused-import
 import hvplot.xarray
@@ -120,10 +118,8 @@ class RasterPlot:
         if is_gui: # update data range for colorbar
             self._plot_params['data']['data_range'] = (xda.min().values.item(), xda.max().values.item())
 
-        # Make Overlay plot with hover tools
-        return (flagged_plot * unflagged_plot).opts(
-            hv.opts.QuadMesh(tools=['hover'])
-        )
+        # Make Overlay plot
+        return flagged_plot * unflagged_plot
 
     def _get_plot_title(self, data, plot_inputs, ms_name):
         ''' Form string containing ms name and selected values using data (xArray Dataset) '''

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_raster_plot_gui.py

@@ -2,28 +2,31 @@
     Create interactive GUI for ms raster plotting
 '''
 
-import holoviews as hv
 import panel as pn
 from vidavis.plot.ms_plot._ms_plot_selectors import (file_selector, title_selector, style_selector,
     axis_selector, aggregation_selector, iteration_selector, selection_selector, plot_starter)
 
-def create_raster_gui(callbacks, data_dims, x_axis, y_axis):
-    ''' Use Holoviz Panel to create a dashboard for plot inputs and raster plot display. '''
+def create_raster_gui(callbacks, plot_info, empty_plot):
+    ''' Use Holoviz Panel to create a dashboard for plot inputs and raster plot display.
+        ms (str): path to MS, if set
+        plot_info (dict): with keys 'ms', 'data_dims', 'x_axis', 'y_axis'
+        empty_plot (hv.Overlay): QuadMesh overlay plot with no data
+    '''
     # Accordion of widgets for plot inputs
-    selectors = get_plot_input_selectors(callbacks, data_dims, x_axis, y_axis)
+    selectors = get_plot_input_selectors(callbacks, plot_info)
 
     # Plot button and spinner while plotting
-    init_plot = plot_starter(callbacks['plot_updating'])
+    init_plot = plot_starter(callbacks['update_plot'])
 
     # Dynamic map for plot, with callback when inputs change or location needed
-    dmap, points = get_plot_dmap(callbacks, selectors, init_plot)
+    #dmap, points = get_plot_dmap(callbacks, selectors, init_plot)
 
     return pn.Row(
         pn.Tabs(             # Row [0]
             ('Plot',                                 # Tabs[0]
                 pn.Column(
-                    dmap * points,  # [0] plot with hv.Points overlay for point_draw
-                    pn.WidgetBox(), # [1] cursor location
+                    pn.pane.HoloViews(empty_plot), # [0] plot
+                    pn.WidgetBox(),                # [1] cursor location
                 )
             ),
             ('Plot Inputs', pn.Column()),            # Tabs[1]
@@ -43,21 +46,22 @@ def create_raster_gui(callbacks, data_dims, x_axis, y_axis):
         sizing_mode='stretch_height',
     )
 
-def get_plot_input_selectors(callbacks, data_dims, x_axis, y_axis):
+def get_plot_input_selectors(callbacks, plot_info):
     ''' Create accordion of widgets for plot inputs selection '''
     # Select MS
-    file_selectors = file_selector('Path to MeasurementSet (ms or zarr) for plot', '~' , callbacks['filename'])
+    file_selectors = file_selector(callbacks, plot_info['ms'])
 
     # Select style - colormaps, colorbar, color limits
     style_selectors = style_selector(callbacks['style'], callbacks['color'])
 
     # Select x, y, and vis axis
-    axis_selectors = axis_selector(x_axis, y_axis, data_dims, True, callbacks['axes'])
+    axis_selectors = axis_selector(plot_info, True, callbacks['axes'])
 
     # Select from ProcessingSet and MeasurementSet
     selection_selectors = selection_selector(callbacks['select_ps'], callbacks['select_ms'])
 
     # Generic axis options, updated when ms is set
+    data_dims = plot_info['data_dims'] if 'data_dims' in plot_info else None
     axis_options = data_dims if data_dims else []
 
     # Select aggregator and axes to aggregate
@@ -81,25 +85,3 @@ def get_plot_input_selectors(callbacks, data_dims, x_axis, y_axis):
     )
     selectors.toggle = True
     return selectors
-
-def get_plot_dmap(callbacks, selectors, init_plot):
-    ''' Dynamic map for updating plot from callback function '''
-    # Connect plot to filename and plot button; add streams for cursor position, drawn points, and selected box
-    # 'update_plot' callback must have parameters (ms, do_plot, x, y, data, bounds)
-    points = hv.Points([]).opts(
-        size=5,
-        fill_color='white'
-    )
-    dmap = hv.DynamicMap(
-        pn.bind(
-            callbacks['update_plot'],
-            ms=selectors[0][0][0],
-            do_plot=init_plot[0],
-        ),
-        streams=[
-            hv.streams.PointerXY(),              # cursor location (x, y)
-            hv.streams.PointDraw(source=points), # fixed cursor location (data)
-            hv.streams.BoundsXY()                # box location (bounds)
-        ]
-    )
-    return dmap, points

{vidavis-0.0.14 → vidavis-0.1.0}/src/vidavis/plot/ms_plot/_raster_plot_inputs.py

@@ -10,7 +10,7 @@ class RasterPlotInputs:
     '''
 
     def __init__(self):
-        self._plot_inputs = {}
+        self._plot_inputs = {'selection': {}}
 
     def get_inputs(self):
         ''' Getter for stored plot inputs '''
@@ -31,8 +31,6 @@ class RasterPlotInputs:
 
     def set_selection(self, selection):
         ''' Add selection dict to existing selection in plot inputs '''
-        if 'selection' not in self._plot_inputs:
-            self._plot_inputs['selection'] = {}
         self._plot_inputs['selection'] |= selection
         if 'data_group_name' in selection:
             self._plot_inputs['data_group'] = selection['data_group_name']
@@ -41,9 +39,7 @@ class RasterPlotInputs:
         ''' Return value for selection key '''
         try:
             return self.get_input('selection')[key]
-        except (TypeError, KeyError):
-            # TypeError: get_input returned None for 'selection'
-            # KeyError: key not in selection
+        except KeyError:
             return None
 
     def set_inputs(self, plot_inputs):
@@ -54,10 +50,13 @@ class RasterPlotInputs:
 
     def remove_input(self, name):
         ''' Remove plot input with name, if it exists '''
-        try:
-            del self._plot_inputs[name]
-        except KeyError:
-            pass
+        if name == 'selection':
+            self._plot_inputs['selection'] = {}
+        else:
+            try:
+                del self._plot_inputs[name]
+            except KeyError:
+                pass
 
     def check_inputs(self):
         ''' Check input values are valid, adjust for data dims '''