saveClass.py

import holoviews as hv
import numpy as np
from IPython.display import display

class savedData:
    def __init__(self, result, metadata, name, description):
        """Object used to hold resulting plot from a measurement, basic description of measurement, and metadata about system state."""
        self._plot = result
        self._metadata = metadata
        self.name = name
        
        #This assumes that object always created with the date as the name (which is the current functionality)
        self.date = name
        
        self.description = description
        self.comment = None
        return
    
    @property
    def data(self):
        """Returns raw data as pandas dataframe"""
        return self.plot.dframe()
    
    @property
    def state(self):
        """Returns state of all instruments at time of measurement as a dictionary, based off snapshot feature of QCoDeS instruments"""
        return self._metadata
    
    @property
    def readableState(self):
        """Prints clean and simplified state of all instruments."""
        for inst in self._metadata:
            snapshot = self._metadata[inst]
            if type(snapshot) == dict:
                self._print_readable_snapshot(snapshot)
            else:
                print(inst + ':\n')
                display(snapshot)
            print('\n')
        return
    
    @property
    def plot(self):
        """Returns the plot associated with the given measurement. With Holoviews objects this should also display the plot inline"""
        if type(self._plot) == hv.Image:
            return self._plot.opts(norm=dict(framewise=True), plot=dict(colorbar=True), style=dict(cmap='jet'))
        return self._plot
    
    def __repr__(self):
        if self.comment:
            return self.comment
        else:
            return self.description
        
    def _print_readable_snapshot(self, snapshot, update: bool=False,
                                    max_chars: int=80) -> None:
            """
            Prints a readable version of the snapshot.
            The readable snapshot includes the name, value and unit of each
            parameter.
            A convenience function to quickly get an overview of the
            status of an instrument.
            Args:
                update: If True, update the state by querying the
                    instrument. If False, just use the latest values in memory.
                    This argument gets passed to the snapshot function.
                max_chars: the maximum number of characters per line. The
                    readable snapshot will be cropped if this value is exceeded.
                    Defaults to 80 to be consistent with default terminal width.
            """
            floating_types = (float, np.integer, np.floating)
            #snapshot = self.snapshot(update=update)

            par_lengths = [len(p) for p in snapshot['parameters']]

            # Min of 50 is to prevent a super long parameter name to break this
            # function
            par_field_len = min(max(par_lengths)+1, 50)

            print(snapshot['parameters']['IDN']['instrument_name'] + ':')
            print('{0:<{1}}'.format('\tparameter ', par_field_len) + 'value')
            print('-'*max_chars)
            for par in sorted(snapshot['parameters']):
                name = snapshot['parameters'][par]['name']
                msg = '{0:<{1}}:'.format(name, par_field_len)

                # in case of e.g. ArrayParameters, that usually have
                # snapshot_value == False, the parameter may not have
                # a value in the snapshot
                val = snapshot['parameters'][par].get('value', 'Not available')

                unit = snapshot['parameters'][par].get('unit', None)
                if unit is None:
                    # this may be a multi parameter
                    unit = snapshot['parameters'][par].get('units', None)
                if isinstance(val, floating_types):
                    msg += '\t{:.5g} '.format(val)
                else:
                    msg += '\t{} '.format(val)
                if unit is not '':  # corresponds to no unit
                    msg += '({})'.format(unit)
                # Truncate the message if it is longer than max length
                if len(msg) > max_chars and not max_chars == -1:
                    msg = msg[0:max_chars-3] + '...'
                print(msg)

            for submodule in snapshot['submodules'].values():
                print_readable_snapshot(submodule)
                #if hasattr(submodule, '_channels'):
                #    submodule = cast('ChannelList', submodule)
                #    if submodule._snapshotable:
                #        for channel in submodule._channels:
                #            channel.print_readable_snapshot()
                #else:
                #    submodule.print_readable_snapshot(update, max_chars)