vidavis 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

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/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/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/plot/ms_plot/_locate_points.py

@@ -10,8 +10,9 @@ import panel as pn
 
 from vidavis.plot.ms_plot._ms_plot_constants import TIME_FORMAT
 
-def cursor_changed(x, y, last_cursor):
+def cursor_changed(cursor, last_cursor):
     ''' Check whether cursor position changed '''
+    x, y = cursor
     if not x and not y:
         return False # not cursor callback
     if last_cursor and last_cursor == (x, y):
@@ -21,7 +22,7 @@ def cursor_changed(x, y, last_cursor):
 def points_changed(data, last_points):
     ''' Check whether point positions changed '''
     # No data = {'x': [], 'y': []}
-    if len(data['x']) == 0 and len(data['y']) == 0:
+    if not data or (len(data['x']) == 0 and len(data['y']) == 0):
         return False # not points callback
     if last_points and last_points == data:
         return False # same points
@@ -36,7 +37,67 @@ def box_changed(bounds, last_box):
         return False # same box
     return True # new box, box changed, or box deleted
 
-def locate_point(xds, position, vis_axis):
+def update_cursor_location(cursor, plot_axes, xds, cursor_locate_box):
+    ''' Show data values for cursor x,y position in cursor location box (pn.WidgetBox) '''
+    # Convert plot values to selection values to select plot data
+    cursor_locate_box.clear()
+
+    x, y = cursor
+    x_axis, y_axis, vis_axis = plot_axes
+    cursor_position = {x_axis: x, y_axis: y}
+    cursor_location = _locate_point(xds, cursor_position, vis_axis)
+
+    location_column = pn.Column(pn.widgets.StaticText(name="Cursor Location"))
+    # Add row of columns to column layout
+    location_row = _layout_point_location(cursor_location)
+    location_column.append(location_row)
+    # Add location column to widget box
+    cursor_locate_box.append(location_column)
+
+def update_points_location(data, plot_axes, xds, points_tab_column, logger):
+    ''' Show data values for points in point_draw in tab and log '''
+    points_tab_column.clear()
+    if data:
+        x_axis, y_axis, vis_axis = plot_axes
+        logger.info("Locate selected points:")
+
+        for point in list(zip(data['x'], data['y'])):
+            # Locate point
+            point_position = {x_axis: point[0], y_axis: point[1]}
+            point_location = _locate_point(xds, point_position, vis_axis)
+            # Format location and add to points locate column
+            location_layout = _layout_point_location(point_location)
+            points_tab_column.append(location_layout)
+            points_tab_column.append(pn.layout.Divider())
+
+            # Format and add to log
+            location_list = [f"{static_text.name}={static_text.value}" for static_text in point_location]
+            logger.info(", ".join(location_list))
+
+def update_box_location(bounds, plot_axes, xds, box_tab_column, logger):
+    ''' Show data values for points in box_select in tab and log '''
+    box_tab_column.clear()
+    if bounds:
+        x_axis, y_axis, vis_axis = plot_axes
+        box_bounds = {x_axis: (bounds[0], bounds[2]), y_axis: (bounds[1], bounds[3])}
+        npoints, point_locations = _locate_box(xds, box_bounds, vis_axis)
+
+        message = f"Locate {npoints} points"
+        message += " (only first 100 shown):" if npoints > 100 else ":"
+        logger.info(message)
+        box_tab_column.append(pn.pane.Str(message))
+
+        for point in point_locations:
+            # Format and add to box locate column
+            location_layout = _layout_point_location(point)
+            box_tab_column.append(location_layout)
+            box_tab_column.append(pn.layout.Divider())
+
+            # Format and add to log
+            location_list = [f"{static_text.name}={static_text.value}" for static_text in point]
+            logger.info(", ".join(location_list))
+
+def _locate_point(xds, position, vis_axis):
     '''
         Get cursor location as values of coordinates and data vars.
             xds (Xarray Dataset): data for plot
@@ -48,15 +109,18 @@ def locate_point(xds, position, vis_axis):
     static_text_list = []
     values, units = _get_point_location(xds, position, vis_axis)
 
-    # Rename baseline coordinate names to not confuse user for selection
-    baseline_names = {'baseline': 'baseline_index', 'baseline_name': 'baseline', 'antenna_name': 'antenna_index', 'antenna': 'antenna_name'}
+    # List indexed coordinate int value with with str value
+    index_coords = {'baseline': 'baseline_name', 'antenna_name': 'antenna', 'polarization': 'polarization_name'}
     for name, value in values.items():
-        name = baseline_names[name] if name in baseline_names else name
+        if name in index_coords.values():
+            continue
+        if name in index_coords and isinstance(value, int):
+            value = f"{values[index_coords[name]]} ({value})" # append name to index
         static_text = _get_location_text(name, value, units)
         static_text_list.append(static_text)
     return static_text_list
 
-def locate_box(xds, bounds, vis_axis):
+def _locate_box(xds, bounds, vis_axis):
     '''
         Get location of each point in box bounds as values of coordinate and data vars.
             xds (Xarray Dataset): data for plot
