evefile 0.1.0rc1__py3-none-any.whl → 0.1.0rc2__py3-none-any.whl

evefile/boundaries/evefile.py

@@ -488,7 +488,7 @@ class EveFile(File):
         dataframe = pd.DataFrame(
             {item.metadata.name: item.data for item in joined_data}
         )
-        dataframe.index.name = "PosRef"
+        dataframe.index.name = "position"
         return dataframe
 
     def show_info(self):

evefile/controllers/joining.py

@@ -466,7 +466,6 @@ import logging
 from functools import reduce
 
 import numpy as np
-from numpy import ma
 
 import evefile.entities
 import evefile.entities.data
@@ -616,56 +615,16 @@ class Join:
     def _fill_axes(self):
         for axis in self._axes:
             if axis.metadata.id in self.evefile.snapshots:
-                self.evefile.snapshots[axis.metadata.id].get_data()
-                axis.position_counts = np.searchsorted(
-                    axis.position_counts,
-                    self.evefile.snapshots[axis.metadata.id].position_counts,
+                axis.join(
+                    positions=self._result_positions,
+                    snapshot=self.evefile.snapshots[axis.metadata.id],
                 )
-                axis.data = np.insert(
-                    axis.data,
-                    axis.position_counts,
-                    self.evefile.snapshots[axis.metadata.id].data,
-                )
-            positions = (
-                np.searchsorted(
-                    axis.position_counts, self._result_positions, side="right"
-                )
-                - 1
-            )
-            axis.position_counts = self._result_positions
-            axis.data = axis.data[positions]
-            if np.any(np.where(positions < 0)):
-                axis.data = ma.masked_array(axis.data)
-                axis.data[np.where(positions < 0)] = ma.masked
+            else:
+                axis.join(positions=self._result_positions, fill=True)
 
     def _fill_channels(self):
         for channel in self._channels:
-            if len(self._result_positions) > len(channel.position_counts):
-                original_values = channel.data
-                channel.data = ma.masked_array(
-                    np.zeros(len(self._result_positions))
-                )
-                channel.data = ma.masked_array(channel.data)
-                positions = np.setdiff1d(
-                    self._result_positions, channel.position_counts
-                )
-                channel.data[
-                    np.searchsorted(
-                        self._result_positions, channel.position_counts
-                    ).astype(np.int64)
-                ] = original_values
-                channel.data[
-                    np.searchsorted(self._result_positions, positions).astype(
-                        np.int64
-                    )
-                ] = ma.masked
-            elif len(self._result_positions) < len(channel.position_counts):
-                channel.data = channel.data[
-                    np.searchsorted(
-                        channel.position_counts, self._result_positions
-                    ).astype(np.int64)
-                ]
-            channel.position_counts = self._result_positions
+            channel.join(positions=self._result_positions)
 
     def _assign_result(self):
         result = [*self._axes]

evefile/entities/data.py

@@ -10,15 +10,15 @@
 
 Data are organised in "datasets" within HDF5, and the
 :mod:`evefile.entities.data` module provides the relevant entities
-to describe these datasets. Although currently (as of 07/2024, eve version
-2.1) neither average nor interval detector channels save the individual
-data points, at least the former is a clear need of the
-engineers/scientists. Hence, the data model already respects this use
-case. As per position (count) there can be a variable number of measured
-points, the resulting array is no longer rectangular, but a "ragged
-array". While storing such arrays is possible directly in HDF5,
-the implementation within evefile is entirely independent of the actual
-representation in the eveH5 file.
+to describe these datasets.
+
+Please note that in contrast to the `evedata
+<https://evedata.docs.radiometry.de/>`_ package, the ``evefile`` package has
+a somewhat reduced data model, *e.g.* not considering individual data points
+for average and interval channels (that are currently not available from the
+underlying data files, anyway). Whether the corresponding module in the
+``evedata`` package will become a true superset of this module remains to be
+seen.
 
 
 Overview
@@ -127,6 +127,8 @@ import logging
 
 import h5py
 import numpy as np
+import pandas as pd
+from numpy import ma
 
 from evefile.entities import metadata
 
@@ -193,6 +195,8 @@ class Data:
         self.options = {}
         self.importer = []
         self._data = None
+        # List of attributes containing data
+        self._data_attributes = ["data"]
 
     def __str__(self):
         """
@@ -307,14 +311,102 @@ class Data:
                 )
         self.metadata.copy_attributes_from(source.metadata)
 
+    def show_info(self):
+        """
+        Print basic information regarding the contents of a data object.
+
+        Often, it is convenient to get a brief overview of the contents of
+        a data object. The output of this method currently contains the
+        following sections:
+
+        * metadata
+        * options (if present)
+        * fields
+
+        The output could look similar to the following:
+
+        .. code-block:: none
+
+            METADATA
+            name: jane
+
+            OPTIONS
+            some_option: value
+
+            FIELDS
+            data
+
+        Here, the ``METADATA`` block simply outputs what you would get with
+
+        .. code-block::
+
+            print(data.metadata)
+
+        If options are present, then the keys of the :attr:`options` dict
+        are returned in the ``OPTIONS`` block. Finally, the ``FIELDS`` block
+        provides an overview of all the attributes containing some kind of
+        data. This will differ depending on the type of data you are looking
+        at.
+        """
+        print("METADATA")
+        print(self.metadata)
+        if self.options:
+            print("\nOPTIONS")
+            for key in self.options:
+                print(key)
+        print("\nFIELDS")
+        for item in dir(self):
+            if (
+                not item.startswith("_")
+                and not callable(getattr(self, item))
+                and item not in ["importer", "metadata", "options"]
+            ):
+                print(item)
+
+    def get_dataframe(self):
+        """
+        Retrieve Pandas DataFrame with data as column.
+
+        .. important::
+
+            While working with a Pandas DataFrame may seem convenient,
+            you're loosing basically all the relevant metadata of the
+            datasets. Hence, this method is rather a convenience method to
+            be backwards-compatible to older interfaces, but it is
+            explicitly *not* suggested for extensive use.
+
+        Returns
+        -------
+        dataframe : :class:`pandas.DataFrame`
+            Pandas DataFrame containing data as column.
+
+        """
+        if self.data is not None:
+            index = np.linspace(1, self.data.size, self.data.size)
+        else:
+            index = [0]
+        dataframe = pd.DataFrame(
+            {item: getattr(self, item) for item in self._data_attributes},
+            index=index,
+        )
+        return dataframe
+
 
 class MonitorData(Data):
     """
     Data from devices monitored, but not controlled by the eve engine.
 
+    Monitors are a concept stemming from the underlying `EPICS layer
+    <https://epics-controls.org/>`_ and are closely related to telemetry in
+    general. In short: You register a certain "device", record an initial
+    value, and from then on only changes to this value (together with a
+    timestamp). This allows you to record any relevant changes in your setup
+    with minimal overhead and data storage.
+
     In contrast to :class:`MeasureData`, :class:`MonitorData` do not have
     a position as primary axis, but a timestamp in milliseconds, *i.e.*,
-    the :attr:`milliseconds` attribute.
+    the :attr:`milliseconds` attribute. This means that without further ado,
+    you cannot plot monitor data against other data.
 
 
     Attributes
@@ -356,6 +448,33 @@ class MonitorData(Data):
             f"<{type(self).__name__}>"
         )
 
