merge devel to master and release 0.2.25 (#857)

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **New Features**
* Improved handling and validation of custom data types, including
enhanced equality checks and string representations.
* Added robust enforcement of the right-hand rule for lattice vectors
and coordinates, and introduced cell rotation to lower-triangular form
for LAMMPS output.
* Enhanced VASP OUTCAR and XML parsing to better extract atom names,
types, and handle the NWRITE parameter.
  * Broadened support for loading virial data from ASE Atoms objects.

* **Bug Fixes**
  * Corrected per-atom property indexing when writing ABACUS STRU files.

* **Chores**
* Updated dependencies and workflow configurations for improved
compatibility and reproducibility.
* Added comprehensive test cases for new features, edge cases, and
custom data type handling.
  * Included new VASP test data files for improved test coverage.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: njzjz

.github/workflows/benchmark.yml

@@ -13,7 +13,7 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: 3.12
-    - uses: astral-sh/setup-uv@v5
+    - uses: astral-sh/setup-uv@v6
       with:
         enable-cache: true
         cache-dependency-glob: |

.github/workflows/pyright.yml

@@ -13,7 +13,7 @@ jobs:
       with:
         python-version: '3.12'
     - run: pip install uv
-    - run: uv pip install --system -e .[amber,ase,pymatgen] rdkit openbabel-wheel
+    - run: uv pip install --system -e .[amber,ase,pymatgen] 'rdkit<2025.3.3' openbabel-wheel
     - uses: jakebailey/pyright-action@v2
       with:
         version: 1.1.363

.github/workflows/test.yml

@@ -18,15 +18,15 @@ jobs:
       uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
-    - uses: astral-sh/setup-uv@v5
+    - uses: astral-sh/setup-uv@v6
       with:
         enable-cache: true
         cache-dependency-glob: |
           **/requirements*.txt
           **/pyproject.toml
         cache-suffix: "py${{ matrix.python-version }}"
     - name: Install dependencies
-      run: uv pip install --system .[test,amber,ase,pymatgen] coverage ./tests/plugin rdkit openbabel-wheel
+      run: uv pip install --system .[test,amber,ase,pymatgen] coverage ./tests/plugin 'rdkit<2025.3.3' openbabel-wheel 'numpy<2.3'
     - name: Test
       run: cd tests && coverage run --source=../dpdata -m unittest && cd .. && coverage combine tests/.coverage && coverage report
     - name: Run codecov

.pre-commit-config.yaml

@@ -21,7 +21,7 @@ repos:
 # Python
 -   repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.11.0
+    rev: v0.12.5
     hooks:
     - id: ruff
       args: ["--fix"]

docs/rtd_environment.yml

@@ -3,6 +3,6 @@ channels:
   - conda-forge
 dependencies:
   - python <3.13
-  - mamba <2
+  - jupyterlite-xeus
   - pip:
     - ..[docs]

dpdata/abacus/stru.py

@@ -314,7 +314,7 @@ def get_atom_mag_cartesian(atommag, angle1, angle2):
         ]
 
 
-def get_carteisan_coords(coords, coord_type, celldm, cell):
+def get_cartesian_coords(coords, coord_type, celldm, cell):
     """Transform the atomic coordinates to cartesian coordinates.
 
     Args:
@@ -378,7 +378,7 @@ def parse_pos(coords_lines, atom_names, celldm, cell):
                 parse_pos_oneline(coords_lines[line_idx])
             )
 
-            coords.append(get_carteisan_coords(np.array(pos), coord_type, celldm, cell))
+            coords.append(get_cartesian_coords(np.array(pos), coord_type, celldm, cell))
 
             move.append(imove)
             velocity.append(ivelocity)
@@ -422,6 +422,25 @@ def parse_pos(coords_lines, atom_names, celldm, cell):
     return atom_numbs, coords, move, mags, velocity, sc, lambda_
 
 
+def right_hand_rule(
+    cell: np.ndarray, coord: np.ndarray
+) -> tuple[np.ndarray, np.ndarray]:
+    """Rotate the cell and coord to make the cell fit the right-hand rule.
+
+    Args:
+        cell (np.ndarray): the cell vectors.
+        coord (np.ndarray): the atomic coordinates in cartesian.
+
+    Returns
+    -------
+    tuple: the rotated cell and coord.
+    """
+    if np.linalg.det(cell) < 0:
+        cell = -cell
+        coord = -coord
+    return cell, coord
+
+
 def get_frame_from_stru(stru):
     """Read the ABACUS STRU file and return the dpdata frame.
 
@@ -473,6 +492,7 @@ def get_frame_from_stru(stru):
         blocks["ATOMIC_POSITIONS"], atom_names, celldm, cell
     )
 