@@ -83,7 +147,7 @@ def locate_box(xds, bounds, vis_axis):
             for y in sel_xds[y_coord].values:
                 for x in sel_xds[x_coord].values:
                     position = {x_coord: x, y_coord: y}
-                    points.append(locate_point(sel_xds, position, vis_axis))
+                    points.append(_locate_point(sel_xds, position, vis_axis))
                     counter += 1
                     if counter == 100:
                         break
@@ -183,3 +247,21 @@ def _get_location_text(name, value, units):
             units.pop(name) # no unit for datetime string
     unit = units[name] if name in units else ""
     return pn.widgets.StaticText(name=name, value=f"{value} {unit}")
+
+def _layout_point_location(text_list):
+    ''' Layout list of StaticText in row of columns containing 3 rows '''
+    location_row = pn.Row()
+    location_col = pn.Column()
+
+    for static_text in text_list:
+        # 3 entries per column; append to row and start new column
+        if len(location_col.objects) == 3:
+            location_row.append(location_col)
+            location_col = pn.Column()
+
+        static_text.margin = (0, 5) # default (5, 10)
+        location_col.append(static_text)
+
+    # Add last column
+    location_row.append(location_col)
+    return location_row

vidavis/plot/ms_plot/_ms_plot.py

@@ -12,15 +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.toolbox import AppContext, get_logger
+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
 
 class MsPlot:
 
@@ -32,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
@@ -45,39 +38,47 @@ class MsPlot:
         # Set up temp dir for output html files
         self._app_context = AppContext(app_name)
 
+        # Initialize plot inputs and params
+        self._plot_inputs = None # object to manage plot inputs
+
+        # Initialize plots
+        self._plot_init = False
+        self._plots = []
+        self._last_plot = None
+        self._plot_params = [] # for plot inputs tab
+
         if show_gui:
             # Enable "toast" notifications
             pn.config.notifications = True
             self._toast = None # for destroy() with new plot or new notification
 
             # Initialize gui panel for callbacks
-            self._gui_layout = None
-            self._first_gui_plot = True
-            self._last_gui_plot = None
             self._gui_plot_data = None
+            self._gui_selection = {}
 
-            # For _update_plot callback: check which inputs and point positions changed
+            # For _update_plot callback: check if inputs changed
             self._last_plot_inputs = None
             self._last_style_inputs = None
-            self._last_cursor = None
-            self._last_points = None
-            self._last_box = None
-
-        # Initialize plot inputs and params
-        self._plot_inputs = {'selection': {}}
-        self._plot_params = None
-
-        # Initialize plots
-        self._plot_init = False
-        self._plots_locked = False
-        self._plots = []
-
-        # Initialize show() panel for callbacks
-        self._show_layout = 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
+        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)
-        self._data = None
+        self._ms_data = None
         self._ms_info = {}
         self._set_ms(ms)
 # pylint: enable=too-many-arguments, too-many-positional-arguments
@@ -94,15 +95,15 @@ class MsPlot:
                                  'field_name', 'source_name', 'field_coords', 'start_frequency', 'end_frequency'
             Returns: list of unique values when single column is requested, else None
         '''
-        if self._data:
-            self._data.summary(data_group, columns)
+        if self._ms_data:
+            self._ms_data.summary(data_group, columns)
         else:
             self._logger.error("Error: MS path has not been set")
 
     def data_groups(self):
         ''' Returns set of data groups from all ProcessingSet ms_xds. '''
-        if self._data:
-            return self._data.data_groups()
+        if self._ms_data:
+            return self._ms_data.data_groups()
         self._logger.error("Error: MS path has not been set")
         return None
 
@@ -111,8 +112,8 @@ class MsPlot:
             Dimension options include 'time', 'baseline' (for visibility data), 'antenna' (for spectrum data), 'antenna1',
                 'antenna2', 'frequency', 'polarization'.
         '''