+    def get_dataframe(self):
+        """
+        Retrieve Pandas DataFrame with data as column.
+
+        The index is named "milliseconds" and contains the values of the
+        :attr:`milliseconds` attribute of the data object.
+
+        .. important::
+
+            While working with a Pandas DataFrame may seem convenient,
+            you're loosing basically all the relevant metadata of the
+            datasets. Hence, this method is rather a convenience method to
+            be backwards-compatible to older interfaces, but it is
+            explicitly *not* suggested for extensive use.
+
+        Returns
+        -------
+        dataframe : :class:`pandas.DataFrame`
+            Pandas DataFrame containing data as column.
+
+        """
+        dataframe = super().get_dataframe()
+        if self.milliseconds.ndim:
+            dataframe.index = self.milliseconds
+        dataframe.index.name = "milliseconds"
+        return dataframe
+
 
 class MeasureData(Data):
     """
@@ -439,6 +558,99 @@ class MeasureData(Data):
     def position_counts(self, positions=None):
         self._position_counts = positions
 
+    def get_dataframe(self):
+        """
+        Retrieve Pandas DataFrame with data as column.
+
+        The index is named "positions" and contains the values of the
+        :attr:`position_counts` attribute of the data object.
+
+        .. important::
+
+            While working with a Pandas DataFrame may seem convenient,
+            you're loosing basically all the relevant metadata of the
+            datasets. Hence, this method is rather a convenience method to
+            be backwards-compatible to older interfaces, but it is
+            explicitly *not* suggested for extensive use.
+
+        Returns
+        -------
+        dataframe : :class:`pandas.DataFrame`
+            Pandas DataFrame containing data as column.
+
+        """
+        dataframe = super().get_dataframe()
+        if self.position_counts is not None and self.position_counts.ndim:
+            dataframe.index = self.position_counts
+        dataframe.index.name = "position"
+        return dataframe
+
+    def join(self, positions=None):
+        """
+        Perform a left join of the data on the provided list of positions.
+
+        The main "quantisation" axis of the values for a device and the
+        common reference is the list of positions. To sensibly compare the
+        data of different devices or plot different device data against each
+        other, the data need to be harmonised, *i.e.* share a common set of
+        positions as indices.
+
+        If positions are not present in the original data, by default,
+        the corresponding entries will be masked and the :attr:`data`
+        attribute converted into a :class:`numpy.ma.MaskedArray`.
+
+        The reason for not using "NaN" (not a number) is, in short,
+        that "NaN" is only defined for floating point numbers, but neither
+        integers nor non-numeric values. Data, however, could generally
+        contain values that are *not* floating point numbers. For a more
+        detailed discussion, see the :mod:`evefile.controllers.joining`
+        module.
+
+        .. note::
+
+            The method will *alter* the data and positions of the underlying
+            :obj:`MeasureData` object. Hence, make sure to make a copy if
+            this is not your intended use case.
+
+
+        Parameters
+        ----------
+        positions : :class:`numpy.ndarray`
+            Array with positions the data should be mapped to.
+
+        Raises
+        ------
+        ValueError
+            Raised if no positions are provided
+
+        """
+        if positions is None:
+            raise ValueError("No positions provided")
+        for item in self._data_attributes:
+            data_ = getattr(self, item)
+            if len(positions) < len(self.position_counts):
+                # pylint: disable=unsubscriptable-object
+                data_ = data_[
+                    np.searchsorted(self.position_counts, positions).astype(
+                        np.int64
+                    )
+                ]
+            elif len(positions) > len(self.position_counts):
+                original_values = data_
+                data_ = ma.masked_array(np.zeros(len(positions)))
+                data_ = ma.masked_array(data_)
+                new_positions = np.setdiff1d(positions, self.position_counts)
+                data_[
+                    np.searchsorted(positions, self.position_counts).astype(
+                        np.int64
+                    )
+                ] = original_values
+                data_[
+                    np.searchsorted(positions, new_positions).astype(np.int64)
+                ] = ma.masked
+            setattr(self, item, data_)
+        self.position_counts = positions
+
     def _import_from_hdf5dataimporter(self, importer=None):
         """
         Import data from HDF5 using data importer.