+    cell, coords = right_hand_rule(cell, coords)
     data = {
         "atom_names": atom_names,
         "atom_numbs": atom_numbs,
@@ -731,66 +751,68 @@ def process_file_input(file_input, atom_names, input_name):
         out += "0.0\n"
         out += str(data["atom_numbs"][iele]) + "\n"
         for iatom in range(data["atom_numbs"][iele]):
-            iatomtype = np.nonzero(data["atom_types"] == iele)[0][iatom]
+            iatomtype = np.nonzero(data["atom_types"] == iele)[0][
+                iatom
+            ]  # it is the atom index
             iout = f"{data['coords'][frame_idx][iatomtype, 0]:.12f} {data['coords'][frame_idx][iatomtype, 1]:.12f} {data['coords'][frame_idx][iatomtype, 2]:.12f}"
             # add flags for move, velocity, mag, angle1, angle2, and sc
             if move is not None:
                 if (
-                    isinstance(ndarray2list(move[natom_tot]), (list, tuple))
-                    and len(move[natom_tot]) == 3
+                    isinstance(ndarray2list(move[iatomtype]), (list, tuple))
+                    and len(move[iatomtype]) == 3
                 ):
                     iout += " " + " ".join(
-                        ["1" if ii else "0" for ii in move[natom_tot]]
+                        ["1" if ii else "0" for ii in move[iatomtype]]
                     )
-                elif isinstance(ndarray2list(move[natom_tot]), (int, float, bool)):
-                    iout += " 1 1 1" if move[natom_tot] else " 0 0 0"
+                elif isinstance(ndarray2list(move[iatomtype]), (int, float, bool)):
+                    iout += " 1 1 1" if move[iatomtype] else " 0 0 0"
             else:
                 iout += " 1 1 1"
 
             if (
                 velocity is not None
-                and isinstance(ndarray2list(velocity[natom_tot]), (list, tuple))
-                and len(velocity[natom_tot]) == 3
+                and isinstance(ndarray2list(velocity[iatomtype]), (list, tuple))
+                and len(velocity[iatomtype]) == 3
             ):
-                iout += " v " + " ".join([f"{ii:.12f}" for ii in velocity[natom_tot]])
+                iout += " v " + " ".join([f"{ii:.12f}" for ii in velocity[iatomtype]])
 
             if mag is not None:
-                if isinstance(ndarray2list(mag[natom_tot]), (list, tuple)) and len(
-                    mag[natom_tot]
+                if isinstance(ndarray2list(mag[iatomtype]), (list, tuple)) and len(
+                    mag[iatomtype]
                 ) in [1, 3]:
-                    iout += " mag " + " ".join([f"{ii:.12f}" for ii in mag[natom_tot]])
-                elif isinstance(ndarray2list(mag[natom_tot]), (int, float)):
-                    iout += " mag " + f"{mag[natom_tot]:.12f}"
+                    iout += " mag " + " ".join([f"{ii:.12f}" for ii in mag[iatomtype]])
+                elif isinstance(ndarray2list(mag[iatomtype]), (int, float)):
+                    iout += " mag " + f"{mag[iatomtype]:.12f}"
 
             if angle1 is not None and isinstance(
-                ndarray2list(angle1[natom_tot]), (int, float)
+                ndarray2list(angle1[iatomtype]), (int, float)
             ):
-                iout += " angle1 " + f"{angle1[natom_tot]:.12f}"
+                iout += " angle1 " + f"{angle1[iatomtype]:.12f}"
 
             if angle2 is not None and isinstance(
-                ndarray2list(angle2[natom_tot]), (int, float)
+                ndarray2list(angle2[iatomtype]), (int, float)
             ):
-                iout += " angle2 " + f"{angle2[natom_tot]:.12f}"
+                iout += " angle2 " + f"{angle2[iatomtype]:.12f}"
 
             if sc is not None:
-                if isinstance(ndarray2list(sc[natom_tot]), (list, tuple)) and len(
-                    sc[natom_tot]
+                if isinstance(ndarray2list(sc[iatomtype]), (list, tuple)) and len(
+                    sc[iatomtype]
                 ) in [1, 3]:
                     iout += " sc " + " ".join(
-                        ["1" if ii else "0" for ii in sc[natom_tot]]
+                        ["1" if ii else "0" for ii in sc[iatomtype]]
                     )
-                elif isinstance(ndarray2list(sc[natom_tot]), (int, float, bool)):
-                    iout += " sc " + "1" if sc[natom_tot] else "0"
+                elif isinstance(ndarray2list(sc[iatomtype]), (int, float, bool)):
+                    iout += " sc " + "1" if sc[iatomtype] else "0"
 
             if lambda_ is not None:
-                if isinstance(ndarray2list(lambda_[natom_tot]), (list, tuple)) and len(
-                    lambda_[natom_tot]
+                if isinstance(ndarray2list(lambda_[iatomtype]), (list, tuple)) and len(
+                    lambda_[iatomtype]
                 ) in [1, 3]:
                     iout += " lambda " + " ".join(
-                        [f"{ii:.12f}" for ii in lambda_[natom_tot]]
+                        [f"{ii:.12f}" for ii in lambda_[iatomtype]]
                     )
-                elif isinstance(ndarray2list(lambda_[natom_tot]), (int, float)):
-                    iout += " lambda " + f"{lambda_[natom_tot]:.12f}"
+                elif isinstance(ndarray2list(lambda_[iatomtype]), (int, float)):
+                    iout += " lambda " + f"{lambda_[iatomtype]:.12f}"
 
             out += iout + "\n"
             natom_tot += 1

dpdata/data_type.py

@@ -64,6 +64,43 @@ def __init__(
         self.required = required
         self.deepmd_name = name if deepmd_name is None else deepmd_name
 
+    def __eq__(self, other) -> bool:
+        """Check if two DataType instances are equal.
+
+        Parameters
+        ----------
+        other : object
+            object to compare with
+
+        Returns
+        -------
+        bool
+            True if equal, False otherwise
+        """
+        if not isinstance(other, DataType):
+            return False
+        return (
+            self.name == other.name
+            and self.dtype == other.dtype
+            and self.shape == other.shape
+            and self.required == other.required
+            and self.deepmd_name == other.deepmd_name
+        )
+
+    def __repr__(self) -> str:
+        """Return string representation of DataType.
+
+        Returns
+        -------
+        str
+            string representation
+        """
+        return (
+            f"DataType(name='{self.name}', dtype={self.dtype.__name__}, "
+            f"shape={self.shape}, required={self.required}, "
+            f"deepmd_name='{self.deepmd_name}')"
+        )
+
     def real_shape(self, system: System) -> tuple[int]:
         """Returns expected real shape of a system."""
         assert self.shape is not None

dpdata/deepmd/mixed.py

@@ -4,6 +4,8 @@
 
 import numpy as np
 
+import dpdata
+
 from .comp import dump as comp_dump
 from .comp import to_system_data as comp_to_system_data
 
@@ -27,10 +29,32 @@ def to_system_data(folder, type_map=None, labels=True):
         all_real_atom_types_concat = index_map[all_real_atom_types_concat]
     all_cells_concat = data["cells"]
     all_coords_concat = data["coords"]
+
+    # handle custom registered data types
     if labels:
-        all_eners_concat = data.get("energies")
-        all_forces_concat = data.get("forces")
-        all_virs_concat = data.get("virials")
+        dtypes = dpdata.system.LabeledSystem.DTYPES
+    else:
+        dtypes = dpdata.system.System.DTYPES
+    reserved = {
+        "atom_numbs",
+        "atom_names",
+        "atom_types",
+        "real_atom_names",
+        "real_atom_types",
+        "cells",
+        "coords",
+        "orig",
+        "nopbc",
+    }
+    extra_data = {}
+    for dtype in dtypes:
+        name = dtype.name
+        if name in reserved:
+            continue
+        if not (len(dtype.shape) and dtype.shape[0] == dpdata.system.Axis.NFRAMES):
+            continue
+        if name in data:
+            extra_data[name] = data.pop(name)
 
     data_list = []
     while True:
@@ -56,16 +80,12 @@ def to_system_data(folder, type_map=None, labels=True):
         all_cells_concat = all_cells_concat[rest_idx]
         temp_data["coords"] = all_coords_concat[temp_idx]
         all_coords_concat = all_coords_concat[rest_idx]
-        if labels:
-            if all_eners_concat is not None and all_eners_concat.size > 0:
-                temp_data["energies"] = all_eners_concat[temp_idx]
-                all_eners_concat = all_eners_concat[rest_idx]
-            if all_forces_concat is not None and all_forces_concat.size > 0:
-                temp_data["forces"] = all_forces_concat[temp_idx]
-                all_forces_concat = all_forces_concat[rest_idx]
-            if all_virs_concat is not None and all_virs_concat.size > 0:
-                temp_data["virials"] = all_virs_concat[temp_idx]
-                all_virs_concat = all_virs_concat[rest_idx]
+
+        for name in extra_data:
+            all_dtype_concat = extra_data[name]
+            temp_data[name] = all_dtype_concat[temp_idx]
+            extra_data[name] = all_dtype_concat[rest_idx]
+
         data_list.append(temp_data)
     return data_list