Add more features

pypi-publish.yml
 - add PYPI CI

tkgui
 - add META_LABEL metadata
 - add metadata_list config editor
 - add rois to plot_widget.listbox
 - refactored nexus_treeview.py and added hdf_viewer.py and nexus_string_views.py
 - added default path to Nexus file viewer

 Experiment
  - add_data_paths function
  - improvement of multi-line plot

 NexusScan
  - moved NexusScan classes into seperate file

 mkdocs.yml
  - removed search to see if this brings search back

Author: DanPorter

.github/workflows/pypi-publish.yml

@@ -0,0 +1,42 @@
+name: PyPiPublish
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  dist:
+    runs-on: "ubuntu-latest"
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build sdist and wheel
+        run: pipx run build
+
+      - name: Upload sdist and wheel as artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+  pypi:
+    # upload to PyPI and make a release on every tag
+    if: github.ref_type == 'tag'
+    needs: [dist]
+
+    runs-on: ubuntu-latest
+    permissions:
+      # this permission is mandatory for trusted publishing To PyPI
+      id-token: write
+    # Specify the GitHub Environment to publish to
+    environment: release
+
+    steps:
+      # download sdist and wheel from dist job
+      - uses: actions/download-artifact@v4
+
+      # publish to PyPI using trusted publishing
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

mkdocs.yml

@@ -3,7 +3,6 @@ repo_name: mmg_toolbox
 repo_url: https://github.com/DiamondLightSource/mmg_toolbox
 plugins:
 - techdocs-diamond
-- search
 - mkdocstrings:
     handlers:
       python:
@@ -88,11 +87,6 @@ nav:
   - diffraction:
     - description/diffraction_diffcalc.md
 markdown_extensions:
-- pymdownx.superfences:
-    custom_fences:
-    - name: mermaid
-      class: mermaid
-      format: !!python/name:pymdownx.superfences.fence_code_format
 - pymdownx.highlight:
     anchor_linenums: true
     line_spans: __span

mmg_toolbox/nexus/__init__.py

@@ -0,0 +1,9 @@
+"""
+NeXus Tools
+"""
+
+from .nexus_scan import NexusScan, NexusDataHolder
+from .nexus_reader import read_nexus_file, read_nexus_files, find_matching_scans
+
+__all__ = ['NexusScan', 'NexusDataHolder', 'read_nexus_file', 'read_nexus_files', 'find_matching_scans']
+

mmg_toolbox/nexus/nexus_reader.py

@@ -1,167 +1,24 @@
 import os
 
-from hdfmap import NexusMap, NexusLoader, load_hdf, create_nexus_map
-from hdfmap.eval_functions import dataset2data, dataset2str
-import h5py
-import numpy as np
-import datetime
+from hdfmap import load_hdf, create_nexus_map
 
-from mmg_toolbox.utils.misc_functions import DataHolder, shorten_string
+from mmg_toolbox.nexus.nexus_scan import NexusDataHolder, NexusScan
 from mmg_toolbox.utils.file_functions import get_scan_number, replace_scan_number
