hdfmap 0.4__tar.gz → 0.5__tar.gz

{hdfmap-0.4/src/hdfmap.egg-info → hdfmap-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hdfmap
-Version: 0.4
+Version: 0.5
 Summary: Map objects within a HDF file and create a dataset namespace
 Author-email: Dan Porter <dan.porter@diamond.ac.uk>
 Maintainer-email: Dan Porter <dan.porter@diamond.ac.uk>
@@ -206,11 +206,11 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
         
-Project-URL: Homepage, https://github.com/DanPorter/hdfmap
-Project-URL: Documentation, https://github.com/DanPorter/hdfmap
-Project-URL: Repository, https://github.com/DanPorter/hdfmap
-Project-URL: Bug Tracker, https://github.com/DanPorter/hdfmap
-Project-URL: Changelog, https://github.com/DanPorter/hdfmap/blob/master/README.md
+Project-URL: Homepage, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Documentation, https://diamondlightsource.github.io/hdfmap/
+Project-URL: Repository, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Bug Tracker, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Changelog, https://github.com/DiamondLightSource/hdfmap/blob/master/README.md
 Keywords: nexus
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Intended Audience :: Science/Research
@@ -231,7 +231,7 @@ Map objects within an HDF file and create a dataset namespace.
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![](https://img.shields.io/github/forks/DiamondLightSource/hdfmap?label=GitHub%20Repo&style=social)](https://github.com/DiamondLightSource/hdfmap)
 
-**Version 0.4**
+**Version 0.5**
 
 | By Dan Porter        | 
 |----------------------|
@@ -349,7 +349,7 @@ map.image_data = {'name': '/hdf/group/dataset'}
 | `map.get_metadata(h5py.File)`            | returns dict of value datasets                        |
 | `map.get_scannables(h5py.File)`          | returns dict of scannable datasets                    |
 | `map.get_scannalbes_array(h5py.File)`    | returns numpy array of scannable datasets             |
-| `map.get_data_block(h5py.File)`          | returns dict like object with metadata and scannables |
+| `map.get_dataholder(h5py.File)`          | returns dict like object with metadata and scannables |
 | `map.get_image(h5py.File, index)`        | returns image data                                    |
 | `map.get_data(h5py.File, 'name')`        | returns data from dataset                             |
 | `map.eval(h5py.File, 'expression')`      | returns output of expression using dataset names      |

{hdfmap-0.4 → hdfmap-0.5}/README.md

@@ -5,7 +5,7 @@ Map objects within an HDF file and create a dataset namespace.
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![](https://img.shields.io/github/forks/DiamondLightSource/hdfmap?label=GitHub%20Repo&style=social)](https://github.com/DiamondLightSource/hdfmap)
 
-**Version 0.4**
+**Version 0.5**
 
 | By Dan Porter        | 
 |----------------------|
@@ -123,7 +123,7 @@ map.image_data = {'name': '/hdf/group/dataset'}
 | `map.get_metadata(h5py.File)`            | returns dict of value datasets                        |
 | `map.get_scannables(h5py.File)`          | returns dict of scannable datasets                    |
 | `map.get_scannalbes_array(h5py.File)`    | returns numpy array of scannable datasets             |
-| `map.get_data_block(h5py.File)`          | returns dict like object with metadata and scannables |
+| `map.get_dataholder(h5py.File)`          | returns dict like object with metadata and scannables |
 | `map.get_image(h5py.File, index)`        | returns image data                                    |
 | `map.get_data(h5py.File, 'name')`        | returns data from dataset                             |
 | `map.eval(h5py.File, 'expression')`      | returns output of expression using dataset names      |

{hdfmap-0.4 → hdfmap-0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hdfmap"
-version = "0.4"
+version = "0.5"
 dependencies = [
   "numpy",
   "h5py",
@@ -32,14 +32,9 @@ classifiers = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/DanPorter/hdfmap"
-Documentation = "https://github.com/DanPorter/hdfmap"
-Repository = "https://github.com/DanPorter/hdfmap"
-"Bug Tracker" = "https://github.com/DanPorter/hdfmap"
-Changelog = "https://github.com/DanPorter/hdfmap/blob/master/README.md"
+Homepage = "https://github.com/DiamondLightSource/hdfmap"
+Documentation = "https://diamondlightsource.github.io/hdfmap/"
+Repository = "https://github.com/DiamondLightSource/hdfmap"
+"Bug Tracker" = "https://github.com/DiamondLightSource/hdfmap"
+Changelog = "https://github.com/DiamondLightSource/hdfmap/blob/master/README.md"
 
-
-[tool.pytest.ini_options]
-pythonpath = [
-  "src",
-]

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/__init__.py

@@ -2,29 +2,29 @@
 hdfmap
 Map objects within an HDF file and create a dataset namespace.
 
---- Usage ---
-# HdfMap from NeXus file:
-from hdfmap import create_nexus_map, load_hdf
-hmap = create_nexus_map('file.nxs')
-with load_hdf('file.nxs') as nxs:
-    address = hmap.get_address('energy')
-    energy = nxs[address][()]
-    string = hmap.format_hdf(nxs, "the energy is {energy:.2f} keV")
-    d = hmap.get_data_block(nxs)  # classic data table, d.scannable, d.metadata
+# Usage
+### HdfMap from NeXus file
+    from hdfmap import create_nexus_map, load_hdf
+    hmap = create_nexus_map('file.nxs')
+    with load_hdf('file.nxs') as nxs:
+        address = hmap.get_address('energy')
+        energy = nxs[address][()]
+        string = hmap.format_hdf(nxs, "the energy is {energy:.2f} keV")
+        d = hmap.get_dataholder(nxs)  # classic data table, d.scannable, d.metadata
 
-# Shortcuts - single file reloading class
-from hdfmap import NexusLoader
-scan = NexusLoader('file.nxs')
-[data1, data2] = scan.get_data(['dataset_name_1', 'dataset_name_2'])
-data = scan.eval('dataset_name_1 * 100 + 2')
-string = scan.format('my data is {dataset_name_1:.2f}')
+### Shortcuts - single file reloading class
+    from hdfmap import NexusLoader
+    scan = NexusLoader('file.nxs')
+    [data1, data2] = scan.get_data(['dataset_name_1', 'dataset_name_2'])
+    data = scan.eval('dataset_name_1 * 100 + 2')
+    string = scan.format('my data is {dataset_name_1:.2f}')
 
-# Shortcuts - multifile load data
-from hdfmap import hdf_data, hdf_eval, hdf_format, hdf_image
-all_data = hdf_data([f"file{n}.nxs" for n in range(100)], 'dataset_name')
-normalised_data = hdf_eval(filenames, 'total / Transmission / (rc / 300.)')
-descriptions = hdf_eval(filenames, 'Energy: {en:5.3f} keV')
-image = hdf_image(filenames, index=31)
+### Shortcuts - multifile load data
+    from hdfmap import hdf_data, hdf_eval, hdf_format, hdf_image
+    all_data = hdf_data([f"file{n}.nxs" for n in range(100)], 'dataset_name')
+    normalised_data = hdf_eval(filenames, 'total / Transmission / (rc / 300.)')
+    descriptions = hdf_eval(filenames, 'Energy: {en:5.3f} keV')
+    image = hdf_image(filenames, index=31)
 
 
 By Dr Dan Porter
@@ -33,9 +33,10 @@ Diamond Light Source Ltd
 """
 
 from .logging import set_all_logging_level
+from .hdf_loader import load_hdf
 from .hdfmap_class import HdfMap
 from .nexus import NexusMap
-from .file_functions import list_files, load_hdf, create_hdf_map, create_nexus_map
+from .file_functions import list_files, create_hdf_map, create_nexus_map
 from .file_functions import hdf_data, hdf_image, hdf_eval, hdf_format, nexus_data_block
 from .reloader_class import HdfLoader, NexusLoader
 
@@ -46,8 +47,8 @@ __all__ = [
     set_all_logging_level
 ]
 
-__version__ = "0.4.0"
-__date__ = "2024/08/16"
+__version__ = "0.5.0"
+__date__ = "2024/09/25"
 
 
 def version_info() -> str:

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/eval_functions.py

@@ -57,6 +57,11 @@ def dataset2data(dataset: h5py.Dataset, index: int | slice = (), direct_load=Fal
         return dataset[index]
     if np.issubdtype(dataset, np.number):
         return np.squeeze(dataset[index])  # numeric np.ndarray
+    try:
+        # str integers will be cast as timestamps (years), capture as int
+        return np.squeeze(dataset[index]).astype(int)
+    except ValueError:
+        pass
     try:
         # timestamp -> datetime64 -> datetime
         timestamp = np.squeeze(dataset[index]).astype(np.datetime64).astype(datetime.datetime)
@@ -72,6 +77,40 @@ def dataset2data(dataset: h5py.Dataset, index: int | slice = (), direct_load=Fal
             return np.squeeze(dataset[index])  # other np.ndarray
 
 
+def dataset2str(dataset: h5py.Dataset, index: int | slice = ()) -> str:
+    """
+    Read the data from a h5py Dataset and convert to a representative string
+        Strings are given with quotes
+        numbers are shorted by attribute 'decimals'
+        numeric arrays are summarised as "dtype (shape)"
+        string arrays are summarised as "['str0', ...]
+
+    :param dataset: h5py.Dataset containing data
+    :param index: index of array (not used if dataset is string/ bytes type)
+    :return str: string representation of data
+    """
+    if np.issubdtype(dataset, np.number):
+        if dataset.size > 1:
+            return f"{dataset.dtype} {dataset.shape}"
+        value = np.squeeze(dataset[index])  # numeric np.ndarray
+        if 'decimals' in dataset.attrs:
+            value = value.round(dataset.attrs['decimals'])
+        return str(value)
+    try:
+        # timestamp -> datetime64 -> datetime
+        timestamp = np.squeeze(dataset[index]).astype(np.datetime64).astype(datetime.datetime)
+        # single datetime obj vs array of datetime obj
+        return f"'{timestamp[()]}'" if timestamp.ndim == 0 else f"['{timestamp[0]}', ...({len(timestamp)})]"
+    except ValueError:
+        try:
+            string_dataset = dataset.asstr()[()]
+            if dataset.ndim == 0:
+                return f"'{round_string_floats(string_dataset)}'"  # bytes or str -> str
+            return f"['{string_dataset[0]}', ...({len(string_dataset)})]"  # str array
+        except ValueError:
+            return str(np.squeeze(dataset[index]))  # other np.ndarray
+
+
 def check_unsafe_eval(eval_str: str) -> None:
     """
     Check str for naughty eval arguments such as sys, os or import

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/file_functions.py

@@ -1,23 +1,15 @@
 import os
-import h5py
 import numpy as np
 
+from . import load_hdf, HdfMap, NexusMap
 from .logging import create_logger
-from .hdfmap_class import HdfMap
-from .nexus import NexusMap
 
 
 EXTENSIONS = ['.nxs', '.hdf', '.hdf5', '.h5']
 DEFAULT_EXTENSION = EXTENSIONS[0]
-DEFAULT_HDF_PATH = "entry1/scan_command"
 logger = create_logger(__name__)
 
 
-def load_hdf(hdf_filename: str) -> h5py.File:
-    """Load hdf file, return h5py.File object"""
-    return h5py.File(hdf_filename, 'r')
-
-
 def list_files(folder_directory: str, extension=DEFAULT_EXTENSION) -> list[str]:
     """Return list of files in directory with extension, returning list of full file paths"""
     try:
@@ -207,4 +199,3 @@ def nexus_data_block(filenames: str | list[str], hdf_map: HdfMap = None, fixed_o
     if not fixed_output and len(filenames) == 1:
         return out[0]
     return out
-

hdfmap-0.5/src/hdfmap/hdf_loader.py

@@ -0,0 +1,12 @@
+
+import h5py
+
+try:
+    import hdf5plugin  # required for compressed data
+except ImportError:
+    print('Warning: hdf5plugin not available.')
+
+
+def load_hdf(hdf_filename: str) -> h5py.File:
+    """Load hdf file, return h5py.File object"""
+    return h5py.File(hdf_filename, 'r')

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/hdfmap_class.py

@@ -8,13 +8,10 @@ from types import SimpleNamespace
 import numpy as np
 import h5py
 
+from . import load_hdf
 from .logging import create_logger
-from .eval_functions import expression_safe_name, extra_hdf_data, eval_hdf, format_hdf, dataset2data
+from .eval_functions import expression_safe_name, extra_hdf_data, eval_hdf, format_hdf, dataset2data, dataset2str
 
-try:
-    import hdf5plugin  # required for compressed data
-except ImportError:
-    print('Warning: hdf5plugin not available.')
 
 # parameters
 SEP = '/'  # HDF path separator
@@ -66,6 +63,15 @@ def generate_identifier(hdf_path: str | bytes) -> str:
     return '_'.join(dict.fromkeys(name.split('_')))
 
 
+def generate_alt_name(hdf_dataset: h5py.Dataset) -> str:
+    """Generate alt_name of dataset if 'local_name' in attributes"""
+    if LOCAL_NAME in hdf_dataset.attrs:
+        alt_name = hdf_dataset.attrs[LOCAL_NAME]
+        if hasattr(alt_name, 'decode'):
+            alt_name = alt_name.decode()
+        return expression_safe_name(alt_name.split('.')[-1])
+
+
 def build_hdf_path(*args: str | bytes) -> str:
     """
     Build path from string or bytes arguments
@@ -117,59 +123,62 @@ class HdfMap:
             outstr = map.format(hdf, 'the data looks like: {data}')
 
     Objects within the HDF file are separated into Groups and Datasets. Each object has a
-    defined 'path' and 'name' paramater, as well as other attributes
-        path -> '/entry/measurement/data' -> the location of an object within the file
-        name -> 'data' -> an path expressed as a simple variable name
+    defined 'path' and 'name' paramater, as well as other attribute:
+
+    - path -> '/entry/measurement/data' -> the location of an object within the file
+    - name -> 'data' -> a path expressed as a simple variable name
+
     Paths are unique location within the file but can be used to identify similar objects in other files
     Names may not be unique within a file and are generated from the final element of the hdf path.
-     - When multiple paths produce the same name, the name is overwritten each time, so the last path in the
+
+    - When multiple paths produce the same name, the name is overwritten each time, so the last path in the
     file has priority.
-     - Names are also stored using the 'local_name' attribute, if it exists
+    - Names are also stored using the 'local_name' attribute, if it exists
 
     Names of different types of datasets are stored for arrays (size > 0) and values (size 0)
     Names for scannables relate to all arrays of a particular size
     A combined list of names is provided where scannables > arrays > values
 
-
-
-    Attributes:
-        map.groups      stores attributes of each group by path
-        map.classes     stores list of group paths by nx_class
-        map.datasets    stores attributes of each dataset by path
-        map.arrays      stores array dataset paths by name
-        map.values      stores value dataset paths by name
-        map.scannables  stores array dataset paths with given size, by name
-        map.combined    stores array and value paths (arrays overwrite values)
-        map.image_data  stores dataset paths of image data
-    E.G.
-        map.groups = {'/hdf/group': ('class', 'name', {attrs}, [datasets])}
-        map.classes = {'class_name': ['/hdf/group1', '/hdf/group2']}
-        map.datasets = {'/hdf/group/dataset': ('name', size, shape, {attrs})}
-        map.arrays = {'name': '/hdf/group/dataset'}
-        map.values = {'name': '/hdf/group/dataset'}
-        map.scannables = {'name': '/hdf/group/dataset'}
-        map.image_data = {'name': '/hdf/group/dataset'}
-
-    Methods:
-        map.populate(h5py.File) -> populates the dictionaries using the  given file
-        map.generate_scannables(array_size) -> populates scannables namespace with arrays of same size
-        map.most_common_size -> returns the most common dataset size > 1
-        map.get_size('name_or_path') -> return dataset size
-        map.get_shape('name_or_path') -> return dataset size
-        map.get_attr('name_or_path', 'attr') -> return value of dataset attribute
-        map.get_path('name_or_group_or_class') -> returns path of object with name
-        map.get_image_path() -> returns default path of detector dataset (or largest dataset)
-        map.get_group_path('name_or_path_or_class') -> return path of group with class
-        map.get_group_datasets('name_or_path_or_class') -> return list of dataset pathes in class
-    File Methods:
-        map.get_metadata(h5py.File) -> returns dict of value datasets
-        map.get_scannables(h5py.File) -> returns dict of scannable datasets
-        map.get_scannalbes_array(h5py.File) -> returns numpy array of scannable datasets
-        map.get_data_block(h5py.File) -> returns dict like object with metadata and scannables
-        map.get_image(h5py.File, index) -> returns image data
-        map.get_data(h5py.File, 'name') -> returns data from dataset
-        map.eval(h5py.File, 'expression') -> returns output of expression
-        map.format(h5py.File, 'string {name}') -> returns output of str expression
+    ### Attributes
+    - map.groups      stores attributes of each group by path
+    - map.classes     stores list of group paths by nx_class
+    - map.datasets    stores attributes of each dataset by path
+    - map.arrays      stores array dataset paths by name
+    - map.values      stores value dataset paths by name
+    - map.metadata   stores value dataset path by altname only
+    - map.scannables  stores array dataset paths with given size, by name
+    - map.combined    stores array and value paths (arrays overwrite values)
+    - map.image_data  stores dataset paths of image data
+    #### E.G.
+    - map.groups = {'/hdf/group': ('class', 'name', {attrs}, [datasets])}
+    - map.classes = {'class_name': ['/hdf/group1', '/hdf/group2']}
+    - map.datasets = {'/hdf/group/dataset': ('name', size, shape, {attrs})}
+    - map.arrays = {'name': '/hdf/group/dataset'}
+    - map.values = {'name': '/hdf/group/dataset'}
+    - map.scannables = {'name': '/hdf/group/dataset'}
+    - map.image_data = {'name': '/hdf/group/dataset'}
+
+    ### Methods
+    - map.populate(h5py.File) -> populates the dictionaries using the  given file
+    - map.generate_scannables(array_size) -> populates scannables namespace with arrays of same size
+    - map.most_common_size -> returns the most common dataset size > 1
+    - map.get_size('name_or_path') -> return dataset size
+    - map.get_shape('name_or_path') -> return dataset size
+    - map.get_attr('name_or_path', 'attr') -> return value of dataset attribute
+    - map.get_path('name_or_group_or_class') -> returns path of object with name
+    - map.get_image_path() -> returns default path of detector dataset (or largest dataset)
+    - map.get_group_path('name_or_path_or_class') -> return path of group with class
+    - map.get_group_datasets('name_or_path_or_class') -> return list of dataset pathes in class
+    ### File Methods
+    - map.get_metadata(h5py.File) -> returns dict of value datasets
+    - map.get_scannables(h5py.File) -> returns dict of scannable datasets
+    - map.get_scannables_array(h5py.File) -> returns numpy array of scannable datasets
+    - map.get_dataholder(h5py.File) -> returns dict like object with metadata and scannables
+    - map.get_image(h5py.File, index) -> returns image data
+    - map.get_data(h5py.File, 'name') -> returns data from dataset
+    - map.get_string(h5py.File, 'name') -> returns string summary of dataset
+    - map.eval(h5py.File, 'expression') -> returns output of expression
+    - map.format(h5py.File, 'string {name}') -> returns output of str expression
     """
 
     def __init__(self, file: h5py.File | None = None):
@@ -208,8 +217,21 @@ class HdfMap:
         """Return str info on groups"""
         out = f"{repr(self)}\n"
         out += "Groups:\n"
-        out += disp_dict(self.groups, 20)
-        out += '\n\nClasses:\n'
+        for path, group in self.groups.items():
+            out += f"{path} [{group.nx_class}: '{group.name}']\n"
+            out += '\n'.join(f"  @{attr}: {self.get_attr(path, attr)}" for attr in group.attrs)
+            out += '\n'
+            for dataset_name in group.datasets:
+                dataset_path = build_hdf_path(path, dataset_name)
+                if dataset_path in self.datasets:
+                    dataset = self.datasets[dataset_path]
+                    out += f"  {dataset_name}: {dataset.shape}\n"
+        return out
+
+    def info_classes(self) -> str:
+        """Return str info on group class names"""
+        out = f"{repr(self)}\n"
+        out += 'Classes:\n'
         out += disp_dict(self.classes, 20)
         return out
 
@@ -274,7 +296,8 @@ class HdfMap:
         # New: add group_name to namespace as standard, helps with names like s5/x + s4/x
         # this significantly increases the number of names in namespaces
         group_name = generate_identifier(f"{hdf_path.split(SEP)[-2]}_{name}")
-        alt_name = generate_identifier(hdf_dataset.attrs[LOCAL_NAME]) if LOCAL_NAME in hdf_dataset.attrs else None
+        # alt_name = generate_identifier(hdf_dataset.attrs[LOCAL_NAME]) if LOCAL_NAME in hdf_dataset.attrs else None
+        alt_name = generate_alt_name(hdf_dataset)
         names = {n: hdf_path for n in {name, group_name, alt_name} if n}
         self.datasets[hdf_path] = Dataset(
             name=name,
@@ -357,11 +380,11 @@ class HdfMap:
         return max(set(array_shapes), key=array_shapes.count)
 
     def scannables_length(self) -> int:
+        """Return the length of the first axis of scannables array"""
         if not self.scannables:
             return 0
         path = next(iter(self.scannables.values()))
-        shape = self.datasets[path].shape
-        return shape[0]
+        return self.datasets[path].size
 
     def generate_scannables(self, array_size):
         """Populate self.scannables field with datasets size that match array_size"""
@@ -418,13 +441,30 @@ class HdfMap:
             return SEP
         return hdf_path
 
-    def find_paths(self, string: str, name_only=True) -> list[str]:
+    def get_group_dataset_path(self, group_name, dataset_name) -> str | None:
+        """Return path of dataset defined by group and dataset name/attribute"""
+        if group_name in self.groups:
+            group_paths = [group_name]
+        else:
+            group_paths = self.classes[group_name]
+        for group_path in group_paths:
+            group = self.groups[group_path]
+            for name in group.datasets:
+                dataset_path = build_hdf_path(group_path, name)
+                dataset = self.datasets[dataset_path]
+                if dataset_name in dataset.names:
+                    return dataset_path
+
+    def find_paths(self, string: str, name_only=True, whole_word=False) -> list[str]:
         """
         Find any dataset paths that contain the given string argument
         :param string: str to find in list of datasets
         :param name_only: if True, search only the name of the dataset, not the full path
+        :param whole_word: if True, search only for whole-word names (case in-sensitive)
         :return: list of hdf paths
         """
+        if whole_word:
+            return [path for name, path in self.combined.items() if string.lower() == name.lower()]
         # find string in combined
         combined_paths = [path for name, path in self.combined.items() if string in name]
         if name_only:
@@ -491,6 +531,17 @@ class HdfMap:
         if self.image_data:
             return next(iter(self.image_data.values()))
 
+    def get_image_shape(self) -> tuple:
+        """Return the scan shape of the detector dataset"""
+        path = self.get_image_path()
+        if path:
+            return self.datasets[path].shape
+        return 0, 0
+
+    def get_image_index(self, index: int) -> tuple:
+        """Return image slice index for index along total scan size"""
+        return np.unravel_index(index, self.get_image_shape()[:-2])
+
     def get_group_datasets(self, name_or_path: str) -> list[str] | None:
         """Find the path associate with the given name and return all datasets in that group"""
         group_path = self.get_group_path(name_or_path)
@@ -501,6 +552,19 @@ class HdfMap:
     "---------------------- FILE READERS --------------------"
     "--------------------------------------------------------"
 
+    def load_hdf(self, filename: str | None = None, name_or_path: str = None) -> h5py.File | h5py.Dataset:
+        """
+        Load hdf file or hdf dataset in open state
+        :param filename: str filename of hdf file, or None to use self.filename
+        :param name_or_path: if given, returns the dataset
+        :return: h5py.File object or h5py.dataset object if dataset name given
+        """
+        if filename is None:
+            filename = self.filename
+        if name_or_path is None:
+            return load_hdf(filename)
+        return load_hdf(filename).get(self.get_path(name_or_path))
+
     def get_data(self, hdf_file: h5py.File, name_or_path: str, index=(), default=None, direct_load=False):
         """
         Return data from dataset in file, converted into either datetime, str or squeezed numpy.array objects
@@ -517,7 +581,23 @@ class HdfMap:
             return dataset2data(hdf_file[path], index, direct_load)
         return default
 
-    def get_metadata(self, hdf_file: h5py.File, default=None, direct_load=False, name_list: list = None) -> dict:
+    def get_string(self, hdf_file: h5py.File, name_or_path: str, index=(), default='') -> str:
+        """
+        Return data from dataset in file, converted into string summary of data
+        See hdfmap.eval_functions.dataset2str for more information.
+        :param hdf_file: hdf file object
+        :param name_or_path: str name or path pointing to dataset in hdf file
+        :param index: index or slice of data in hdf file
+        :param default: value to return if name not found in hdf file
+        :return: dataset2str(dataset) -> str
+        """
+        path = self.get_path(name_or_path)
+        if path and path in hdf_file:
+            return dataset2str(hdf_file[path], index)
+        return default
+
+    def get_metadata(self, hdf_file: h5py.File, default=None, direct_load=False,
+                     name_list: list = None, string_output=False) -> dict:
         """
         Return metadata dict from file, loading data for each item in the metadata list
         The metadata list is taken from name_list, otherwise self.metadata or self.values
@@ -525,27 +605,53 @@ class HdfMap:
         :param default: Value to return for names not associated with a dataset
         :param direct_load: if True, loads data from hdf file directory, without conversion
         :param name_list: if available, uses this list of dataset names to generate the metadata list
-        :return:
+        :param string_output: if True, returns string summary of each value
+        :return: {name: value}
         """
         extra = extra_hdf_data(hdf_file)
         if name_list:
             metadata_paths = {name: self.combined.get(name, '') for name in name_list}
         else:
-            metadata_paths = self.metadata if len(self.metadata) > 0 else self.values
-        metadata = {
-            name: dataset2data(hdf_file[path], direct_load=direct_load) if path in hdf_file else default
-            for name, path in metadata_paths.items()
-        }
+            metadata_paths = self.metadata if self.metadata else self.values
+        if string_output:
+            extra = {key: f"'{val}'" for key, val in extra.items()}
+            metadata = {
+                name: dataset2str(hdf_file[path]) if path in hdf_file else str(default)
+                for name, path in metadata_paths.items()
+            }
+        else:
+            metadata = {
+                name: dataset2data(hdf_file[path], direct_load=direct_load) if path in hdf_file else default
+                for name, path in metadata_paths.items()
+            }
         return {**extra, **metadata}
 
-    def get_scannables(self, hdf_file: h5py.File) -> dict:
+    def create_metadata_list(self, hdf_file: h5py.File, default=None, name_list: list = None,
+                             line_separator: str = '\n', value_separator: str = '=') -> str:
+        """
+        Return a metadata string, using self.get_metadata
+        :param hdf_file: hdf file object
+        :param default: Value to return for names not associated with a dataset
+        :param name_list: if available, uses this list of dataset names to generate the metadata list
+        :param line_separator: str separating each metadata parameter
+        :param value_separator: str separating name from value
+        :return: multi-line string
+        """
+        return line_separator.join(
+            f"{name}{value_separator}{value}"
+            for name, value in self.get_metadata(hdf_file, default=default,
+                                                 name_list=name_list, string_output=True).items()
+        )
+
+    def get_scannables(self, hdf_file: h5py.File, flatten: bool = False) -> dict:
         """Return scannables from file (values associated with hdfmap.scannables)"""
         return {
-            name: hdf_file[path][()] for name, path in self.scannables.items()
+            name: hdf_file[path][()].flatten() if flatten else hdf_file[path][()]
+            for name, path in self.scannables.items()
             if path in hdf_file
         }
 
-    def get_image(self, hdf_file: h5py.File, index: slice = None) -> np.ndarray | None:
+    def get_image(self, hdf_file: h5py.File, index: int | tuple | slice = None) -> np.ndarray | None:
         """
         Get image data from file, using default image path
         :param hdf_file: hdf file object
@@ -553,26 +659,28 @@ class HdfMap:
         :return: numpy array of image
         """
         if index is None:
-            index = self.scannables_length() // 2
+            index = self.get_image_index(self.scannables_length() // 2)
+        if isinstance(index, int):
+            index = self.get_image_index(index)
         image_path = self.get_image_path()
         logger.debug(f"image path: {image_path}")
         if image_path and image_path in hdf_file:
             return hdf_file[image_path][index].squeeze()  # remove trailing dimensions
 
-    def _get_numeric_scannables(self, hdf_file: h5py.File) -> list[tuple[str, str]]:
+    def _get_numeric_scannables(self, hdf_file: h5py.File) -> list[tuple[str, str, np.ndarray]]:
         """Return numeric scannables available in file"""
         return [
-            (name, path) for name, path in self.scannables.items()
-            if hdf_file.get(path) and np.issubdtype(hdf_file.get(path).dtype, np.number)
+            (name, path, dataset[()].flatten()) for name, path in self.scannables.items()
+            if (dataset := hdf_file.get(path)) and np.issubdtype(dataset.dtype, np.number)
         ]
 
     def get_scannables_array(self, hdf_file: h5py.File) -> np.ndarray:
-        """Return 2D array of all scannables in file"""
+        """Return 2D array of all numeric scannables in file"""
         _scannables = self._get_numeric_scannables(hdf_file)
         dtypes = np.dtype([
-            (name, hdf_file[path].dtype) for name, path in _scannables
+            (name, hdf_file[path].dtype) for name, path, array in _scannables
         ])
-        return np.array([hdf_file.get(path)[()] for name, path in _scannables], dtype=dtypes)
+        return np.array([array for name, path, array in _scannables], dtype=dtypes)
 
     def create_scannables_table(self, hdf_file: h5py.File, delimiter=', ',
                                 string_spec='', format_spec='f', default_decimals=8) -> str:
@@ -594,21 +702,21 @@ class HdfMap:
         fmt = string_spec + '.%d' + format_spec
         formats = [
             '{:' + fmt % self.get_attr(path, 'decimals', default=default_decimals) + '}'
-            for name, path in _scannables
+            for name, path, array in _scannables
         ]
 
         length = self.scannables_length()
-        out = delimiter.join([name for name, _ in _scannables]) + '\n'
+        out = delimiter.join([name for name, _, _ in _scannables]) + '\n'
         out += '\n'.join([
             delimiter.join([
-                fmt.format(hdf_file.get(path)[n])
-                for (_, path), fmt in zip(_scannables, formats)
+                fmt.format(array[n])
+                for (_, path, array), fmt in zip(_scannables, formats)
             ])
             for n in range(length)
         ])
         return out
 
-    def get_dataholder(self, hdf_file: h5py.File) -> DataHolder:
+    def get_dataholder(self, hdf_file: h5py.File, flatten_scannables: bool = False) -> DataHolder:
         """
         Return DataHolder object - a simple replication of scisoftpy.dictutils.DataHolder
         Also known as DLS dat format.
@@ -617,10 +725,11 @@ class HdfMap:
             dataholder['scannable'] -> array
             dataholder.metadata['value'] -> metadata
         :param hdf_file: h5py.File object
+        :param flatten_scannables: bool, it True the scannables will be flattened arrays
         :return: data_object (similar to dict)
         """
         metadata = self.get_metadata(hdf_file)
-        scannables = self.get_scannables(hdf_file)
+        scannables = self.get_scannables(hdf_file, flatten=flatten_scannables)
         scannables['metadata'] = DataHolder(**metadata)
         return DataHolder(**scannables)
 
@@ -642,13 +751,17 @@ class HdfMap:
         """
         return format_hdf(hdf_file, expression, self.combined)
 
-    def info_data(self, hdf_file):
+    def create_dataset_summary(self, hdf_file: h5py.File) -> str:
+        """Create summary of all datasets in file"""
+        return '\n'.join(f"{path:60}: {self.get_string(hdf_file, path)}" for path in self.datasets)
+
+    def info_data(self, hdf_file: h5py.File) -> str:
         """Return string showing metadata values associated with names"""
         out = repr(self) + '\n'
         out += "Combined Namespace:\n"
         out += '\n'.join([
             f"{name:>30}: " +
-            f"{str(data if np.size(data := dataset2data(hdf_file[path])) <= 1 else self.datasets[path].shape):20}" +
+            f"{dataset2str(hdf_file[path]):20}" +
             f": {path:60}"
             for name, path in self.combined.items()
         ])

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/logging.py

@@ -30,7 +30,8 @@ def set_all_logging_level(level: str | int):
     """
     try:
         level = level.upper()
-        level = logging.getLevelNamesMapping()[level]
+        # level = logging.getLevelNamesMapping()[level]  # Python >3.11
+        level = logging._nameToLevel[level]
     except AttributeError:
         level = int(level)
 

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/nexus.py

@@ -147,17 +147,21 @@ class NexusMap(HdfMap):
         out += disp_dict({k: v for k, v in self.classes.items() if k in nx_classes}, 20)
         out += '\nDefaults:\n'
         out += f"  @{NX_DEFAULT}: {self.find_attr(NX_DEFAULT)}\n"
-        out += f"  @{NX_AXES}: {self.find_attr(NX_AXES)}\n"
-        out += f"  @{NX_SIGNAL}: {self.find_attr(NX_SIGNAL)}\n"
+        out += f"  @{NX_AXES}: {self.get_path(NX_AXES)}\n"
+        out += f"  @{NX_SIGNAL}: {self.get_path(NX_SIGNAL)}\n"
         return out
 
     def _default_nexus_paths(self, hdf_file):
         """Load Nexus default axes and signal"""
         try:
             axes_paths, signal_path = find_nexus_data(hdf_file)
-            # TODO: add method of including multiple axes, e.g. axes1, axes2, ..., or self.get_axes
             if axes_paths and axes_paths[0] in hdf_file:
                 self.arrays[NX_AXES] = axes_paths[0]
+                n = 0
+                for axes_path in axes_paths:
+                    if axes_path in hdf_file and isinstance(hdf_file[axes_path], h5py.Dataset):
+                        self.arrays[f"{NX_AXES}{n}"] = axes_path
+                        n += 1
                 logger.info(f"DEFAULT axes: {axes_paths}")
             if signal_path in hdf_file:
                 self.arrays[NX_SIGNAL] = signal_path
@@ -165,6 +169,12 @@ class NexusMap(HdfMap):
         except KeyError:
             pass
 
+    def nexus_defaults(self):
+        """Return default axes and signal paths"""
+        axes_paths = [self.arrays[axes] for n in range(10) if (axes := f"{NX_AXES}{n}") in self.arrays]
+        signal_path = self.arrays[NX_SIGNAL]
+        return axes_paths, signal_path
+
     def _scannables_from_scan_fields_or_nxdata(self, hdf_file: h5py.File):
         """Generate scannables from scan_field names or default NXdata"""
         # find 'scan_fields' to generate scannables list

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap/reloader_class.py

@@ -5,25 +5,25 @@ Reloader class
 import h5py
 import numpy as np
 
-from .hdfmap_class import HdfMap
-from .nexus import NexusMap
-from .file_functions import load_hdf, create_hdf_map, create_nexus_map
+from . import load_hdf, HdfMap, NexusMap
+from .file_functions import create_hdf_map, create_nexus_map
 
 
 class HdfLoader:
     """
-    HDF Loader
-    contains the filename and hdfmap for a HDF file, the hdfmap contains all the dataset paths and a
+    HDF Loader contains the filename and hdfmap for a HDF file, the hdfmap contains all the dataset paths and a
     namespace, allowing data to be called from the file using variable names, loading only the required datasets
     for each operation.
-    E.G.
+
+    ### E.G.
         hdf = HdfLoader('file.hdf')
-        [data1, data2] = hdf.get_data(['dataset_name_1', 'dataset_name_2'])
+        [data1, data2] = hdf.get_data(*['dataset_name_1', 'dataset_name_2'])
         data = hdf.eval('dataset_name_1 * 100 + 2')
         string = hdf.format('my data is {dataset_name_1:.2f}')
+        print(hdf.summary())
     """
 
-    def __init__(self, hdf_filename: str, hdf_map: HdfMap | None = None):
+    def __init__(self, hdf_filename: str, hdf_map: HdfMap | NexusMap | None = None):
         self.filename = hdf_filename
         if hdf_map is None:
             self.map = create_hdf_map(hdf_filename)
@@ -51,14 +51,15 @@ class HdfLoader:
         """Return hdf path of object in HdfMap"""
         return self.map.get_path(name_or_path)
 
-    def find_hdf_paths(self, string: str, name_only: bool = True) -> list[str]:
+    def find_hdf_paths(self, string: str, name_only: bool = True, whole_word: bool = False) -> list[str]:
         """
         Find any dataset paths that contain the given string argument
         :param string: str to find in list of datasets
         :param name_only: if True, search only the name of the dataset, not the full path
+        :param whole_word: if True, search only for case in-sensitive name
         :return: list of hdf paths
         """
-        return self.map.find_paths(string, name_only)
+        return self.map.find_paths(string, name_only, whole_word)
 
     def find_names(self, string: str) -> list[str]:
         """
@@ -84,6 +85,21 @@ class HdfLoader:
             return out[0]
         return out
 
+    def get_string(self, *name_or_path, index: slice = (), default=''):
+        """
+        Return data from dataset in file, converted into summary string
+        See hdfmap.eval_functions.dataset2data for more information.
+        :param name_or_path: str name or path pointing to dataset in hdf file
+        :param index: index or slice of data in hdf file
+        :param default: value to return if name not found in hdf file
+        :return: dataset2str(dataset) -> str
+        """
+        with self._load() as hdf:
+            out = [self.map.get_string(hdf, name, index, default) for name in name_or_path]
+        if len(name_or_path) == 1:
+            return out[0]
+        return out
+
     def get_image(self, index: slice = None) -> np.ndarray:
         """
         Get image data from file, using default image path
@@ -102,6 +118,11 @@ class HdfLoader:
         with self._load() as hdf:
             return self.map.get_scannables(hdf)
 
+    def summary(self) -> str:
+        """Return string summary of datasets"""
+        with self._load() as hdf:
+            return self.map.create_dataset_summary(hdf)
+
     def eval(self, expression: str):
         """
         Evaluate an expression using the namespace of the hdf file

{hdfmap-0.4 → hdfmap-0.5/src/hdfmap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hdfmap
-Version: 0.4
+Version: 0.5
 Summary: Map objects within a HDF file and create a dataset namespace
 Author-email: Dan Porter <dan.porter@diamond.ac.uk>
 Maintainer-email: Dan Porter <dan.porter@diamond.ac.uk>
@@ -206,11 +206,11 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
         
-Project-URL: Homepage, https://github.com/DanPorter/hdfmap
-Project-URL: Documentation, https://github.com/DanPorter/hdfmap
-Project-URL: Repository, https://github.com/DanPorter/hdfmap
-Project-URL: Bug Tracker, https://github.com/DanPorter/hdfmap
-Project-URL: Changelog, https://github.com/DanPorter/hdfmap/blob/master/README.md
+Project-URL: Homepage, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Documentation, https://diamondlightsource.github.io/hdfmap/
+Project-URL: Repository, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Bug Tracker, https://github.com/DiamondLightSource/hdfmap
+Project-URL: Changelog, https://github.com/DiamondLightSource/hdfmap/blob/master/README.md
 Keywords: nexus
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Intended Audience :: Science/Research
@@ -231,7 +231,7 @@ Map objects within an HDF file and create a dataset namespace.
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![](https://img.shields.io/github/forks/DiamondLightSource/hdfmap?label=GitHub%20Repo&style=social)](https://github.com/DiamondLightSource/hdfmap)
 
-**Version 0.4**
+**Version 0.5**
 
 | By Dan Porter        | 
 |----------------------|
@@ -349,7 +349,7 @@ map.image_data = {'name': '/hdf/group/dataset'}
 | `map.get_metadata(h5py.File)`            | returns dict of value datasets                        |
 | `map.get_scannables(h5py.File)`          | returns dict of scannable datasets                    |
 | `map.get_scannalbes_array(h5py.File)`    | returns numpy array of scannable datasets             |
-| `map.get_data_block(h5py.File)`          | returns dict like object with metadata and scannables |
+| `map.get_dataholder(h5py.File)`          | returns dict like object with metadata and scannables |
 | `map.get_image(h5py.File, index)`        | returns image data                                    |
 | `map.get_data(h5py.File, 'name')`        | returns data from dataset                             |
 | `map.eval(h5py.File, 'expression')`      | returns output of expression using dataset names      |

{hdfmap-0.4 → hdfmap-0.5}/src/hdfmap.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 src/hdfmap/__init__.py
 src/hdfmap/eval_functions.py
 src/hdfmap/file_functions.py
+src/hdfmap/hdf_loader.py
 src/hdfmap/hdfmap_class.py
 src/hdfmap/logging.py
 src/hdfmap/nexus.py

{hdfmap-0.4 → hdfmap-0.5}/tests/test_edge_cases.py

@@ -1,7 +1,9 @@
 from os import path
 import json
 import hdfmap
+import hdfmap.hdf_loader
 
+from . import only_dls_file_system
 
 # Edge case files, create this list from create_test_files.py
 TEST_FILES = path.join(path.dirname(__file__), 'data', 'test_files.json')
@@ -9,6 +11,7 @@ with open(TEST_FILES, 'r') as f:
     CHECK_FILES = json.load(f)
 
 
+@only_dls_file_system
 def test_edge_cases():
     n = 0
     for chk in CHECK_FILES:
@@ -26,19 +29,23 @@ def test_edge_cases():
     print(f"Completed {n} edge case files")
 
 
+@only_dls_file_system
 def test_old_i16_file():
     filename = '/dls/science/groups/das/ExampleData/hdfmap_tests/i16/1040311.nxs'
+    assert path.isfile(filename) is True, f"{filename} doesn't exist"
     mymap = hdfmap.create_nexus_map(filename)
-    with hdfmap.load_hdf(filename) as hdf:
+    with hdfmap.hdf_loader.load_hdf(filename) as hdf:
         value, address = mymap.eval(hdf, 'np.sum(sum), _sum')
     assert abs(value + 407) < 0.01, 'expression "np.sum(sum)" gives wrong result'
     assert address == '/entry1/measurement/sum', 'expression "_sum" returns wrong address'
 
 
+@only_dls_file_system
 def test_new_i16_file():
     filename = '/dls/science/groups/das/ExampleData/hdfmap_tests/i16/1040323.nxs'
+    assert path.isfile(filename) is True, f"{filename} doesn't exist"
     mymap = hdfmap.create_nexus_map(filename)
-    with hdfmap.load_hdf(filename) as hdf:
+    with hdfmap.hdf_loader.load_hdf(filename) as hdf:
         h, k, l, hkl, _h, fname = mymap.eval(hdf, 'h, k, l, hkl, _h, filename')
     assert h.shape == (21,), 'expression "h" has wrong shape'
     assert hkl == '--', 'default for expression "hkl" is incorrect'

{hdfmap-0.4 → hdfmap-0.5}/tests/test_file_functions.py

@@ -1,13 +1,14 @@
 import pytest
 import os
 import hdfmap.file_functions as ff
+import hdfmap.hdf_loader
 
 DATA_FOLDER = os.path.join(os.path.dirname(__file__), 'data')
 
 
 @pytest.fixture
 def files():
-    files = ff.list_files(DATA_FOLDER)
+    files = ff.list_files(DATA_FOLDER, extension='.nxs')
     yield files
 
 
@@ -30,7 +31,7 @@ def test_hdf_eval(files):
     file = files[0]
     mymap = ff.create_hdf_map(file)
     expr = "int(total[0] / Transmission)"
-    with ff.load_hdf(file) as hdf:
+    with hdfmap.hdf_loader.load_hdf(file) as hdf:
         out = mymap.eval(hdf, expr)
     assert ff.hdf_eval(file, expr) == out, "expression output doesn't match"
 
@@ -39,7 +40,7 @@ def test_hdf_format(files):
     file = files[0]
     mymap = ff.create_hdf_map(file)
     expr = "energy is {en:.2f} keV"
-    with ff.load_hdf(file) as hdf:
+    with hdfmap.hdf_loader.load_hdf(file) as hdf:
         out = mymap.format_hdf(hdf, expr)
     assert ff.hdf_format(file, expr) == out, "expression output doesn't match"
 
@@ -47,6 +48,6 @@ def test_hdf_format(files):
 def test_hdf_image(files):
     file = files[0]
     mymap = ff.create_hdf_map(file)
-    with ff.load_hdf(file) as hdf:
+    with hdfmap.hdf_loader.load_hdf(file) as hdf:
         image = mymap.get_image(hdf)
     assert ff.hdf_image(file).shape == image.shape, "image doesn't match"

{hdfmap-0.4 → hdfmap-0.5}/tests/test_hdfmap_class.py

@@ -1,6 +1,7 @@
 import pytest
 import os
 import hdfmap
+import hdfmap.hdf_loader
 
 DATA_FOLDER = os.path.join(os.path.dirname(__file__), 'data')
 FILE_HKL = DATA_FOLDER + "/1049598.nxs"  # hkl scan, pilatus
@@ -8,7 +9,7 @@ FILE_HKL = DATA_FOLDER + "/1049598.nxs"  # hkl scan, pilatus
 
 @pytest.fixture
 def hdf_map():
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         hdf_map = hdfmap.HdfMap(hdf)
     yield hdf_map
 
@@ -70,22 +71,31 @@ def test_get_group_datasets(hdf_map):
 
 
 def test_get_data(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         en = hdf['/entry1/before_scan/mono/en'][()]
         h = hdf['/entry1/measurement/h'][()]
         cmd = hdf['/entry1/scan_command'].asstr()[()]
+        scanno = int(hdf['/entry1/entry_identifier'][()])
         assert hdf_map.get_data(hdf, 'en') == en, "'en' produces wrong result"
         assert (hdf_map.get_data(hdf, 'h') == h).all(), "'h' produces wrong result"
         assert hdf_map.get_data(hdf, 'scan_command')[:8] == cmd[:8], "'cmd' produces wrong result"
+        assert hdf_map.get_data(hdf, 'entry_identifier') == scanno, "'entry_identifier' gives wrong result"
+
+
+def test_get_string(hdf_map):
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
+        assert hdf_map.get_string(hdf, 'en') == '3.5800002233729673'
+        assert hdf_map.get_string(hdf, 'h') == 'float64 (101,)'
+        assert hdf_map.get_string(hdf, 'start_time') == "'2024-05-17 14:13:27.025000'"
 
 
 def test_get_image(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         assert hdf_map.get_image(hdf).shape == (195, 487)
 
 
 def test_get_dataholder(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         d = hdf_map.get_dataholder(hdf)
     assert d.metadata.filepath == FILE_HKL, "Filename not included in data object metadata"
     assert int(100 * d.metadata.en) == 358, "metadata energy is wrong"
@@ -93,39 +103,49 @@ def test_get_dataholder(hdf_map):
 
 
 def test_get_metadata(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         meta = hdf_map.get_metadata(hdf)
         meta_small = hdf_map.get_metadata(hdf, name_list=['scan_command', 'incident_energy'])
+        meta_string = hdf_map.get_metadata(hdf, string_output=True)
     assert len(meta) == 423, "Length of metadata wrong"
     assert meta['filename'] == '1049598.nxs', "filename is wrong"
     assert abs(meta_small['incident_energy'] - 3.58) < 0.01, "Energy is wrong"
+    cmd = "'scan hkl [-0.05, -7.878e-16, 0.933] [0.05, -7.878e-16, 0.933] [0.001, 0, 0] BeamOK pil3_100k 1 roi2 roi1'"
+    assert meta_string['scan_command'] == cmd
+    assert meta_string['ppchi'] == '-44.999994057'
+
+
+def test_create_metadata_list(hdf_map):
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
+        meta = hdf_map.create_metadata_list(hdf)
+    assert len(meta) == 11391, "Length of metadata list wrong"
 
 
 def test_get_scannables(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         scannables = hdf_map.get_scannables(hdf)
     assert len(scannables) == 131, "Length of scannables is wrong"
 
 
 def test_get_scannables_array(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         scannables = hdf_map.get_scannables_array(hdf)
         assert scannables.shape == (129, 101), "scannables array is wrong shape"
 
 
 def test_create_scannables_table(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         scannables = hdf_map.create_scannables_table(hdf, '\t')
         assert len(scannables) == 165703, "scannables str is wrong length"
 
 
 def test_eval(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         out = hdf_map.eval(hdf, 'int(np.max(sum / Transmission / count_time))')
         assert out == 6533183, "Expression output gives wrong result"
 
 
 def test_format_hdf(hdf_map):
-    with hdfmap.load_hdf(FILE_HKL) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_HKL) as hdf:
         out = hdf_map.format_hdf(hdf, 'The energy is {en:.3} keV')
         assert out == 'The energy is 3.58 keV', "Expression output gives wrong result"

{hdfmap-0.4 → hdfmap-0.5}/tests/test_many_files.py

@@ -1,7 +1,9 @@
 import os
 from time import perf_counter
 import hdfmap
+import hdfmap.hdf_loader
 
+from . import only_dls_file_system
 
 # Folder with over 1000 files
 THOUSAND_FILES = '/dls/science/groups/das/ExampleData/hdfmap_tests/i16/cm37262-1'
@@ -10,13 +12,15 @@ NFILES = 1332  # number of files to test (max 1332)
 FORMAT_STRING = '#{entry_identifier}: {start_time} : E={incident_energy:.3f} keV : {scan_command}'
 
 
+@only_dls_file_system
 def test_compare_time_for_many_files():
     files = hdfmap.list_files(THOUSAND_FILES)[:NFILES]
+    assert len(files) > 1, "Files not found"
     # time to read single entry from each files
     start = perf_counter()
     output1 = []
     for file in files:
-        with hdfmap.load_hdf(file) as hdf:
+        with hdfmap.hdf_loader.load_hdf(file) as hdf:
             output1.append((
                 hdf['/entry1/scan_command'][()],
                 hdf['/entry1/entry_identifier'][()],
@@ -36,7 +40,7 @@ def test_compare_time_for_many_files():
     start = perf_counter()
     output1 = []
     for file in files:
-        with hdfmap.load_hdf(file) as hdf:
+        with hdfmap.hdf_loader.load_hdf(file) as hdf:
             output1.append((
                 hdf['/entry1/scan_command'][()],
                 hdf['/entry1/entry_identifier'][()],

{hdfmap-0.4 → hdfmap-0.5}/tests/test_nexus.py

@@ -4,11 +4,11 @@ import hdfmap
 
 DATA_FOLDER = os.path.join(os.path.dirname(__file__), 'data')
 FILE_NEW_NEXUS = DATA_FOLDER + '/1040323.nxs'  # new nexus format
+FILE_3D_NEXUS = DATA_FOLDER + '/i06-353130.nxs'  # new nexus format
 
 hdfmap.set_all_logging_level('debug')
 
 
-
 @pytest.fixture
 def hdf_map():
     hdf_map = hdfmap.NexusMap()
@@ -19,7 +19,7 @@ def hdf_map():
 
 def test_populate(hdf_map):
     assert len(hdf_map.datasets) == 431, "Wrong number of datasets"
-    assert len(hdf_map.combined) == 634, "Wrong number of names in map.combined"
+    assert len(hdf_map.combined) == 633, "Wrong number of names in map.combined"
     assert hdf_map.scannables_length() == 21, "Wrong length for scannables"
     assert hdf_map['axes'] == '/entry/measurement/h', "Wrong path for default axes"
     assert hdf_map.get_image_path() == '/entry/instrument/pil3_100k/data', "Wrong image path"
@@ -32,11 +32,28 @@ def test_dataset_names(hdf_map):
 
 
 def test_nexus_eval(hdf_map):
-    with hdfmap.load_hdf(FILE_NEW_NEXUS) as hdf:
+    with hdfmap.hdf_loader.load_hdf(FILE_NEW_NEXUS) as hdf:
         out = hdf_map.eval(hdf, 'int(np.max(total / Transmission / count_time))')
         assert out == 70, "Expression output gives wrong result"
         path = hdf_map.eval(hdf, '_axes')
         assert path == '/entry/measurement/h', "Wrong axes path"
         title = hdf_map.format_hdf(hdf, '{filename}: {scan_command}')
         correct = '1040323.nxs: scan hkl [0.97, 0.022, 0.112] [0.97, 0.022, 0.132] [0, 0, 0.001] MapperProc pil3_100k 1'
-        assert title == correct, "Expression output gives wrong result"
+        assert title == correct, "Expression output gives wrong result"
+
+
+def test_3d_scan(hdf_map):
+    hdf_map = hdfmap.create_nexus_map(FILE_3D_NEXUS)
+    assert hdf_map.scannables_length() == 80, "Scannables have the wrong length"
+    axes, signal = hdf_map.nexus_defaults()
+    assert len(axes) == 3, "Number of default axes is wrong"
+    assert signal == '/entry/medipix/data', "Incorrect default signal"
+    with hdf_map.load_hdf() as hdf:
+        table = hdf_map.create_scannables_table(hdf)
+        assert table.count('\n') == 80, "table has the wrong length"
+        assert len(table) == 4085, "wrong number of characters in table"
+
+        image = hdf_map.get_image(hdf, index=None)
+        assert image.shape == (512, 512), "image shape is wrong"
+
+