clean up the string output in read_nexus (#712)

Author: lukaspie

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.12.0
+    rev: v0.14.0
     hooks:
       # Run the linter.
       - id: ruff

src/pynxtools/nexus/nexus.py

@@ -425,6 +425,91 @@ def get_inherited_hdf_nodes(
     return (class_path, nxdl_elem_path, elist)
 
 
+def safe_str(value, precision: int = 8) -> str:
+    """Return a deterministic string representation of arrays, lists, or scalars.
+
+    Floats are formatted consistently across systems to ensure deterministic
+    output. Special handling is applied to simplify representation:
+      - `0.0` → `'0.0'`
+      - `1.0` → `'1'`
+      - `1.50` → `'1.5'`
+      - Non-integer floats keep up to `precision` decimals with trailing zeros
+        and dots removed.
+
+    Arrays and lists are formatted elementwise using the same rules.
+
+    Args:
+        value: The input value to format. Can be a scalar, list, tuple,
+            NumPy array, or basic type such as int, float, str, or bytes.
+        precision (int): Maximum number of decimal places for non-integer
+            floats. Defaults to 8.
+
+    Returns:
+        str: Deterministic string representation of the input.
+    """
+    # Normalize NumPy scalar and 0D array types
+    if isinstance(value, np.generic):
+        value = value.item()
+    elif isinstance(value, np.ndarray) and value.shape == ():
+        value = value.item()
+
+    def format_float(value: float) -> str:
+        """Format a float deterministically."""
+        if value == 0.0:
+            return "0.0"
+        if value.is_integer():
+            return str(int(value))
+        if abs(value) < 10**-precision or abs(value) >= 10 ** (precision + 1):
+            return f"{value:.{precision}e}"
+        return f"{value:.{precision}f}".rstrip("0").rstrip(".")
+
+    # --- Arrays ---
+    if isinstance(value, np.ndarray):
+        flat = value.flatten()
+        formatted = []
+        for v in flat:
+            if isinstance(v, (np.generic, np.ndarray)):
+                v = v.item()
+            if isinstance(v, float):
+                formatted.append(format_float(v))
+            elif isinstance(v, (int, bool)):
+                formatted.append(str(v))
+            elif isinstance(v, str):
+                formatted.append(v)
+            elif isinstance(v, bytes):
+                formatted.append(v.decode(errors="replace"))
+            else:
+                formatted.append(str(v))
+        reshaped = np.array(formatted, dtype=object).reshape(value.shape)
+        return np.array2string(
+            reshaped,
+            separator=", ",
+            formatter={"all": lambda x: str(x)},
+            max_line_width=1000000,
+            threshold=6,
+        )
+
+    # --- Lists / tuples ---
+    if isinstance(value, list | tuple):
+        formatted = [safe_str(v, precision) for v in value]
+        return "[" + ", ".join(formatted) + "]"
+
+    # --- Floats ---
+    if isinstance(value, float | np.floating):
+        return format_float(float(value))
+
+    # --- Integers / booleans ---
+    elif isinstance(value, (int, np.integer, bool, np.bool_)):
+        return str(value)
+
+    # --- Strings / bytes ---
+    elif isinstance(value, (bytes, str)):
+        return value if isinstance(value, str) else value.decode(errors="replace")
+
+    # --- Fallback ---
+    return str(value)
+
+
 def process_node(hdf_node, hdf_path, parser, logger, doc=True):
     """Processes an hdf5 node.
     - it logs the node found and also checks for its attributes
@@ -436,11 +521,11 @@ def process_node(hdf_node, hdf_path, parser, logger, doc=True):
     if isinstance(hdf_node, h5py.Dataset):
         logger.debug(f"===== FIELD (/{hdf_path}): {hdf_node}")
         val = (
-            str(decode_if_string(hdf_node[()])).split("\n")
+            safe_str(decode_if_string(hdf_node[()])).split("\n")
             if len(hdf_node.shape) <= 1
-            else str(decode_if_string(hdf_node[0])).split("\n")
+            else safe_str(decode_if_string(hdf_node[0])).split("\n")
         )
-        logger.debug(f"value: {val[0]} {'...' if len(val) > 1 else ''}")
+        logger.debug(f"value: {val[0]}{' ...' if len(val) > 1 else ''}")
     else:
         logger.debug(
             f"===== GROUP (/{hdf_path} "
@@ -460,8 +545,8 @@ def process_node(hdf_node, hdf_path, parser, logger, doc=True):
         )
     for key, value in hdf_node.attrs.items():
         logger.debug(f"===== ATTRS (/{hdf_path}@{key})")
-        val = str(decode_if_string(value)).split("\n")
-        logger.debug(f"value: {val[0]} {'...' if len(val) > 1 else ''}")
+        val = safe_str(decode_if_string(value)).split("\n")
+        logger.debug(f"value: {val[0]}{' ...' if len(val) > 1 else ''}")
         (req_str, nxdef, nxdl_path) = get_nxdl_doc(hdf_info, logger, doc, attr=key)
         if (
             parser is not None

src/pynxtools/nomad/parser.py

@@ -149,7 +149,7 @@ def _get_value(hdf_node):
             def decode_array(arr):
                 result = []
                 for x in arr:
-                    if isinstance(x, (np.ndarray, list)):
+                    if isinstance(x, np.ndarray | list):
                         result.append(decode_array(x))
                     else:
                         result.append(str(decode_or_not(x)))