-        if self._data:
-            return self._data.get_dimension_values(dimension)
+        if self._ms_data:
+            return self._ms_data.get_dimension_values(dimension)
         self._logger.error("Error: MS path has not been set")
         return None
 
@@ -120,8 +121,8 @@ class MsPlot:
         ''' Plot antenna positions.
                 label_antennas (bool): label positions with antenna names.
         '''
-        if self._data:
-            self._data.plot_antennas(label_antennas)
+        if self._ms_data:
+            self._ms_data.plot_antennas(label_antennas)
         else:
             self._logger.error("Error: MS path has not been set")
 
@@ -130,50 +131,86 @@ class MsPlot:
                 data_group (str): data group to use for field and source xds.
                 label_fields (bool): label all fields on the plot if True, else label central field only
         '''
-        if self._data:
-            self._data.plot_phase_centers(data_group, label_fields)
+        if self._ms_data:
+            self._ms_data.plot_phase_centers(data_group, label_fields)
         else:
             self._logger.error("Error: MS path has not been set")
 
     def clear_plots(self):
         ''' Clear plot list '''
-        while self._plots_locked:
-            time.sleep(1)
         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):
+        ''' Disconnect streams when plot data is going to be replaced '''
+        if self._show_panel and len(self._show_panel.objects) == 4:
+            # Remove dmap (streams with callback) from previous plot
+            self._show_panel[0][0] = self._last_plot.opts(tools=['hover'])
+            # Remove locate widgets
+            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._data:
-            self._data.clear_selection()
-
-        self._plot_inputs['selection'] = {}
+        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.")
 
-        # Do not delete plot list until rendered
-        self._plots_locked = True
-
         # Single plot or combine plots into layout using subplots (rows, columns)
-        layout_plot = self._layout_plots(self._plot_inputs['subplots'])
-
-        # Render plot as Bokeh Figure or GridPlot so can show() in script without tying up thread
-        bokeh_fig = hv.render(layout_plot)
+        subplots = self._plot_inputs.get_input('subplots')
+        plot = self._layout_plots(subplots)
 
-        self._plots_locked = False
+        # Add plot inputs column tab
+        inputs_column = None
         if self._plot_params:
-            # Show plot and plot inputs in tabs
-            column = pn.Column()
-            for param in self._plot_params:
-                column.append(pn.pane.Str(param))
-            self._show_layout = pn.Tabs(('Plot', bokeh_fig), ('Plot Inputs', column))
+            inputs_column = pn.Column()
+            self._fill_inputs_column(inputs_column)
+
+        # Show plots and plot inputs in tabs
+        if self._plot_inputs.is_layout():
+            self._show_panel = pn.Tabs(('Plot', plot))
+            if inputs_column:
+                self._show_panel.append(('Plot Inputs', inputs_column))
         else:
-            self._show_layout = pn.pane.Bokeh(bokeh_fig)
-        self._show_layout.show(title=self._app_name, threaded=True)
+            plot = plot.opts(
+                hv.opts.QuadMesh(**self._locate_plot_options),
+                hv.opts.Scatter(**self._locate_plot_options)
+            )
+            # Add DynamicMap for streams for single plot
+            dmap = self._get_locate_dmap(self._locate)
+
+            # Create panel layout
+            self._show_panel = pn.Tabs(
+                ('Plot',
+                    pn.Column(
+                        plot * dmap,
+                        pn.WidgetBox(), # cursor info
+                    )
+                ),
+                sizing_mode='stretch_width',
+            )
+            if inputs_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_panel.show(title=self._app_name, threaded=True)
 
     def save(self, filename='ms_plot.png', fmt='auto', width=900, height=600):
         '''
@@ -193,17 +230,20 @@ class MsPlot:
 
         # Combine plots into layout using subplots (rows, columns) if not single plot.
         # Set fixed size for export.
-        layout_plot = self._layout_plots(self._plot_inputs['subplots'], (width, height))
+        subplots = self._plot_inputs.get_input('subplots')
+        plot = self._layout_plots(subplots, (width, height))
 
-        if not isinstance(layout_plot, hv.Layout) and self._plot_inputs['iter_axis']:
+        iter_axis = self._plot_inputs.get_input('iter_axis')
+        if not isinstance(plot, hv.Layout) and iter_axis:
             # Save iterated plots individually, with index appended to filename