@@ -555,6 +767,87 @@ class AxisData(MeasureData):
         for attribute in importer.mapping.values():
             setattr(self, attribute, getattr(self, attribute)[indices])
 
+    def join(self, positions=None, fill=False, snapshot=None):
+        """
+        Perform a left join of the data on the provided list of positions.
+
+        The main "quantisation" axis of the values for a device and the
+        common reference is the list of positions. To sensibly compare the
+        data of different devices or plot different device data against each
+        other, the data need to be harmonised, *i.e.* share a common set of
+        positions as indices.
+
+        If positions are not present in the original data, by default,
+        the corresponding entries will be masked and the :attr:`data`
+        attribute converted into a :class:`numpy.ma.MaskedArray`.
+
+        The reason for not using "NaN" (not a number) is, in short,
+        that "NaN" is only defined for floating point numbers, but neither
+        integers nor non-numeric values. Data, however, could generally
+        contain values that are *not* floating point numbers. For a more
+        detailed discussion, see the :mod:`evefile.controllers.joining`
+        module.
+
+        .. note::
+
+            The method will *alter* the data and positions of the underlying
+            :obj:`MeasureData` object. Hence, make sure to make a copy if
+            this is not your intended use case.
+
+
+        Parameters
+        ----------
+        positions : :class:`numpy.ndarray`
+            Array with positions the data should be mapped to.
+
+        fill : :class:`bool`
+            Whether to fill missing positions with previous values.
+
+            Only in case a previous value exists for a given position (or a
+            snapshot containing a previous value is provided as additional
+            parameter), filling for the position will be performed.
+            Otherwise, the position is masked.
+
+        snapshot : :class:`AxisData`
+            Snapshot data corresponding to the original :obj:`AxisData` object.
+
+        Raises
+        ------
+        ValueError
+            Raised if no positions are provided
+
+        """
+        if snapshot is not None:
+            fill = True
+        if not fill:
+            super().join(positions=positions)
+        else:
+            if snapshot:
+                snapshot.get_data()
+                insert_positions = np.searchsorted(
+                    self.position_counts,
+                    snapshot.position_counts,
+                )
+                self.data = np.insert(
+                    self.data,
+                    insert_positions,
+                    snapshot.data,
+                )
+                self.position_counts = np.insert(
+                    self.position_counts,
+                    insert_positions,
+                    snapshot.position_counts,
+                )
+            new_positions = (
+                np.searchsorted(self.position_counts, positions, side="right")
+                - 1
+            )
+            self.position_counts = positions
+            self.data = self.data[new_positions]
+            if np.where(new_positions < 0)[0].size:
+                self.data = ma.masked_array(self.data)
+                self.data[np.where(new_positions < 0)] = ma.masked
+
 
 class ChannelData(MeasureData):
     """
@@ -743,12 +1036,6 @@ class AverageChannelData(ChannelData):
     metadata : :class:`evefile.entities.metadata.AverageChannelMetadata`
         Relevant metadata for the individual device.
 
-    raw_data : Any
-        The raw individual values measured.
-
-    attempts : numpy.ndarray
-        Short description
-
 
     Examples
     --------
@@ -764,56 +1051,44 @@ class AverageChannelData(ChannelData):
     def __init__(self):
         super().__init__()
         self.metadata = metadata.AverageChannelMetadata()
-        self.raw_data = None
-        self.attempts = np.ndarray(shape=[], dtype=int)
-        self._mean = None
-        self._std = None
+        self._attempts = None
+        self._data_attributes = ["data", "attempts"]
 
     @property
-    def mean(self):
+    def attempts(self):
         """
