cubevis 0.5.13__py3-none-any.whl → 0.5.15__py3-none-any.whl

cubevis/data/measurement_set/processing_set/_ps_stats.py

@@ -1,218 +0,0 @@
-'''
-   Calculate statistics on xradio ProcessingSet data.
-'''
-
-import dask
-import numpy as np
-
-from xradio.measurement_set.load_processing_set import ProcessingSetIterator
-from graphviper.graph_tools import generate_dask_workflow
-from graphviper.graph_tools.coordinate_utils import make_parallel_coord, interpolate_data_coords_onto_parallel_coords
-from graphviper.graph_tools.map import map as graph_map
-from graphviper.graph_tools.reduce import reduce as graph_reduce
-
-try:
-    from toolviper.dask.client import get_client
-    _HAVE_TOOLVIPER = True
-except ImportError:
-    _HAVE_TOOLVIPER = False
-
-from cubevis.data.measurement_set.processing_set._xds_data import get_correlated_data, get_axis_data
-
-def calculate_ps_stats(ps_xdt, ps_store, vis_axis, data_group, logger):
-    '''
-        Calculate stats for unflagged visibilities: min, max, mean, std
-        ps_xdt (xarray.DataTree): input MeasurementSet opened from zarr file
-        ps_store (str): path to visibility zarr file
-        vis_axis (str): complex component (amp, phase, real, imag)
-        Returns: stats tuple (min, max, mean, stddev) or None if all data flagged (count=0)
-    '''
-    input_params = {}
-    input_params['input_data_store'] = ps_store
-    input_params['xdt'] = ps_xdt
-    input_params['vis_axis'] = vis_axis
-    input_params['data_group'] = data_group
-    for ms_xdt in ps_xdt.values():
-        if data_group in ms_xdt.attrs['data_groups']:
-            input_params['correlated_data'] = get_correlated_data(ms_xdt.ds, data_group)
-            break
-
-    if _HAVE_TOOLVIPER:
-        active_client = get_client() # could be None if not set up outside cubevis
-    else:
-        active_client = None
-    n_threads = active_client.thread_info()['n_threads'] if active_client is not None else 4
-    logger.debug(f"Setting {n_threads} n_chunks for parallel coords.")
-    mapping = _get_task_data_mapping(ps_xdt, n_threads)
-
-    data_min, data_max, data_mean = _calc_basic_stats(ps_xdt, mapping, input_params, logger)
-    if np.isfinite(data_mean):
-        input_params['mean'] = data_mean
-        data_stddev = _calc_stddev(ps_xdt, mapping, input_params, logger)
-        return data_min, data_max, data_mean, data_stddev
-    return None
-
-def _get_task_data_mapping(ps_xdt, n_threads):
-    frequencies = ps_xdt.xr_ps.get_freq_axis()
-    parallel_coords = {"frequency": make_parallel_coord(coord=frequencies, n_chunks=n_threads)}
-    return interpolate_data_coords_onto_parallel_coords(parallel_coords, ps_xdt)
-
-def _calc_basic_stats(ps_xdt, mapping, input_params, logger):
-    ''' Calculate min, max, mean using graph map/reduce '''
-    graph = graph_map(
-        input_data=ps_xdt,
-        node_task_data_mapping=mapping,
-        node_task=_map_stats,
-        input_params=input_params
-    )
-    reduce_map = graph_reduce(
-        graph, _reduce_stats, input_params, mode='tree'
-    )
-    dask_graph = generate_dask_workflow(reduce_map)
-    #dask_graph.visualize(filename='stats.png')
-    results = dask.compute(dask_graph)
-
-    data_min, data_max, data_sum, data_count = results[0]
-    if data_count == 0.0:
-        logger.debug("stats: no unflagged data")
-        return (data_min, data_max, np.inf)
-
-    data_mean = data_sum / data_count
-    logger.debug(f"basic stats: min={data_min:.4f}, max={data_max:.4f}, sum={data_sum:.4f}, count={data_count} mean={data_mean:.4f}")
-    return data_min, data_max, data_mean
-
-def _calc_stddev(ps_xdt, mapping, input_params, logger):
-    ''' Calculate stddev using graph map/reduce '''
-    graph = graph_map(
-        input_data=ps_xdt,
-        node_task_data_mapping=mapping,
-        node_task=_map_variance,
-        input_params=input_params
-    )
-    reduce_map = graph_reduce(
-        graph, _reduce_variance, input_params, mode='tree'
-    )
-    dask_graph = generate_dask_workflow(reduce_map)
-    results = dask.compute(dask_graph)
-
-    var_sum, var_count = results[0]
-    data_variance = var_sum / var_count
-    data_stddev = data_variance ** 0.5
-    logger.debug(f"stats: variance={data_variance:.4f}, stddev={data_stddev:.4f}")
-    return data_stddev
-
-def _get_stats_xda(xds, vis_axis, data_group):
-    ''' Return xda with only unflagged cross-corr visibility data '''
-    # apply flags to get unflagged vis data
-    xda = get_axis_data(xds, vis_axis, data_group)
-    unflagged_xda = xda.where(np.logical_not(xds.FLAG))
-
-    if unflagged_xda.count() > 0 and "baseline_antenna1_name" in unflagged_xda.coords:
-        # if unflagged data, remove autocorrelation baselines
-        stats_xda = unflagged_xda.where(
-            unflagged_xda.baseline_antenna1_name != unflagged_xda.baseline_antenna2_name
-        )
-        if stats_xda.count() > 0:
-            # return xda with nan where flagged or auto-corr
-            return stats_xda
-
-    # return xda with nan where flagged
-    return unflagged_xda
-
-def _map_stats(input_params):
-    ''' Return min, max, sum, and count of data chunk '''
-    vis_axis = input_params['vis_axis']
-    data_group = input_params['data_group']
-    correlated_data = input_params['correlated_data']
-    min_vals = []
-    max_vals = []
-    sum_vals = []
-    count_vals = []
-
-    ps_iter = ProcessingSetIterator(
-        input_params['data_selection'],
-        input_params['input_data_store'],
-        input_params['xdt'],
-        input_params['data_group'],
-        include_variables=[correlated_data, 'FLAG'],
-        load_sub_datasets=False
-    )
-
-    for xds in ps_iter:
-        xda = _get_stats_xda(xds, vis_axis, data_group)
-        if xda.count() > 0:
-            xda_data = xda.values.ravel()
-            try:
-                min_vals.append(xda_data[np.nanargmin(xda_data)])
-            except ValueError:
-                pass
-            try:
-                max_vals.append(xda_data[np.nanargmax(xda_data)])
-            except ValueError:
-                pass
-            sum_vals.append(np.nansum(xda))
-            count_vals.append(xda.count().values)
-    try:
-        min_value = np.nanmin(min_vals)
-    except ValueError:
-        min_value = np.nan
-    try:
-        max_value = np.nanmax(max_vals)
-    except ValueError:
-        max_value = np.nan
-    return (min_value, max_value, sum(sum_vals), sum(count_vals))
-
-# pylint: disable=unused-argument
-def _reduce_stats(graph_inputs, input_params):
-    ''' Compute min, max, sum, and count of all data.
-        input_parameters seems to be required although unused. '''
-    data_min = 0.0
-    mins = [values[0] for values in graph_inputs]
-    if not np.isnan(mins).all():
-        data_min = min(0.0, np.nanmin(mins))
-
-    data_max = 0.0
-    maxs = [values[1] for values in graph_inputs]
-    if not np.isnan(maxs).all():
-        data_max = max(0.0, np.nanmax(maxs))
-
-    data_sum = sum(values[2] for values in graph_inputs)
-    data_count = sum(values[3] for values in graph_inputs)
-    return (data_min, data_max, data_sum, data_count)
-# pylint: enable=unused-argument
-
-def _map_variance(input_params):
-    ''' Return sum, count, of (xda - mean) squared '''
-    vis_axis = input_params['vis_axis']
-    data_group = input_params['data_group']
-    correlated_data = input_params['correlated_data']
-    mean = input_params['mean']
-
-    sq_diff_sum = 0.0
-    sq_diff_count = 0
-
-    ps_iter = ProcessingSetIterator(
-        input_params['data_selection'],
-        input_params['input_data_store'],
-        input_params['xdt'],
-        input_params['data_group'],
-        include_variables=[correlated_data, 'FLAG'],
-        load_sub_datasets=False
-    )
-
-    for xds in ps_iter:
-        xda = _get_stats_xda(xds, vis_axis, data_group)
-        if xda.size > 0:
-            sq_diff = (xda - mean) ** 2
-            sq_diff_sum += np.nansum(sq_diff)
-            sq_diff_count += sq_diff.count().values
-    return (sq_diff_sum, sq_diff_count)
-
-# pylint: disable=unused-argument
-def _reduce_variance(graph_inputs, input_params):
-    ''' Compute sum and count of all (xda-mean) squared data.
-        input_parameters seems to be required although unused. '''
-    sq_diff_sum = sum(values[0] for values in graph_inputs)
-    sq_diff_count = sum(values[1] for values in graph_inputs)
-    return (sq_diff_sum, sq_diff_count)
-# pylint: enable=unused-argument

cubevis/data/measurement_set/processing_set/_xds_data.py

@@ -1,149 +0,0 @@
-''' Get MeasurementSet data from xarray Dataset '''
-
-from astropy import constants
-import numpy as np
-import xarray as xr
-
-from cubevis.plot.ms_plot._ms_plot_constants import SPECTRUM_AXIS_OPTIONS, UVW_AXIS_OPTIONS, VIS_AXIS_OPTIONS, WEIGHT_AXIS_OPTIONS
-
-def get_correlated_data(xds, data_group):
-    ''' Return correlated_data value in data_group dict '''
-    return xds.attrs['data_groups'][data_group]['correlated_data']
-
-def get_axis_data(xds, axis, data_group=None):
-    ''' Get requested axis data from xarray dataset.
-            xds (dict): msv4 xarray.Dataset
-            axis (str): axis data to retrieve.
-            data_group (str): correlated data group name.
-        Returns:    xarray.DataArray
-    '''
-    group_info = xds.data_groups[data_group]
-    xda = None
-    if _is_coordinate_axis(axis):
-        xda = xds[axis]
-    elif _is_antenna_axis(axis):
-        xda = _get_antenna_axis(xds, axis)
-    elif _is_vis_axis(axis):
-        xda = _calc_vis_axis(xds, axis, group_info)
-    elif _is_uvw_axis(axis):
-        xda = _calc_uvw_axis(xds, axis, group_info)
-    elif _is_weight_axis(axis):
-        xda = _calc_weight_axis(xds, axis, group_info)
-    elif 'spw' in axis:
-        xda = _get_spw_axis(xds, axis)
-    elif 'wave' in axis:
-        xda = _calc_wave_axis(xds, axis, group_info)
-    elif axis == 'field':
-        xda = xr.DataArray([xds[group_info['correlated_data']].field_and_source_xds.field_name])
-    elif axis == 'flag':
-        xda = xds[group_info['flag']]
-    elif axis == 'intents':
-        xda = xr.DataArray(["".join(xds.partition_info['intents'])])
-    elif axis == 'channel':
-        xda = xr.DataArray(np.array(range(xds.frequency.size)))
-    return xda
-
-def _is_coordinate_axis(axis):
-    return axis in ['scan_number', 'time', 'frequency', 'polarization',
-        #'velocity': 'frequency', # calculate
-        # TODO?
-        #'observation':  no id, xds.observation_info (observer, project, release date)
-        #'feed1':  no id, xds.antenna_xds
-        #'feed2':  no id, xds.antenna_xds
-    ]
-
-def _is_vis_axis(axis):
-    return axis in VIS_AXIS_OPTIONS
-
-def _is_uvw_axis(axis):
-    return axis in UVW_AXIS_OPTIONS
-
-def _is_antenna_axis(axis):
-    return 'baseline' in axis or 'antenna' in axis
-
-def _is_weight_axis(axis):
-    return axis in WEIGHT_AXIS_OPTIONS
-
-def _get_spw_axis(xds, axis):
-    if axis == 'spw_id':
-        return xr.DataArray([xds.frequency.spectral_window_id])
-    if axis == 'spw_name':
-        return xr.DataArray([xds.frequency.spectral_window_name])
-    raise ValueError(f"Invalid spw axis {axis}")
-
-def _calc_vis_axis(xds, axis, group_info):
-    ''' Calculate axis from correlated data '''
-    correlated_data = group_info['correlated_data']
-    xda = xds[correlated_data]
-
-    # Single dish spectrum
-    if correlated_data == "SPECTRUM":
-        if axis in SPECTRUM_AXIS_OPTIONS:
-            return xda.assign_attrs(units='Jy')
-        raise RuntimeError(f"Vis axis {axis} invalid for SPECTRUM dataset, select from {SPECTRUM_AXIS_OPTIONS}")
-
-    # Interferometry visibilities
-    if axis == 'amp':
-        return np.absolute(xda).assign_attrs(units='Jy')
-    if axis == 'phase':
-        # np.angle(xda) returns ndarray not xr.DataArray
-        return (np.arctan2(xda.imag, xda.real) * 180.0/np.pi).assign_attrs(units="deg")
-    if axis == 'real':
-        return np.real(xda.assign_attrs(units='Jy'))
-    if axis == 'imag':
-        return np.imag(xda.assign_attrs(units='Jy'))
-    return None
-
-def _calc_uvw_axis(xds, axis, group_info):
-    ''' Calculate axis from UVW xarray DataArray '''
-    if 'uvw' not in group_info:
-        raise RuntimeError(f"Axis {axis} is not valid in this dataset, no uvw data")
-
-    uvw_xda = xds[group_info['uvw']]
-
-    if axis == 'u':
-        return uvw_xda.isel(uvw_label=0)
-    if axis == 'v':
-        return uvw_xda.isel(uvw_label=1)
-    if axis == 'w':
-        return uvw_xda.isel(uvw_label=2)
-
-    # uvdist
-    u_xda = uvw_xda.isel(uvw_label=0)
-    v_xda = uvw_xda.isel(uvw_label=1)
-    return np.sqrt(np.square(u_xda) + np.square(v_xda))
-
-def _calc_wave_axis(xds, axis, group_info):
-    wave_axes = {'uwave': 'u', 'vwave': 'v', 'wwave': 'w', 'uvwave': 'uvdist'}
-    if axis not in wave_axes:
-        raise ValueError(f"Invalid wave axis {axis}")
-    uvwdist_array = _calc_uvw_axis(xds, wave_axes[axis], group_info).values / constants.c
-    uvwdist_len = len(uvwdist_array)
-    freq_array = xds.frequency.values
-    wave = np.zeros(shape=(len(freq_array), uvwdist_len), dtype=np.double)
-
-    for i, in range(uvwdist_len):
-        wave[:, i] = uvwdist_array[i] * freq_array
-
-    wave_xda = xr.DataArray(wave, dims=['frequency', 'uvw_label'])
-    return wave_xda
-
-def _calc_weight_axis(xds, axis, group_info):
-    weight = xds[group_info['weight']]
-    if axis == 'weight':
-        return weight
-    return np.sqrt(1.0 / weight)
-
-def _get_antenna_axis(xds, axis):
-    if 'antenna_name' in xds.coords:
-        return xds.antenna_name
-
-    if axis == 'antenna1':
-        return xds.baseline_antenna1_name
-    if axis == 'antenna2':
-        return xds.baseline_antenna2_name
-    if axis == 'baseline_id':
-        return xds.baseline_id
-    if axis == 'baseline':
-        return xds.baseline
-    raise ValueError(f"Invalid antenna/baseline axis {axis}")

cubevis/plot/__init__.py

@@ -1 +0,0 @@
-''' Module for plotting functions.  Currently supported MeasurementSet plots only. '''

cubevis/plot/ms_plot/__init__.py

@@ -1,29 +0,0 @@
-''' This module contains classes and utilities to support MS plotting '''
-
-from ._ms_plot import MsPlot
-
-from ._ms_plot_constants import (
-    SPECTRUM_AXIS_OPTIONS,
-    UVW_AXIS_OPTIONS,
-    VIS_AXIS_OPTIONS,
-    WEIGHT_AXIS_OPTIONS,
-    PS_SELECTION_OPTIONS,
-    MS_SELECTION_OPTIONS,
-    AGGREGATOR_OPTIONS,
-    DEFAULT_UNFLAGGED_CMAP,
-    DEFAULT_FLAGGED_CMAP,
-)
-
-from ._ms_plot_selectors import (
-    file_selector,
-    title_selector,
-    style_selector,
-    axis_selector,
-    aggregation_selector,
-    iteration_selector,
-    selection_selector,
-    plot_starter,
-)
-
-from ._raster_plot_inputs import check_inputs
-from ._raster_plot import RasterPlot

cubevis/plot/ms_plot/_ms_plot.py

@@ -1,242 +0,0 @@
-'''
-Base class for ms plots
-'''
-
-import os
-import time
-
-from bokeh.plotting import show
-import hvplot
-import holoviews as hv
-import numpy as np
-import panel as pn
-
-try:
-    from toolviper.utils.logger import get_logger, setup_logger
-    _HAVE_TOOLVIPER = True
-except ImportError:
-    _HAVE_TOOLVIPER = False
-
-from cubevis.data.measurement_set._ms_data import MsData
-from cubevis.toolbox import AppContext
-from cubevis.utils._logging import get_logger
-
-class MsPlot:
-
-    ''' Base class for MS plots with common functionality '''
-
-    def __init__(self, ms=None, log_level="info", show_gui=False, app_name="MsPlot"):
-        if not ms and not show_gui:
-            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=False, log_level=log_level.upper())
-        else:
-            self._logger = get_logger()
-            self._logger.setLevel(log_level.upper())
-
-        # Save parameters; ms set below
-        self._show_gui = show_gui
-        self._app_name = app_name
-
-        # Set up temp dir for output html files; do not add cubevis bokeh libraries
-        self._app_context = AppContext(app_name, init_bokeh=False)
-
-        if show_gui:
-            # Enable "toast" notifications
-            pn.config.notifications = True
-            self._toast = None # for destroy() with new plot or new notification
-
-        # Initialize plot inputs and params
-        self._plot_inputs = {}
-
-        # Initialize plots
-        self._plot_init = False
-        self._plots_locked = False
-        self._plots = []
-
-        # Set data (if ms)
-        self._data = None
-        self._ms_info = {}
-        self._set_ms(ms)
-
-    def summary(self, data_group='base', columns=None):
-        ''' Print ProcessingSet summary.
-            Args:
-                data_group (str): data group to use for summary.
-                columns (None, str, list): type of metadata to list.
-                    None:      Print all summary columns in ProcessingSet.
-                    'by_msv4': Print formatted summary metadata by MSv4.
-                    str, list: Print a subset of summary columns in ProcessingSet.
-                        Options: 'name', 'intents', 'shape', 'polarization', 'scan_name', 'spw_name',
-                                 'field_name', 'source_name', 'field_coords', 'start_frequency', 'end_frequency'
-            Returns: list of unique values when single column is requested, else None
-        '''
-        self._data.summary(data_group, columns)
-
-    def data_groups(self):
-        ''' Returns set of data groups from all ProcessingSet ms_xds. '''
-        return self._data.data_groups()
-
-    def antennas(self, plot_positions=False, label_antennas=False):
-        ''' Returns list of antenna names in ProcessingSet antenna_xds.
-                plot_positions (bool): show plot of antenna positions.
-                label_antennas (bool): label positions with antenna names.
-        '''
-        return self._data.get_antennas(plot_positions, label_antennas)
-
-    def plot_phase_centers(self, data_group='base', label_fields=False):
-        ''' Plot the phase center locations of all fields in the Processing Set and highlight central field.
-                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
-        '''
-        self._data.plot_phase_centers(data_group, label_fields)
-
-    def clear_plots(self):
-        ''' Clear plot list '''
-        while self._plots_locked:
-            time.sleep(1)
-        self._plots.clear()
-
-    def clear_selection(self):
-        ''' Clear selection in data and restore to original '''
-        if self._data:
-            self._data.clear_selection()
-
-    def show(self):
-        ''' 
-        Show interactive Bokeh plots in a browser. Plot tools include pan, zoom, hover, and save.
-        '''
-        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)
-        # Not layout if subplots is single plot (default if None) or if only one plot saved
-        subplots = self._plot_inputs['subplots']
-        layout_plot, is_layout = self._layout_plots(subplots)
-
-        # Render to bokeh figure
-        if is_layout:
-            # Show plots in columns
-            plot = hv.render(layout_plot.cols(subplots[1]))
-        else:
-            # Show single plot
-            plot = hv.render(layout_plot)
-
-        self._plots_locked = False
-        show(plot)
-
-    def save(self, filename='ms_plot.png', fmt='auto', width=900, height=600):
-        '''
-        Save plot to file with filename, format, and size.
-        If iteration plots were created:
-            If subplots is a grid, the layout plot will be saved to a single file.
-            If subplots is a single plot, iteration plots will be saved individually,
-                with a plot index appended to the filename: {filename}_{index}.{ext}.
-        '''
-        if not self._plots:
-            raise RuntimeError("No plot to save.  Run plot() to create plot.")
-
-        start_time = time.time()
-
-        # Save single plot or combine plots into layout using subplots (rows, columns).
-        # Not layout if subplots is single plot or if only one plot saved.
-        subplots = self._plot_inputs['subplots']
-        layout_plot, is_layout = self._layout_plots(subplots)
-
-        if is_layout:
-            # Save plots combined into one layout
-            hvplot.save(layout_plot.cols(subplots[1]), filename=filename, fmt=fmt)
-            self._logger.info("Saved plot to %s.", filename)
-        else:
-            # Save plots individually, with index appended if exprange='all' and multiple plots.
-            if self._plot_inputs['iter_axis'] is None:
-                hvplot.save(layout_plot.opts(width=width, height=height), filename=filename, fmt=fmt)
-                self._logger.info("Saved plot to %s.", filename)
-            else:
-                name, ext = os.path.splitext(filename)
-                iter_range = self._plot_inputs['iter_range'] # None or (start, end)
-                plot_idx = 0 if iter_range is None else iter_range[0]
-
-                for plot in self._plots:
-                    exportname = f"{name}_{plot_idx}.{ext}"
-                    hvplot.save(plot.opts(width=width, height=height), filename=exportname, fmt=fmt)
-                    self._logger.info("Saved plot to %s.", exportname)
-                    plot_idx += 1
-
-        self._logger.debug("Save elapsed time: %.2fs.", time.time() - start_time)
-
-    def _layout_plots(self, subplots):
-        subplots = (1, 1) if subplots is None else subplots
-        num_plots = len(self._plots)
-        num_layout_plots = min(num_plots, np.prod(subplots))
-
-        if num_layout_plots == 1:
-            return self._plots[0], False
-
-        # Set plots in layout
-        plot_count = 0
-        layout = None
-        for i in range(num_layout_plots):
-            plot = self._plots[i]
-            layout = plot if layout is None else layout + plot
-            plot_count += 1
-
-        is_layout = plot_count > 1
-        return layout, is_layout
-
-    def _set_ms(self, ms):
-        ''' Update ms info for input ms filepath (MSv2 or zarr), or None in show_gui mode.
-            Return whether ms changed (false if ms is None). '''
-        self._ms_info['ms'] = ms
-        ms_error = ""
-        ms_changed = ms and (not self._data or not self._data.is_ms_path(ms))
-
-        if ms_changed:
-            try:
-                # Set new MS data
-                self._data = MsData(ms, self._logger)
-                ms_path = self._data.get_path()
-                self._ms_info['ms'] = ms_path
-                root, ext = os.path.splitext(os.path.basename(ms_path))
-                while ext != '':
-                    root, ext = os.path.splitext(root)
-                self._ms_info['basename'] = root
-                self._ms_info['data_dims'] = self._data.get_data_dimensions()
-            except RuntimeError as e:
-                ms_error = str(e)
-                self._data = None
-
-        if ms_error:
-            self._notify(ms_error, 'error', 0)
-
-        return ms_changed
-
-    def _notify(self, message, level, duration=3000):
-        ''' Log message. If show_gui, notify user with toast for duration in ms.
-            Zero duration must be dismissed. '''
-        if self._show_gui:
-            pn.state.notifications.position = 'top-center'
-            if self._toast:
-                self._toast.destroy()
-
-        if level == "info":
-            self._logger.info(message)
-            if self._show_gui:
-                self._toast = pn.state.notifications.info(message, duration=duration)
-        elif level == "error":
-            self._logger.error(message)
-            if self._show_gui:
-                self._toast = pn.state.notifications.error(message, duration=duration)
-        elif level == "success":
-            self._logger.info(message)
-            if self._show_gui:
-                self._toast = pn.state.notifications.success(message, duration=duration)
-        elif level == "warning":
-            self._logger.warning(message)
-            if self._show_gui:
-                self._toast = pn.state.notifications.warning(message, duration=duration)

cubevis/plot/ms_plot/_ms_plot_constants.py

@@ -1,22 +0,0 @@
-''' Define constants used for plotting MeasurementSets '''
-
-SPECTRUM_AXIS_OPTIONS = ['amp', 'real']
-UVW_AXIS_OPTIONS = ['u', 'v', 'w', 'uvdist']
-VIS_AXIS_OPTIONS = ['amp', 'phase', 'real', 'imag']
-WEIGHT_AXIS_OPTIONS = ['weight', 'sigma']
-
-PS_SELECTION_OPTIONS = {
-    'MSv4 Name': 'name',
-    'Intents': 'intents',
-    'Scan Name': 'scan_name',
-    'Spectral Window Name': 'spw_name',
-    'Field Name': 'field_name',
-    'Source Name': 'source_name',
-    'Line Name': 'line_name'
-}
-MS_SELECTION_OPTIONS = ['Data Group', 'Time', 'Baseline', 'Antenna1', 'Antenna2', 'Frequency', 'Polarization']
-
-AGGREGATOR_OPTIONS = ['None', 'max', 'mean', 'median', 'min', 'std', 'sum', 'var']
-
-DEFAULT_UNFLAGGED_CMAP = "Viridis"
-DEFAULT_FLAGGED_CMAP = "Reds"