-            plot_idx = 0 if self._plot_inputs['iter_range'] is None else self._plot_inputs['iter_range'][0]
+            iter_range = self._plot_inputs.get_input('iter_range')
+            plot_idx = 0 if iter_range is None else iter_range[0]
             for plot in self._plots:
                 exportname = f"{name}_{plot_idx}{ext}"
                 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):
@@ -266,22 +306,22 @@ class MsPlot:
             Return whether ms changed (false if ms_path is None, not set yet), even if error. '''
         self._ms_info['ms'] = ms_path
         ms_error = ""
-        if not ms_path or (self._data and self._data.is_ms_path(ms_path)):
+        if not ms_path or (self._ms_data and self._ms_data.is_ms_path(ms_path)):
             return False
 
         try:
             # Set new MS data
-            self._data = MsData(ms_path, self._logger)
-            data_path = self._data.get_path()
+            self._ms_data = MsData(ms_path, self._logger)
+            data_path = self._ms_data.get_path()
             self._ms_info['ms'] = data_path
             root, ext = os.path.splitext(os.path.basename(data_path))
             while ext != '':
                 root, ext = os.path.splitext(root)
             self._ms_info['basename'] = root
-            self._ms_info['data_dims'] = self._data.get_data_dimensions()
+            self._ms_info['data_dims'] = self._ms_data.get_data_dimensions()
         except RuntimeError as e:
             ms_error = str(e)
-            self._data = None
+            self._ms_data = None
         if ms_error:
             self._notify(ms_error, 'error', 0)
         return True
@@ -320,4 +360,86 @@ class MsPlot:
                 del plot_inputs[key]
             except KeyError:
                 pass
-        self._plot_params = sorted([f"{key}={value}" for key, value in plot_inputs.items()])
+        if not self._plot_params:
+            self._plot_params = plot_inputs
+        else:
+            for param, value in self._plot_params.items():
+                if plot_inputs[param] != value:
+                    if isinstance(value, list):
+                        # append new value to existing list if not repeat
+                        if plot_inputs[param] != value[-1]:
+                            value.append(plot_inputs[param])
+                    else:
+                        # make list to include new value
+                        value = [value, plot_inputs[param]]
+                    self._plot_params[param] = value
+
+    def _fill_inputs_column(self, inputs_tab_column):
+        ''' Format plot inputs and list in Panel column '''
+        if self._plot_params:
+            inputs_tab_column.clear()
+            plot_params = sorted([f"{key}={value}" for key, value in self._plot_params.items()])
+            for param in plot_params:
+                str_pane = pn.pane.Str(param)
+                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:
+            x_axis = self._plot_inputs.get_input('x_axis')
+            y_axis = self._plot_inputs.get_input('y_axis')
+            vis_axis = self._plot_inputs.get_input('vis_axis')
+            self._plot_axes = (x_axis, y_axis, vis_axis)
+        return self._plot_axes
+
+    def _locate(self, x, y, data, bounds):
+        ''' Callback for all show plot streams '''
+        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):
+        ''' Show location from cursor position in cursor locate box '''
+        cursor = (x, y)
+        if cursor_changed(cursor, self._last_cursor):
+            # new cursor position - update cursor location box
+            plot_axes = self._get_plot_axes()
+            cursor_box = tabs[0][1]
+            update_cursor_location(cursor, plot_axes, plot_data, cursor_box)
+            self._last_cursor = cursor
+
+    def _locate_points(self, point_data, plot_data, tabs):
+        ''' Show points locations from point_draw tool '''
+        if points_changed(point_data, self._last_points):
+            # new points position - update selected points location tab
+            plot_axes = self._get_plot_axes()
+            points_tab = tabs[2]
+            update_points_location(point_data, plot_axes, plot_data, points_tab, self._logger)
+            self._last_points = point_data
+
+    def _locate_box(self, box_bounds, plot_data, tabs):
+        ''' Show points locations in box from box_select tool '''
+        if box_changed(box_bounds, self._last_box):
+            # new box_select position - update selected box location tab
+            plot_axes = self._get_plot_axes()
+            box_tab = tabs[3]
+            update_box_location(box_bounds, plot_axes, plot_data, box_tab, self._logger)
+            self._last_box = box_bounds

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/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():