-        Mean values for channel data.
+        Number of attempts needed until final data were recorded.
 
         Returns
         -------
-        mean : :class:`numpy.ndarray`
-            The mean of the values recorded.
-
-            If more values have been recorded than should be averaged
-            over, only the number of values to average over are taken from
-            the end of the individual :attr:`raw_data` row.
+        attempts : :class:`numpy.ndarray`
+            Number of attempts
 
         """
-        if self._mean is None:
-            if self.raw_data is not None:
-                self._mean = self.raw_data.mean(axis=1)
-            else:
-                self._mean = self.data
-        return self._mean
+        if self._attempts is None:
+            self.get_data()
+        return self._attempts
+
+    @attempts.setter
+    def attempts(self, attempts=None):
+        self._attempts = attempts
 
     @property
-    def std(self):
+    def mean(self):
         """
-        Standard deviation values for channel data.
+        Mean values for channel data.
 
         Returns
         -------
         mean : :class:`numpy.ndarray`
-            The standard deviation of the values recorded.
+            The mean of the values recorded.
 
-            If more values have been recorded than should be averaged
-            over, only the number of values to average over are taken from
-            the end of the individual :attr:`raw_data` row to calculate
-            the standard deviation.
+            As at least up to eveH5 v7.x only the averaged values are stored
+            in the HDF5 file, this simply returns the values stored
+            in :attr:`data`.
 
         """
-        if self._std is None and self.raw_data is not None:
-            self._std = self.raw_data.std(axis=1)
-        return self._std
-
-    @std.setter
-    def std(self, std=None):
-        self._std = std
+        return self.data
 
 
 class IntervalChannelData(ChannelData):
@@ -838,14 +1113,6 @@ class IntervalChannelData(ChannelData):
     metadata : :class:`evefile.entities.metadata.IntervalChannelMetadata`
         Relevant metadata for the individual device.
 
-    raw_data : Any
-        The raw individual values measured in the given time interval.
-
-    counts : numpy.ndarray
-        The number of values measured in the given time interval.
-
-        Note that this value may change for each individual position.
-
 
     Examples
     --------
@@ -861,28 +1128,28 @@ class IntervalChannelData(ChannelData):
     def __init__(self):
         super().__init__()
         self.metadata = metadata.IntervalChannelMetadata()
-        self.raw_data = None
-        self.counts = np.ndarray(shape=[], dtype=int)
-        self._mean = None
+        self._counts = None
         self._std = None
+        self._data_attributes = ["data", "counts", "std"]
 
     @property
-    def mean(self):
+    def counts(self):
         """
-        Mean values for channel data.
+        The number of values measured in the given time interval.
 
         Returns
         -------
-        mean : :class:`numpy.ndarray`
-            The mean of the values measured in the given time interval.
+        counts : :class:`numpy.ndarray`
+            Number of values measured in the given time interval
 
         """
-        if self._mean is None:
-            if self.raw_data is not None:
-                self._mean = self.raw_data.mean(axis=1)
-            else:
-                self._mean = self.data
-        return self._mean
+        if self._counts is None:
+            self.get_data()
+        return self._counts
+
+    @counts.setter
+    def counts(self, counts=None):
+        self._counts = counts
 
     @property
     def std(self):
@@ -891,19 +1158,35 @@ class IntervalChannelData(ChannelData):
 
         Returns
         -------
-        mean : :class:`numpy.ndarray`
-            The standard deviation of the values measured in the given
-            time interval.
+        std : :class:`numpy.ndarray`
+            Standard deviation values for channel data.
 
         """
-        if self._std is None and self.raw_data is not None:
-            self._std = self.raw_data.std(axis=1)
+        if self._std is None:
+            self.get_data()
         return self._std
 
     @std.setter
     def std(self, std=None):
         self._std = std
 
+    @property
+    def mean(self):
+        """
+        Mean values for channel data.
+
+        Returns
+        -------
+        mean : :class:`numpy.ndarray`
+            The mean of the values measured in the given time interval.
+
+            As at least up to eveH5 v7.x only the averaged values are stored
+            in the HDF5 file, this simply returns the values stored
+            in :attr:`data`.
+
+        """
+        return self.data
+
 
 class NormalizedChannelData:
     """
@@ -918,14 +1201,6 @@ class NormalizedChannelData:
     metadata : :class:`evefile.entities.metadata.AreaChannelMetadata`
         Relevant metadata for normalization.
 
-    normalized_data : Any
-        Data that have been normalized.
-
-        Normalization takes place by dividing by the values of the
-        normalizing channel.
-
-    normalizing_data : Any
-        Data used for normalization.
 
     Raises
     ------
@@ -947,8 +1222,45 @@ class NormalizedChannelData:
     def __init__(self):
         super().__init__()
         self.metadata = metadata.NormalizedChannelMetadata()
-        self.normalized_data = None
-        self.normalizing_data = None
+        self._normalized_data = None
+        self._normalizing_data = None
+
+    @property
+    def normalized_data(self):
+        """
+        Data that have been normalized.
+
+        Normalization takes place by dividing by the values of the
+        normalizing channel.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data that have been normalized.
+
+        """
+        return self._normalized_data
+
+    @normalized_data.setter
+    def normalized_data(self, normalized_data=None):
+        self._normalized_data = normalized_data
+
+    @property
+    def normalizing_data(self):
+        """
+        Data used for normalization.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data used for normalization.
+
+        """
+        return self._normalizing_data
+
+    @normalizing_data.setter
+    def normalizing_data(self, normalizing_data=None):
+        self._normalizing_data = normalizing_data
 
 
 class SinglePointNormalizedChannelData(
@@ -990,6 +1302,52 @@ class SinglePointNormalizedChannelData(
     def __init__(self):
         super().__init__()
         self.metadata = metadata.SinglePointNormalizedChannelMetadata()
+        self._data_attributes = [
+            "data",
+            "normalized_data",
+            "normalizing_data",
+        ]
+
+    @property
+    def normalized_data(self):
+        """
+        Data that have been normalized.
+
+        Normalization takes place by dividing by the values of the
+        normalizing channel.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data that have been normalized.
+
+        """
+        if self._normalized_data is None:
+            self.get_data()
+        return self._normalized_data
+
+    @normalized_data.setter
+    def normalized_data(self, normalized_data=None):
+        self._normalized_data = normalized_data
+
+    @property
+    def normalizing_data(self):
+        """
+        Data used for normalization.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data used for normalization.
+
+        """
+        if self._normalizing_data is None:
+            self.get_data()
+        return self._normalizing_data
+
+    @normalizing_data.setter
+    def normalizing_data(self, normalizing_data=None):
+        self._normalizing_data = normalizing_data
 
 
 class AverageNormalizedChannelData(AverageChannelData, NormalizedChannelData):
@@ -1029,6 +1387,53 @@ class AverageNormalizedChannelData(AverageChannelData, NormalizedChannelData):
     def __init__(self):
         super().__init__()
         self.metadata = metadata.AverageNormalizedChannelMetadata()
+        self._data_attributes = [
+            "data",
+            "attempts",
+            "normalized_data",
+            "normalizing_data",
+        ]
+
+    @property
+    def normalized_data(self):
+        """
+        Data that have been normalized.
+
+        Normalization takes place by dividing by the values of the
+        normalizing channel.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data that have been normalized.
+
+        """
+        if self._normalized_data is None:
+            self.get_data()
+        return self._normalized_data
+
+    @normalized_data.setter
+    def normalized_data(self, normalized_data=None):
+        self._normalized_data = normalized_data
+
+    @property
+    def normalizing_data(self):
+        """
+        Data used for normalization.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data used for normalization.
+
+        """
+        if self._normalizing_data is None:
+            self.get_data()
+        return self._normalizing_data
+
+    @normalizing_data.setter
+    def normalizing_data(self, normalizing_data=None):
+        self._normalizing_data = normalizing_data
 
 
 class IntervalNormalizedChannelData(
@@ -1069,6 +1474,54 @@ class IntervalNormalizedChannelData(
     def __init__(self):
         super().__init__()
         self.metadata = metadata.IntervalNormalizedChannelMetadata()
+        self._data_attributes = [
+            "data",
+            "counts",
+            "std",
+            "normalized_data",
+            "normalizing_data",
+        ]
+
+    @property
+    def normalized_data(self):
+        """
+        Data that have been normalized.
+
+        Normalization takes place by dividing by the values of the
+        normalizing channel.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data that have been normalized.
+
+        """
+        if self._normalized_data is None:
+            self.get_data()
+        return self._normalized_data
+
+    @normalized_data.setter
+    def normalized_data(self, normalized_data=None):
+        self._normalized_data = normalized_data
+
+    @property
+    def normalizing_data(self):
+        """
+        Data used for normalization.
+
+        Returns
+        -------
+        normalized_data : Any
+            Data used for normalization.
+
+        """
+        if self._normalizing_data is None:
+            self.get_data()
+        return self._normalizing_data
+
+    @normalizing_data.setter
+    def normalizing_data(self, normalizing_data=None):
+        self._normalizing_data = normalizing_data
 
 
 class DataImporter:

evefile/entities/metadata.py

@@ -125,6 +125,37 @@ class Metadata:
         super().__init__()
         self.name = ""
         self.options = {}
+        # Note: Attributes are listed manually here for explicit ordering in
+        #       string representation using self.__str__
+        # Use only append or extend in subclasses!
+        self._attributes = ["name"]
+
+    def __str__(self):
+        """
+        Human-readable representation of the metadata.
+
+        Returns
+        -------
+        output : :class:`str`
+            Multiline string with one attribute per line
+
+        """
+        output = []
+        attribute_name_length = max(
+            len(attribute) for attribute in self._attributes
+        )
+        for attribute in self._attributes:
+            output.append(
+                f"{attribute:>{attribute_name_length}}:"
+                f" {getattr(self, attribute)}"
+            )
+        if self.options:
+            key_name_length = max(len(key) for key in self.options)
+            output.append("")
+            output.append("SCALAR OPTIONS")
+            for key, value in self.options.items():
+                output.append(f"{key:>{key_name_length}}:" f" {value}")
+        return "\n".join(output)
 
     def copy_attributes_from(self, source=None):
         """
@@ -223,6 +254,10 @@ class MonitorMetadata(Metadata, AbstractDeviceMetadata):
 
     """
 
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["id", "pv", "access_mode"])
+
 
 class MeasureMetadata(Metadata):
     """
@@ -252,6 +287,7 @@ class MeasureMetadata(Metadata):
     def __init__(self):
         super().__init__()
         self.unit = ""
+        self._attributes.append("unit")
 
 
 class DeviceMetadata(MeasureMetadata, AbstractDeviceMetadata):
@@ -273,6 +309,10 @@ class DeviceMetadata(MeasureMetadata, AbstractDeviceMetadata):
 
     """
 
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["id", "pv", "access_mode"])
+
 
 class AxisMetadata(MeasureMetadata, AbstractDeviceMetadata):
     """
@@ -295,6 +335,7 @@ class AxisMetadata(MeasureMetadata, AbstractDeviceMetadata):
     def __init__(self):
         super().__init__()
         self.deadband = 0.0
+        self._attributes.extend(["id", "pv", "access_mode", "deadband"])
 
 
 class ChannelMetadata(MeasureMetadata, AbstractDeviceMetadata):
@@ -316,6 +357,10 @@ class ChannelMetadata(MeasureMetadata, AbstractDeviceMetadata):
 
     """
 
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["id", "pv", "access_mode"])
+
 
 class TimestampMetadata(MeasureMetadata):
     """
@@ -407,6 +452,9 @@ class AverageChannelMetadata(ChannelMetadata):
         self.low_limit = 0.0
         self.max_attempts = 0
         self.max_deviation = 0.0
+        self._attributes.extend(
+            ["n_averages", "low_limit", "max_attempts", "max_deviation"]
+        )
 
 
 class IntervalChannelMetadata(ChannelMetadata):
@@ -437,6 +485,7 @@ class IntervalChannelMetadata(ChannelMetadata):
     def __init__(self):
         super().__init__()
         self.trigger_interval = 0.0
+        self._attributes.append("trigger_interval")
 
 
 class NormalizedChannelMetadata:
@@ -486,6 +535,10 @@ class SinglePointNormalizedChannelMetadata(
 
     """
 
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["normalize_id"])
+
 
 class AverageNormalizedChannelMetadata(
     ChannelMetadata, NormalizedChannelMetadata
@@ -508,6 +561,10 @@ class AverageNormalizedChannelMetadata(
 
     """
 
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["normalize_id"])
+
 
 class IntervalNormalizedChannelMetadata(
     ChannelMetadata, NormalizedChannelMetadata
@@ -529,3 +586,7 @@ class IntervalNormalizedChannelMetadata(
     you can instantiate an object as usual.
 
     """
+
+    def __init__(self):
+        super().__init__()
+        self._attributes.extend(["normalize_id"])

{evefile-0.1.0rc1.dist-info → evefile-0.1.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evefile
-Version: 0.1.0rc1
+Version: 0.1.0rc2
 Summary: Transitional package to read eveH5 files containing synchrotron radiometry data recorded at BESSY/MLS in Berlin
 Home-page: https://www.ptb.de/cms/en/ptb/fachabteilungen/abt7/ptb-sr.html
 Author: Till Biskup
@@ -53,6 +53,11 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
+
+.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.16815768.svg
+   :target: https://doi.org/10.5281/zenodo.16815768
+   :align: right
+
 =======
 evefile
 =======

{evefile-0.1.0rc1.dist-info → evefile-0.1.0rc2.dist-info}/RECORD

@@ -1,30 +1,30 @@
 evefile/__init__.py,sha256=DtUfummsLsWO7A-xiqL1hUEBll8Qc1z7829P9Sb0kOk,215
 evefile/__pycache__/__init__.cpython-311.pyc,sha256=RkdWBYZ3wcT04KJ8H7KPKwhPhMc-GV9vbGSuOIOtqjE,398
 evefile/boundaries/__init__.py,sha256=OKIxX1YeMY3Bda2g27xm-uQwH191EL6qLIHoPIoz_88,64
-evefile/boundaries/evefile.py,sha256=4ZfSrpSx6Bb_1d5Y-nQ4sOOk0MJ0tJSHnj1d_gPzr2E,18184
+evefile/boundaries/evefile.py,sha256=uVptvR2-1bvCjByxi4JNO45VkMyt7t6pYBwRa5vjO9w,18186
 evefile/boundaries/eveh5.py,sha256=u-aEXXBoQYCfKb7l7w1x2VVKlQ2mT5S8gMdLiHZteYU,29750
 evefile/boundaries/__pycache__/__init__.cpython-311.pyc,sha256=GnLdTDzJRRVDQg_l9nctkGQs0GU8oILd3Lg1XY7kKhg,251
-evefile/boundaries/__pycache__/evefile.cpython-311.pyc,sha256=YKFIUnzmKCmT-7bAxK2wq7DfP9LZ0kAXHF6JdNuXIJg,22018
+evefile/boundaries/__pycache__/evefile.cpython-311.pyc,sha256=n0oPx3nUc5SMzKGNektf1o4YBIuWllxQma9jd0bLKlE,22020
 evefile/boundaries/__pycache__/eveh5.cpython-311.pyc,sha256=IpaPRhZkmdR-z6x257TujkwRgAeyuhPwAn7NnvslNJM,35831
 evefile/controllers/__init__.py,sha256=K4ysYHyf7p5dFDIppJyx8-ydZpLfwvjoikhUcOapKuQ,147
-evefile/controllers/joining.py,sha256=Qsvv9o3l6l1PFsgroJKiUU24gMvJeRn1RT05tsflsYs,43986
+evefile/controllers/joining.py,sha256=o0GI6bBxtAU5uZkXoZ6JhgerZ_fgD3Y6IaoYt4UjSJI,42173
 evefile/controllers/timestamp_mapping.py,sha256=_plmzVtY_CaVp3wYy1VhfGenRwWLRJiIA6yw398r_Ec,4686
 evefile/controllers/version_mapping.py,sha256=zplXv7lKvvzd0NI1pMpavVFCdrkauXBnT_uvXTJu8PQ,41958
 evefile/controllers/__pycache__/__init__.cpython-311.pyc,sha256=OAlQR88n3ns13ecANQdSyPZ4w0F350NhCicFxjMAJmw,356
-evefile/controllers/__pycache__/joining.cpython-311.pyc,sha256=QLLjKLNI7k5zjtHY0QWcCOVSOHIht24jVbV1sP2wH1g,50194
+evefile/controllers/__pycache__/joining.cpython-311.pyc,sha256=si4e2UAuNQrQ6fGp6vXf_a7MUimLLeKDDh148OUzwPo,48080
 evefile/controllers/__pycache__/timestamp_mapping.cpython-311.pyc,sha256=yDqvWtdJg9FfAoT3vSQ2jI9tuIslMZxGTNjCOXtPpRs,4898
 evefile/controllers/__pycache__/version_mapping.cpython-311.pyc,sha256=rQ-M_O5po_E3bwjbG200AdZBT_g8N0WShDX-BFpYKl4,52416
 evefile/entities/__init__.py,sha256=VfS-6fdCiqlYobw7gcCMcfdm8Fct_6AnSPw99JHV2bo,170
-evefile/entities/data.py,sha256=UAW-N8naWSMC_HMBVEESq120ZcDiHVWFTj3ucY0RwNY,40761
+evefile/entities/data.py,sha256=w6XMPqCtYqPGcRGmmZsWbOfT2WHsevc82Ws5uMB3tjc,54930
 evefile/entities/file.py,sha256=grOHe2ONwieh58imbEq1ahLZyXooardctNanvcuWOJs,9816
-evefile/entities/metadata.py,sha256=tXMG8vyzDT-0Zk1UQJPRXIqzeTa984pM7zOUo7UP8HU,16100
+evefile/entities/metadata.py,sha256=DVgLWM3bob2JWh_wpf6jGJ6LnIRsErB_AJmOx-u_P3E,18111
 evefile/entities/__pycache__/__init__.cpython-311.pyc,sha256=Rc8OF9IeRYpJbN7Qw5AFn5qPxm7g_carXQKqnuZUHz4,380
-evefile/entities/__pycache__/data.cpython-311.pyc,sha256=xKsTEBQ9K7RfeKkaqp71ShmYMXJFem_mVQB7ky6MPM8,52458
+evefile/entities/__pycache__/data.cpython-311.pyc,sha256=B_mzzKZ6uqGufF52z9I4jM8eIIMEEUF-zIVdSDEzS24,68181
 evefile/entities/__pycache__/file.cpython-311.pyc,sha256=scDx1m5UN-HcCqAArH3Gzw-tSjE0fWSiiTzR8xTSlfg,11764
-evefile/entities/__pycache__/metadata.cpython-311.pyc,sha256=6opdeMMvA3Jll8NhfBwMAj7uvc8nj7PVahYVQjynrYk,20736
-evefile-0.1.0rc1.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-evefile-0.1.0rc1.dist-info/licenses/LICENSE,sha256=VYLxbjlmThdMWJAgeCXSLlcHUDR0kk0C40P92FH3o3M,766
-evefile-0.1.0rc1.dist-info/METADATA,sha256=NIfIY61ON08Ehm5NtyfjP383yGGvONvrw0GQyItkono,4936
-evefile-0.1.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-evefile-0.1.0rc1.dist-info/top_level.txt,sha256=AiXT2Ch6ZWznVmfIXckmjoPXMfucyXMj4SP_46hKN7s,8
-evefile-0.1.0rc1.dist-info/RECORD,,
+evefile/entities/__pycache__/metadata.cpython-311.pyc,sha256=AMbmJ_dJbM6fzzMw124sH6CYvUEaYNeV0vTn1CHEJEQ,24716
+evefile-0.1.0rc2.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+evefile-0.1.0rc2.dist-info/licenses/LICENSE,sha256=VYLxbjlmThdMWJAgeCXSLlcHUDR0kk0C40P92FH3o3M,766
+evefile-0.1.0rc2.dist-info/METADATA,sha256=SLm_dKzLTvD7OxUUzKT9yzUOLxOr1_o9RaN1Wyfs5qQ,5075
+evefile-0.1.0rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+evefile-0.1.0rc2.dist-info/top_level.txt,sha256=AiXT2Ch6ZWznVmfIXckmjoPXMfucyXMj4SP_46hKN7s,8
+evefile-0.1.0rc2.dist-info/RECORD,,