-from mmg_toolbox.beamline_metadata.hdfmap_generic import HdfMapMMGMetadata as Md
-from mmg_toolbox.nexus.nexus_functions import get_dataset_value
-from mmg_toolbox.nexus.instrument_model import NXInstrumentModel
-from mmg_toolbox.xas.nxxas_loader import load_xas_scans, SpectraContainer
 
 
-class NexusScan(NexusLoader):
-    """
-    Light-weight NeXus file reader
-
-    Example:
-        scan = NexusScan('scan.nxs')
-        scan('scan_command') -> returns value
-
-    :param nxs_filename: path to nexus file
-    :param hdf_map: NexusMap object or None
-    """
-    MAX_STR_LEN: int = 100
-
-    def __init__(self, nxs_filename: str, hdf_map: NexusMap | None = None):
-        super().__init__(nxs_filename, hdf_map)
-
-        from mmg_toolbox.utils.fitting import ScanFitManager, poisson_errors
-        self.fit = ScanFitManager(self)
-        self._error_function = poisson_errors
-        from mmg_toolbox.plotting.scan_plot_manager import ScanPlotManager
-        self.plot = ScanPlotManager(self)
-
-    def __repr__(self):
-        return f"NexusScan('{self.filename}')"
-
-    def scan_number(self) -> int:
-        return get_scan_number(self.filename)
-
-    def title(self) -> str:
-        return f"#{self.scan_number()}"
-
-    def label(self) -> str:
-        return f"#{self.scan_number()}"
-
-    def load_hdf(self) -> h5py.File:
-        """Load the Hdf file"""
-        return load_hdf(self.filename)
-
-    def datasets(self, *args) -> list[h5py.Dataset]:
-        """Return HDF5 datasets from NeXus file (leaves file in open state)"""
-        with self.load_hdf() as hdf:
-            return [hdf[self.map.combined[name]] for name in args]
-
-    def arrays(self, *args, units: str = '', default: np.ndarray = np.array([np.nan])) -> list[np.ndarray]:
-        """Return Numpy arrays"""
-        with self.load_hdf() as hdf:
-            return [
-                get_dataset_value(self.map.combined[name], hdf, units=units, default=default)
-                for name in args
-            ]
-
-    def values(self, *args, value_func=np.mean,
-               units: str = '', default: np.ndarray = np.array(np.nan)) -> list[np.floating]:
-        """Return float values"""
-        with self.load_hdf() as hdf:
-            return [
-                value_func(get_dataset_value(self.map.combined[name], hdf, units=units, default=default))
-                for name in args
-            ]
-
-    def times(self, *args) -> list[datetime.datetime]:
-        """Return datetime object"""
-        with self.load_hdf() as hdf:
-            return [dataset2data(hdf[self.map.combined[name]]) for name in args]
-
-    def strings(self, *args, units=False) -> list[str]:
-        """Return string value"""
-        with self.load_hdf() as hdf:
-            return [dataset2str(hdf[self.map.combined[name]], units=units) for name in args]
-
-    def image(self, index: int | tuple | slice | None = None) -> np.ndarray:
-        """Return image or selection from default detector"""
-        with self.load_hdf() as hdf:
-            return self.map.get_image(hdf, index)
-
-    def table(self, delimiter=', ', string_spec='', format_spec='f', default_decimals=8) -> str:
-        """Return data table"""
-        with self.load_hdf() as hdf:
-            return self.map.create_scannables_table(hdf, delimiter, string_spec, format_spec, default_decimals)
-
-    #TODO: Remove this?
-    def get_plot_data(self, x_axis: str = 'axes0', y_axis: str = 'signal0') -> dict:
-        with self.load_hdf() as hdf:
-            cmd = self.map.eval(hdf, Md.cmd)
-            if len(cmd) > self.MAX_STR_LEN:
-                cmd = shorten_string(cmd)
-            xdata = self.map.eval(hdf, x_axis)
-            ydata = self.map.eval(hdf, y_axis)
-            yerror = self._error_function(ydata)
-            x_lab, y_lab = self.map.generate_ids(x_axis, y_axis, modify_missing=False)
-            return {
-                'x': xdata,
-                'y': ydata,
-                'yerror': yerror,
-                'xlabel': x_lab,
-                'ylabel': y_lab,
-                'title': f"#{self.scan_number()}\n{cmd}"
-            }
-
-    def xas_scan(self) -> SpectraContainer:
-        """Load XAS Spectra"""
-        return load_xas_scans(self.filename)[0]
-
-    def instrument_model(self) -> NXInstrumentModel:
-        """return instrument model"""
-        with self.load_hdf() as hdf:
-            return NXInstrumentModel(hdf)
-
-
-class NexusDataHolder(DataHolder, NexusScan):
+def read_nexus_file(filename: str, flatten_scannables: bool = True) -> NexusDataHolder:
     """
-    Nexus data holder class
-     - Automatically reads scannable and metadata from file
-     - acts like the old .dat DataHolder class
-     - has additional functions to read data from NeXus file
-
-    Example:
-        scan = NexusDataHolder('12345.nxs')
-        scan.eta -> returns array
-        scan.metadata.metadata -> returns value
-        scan('signal') -> evaluate expression
-
-    :param filename: path to Nexus file
-    :param hdf_map: NexusMap object or None to generate
-    :param flatten_scannables: if True, flattens all scannable arrays to 1D
+    Read Nexus file as DataHolder
     """
-    filename: str
-    map: NexusMap
-    metadata: DataHolder
-
-    def __init__(self, filename: str | None, hdf_map: NexusMap | None = None, flatten_scannables: bool = True):
-        NexusScan.__init__(self, filename, hdf_map)
-
-        with load_hdf(filename) as hdf:
-            metadata = self.map.get_metadata(hdf)
-            scannables = self.map.get_scannables(hdf, flatten=flatten_scannables)
-        DataHolder.__init__(self, **scannables)
-        self.metadata = DataHolder(**metadata)
-
-    def __repr__(self):
-        return f"NexusDataHolder('{self.filename}')"
+    return NexusDataHolder(filename, flatten_scannables=flatten_scannables)
 
 
-def read_nexus_file(filename: str, flatten_scannables: bool = True) -> NexusDataHolder:
+def read_nexus_files(*filenames: str) -> list[NexusScan]:
     """
-    Read Nexus file as DataHolder
+    Read Nexus files as NexusScan
     """
-    return NexusDataHolder(filename, flatten_scannables=flatten_scannables)
+    hdf_map = create_nexus_map(filenames[0])
+    return [NexusScan(f, hdf_map) for f in filenames]
 
 
 def find_matching_scans(filename: str, match_field: str = 'scan_command',