GraphAtoms 2.3.2__tar.gz → 2.3.3__tar.gz

{graphatoms-2.3.2 → graphatoms-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.3.2
+Version: 2.3.3
 Summary: The Chemical Core Class for Graph Theory Analysis.
 Keywords: chemistry,graph theory,reaction,event,KMC
 Author: LiuGaoyong
@@ -14,12 +14,12 @@ Requires-Dist: ase
 Requires-Dist: pymatgen>2023.6
 Requires-Dist: rdkit>=2025
 Requires-Dist: numpy>=2,<3
-Requires-Dist: pandas>=2,<4
 Requires-Dist: scipy>=1.10,<2
 Requires-Dist: scikit-learn>=1.5
 Requires-Dist: array-api-compat>=1.10
 Requires-Dist: array-api-extra>=0.10
 Requires-Dist: pyarrow
+Requires-Dist: pandas
 Requires-Dist: igraph>=0.11
 Requires-Dist: h5py>=3.16
 Requires-Dist: numpydantic

{graphatoms-2.3.2 → graphatoms-2.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.3.2"
+version = "2.3.3"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -27,12 +27,12 @@ dependencies = [
     "pymatgen>2023.6",
     "rdkit>=2025",
     "numpy>=2,<3",
-    "pandas>=2,<4",
     "scipy>=1.10,<2",
     "scikit-learn>=1.5",
     "array-api-compat>=1.10",
     "array_api-extra>=0.10",
     "pyarrow",
+    "pandas",
     "igraph>=0.11",
     "h5py>=3.16",
     "numpydantic",
@@ -146,29 +146,29 @@ benchmark = "pytest -s src/tests-benchmark/*.py"
 
 [tool.pixi.dependencies]
 python = ">=3.12"
-pytest = ">=9.0.3,<10"
-array-api-compat = ">=1.15.0,<2"
-array-api-extra = ">=0.11.0,<0.12"
-array-api-strict = ">=2.5,<3"
-ase = ">=3.28.0,<4"
-pymatgen = ">=2026.5.4,<2027"
-rdkit = ">=2025.9.5,<2027"
-openbabel = ">=3.1.1,<4"
-pyarrow = ">=21.0.0,<25"
-scikit-learn = ">=1.8.0,<2"
-python-igraph = ">=0.11.9,<0.12"
-numpy = ">=2.0.0,<3"
-pydantic = ">=2.10.0,<3"
-numpydantic = ">=1.8.1,<2"
-python-snappy = ">=0.7.3,<0.8"
-h5py = ">=3.16.0,<4"
-hydra-core = ">=1.3.2,<2"
-tomli-w = ">=1.2.0,<2"
-loguru = ">=0.7.3,<0.8"
-jupyterlab = ">=4.5.8,<5"
-joblib = ">=1.1.0,<2"
-ovld = ">=0.5.15,<0.6"
-pytest-xdist = ">=3.8.0,<4"
-executorlib = ">=1.8,<2"
-typer = ">=0.20,<1"
-grpcio = ">=1.52.0,<2"
+pytest = ">=8"
+array-api-compat = ">=1.15.0"
+array-api-extra = ">=0.11.0"
+array-api-strict = ">=2.5"
+ase = ">=3.28.0"
+pymatgen = ">=2026.5.4"
+rdkit = ">=2025.9.5"
+openbabel = ">=3.1.1"
+pyarrow = ">=21.0.0"
+scikit-learn = ">=1.8.0"
+python-igraph = ">=0.11.9"
+numpy = ">=2.0.0"
+pydantic = ">=2.10.0"
+numpydantic = ">=1.8.1"
+python-snappy = ">=0.7.3"
+h5py = ">=3.16"
+hydra-core = ">=1.3.0"
+tomli-w = ">=1.2.0"
+loguru = ">=0.7.3"
+jupyterlab = ">=4.5.8"
+joblib = ">=1.1.0"
+ovld = ">=0.5.15"
+pytest-xdist = ">=3.8.0"
+executorlib = ">=1.8"
+typer = ">=0.20"
+grpcio = ">=1.52.0"

{graphatoms-2.3.2 → graphatoms-2.3.3}/pyproject.toml.orig

@@ -12,7 +12,7 @@ graphatoms-network = "graphatoms.enterpoint.network:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 [project]
 name = "graphatoms"
-version = "2.3.2"
+version = "2.3.3"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
@@ -39,12 +39,12 @@ dependencies = [
 
     # Scientific Computing
     "numpy>=2,<3",
-    "pandas>=2,<4",
     "scipy>=1.10,<2",
     "scikit-learn>=1.5",
     "array-api-compat>=1.10",
     "array_api-extra>=0.10",
     "pyarrow",
+    "pandas",
 
     # Graph Theory
     "igraph>=0.11", # high performance graph library based on C
@@ -145,29 +145,29 @@ benchmark = "pytest -s src/tests-benchmark/*.py"
 
 [tool.pixi.dependencies]
 python = ">=3.12"
-pytest = ">=9.0.3,<10"
-array-api-compat = ">=1.15.0,<2"
-array-api-extra = ">=0.11.0,<0.12"
-array-api-strict = ">=2.5,<3"
-ase = ">=3.28.0,<4"
-pymatgen = ">=2026.5.4,<2027"
-rdkit = ">=2025.9.5,<2027"
-openbabel = ">=3.1.1,<4"
-pyarrow = ">=21.0.0,<25"
-scikit-learn = ">=1.8.0,<2"
-python-igraph = ">=0.11.9,<0.12"
-numpy = ">=2.0.0,<3"
-pydantic = ">=2.10.0,<3"
-numpydantic = ">=1.8.1,<2"
-python-snappy = ">=0.7.3,<0.8"
-h5py = ">=3.16.0,<4"
-hydra-core = ">=1.3.2,<2"
-tomli-w = ">=1.2.0,<2"
-loguru = ">=0.7.3,<0.8"
-jupyterlab = ">=4.5.8,<5"
-joblib = ">=1.1.0,<2"
-ovld = ">=0.5.15,<0.6"
-pytest-xdist = ">=3.8.0,<4"
-executorlib = ">=1.8,<2"
-typer = ">=0.20,<1"
-grpcio = ">=1.52.0,<2"
+pytest = ">=8"
+array-api-compat = ">=1.15.0"
+array-api-extra = ">=0.11.0"
+array-api-strict = ">=2.5"
+ase = ">=3.28.0"
+pymatgen = ">=2026.5.4"
+rdkit = ">=2025.9.5"
+openbabel = ">=3.1.1"
+pyarrow = ">=21.0.0"
+scikit-learn = ">=1.8.0"
+python-igraph = ">=0.11.9"
+numpy = ">=2.0.0"
+pydantic = ">=2.10.0"
+numpydantic = ">=1.8.1"
+python-snappy = ">=0.7.3"
+h5py = ">=3.16"
+hydra-core = ">=1.3.0"
+tomli-w = ">=1.2.0"
+loguru = ">=0.7.3"
+jupyterlab = ">=4.5.8"
+joblib = ">=1.1.0"
+ovld = ">=0.5.15"
+pytest-xdist = ">=3.8.0"
+executorlib = ">=1.8"
+typer = ">=0.20"
+grpcio = ">=1.52.0"

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/dataclasses/_pydanticModel.py

@@ -126,7 +126,7 @@ class OurBaseModel(PydanticFactoryMixin, _IndexMaskMixin):
                 if v0.shape != v1.shape:
                     return False
                 if np.all(v0 == v1):
-                    return True
+                    continue
                 elif not np.allclose(v0, v1):
                     return False
             else:

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/network/_metadata.py

@@ -1,6 +1,7 @@
 import dataclasses as dc
+import types
 from pathlib import Path
-from typing import Any, Self, override
+from typing import Any, Self, Union, get_args, get_origin, override
 
 import numpy as np
 import pandas as pd
@@ -15,6 +16,25 @@ from graphatoms.utils.bytestool import atomic_write
 __all__ = ["MetaData"]
 
 
+def _is_list_of_optional_str(annotation: Any) -> bool:
+    """Whether the annotation is ``list[str | None]``."""
+    if get_origin(annotation) is not list:
+        return False
+    element = get_args(annotation)[0]
+    if get_origin(element) not in (Union, types.UnionType):
+        return False
+    return set(get_args(element)) == {str, type(None)}
+
+
+def _missing_to_none(value: Any) -> Any:
+    """Convert a missing value marker of pandas to ``None``."""
+    if value is None or value is pd.NA:
+        return None
+    if isinstance(value, float) and np.isnan(value):
+        return None
+    return value
+
+
 class _MetaDataBasic(OurBaseModel, EventConfig):
     gas_sticking: dict[str, NonNegativeFloat] = {}
 
@@ -109,7 +129,23 @@ class _MetaDataTable(BaseModel):
 
     @classmethod
     def from_dataframe(cls, df: pd.DataFrame) -> Self:
-        return cls(**{k: df[k].to_list() for k in df.columns})
+        """Create the table from a DataFrame.
+
+        Note:
+            Since pandas 3.0, a string column containing missing values is
+            read back as the new default string dtype (``str``), whose
+            missing value marker is ``numpy.nan`` instead of ``None``.
+            Such ``nan`` values are rejected by the ``str | None`` fields,
+            so they are converted back to ``None`` here.
+        """
+        data: dict[str, list[Any]] = {}
+        for k in df.columns:
+            values: list[Any] = df[k].to_list()
+            field = cls.__pydantic_fields__.get(k)
+            if field is not None and _is_list_of_optional_str(field.annotation):
+                values = [_missing_to_none(v) for v in values]
+            data[k] = values
+        return cls(**data)
 
     def merge(self, other: Self, idxs: list[int] | None = None) -> None:
         if idxs is None:

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/network/_scheduler.py

@@ -46,10 +46,11 @@ class Scheduler(BaseModel):
     @validate_call
     def read_npz(cls, filename: FilePath, *args, **kwargs) -> Self:
         data: dict[str, dict[str, NDArray]] = defaultdict(dict)
-        dct: Mapping[str, NDArray] = np.load(filename)
-        for k, v in dct.items():
-            k2, k1 = k.split("_")
-            data[k1][k2] = v
+        with np.load(filename) as npz:
+            dct: Mapping[str, NDArray] = npz
+            for k, v in dct.items():
+                k2, k1 = k.rsplit("_", 1)
+                data[k1][k2] = v
         return cls(**data)
 
     def can_be_skip(
@@ -62,7 +63,6 @@ class Scheduler(BaseModel):
         **kwargs,
     ) -> tuple[bool, float]:
         diffpositions = np.asarray(diffpositions, dtype=float)
-        print(diffpositions)
         assert 0 <= thetacutoff <= 180, "thetacutoff must be in 0-180"
         if isinstance(graph, str):
             if is_fixed is None:
@@ -110,7 +110,6 @@ class Scheduler(BaseModel):
             cos: np.ndarray = cosine_similarity(dR, dR_new)
             if np.max(cos) <= np.cos(np.deg2rad(thetacutoff)):
                 self.dR[key] = np.vstack((dR, dR_new))  # row_stack
-                print(self.dR[key])
                 return False, np.max(cos)
             return True, np.max(cos)
 

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/parallel/__init__.py

@@ -10,7 +10,7 @@ from graphatoms.enterpoint.parallel._base import (
 )
 from graphatoms.enterpoint.parallel._dask import DaskExecutor
 from graphatoms.enterpoint.parallel._executorlib import ExecutorLibExecutor
-from graphatoms.enterpoint.parallel._ray import _RAY_AVAILABLE, RayExecutor, ray
+from graphatoms.enterpoint.parallel._ray import RayExecutor, ray
 
 __all__ = [
     "SerialExecutor",
@@ -18,6 +18,14 @@ __all__ = [
     "ParallelExecutorABC",
     "get_executor",
 ]
+BACKENDS = [
+    "serial",
+    "multiprocessing",
+    "ray",
+    "dask",
+    "executorlib",
+    "joblib",
+]
 
 
 def get_executor(
@@ -40,7 +48,11 @@ def get_executor(
     backend = str(backend).lower()
     if backend in ("ray",):
         return RayExecutor(nworkers=nworkers, **kwargs)  # type: ignore[arg-type]
-    elif backend in ("dask",):
+    # `ncpus_for_tasks` only applies to the ray backend; `RunnerABC` passes
+    # it unconditionally, so drop it for the other backends instead of
+    # forwarding it to `ProcessPoolExecutor`.
+    kwargs.pop("ncpus_for_tasks", None)
+    if backend in ("dask",):
         return DaskExecutor(nworkers=nworkers, **kwargs)  # type: ignore[arg-type]
     elif backend in ("executorlib",):
         return ExecutorLibExecutor(  # type: ignore[arg-type]
@@ -53,10 +65,7 @@ def get_executor(
             nworkers = None
         return MultiprocessingExecutor(nworkers=nworkers, **kwargs)  # type: ignore[call-arg]
     else:
-        raise ValueError(
-            f"Unknown backend: {backend} Available: "
-            f"{['serial', 'multiprocessing', 'ray', 'dask', 'executorlib']}"
-        )
+        raise ValueError(f"Unknown backend: {backend} Available: {BACKENDS}")
 
 
 def executor_map(
@@ -69,12 +78,19 @@ def executor_map(
 ) -> Sequence[Any]:
     if isinstance(executor, RayExecutor):
         dct: dict[int, ray.ObjectRef] = {}
+        # Hold a strong reference to every deduplicated object.  Keying the
+        # cache on `id(v)` alone is only safe while the objects stay alive;
+        # if an intermediate object were collected, CPython could hand its
+        # `id` to a *different* object and the wrong value would be
+        # substituted into a task.
+        keepalive: list[Any] = []
         remote_params: list[dict[str, ray.ObjectRef]] = []
         for params in fn_params:
             item: dict[str, ray.ObjectRef] = {}
             for k, v in params.items():
                 if id(v) not in dct:
                     dct[id(v)] = ray.put(v)
+                    keepalive.append(v)
                 item[k] = dct[id(v)]
             remote_params.append(item)
         fn_params = remote_params

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/parallel/_base.py

@@ -111,12 +111,21 @@ class MultiprocessingExecutor(ParallelExecutorABC):
             return_when=cf.FIRST_COMPLETED,
             timeout=timeout,
         )
-        self.__executor.map
-        return self.get(list(done)[0]), undone  # type: ignore[override]
+        if len(done) == 0:
+            raise TimeoutError(
+                "concurrent.futures.wait() returned no finished task "
+                f"within timeout={timeout!r}."
+            )
+        # `FIRST_COMPLETED` may return *several* futures at once.  Only one
+        # result can be returned by this API, so the other already-finished
+        # futures must be pushed back into the remaining list; otherwise their
+        # results are silently dropped by callers that loop until the list is
+        # empty.
+        done = list(done)
+        return self.get(done[0]), list(undone) + done[1:]  # type: ignore[override]
 
     @override
     def map(self, fn, *iterables, timeout=None, chunksize=1) -> list[Any]:
-        print(iterables)
         return list(
             self.__executor.map(
                 fn,
@@ -128,6 +137,16 @@ class MultiprocessingExecutor(ParallelExecutorABC):
 
 
 class SerialExecutor(MultiprocessingExecutor):
+    """Run tasks one at a time.
+
+    .. warning::
+        This is *not* an in-process executor: it delegates to a
+        single-worker :class:`~concurrent.futures.ProcessPoolExecutor`, so
+        every task and its arguments must be picklable and each call runs in a
+        forked child process.  See the project bug report for the implications
+        under Slurm.
+    """
+
     @override
-    def __init__(self, *, nworkers=None, **kwargs) -> None:
-        super().__init__(nworkers=1, **kwargs)
+    def __init__(self, *a, **kw) -> None:
+        super().__init__(nworkers=1)

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/parallel/_ray.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import weakref
 from collections.abc import Callable
@@ -18,6 +20,17 @@ if TYPE_CHECKING:
     import ray  # type: ignore
 
 
+###############################################################################
+# NOTE: `from __future__ import annotations` above is required, *not* optional.
+# `ray` is an optional dependency (it is only a dev dependency in
+# pyproject.toml), so when it is absent this module sets `ray = None`.  Without
+# postponed evaluation the `-> ray.ObjectRef` annotations below would be
+# evaluated eagerly at class-definition time and raise
+# `AttributeError: 'NoneType' object has no attribute 'ObjectRef'`, which makes
+# `import graphatoms.enterpoint.parallel` (and therefore `graphatoms-run`)
+# fail on any installation that does not happen to have ray installed.
+
+
 class RayExecutor(ParallelExecutorABC):
     """An executor backed by :mod:`ray`."""
 
@@ -35,15 +48,12 @@ class RayExecutor(ParallelExecutorABC):
             raise ImportError(
                 "ray is not installed. Install it with: pip install ray"
             )
-        try:
-            if not ray.is_initialized():  # type: ignore
-                ray.init(  # type: ignore
-                    ignore_reinit_error=True,
-                    num_cpus=nworkers,
-                    **kwargs,
-                )
-        except Exception:
-            pass
+        if not ray.is_initialized():  # type: ignore
+            ray.init(  # type: ignore
+                ignore_reinit_error=True,
+                num_cpus=nworkers,
+                **kwargs,
+            )
 
     @override
     def submit(
@@ -68,7 +78,7 @@ class RayExecutor(ParallelExecutorABC):
             func_ref = weakref.ref(func)  # type: ignore
         except TypeError:
 
-            def func_ref():  # type: ignore
+            def func_ref() -> Callable[..., Any]:  # type: ignore
                 return func
 
         self._remote_fn_cache[key] = (func_ref, remote_fn)  # type: ignore
@@ -90,8 +100,21 @@ class RayExecutor(ParallelExecutorABC):
         timeout: float | None = None,
         **kwargs,
     ) -> tuple[Any, list[ray.ObjectRef]]:  # type: ignore
-        done, unfinished = ray.wait(futures, timeout=timeout)  # type: ignore
-        return ray.get(done)[0], unfinished  # type: ignore
+        done, unfinished = ray.wait(  # type: ignore
+            futures,
+            timeout=timeout,
+            num_returns=1,
+            **kwargs,
+        )
+        if len(done) == 0:
+            raise TimeoutError(
+                "ray.wait() returned no finished task "
+                f"within timeout={timeout!r}."
+            )
+        # `ray.wait` defaults to `num_returns=1`, but a caller may ask for
+        # more.  Keep every finished ref accounted for so that no completed
+        # result is silently dropped from the caller's work queue.
+        return ray.get(done[0]), list(unfinished) + list(done[1:])  # type: ignore
 
     @override
     def map(self, fn, *iterables, timeout=None, chunksize=1) -> list[Any]:

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/runner/__init__.py

@@ -7,12 +7,18 @@ import hydra
 
 from graphatoms.enterpoint.config import CONFIG_DIR, Config
 
-# from .general.otfkmc import OTFKMC as OnTheFlyKMC
-# from .general.rxngen import ReactionNetworkGenerator
 from .v2.general.otfkmc import OTFKMC as OnTheFlyKMC
 from .v2.general.rxngen import ReactionNetworkGenerator
-from .v2.ray.otfkmc import RayOTFKMC as RayOnTheFlyKMC
-from .v2.ray.rxngen import RayReactionNetworkGenerator
+
+# NOTE: the experimental ray actors under `.v2.ray` are intentionally *not*
+# imported here.  They import `ray` unconditionally at module import time,
+# while ray is only a dev dependency, so importing them would make the
+# `graphatoms-run` console script unusable on any installation without ray.
+# The `parallel: ray` backend itself lives in
+# `graphatoms.enterpoint.parallel` and is selected through the config; these
+# actor-based runners are still work in progress.
+# from .v2.ray.otfkmc import RayOTFKMC as RayOnTheFlyKMC
+# from .v2.ray.rxngen import RayReactionNetworkGenerator
 
 
 @hydra.main(
@@ -23,17 +29,7 @@ from .v2.ray.rxngen import RayReactionNetworkGenerator
 def run(cfg: Config) -> None:
     if str(cfg.run_type).lower() == "otfkmc":
         OnTheFlyKMC(config=cfg).run()
-        return
-        if str(cfg.parallel).lower() == "ray":
-            RayOnTheFlyKMC(config=cfg).run()
-        else:
-            OnTheFlyKMC(config=cfg).run()
     elif str(cfg.run_type).lower() == "rxngen":
         ReactionNetworkGenerator(config=cfg).run()
-        return
-        if str(cfg.parallel).lower() == "ray":
-            RayReactionNetworkGenerator(config=cfg).run()
-        else:
-            ReactionNetworkGenerator(config=cfg).run()
     else:
         raise ValueError(f" run_type `{cfg.run_type}` is not supported.")

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/enterpoint/runner/general/rxngen.py

@@ -40,34 +40,44 @@ class ReactionNetworkGenerator(ExplorationBase):
         if not self.config.restart:
             self.__match_apply_recorder = MatchApplyRecorder()
             self.__match_apply_recorder.persist(self.__path)
-            self.__system_dct: dict[str, System] = {
+            self.__initial_system_dct: dict[str, System] = {
                 sys.get_key_for_metadata(use_positions_uuid=False): sys
                 for sys in self.get_batch_system_for()
             }
         else:
-            data = self.__path.read_text()
-            obj = MatchApplyRecorder.model_validate_json(data)
-            self.__match_apply_recorder: MatchApplyRecorder = obj
-            self.__system_dct: dict[str, System] = {
-                k: System.from_ase(
-                    v,
-                    parse_bonds=self.config.bonds,  # type: ignore
-                    parse_atoms_is_outer_or_not=True,
+            self.__match_apply_recorder = (
+                MatchApplyRecorder.model_validate_json(
+                    json_data=self.__path.read_text(),
                 )
-                for k, v in self.network.db_system.items()
-            }
+            )
+            self.__initial_system_dct = self.__system_dct_from_db
+
+    @property
+    def __explred_systems(self) -> set[str]:
+        return set(self.__match_apply_recorder.record.keys())
+
+    @property
+    def __system_dct_from_db(self) -> dict[str, System]:
+        return {
+            k: System.from_ase(
+                v,
+                parse_bonds=self.config.bonds,  # type: ignore
+                parse_atoms_is_outer_or_not=True,
+            )
+            for k, v in self.network.db_system.items()
+        }
 
     @override
     def run(self) -> None:
         """Run the simulation for the given number of steps."""
-        system_dct: dict[str, System] = self.__system_dct
+        system_dct: dict[str, System] = self.__initial_system_dct
         for self.__istep in range(self.config.max_steps):
             un_explred_systems: dict[str, System] = {
                 k: v
                 for k, v in system_dct.items()
-                if k not in self.network.db_system
+                if k not in self.__explred_systems
             }
-            if len(system_dct) == 0:
+            if len(un_explred_systems) == 0:
                 msg = f"Istep={self.__istep}: No system left to explore."
                 self.logger.info(self._reformat_message(msg))
                 break

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/geometry/_bond_list.py

@@ -117,7 +117,7 @@ def bond_list(
     )
     matrix = sp.csr_matrix(matrix, dtype=int)
     if infer_order:
-        raise NotImplementedError("infer_order is not implemented.")
+        raise NotImplementedError("infer_order is not implemented now.")
         edges = sp.coo_array(matrix).coords
         get_adjacency_by_rdkit(
             numbers=np.array(
@@ -133,7 +133,6 @@ def bond_list(
             target=edges[1],
             infer_order=False,
         )
-
     return matrix
 
 

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/geometry/_neighbor_list.py

@@ -64,13 +64,17 @@ def _matscipy_neighbor_list(
     sorted: bool = True,
 ) -> tuple[np.ndarray, ...]:
     try:
-        pass  # type: ignore
+        from matscipy.neighbours import (  # type: ignore  # noqa: F401
+            neighbour_list as _matscipy_neighbour_list,
+        )
     except Exception:
         raise Exception(
             "Please install `matscipy` to speed up "  #
             "the calculation of neighbor list.",
         )
-    raise NotImplementedError
+    raise NotImplementedError(
+        "The `matscipy` neighbor-list backend is not implemented yet."
+    )
 
 
 #############################################################
@@ -213,7 +217,6 @@ def neighbor_list(
             max_nbins=int(max_nbins),
         )  # type: ignore
     elif backend == "matscipy":
-        raise NotImplementedError
         return _matscipy_neighbor_list(
             quantities=quantities,
             a=a,

{graphatoms-2.3.2 → graphatoms-2.3.3}/src/graphatoms/system/graph.py

@@ -463,10 +463,24 @@ class SysGraph(BondGraph, Structure, AtomTag, GasMixin):
         # for bond attribute
         df = graph.get_edge_dataframe()
         assert len(df.columns) >= 2, df.columns
-        dct["pair"] = df[df.columns[:2]].to_numpy()
-        for k in set(df.columns[2:]) & {"order", "distance"}:
-            if not df[k].isnull().all():
-                dct[k] = df[k].to_numpy()
+        pair = df[df.columns[:2]].to_numpy()
+        attrs = {
+            k: df[k].to_numpy()
+            for k in set(df.columns[2:]) & {"order", "distance"}
+            if not df[k].isnull().all()
+        }
+        if not graph.is_directed():
+            # An undirected igraph keeps one edge per bond, while
+            # `BondGraph.pair` uses the symmetric (i, j) / (j, i) form.
+            # Rebuild it from the edge list here so the round-trip is
+            # lossless without storing a second copy of the bond list on
+            # the graph object.
+            pair = np.vstack([pair, pair[:, ::-1]])
+            perm = np.lexsort((pair[:, 1], pair[:, 0]))
+            pair = pair[perm]
+            attrs = {k: np.concatenate([v, v])[perm] for k, v in attrs.items()}
+        dct["pair"] = pair
+        dct.update(attrs)
         return cls.from_dict(dct, **kwargs)
 
     def to_igraph(self, *args, **kwargs) -> IGraph: