cubevis 0.5.13__tar.gz → 0.5.15__tar.gz

{cubevis-0.5.13 → cubevis-0.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cubevis
-Version: 0.5.13
+Version: 0.5.15
 Summary: visualization toolkit and apps for casa
 License: LGPL
 Author-email: Darrell Schiebel <darrell@schiebel.us>,Pam Harris <pharris@nrao.edu>

{cubevis-0.5.13 → cubevis-0.5.15}/cubevis/private/apps/__init__.py

@@ -32,6 +32,11 @@ from cubevis.utils import copydoc, ImportProtectedModule
 from cubevis.bokeh.state import initialize_session
 initialize_session()
 
+###
+### This import roundabout was introduced when astroviper and casa6 apps were in the same
+### package to avoid forcing the user to install BOTH astroviper and casa6 even if they
+### were only going to use one of the applications. Now it could be removed...
+###
 sys.modules[__name__].__class__ = ImportProtectedModule( __name__, { 'plotants': '._plotants',
                                                                      'plotbandpass': '._plotbandpass',
                                                                      'CreateMask': '._createmask',
@@ -40,5 +45,4 @@ sys.modules[__name__].__class__ = ImportProtectedModule( __name__, { 'plotants':
                                                                      'iclean': '..casatasks.iclean',
                                                                      'createmask': '..casatasks.createmask',
                                                                      'createregion': '..casatasks.createregion',
-                                                                     'MsRaster': '._ms_raster',
                                                                    } )

{cubevis-0.5.13 → cubevis-0.5.15}/cubevis/toolbox/_cube.py

@@ -881,7 +881,7 @@ class CubeMask:
         ### power: 𝑦=(𝛼^𝑥−1)/(𝛼−1)
         self._cm_adjust['alpha-value'] = TextInput( value="1000", prefix="alpha", max_width=170, visible=False )
         self._cm_adjust['gamma-value'] = TextInput( value="1", prefix="gamma", max_width=170, visible=False )
-        self._cm_adjust['equation'] = Div(text='''<math><mrow><mi>y</mi><mo>=</mo><mi>x</mi></mrow></math>''')  # linear
+        self._cm_adjust['equation'] = Div(text='''<math><mrow><mi>y</mi><mo>=</mo><mi>x</mi></mrow></math>''', margin=(12, 0, 0, 0))  # linear
         self._cm_adjust['scaling'] = Dropdown( label='linear',
                                                menu=[ ('linear', 'linear'), ('log', 'log'), ('sqrt','sqrt'),
                                                       ('square', 'square'), ('gamma', 'gamma'), ('power', 'power') ],
@@ -1048,6 +1048,7 @@ class CubeMask:
 
             return dict( result='failure', update={ } )
 
+        scaling_background = '#f8f8f8'
         return column( self._cm_adjust['fig'],
                        row( Tip( self._cm_adjust['min input'],
                                   tooltip=Tooltip( content=HTML("set minimum clip here or drag the left red line above"),
@@ -1055,16 +1056,18 @@ class CubeMask:
                             Tip( self._cm_adjust['max input'],
                                   tooltip=Tooltip( content=HTML("set maximum clip here or drag the right red line above"),
                                                    position="top_left" ) ), width_policy='min' ),
-                       row( Tip( self._cm_adjust['scaling'],
-                                  tooltip=Tooltip( content=HTML('scaling function applied to image intensities'),
-                                                   position="top" ) ),
-                            self._cm_adjust['equation'] ),
-                       row( Tip( self._cm_adjust['alpha-value'],
-                                  tooltip=Tooltip( content=HTML('set alpha value as indicated in the equation'),
-                                                   position="top" ) ),
-                            Tip( self._cm_adjust['gamma-value'],
-                                  tooltip=Tooltip( content=HTML('set gamma value as indicated in the equation'),
-                                                   position="top" ) ) ),
+                       column( Div(text="<small>scaling</small>", styles={'background-color': scaling_background, 'margin': '0px'}),
+                               row( Tip( self._cm_adjust['scaling'],
+                                         tooltip=Tooltip( content=HTML('scaling function applied to image intensities'),
+                                                          position="top" ) ),
+                                    self._cm_adjust['equation'] ),
+                               row( Tip( self._cm_adjust['alpha-value'],
+                                         tooltip=Tooltip( content=HTML('set alpha value as indicated in the equation'),
+                                                          position="top" ) ),
+                                    Tip( self._cm_adjust['gamma-value'],
+                                         tooltip=Tooltip( content=HTML('set gamma value as indicated in the equation'),
+                                                          position="top" ) ) ),
+                               width=325, styles={'background-color': scaling_background, 'border': '1px solid black', 'padding': '10px'} ),
                        sizing_mode="scale_width" )
 
     def bitmask_ctrl( self, reuse=None, **kw ):

{cubevis-0.5.13 → cubevis-0.5.15}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
 ]
 requires-python = ">=3.10"
 readme = "readme.rst"
-version = "0.5.13"
+version = "0.5.15"
 
 [project.license]
 text = "LGPL"

cubevis-0.5.13/cubevis/data/measurement_set/__init__.py

@@ -1,7 +0,0 @@
-'''
-    Module to access MeasurementSet data using MsData class.
-'''
-
-from ._ms_data import (
-    MsData
-)

cubevis-0.5.13/cubevis/data/measurement_set/_ms_data.py

@@ -1,178 +0,0 @@
-'''
-    Class for accessing and selecting MeasurementSet data using a data backend.
-'''
-
-from cubevis.data.measurement_set.processing_set._ps_data import PsData
-
-class MsData:
-    '''
-    Access and select MeasurementSet data.
-    Current backend implementation is PsData using xradio Processing Set.
-    '''
-
-    def __init__(self, ms_path, logger):
-        self._ms_path = ms_path
-        self._logger = logger
-        self._data = None
-        self._data_initialized = False
-        self._init_data(ms_path)
-
-    def is_valid(self):
-        ''' Returns whether MS path has been set so data can be accessed. '''
-        return self._data_initialized
-
-    def is_ms_path(self, path):
-        ''' Check if input path matches input ms path or zarr path '''
-        return path == self.get_path() or path == self._ms_path
-
-    def get_path(self):
-        ''' Returns path of MS/zarr file or None if not set. '''
-        if self._data_initialized:
-            return self._data.get_path() # path to zarr file
-        if self._ms_path:
-            return self._ms_path # path to ms v2
-        return None
-
-    def summary(self, data_group='base', columns=None):
-        ''' Print summary of Processing Set data.
-                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_number', 'spw_name',
-                                 'field_name, 'source_name', 'field_coords', 'start_frequency', 'end_frequency'
-        '''
-        # ProcessingSet function
-        if self._data_initialized:
-            self._data.summary(data_group, columns)
-        else:
-            self._log_no_ms()
-
-    def get_ps_summary(self):
-        ''' Return Pandas DataFrame summary of ProcessingSet '''
-        if self._data_initialized:
-            return self._data.get_summary()
-        self._log_no_ms()
-        return None
-
-    def data_groups(self):
-        ''' Returns set of data group names in Processing Set data. '''
-        # ProcessingSet function
-        if self._data_initialized:
-            return self._data.get_data_groups()
-        self._log_no_ms()
-        return None
-
-    def get_antennas(self, plot_positions=False, label_antennas=False):
-        ''' Returns list of antenna names in data.
-                plot_positions (bool): show plot of antenna positions.
-                label_antennas (bool): label positions with antenna names.
-        '''
-        # Antenna positions plot is ProcessingSet function
-        if self._data_initialized:
-            return self._data.get_antennas(plot_positions, label_antennas)
-        self._log_no_ms()
-        return None
-
-    def plot_phase_centers(self, data_group='base', label_all_fields=False):
-        ''' Plot the phase center locations of all fields in the Processing Set (original or selected) and label central field.
-                label_all_fields (bool); label all fields on the plot
-                data_group (str); data group to use for processing.
-        '''
-        # ProcessingSet function
-        if self._data_initialized:
-            self._data.plot_phase_centers(label_all_fields, data_group)
-        else:
-            self._log_no_ms()
-
-    def get_num_ms(self):
-        ''' Returns number of MeasurementSets in data. '''
-        if self._data_initialized:
-            return self._data.get_ps_len()
-        self._log_no_ms()
-        return None
-
-    def get_max_data_dims(self):
-        ''' Returns maximum length of dimensions in data. '''
-        if self._data_initialized:
-            return self._data.get_max_dims()
-        self._log_no_ms()
-        return None
-
-    def get_data_dimensions(self):
-        ''' Returns names of data dimensions. '''
-        if self._data_initialized:
-            return self._data.get_data_dimensions()
-        self._log_no_ms()
-        return None
-
-    def get_dimension_values(self, dim):
-        ''' Return values for dimension in current data.
-                dim (str): dimension name
-        '''
-        if self._data_initialized:
-            return self._data.get_dimension_values(dim)
-        self._log_no_ms()
-        return None
-
-    def get_dimension_attrs(self, dim):
-        ''' Return dict of data attributes for dimension.
-                dim (str): dimension name
-        '''
-        if self._data_initialized:
-            return self._data.get_dimension_attrs(dim)
-        self._log_no_ms()
-        return None
-
-    def get_first_spw(self):
-        ''' Returns name of first spw by id. '''
-        if self._data_initialized:
-            return self._data.get_first_spw()
-        self._log_no_ms()
-        return None
-
-    def select_data(self, selection):
-        ''' Apply selection in data.
-                selection (dict): fields and values to select
-        '''
-        if self._data_initialized:
-            self._data.select_data(selection)
-        else:
-            self._log_no_ms()
-
-    def clear_selection(self):
-        ''' Clears selection dict and selected data. '''
-        if self._data_initialized:
-            self._data.clear_selection()
-
-    def get_vis_stats(self, selection, vis_axis):
-        ''' Returns statistics (min, max, mean, std) for data selected by selection.
-                selection (dict): fields and values to select
-        '''
-        if self._data_initialized:
-            return self._data.get_vis_stats(selection, vis_axis)
-        self._log_no_ms()
-        return None
-
-    def get_correlated_data(self, data_group):
-        ''' Returns name of correlated data variable in Processing Set data group '''
-        if self._data_initialized:
-            return self._data.get_correlated_data(data_group)
-        self._log_no_ms()
-        return None
-
-    def get_raster_data(self, plot_inputs):
-        ''' Returns xarray Dataset after applying plot inputs and raster plane selection '''
-        if self._data_initialized:
-            return self._data.get_raster_data(plot_inputs)
-        self._log_no_ms()
-        return None
-
-    def _log_no_ms(self):
-        self._logger.info("No MS path set, cannot access data")
-
-    def _init_data(self, ms_path):
-        ''' Data backend for MeasurementSet; currently xradio ProcessingSet '''
-        if ms_path:
-            self._data = PsData(ms_path, self._logger)
-            self._data_initialized = True

cubevis-0.5.13/cubevis/data/measurement_set/processing_set/__init__.py

@@ -1,30 +0,0 @@
-'''
-    Module to access MeasurementSet data using xradio ProcessingSetXdt and Xarray objects.
-'''
-
-from ._ps_concat import (
-    concat_ps_xdt,
-)
-
-from ._ps_coords import (
-    set_coordinates,
-    set_datetime_coordinate,
-    set_index_coordinates,
-)
-
-from ._ps_data import (
-    PsData,
-)
-
-from ._ps_io import (
-    get_processing_set,
-)
-
-from ._ps_raster_data import (
-    raster_data,
-)
-
-from ._xds_data import (
-    get_axis_data,
-    get_correlated_data,
-)

cubevis-0.5.13/cubevis/data/measurement_set/processing_set/_ps_concat.py

@@ -1,98 +0,0 @@
-'''
-Concat ProcessingSet xarray DataSets into single xds by time dimension (in order)
-'''
-
-import xarray as xr
-
-from cubevis.data.measurement_set.processing_set._ps_coords import set_coordinates
-
-def concat_ps_xdt(ps_xdt, logger):
-    ''' Concatenate xarray Datasets in ProcessingSet by time dimension.
-        Return concat xds. '''
-    if len(ps_xdt) == 0:
-        raise RuntimeError("Processing set empty after selection.")
-
-    ps = {}
-    for name, ms_xdt in ps_xdt.items():
-        # Set units to str not list and set baseline coordinate.  Returns xarray.Dataset
-        ps[name] = set_coordinates(ms_xdt)
-
-    if len(ps) == 1:
-        logger.debug("Processing set contains one dataset, nothing to concat.")
-        return list(ps.values())[0]
-
-    # Split xds by time gaps
-    sorted_times = _get_sorted_times(ps)
-    xds_list = []
-    time_list = []
-    for xds in ps.values():
-        xdss, times = _split_xds_by_time_gap(xds, sorted_times)
-        xds_list.extend(xdss)
-        time_list.extend(times)
-
-    if len(xds_list) > len(ps_xdt):
-        logger.debug(f"Split {len(ps_xdt)} datasets by time gap into {len(xds_list)} datasets.")
-
-    # Create sorted xds list using sorted times
-    time_list.sort()
-    sorted_xds = [None] * len(time_list)
-
-    for xds in xds_list:
-        try:
-            first_xds_time = xds.time.values[0]
-        except IndexError: # only one value
-            first_xds_time = xds.time.values
-
-        for idx, value in enumerate(time_list):
-            if value == first_xds_time and sorted_xds[idx] is None:
-                if "baseline" in xds.coords:
-                    # Cannot concat with non-dim string coord
-                    xds = xds.drop("baseline_antenna1_name")
-                    xds = xds.drop("baseline_antenna2_name")
-                # Convert MeasurementSetXds to xr Dataset for concat
-                # (TypeError: MeasurementSetXds.__init__() got an unexpected keyword argument 'coords')
-                sorted_xds[idx] = xr.Dataset(xds.data_vars, xds.coords, xds.attrs)
-                break
-    return xr.concat(sorted_xds, dim='time')
-
-def _get_sorted_times(ps):
-    values = []
-    for key in ps:
-        time_values = ps[key].time.values
-        if time_values.size > 1:
-            values.extend(time_values.tolist())
-        else:
-            values.append(time_values)
-    return sorted(values)
-
-def _split_xds_by_time_gap(xds, sorted_times):
-    ''' Split xds where there is a gap in sorted times.
-        Return list of xds and first time in each one. '''
-    times = xds.time.values.ravel()
-    xds_list = []
-    first_times = [times[0]]
-
-    if len(times) == 1:
-        xds_list.append(xds)
-    else:
-        sorted_time_idx = sorted_times.index(times[0])
-        idx = xds_start_idx = 0 # start for iselection
-
-        for idx, time in enumerate(times):
-            if time == sorted_times[sorted_time_idx]:
-                # No time gap, go to next time
-                sorted_time_idx += 1
-                continue
-
-            # Found time gap, select xds
-            xds_list.append(xds.isel(time=slice(xds_start_idx, idx)))
-
-            # start next xds with new first time, find idx in sorted times (skip ahead)
-            xds_start_idx = idx
-            first_times.append(times[idx])
-            sorted_time_idx = sorted_times.index(time) + 1 # for next time
-
-        # add last time range xds
-        xds_list.append(xds.isel(time=slice(xds_start_idx, idx + 1)))
-
-    return xds_list, first_times

cubevis-0.5.13/cubevis/data/measurement_set/processing_set/_ps_coords.py

@@ -1,78 +0,0 @@
-'''
-Modify/add xarray Dataset coordinates for plotting.
-'''
-
-import numpy as np
-from pandas import to_datetime
-
-def set_coordinates(ms_xdt):
-    ''' Convert coordinate units and add baseline coordinate for plotting.
-        Returns xarray.Dataset
-    '''
-    _set_coordinate_unit(ms_xdt)
-    _set_frequency_unit(ms_xdt)
-    return _add_baseline_coordinate(ms_xdt)
-
-def set_datetime_coordinate(ms_xds):
-    ''' Convert float time to datetime for plotting. '''
-    time_attrs = ms_xds.time.attrs
-    try:
-        ms_xds.coords['time'] = to_datetime(ms_xds.time, unit=time_attrs['units'], origin=time_attrs['format'])
-    except TypeError:
-        ms_xds.coords['time'] = to_datetime(ms_xds.time, unit=time_attrs['units'][0], origin=time_attrs['format'])
-    ms_xds.time.attrs = time_attrs
-
-def _set_coordinate_unit(ms_xdt):
-    ''' Set coordinate units attribute as string not list for plotting. '''
-    for coord in ms_xdt.coords:
-        # Plots need unit to be string not list
-        if 'units' in ms_xdt.coords[coord].attrs:
-            units = ms_xdt.coords[coord].units
-            if isinstance(units, list) and len(units) == 1:
-                ms_xdt.coords[coord].attrs['units'] = units[0]
-
-def set_index_coordinates(ms_xds, coordinates):
-    ''' Return ms_xds with new coordinate for string values (name) then replace coordinate with numerical index. '''
-    for coordinate in coordinates:
-        if coordinate == "polarization":
-            ms_xds = ms_xds.assign_coords({"polarization_name": (ms_xds.polarization.dims, ms_xds.polarization.values)})
-            ms_xds["polarization"] = np.array(range(ms_xds.polarization.size))
-        elif coordinate == "baseline":
-            ms_xds = ms_xds.assign_coords({"baseline_name": (ms_xds.baseline.dims, ms_xds.baseline.values)})
-            ms_xds["baseline"] = np.array(range(ms_xds.baseline.size))
-        elif coordinate == "antenna_name":
-            ms_xds = ms_xds.assign_coords({"antenna": (ms_xds.antenna_name.dims, ms_xds.antenna_name.values)})
-            ms_xds["antenna_name"] = np.array(range(ms_xds.antenna_name.size))
-    return ms_xds
-
-def _set_frequency_unit(ms_xdt):
-    ''' Convert frequency to GHz. Note attrs (channel_width, reference_frequency) still have Hz units in dict '''
-    if ms_xdt.frequency.attrs['units'] == "Hz":
-        frequency_xda = ms_xdt.frequency / 1e9
-        frequency_attrs = ms_xdt.frequency.attrs
-        frequency_attrs['units'] = "GHz"
-        frequency_xda = frequency_xda.assign_attrs(frequency_attrs)
-        ms_xdt.coords['frequency'] = frequency_xda
-
-def _add_baseline_coordinate(ms_xdt):
-    '''
-        Replace "baseline_id" (int) with "baseline" (string) coordinate "ant1 & ant2".
-        Baseline ids are not consistent across ms_xdts. 
-    '''
-    # Cannot assign coords to DataTree.
-    baseline_ms_xdt = ms_xdt.to_dataset() # mutable Dataset
-
-    if 'baseline_id' not in baseline_ms_xdt.coords:
-        return baseline_ms_xdt
-
-    ant1_names = ms_xdt.baseline_antenna1_name.values
-    ant2_names = ms_xdt.baseline_antenna2_name.values
-    if ant1_names.size == 1:
-        baseline_names = f"{ant1_names.item()} & {ant2_names.item()}"
-        baseline_ms_xdt = baseline_ms_xdt.assign_coords({"baseline": np.array(baseline_names)})
-    else:
-        baseline_names = [f"{ant1_names[idx]} & {ant2_names[idx]}" for idx in range(len(ant1_names))]
-        baseline_ms_xdt = baseline_ms_xdt.assign_coords({"baseline": ("baseline_id", np.array(baseline_names))})
-        baseline_ms_xdt = baseline_ms_xdt.swap_dims({"baseline_id": "baseline"})
-    baseline_ms_xdt = baseline_ms_xdt.drop("baseline_id")
-    return baseline_ms_xdt