GraphAtoms 2.3.0__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.3.0
+Version: 2.3.2
 Summary: The Chemical Core Class for Graph Theory Analysis.
 Keywords: chemistry,graph theory,reaction,event,KMC
 Author: LiuGaoyong

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.3.0"
+version = "2.3.2"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -56,7 +56,7 @@ Issues = "https://github.com/LiuGaoyong/GraphAtoms/issues/"
 
 [project.scripts]
 graphatoms-config = "graphatoms.enterpoint.config:print_config"
-graphatoms-network = "graphatoms.enterpoint.view:main"
+graphatoms-network = "graphatoms.enterpoint.network:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 
 [[project.authors]]

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

@@ -8,11 +8,11 @@ Repository = "https://github.com/LiuGaoyong/GraphAtoms"
 Issues = "https://github.com/LiuGaoyong/GraphAtoms/issues/"
 [project.scripts]
 graphatoms-config = "graphatoms.enterpoint.config:print_config"
-graphatoms-network = "graphatoms.enterpoint.view:main"
+graphatoms-network = "graphatoms.enterpoint.network:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 [project]
 name = "graphatoms"
-version = "2.3.0"
+version = "2.3.2"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]

{graphatoms-2.3.0 → graphatoms-2.3.2}/src/graphatoms/dataclasses/_pydanticMixin.py

@@ -229,7 +229,11 @@ class __Json(PydanticConvertFactoryMixin):
                 indent=indent,
             )
         )
-        filename.write_text(self.to_str(**kwargs), "utf-8")
+        bytesutils.atomic_write_text(
+            target=filename,
+            text=self.to_str(**kwargs),
+            encoding="utf-8",
+        )
         return filename
 
     @classmethod
@@ -260,13 +264,15 @@ class __Toml(PydanticConvertFactoryMixin):
                 numpy_ndarray_compatible=True,
             )
         )
-        with filename.open("wb") as f:
-            toml_w.dump(
+        bytesutils.atomic_write_text(
+            target=filename,
+            text=toml_w.dumps(
                 self.to_dict(**kwargs),
-                f,
                 indent=indent,
                 multiline_strings=True,
-            )
+            ),
+            encoding="utf-8",
+        )
         return filename
 
     @classmethod
@@ -301,16 +307,17 @@ class __Yaml(PydanticConvertFactoryMixin):
                 numpy_ndarray_compatible=True,
             )
         )
-        with filename.open("w", encoding="utf-8") as f:
-            f.write(
-                OmegaConf.to_yaml(
-                    self.to_dict(**kwargs),
-                    # f,
-                    # encoding="utf-8",
-                    # # default_flow_style=False,
-                    # indent=4,
-                )
-            )
+        bytesutils.atomic_write_text(
+            target=filename,
+            text=OmegaConf.to_yaml(
+                self.to_dict(**kwargs),
+                # f,
+                # encoding="utf-8",
+                # # default_flow_style=False,
+                # indent=4,
+            ),
+            encoding="utf-8",
+        )
         return filename
 
     @classmethod
@@ -345,10 +352,14 @@ class __Npz(PydanticConvertFactoryMixin):
                 numpy_ndarray_compatible=True,
             )
         )
-        (np.savez_compressed if compress else np.savez)(
-            filename,
-            allow_pickle=False,
-            **self.to_dict(**kwargs),
+        func = np.savez_compressed if compress else np.savez
+        bytesutils.atomic_write(
+            target=filename,
+            writer=lambda p: func(
+                p,
+                allow_pickle=False,
+                **self.to_dict(**kwargs),
+            ),
         )
         return filename
 
@@ -411,7 +422,14 @@ class __Pickle(PydanticConvertFactoryMixin):
                 numpy_ndarray_compatible=True,
             )
         )
-        dump(self.to_dict(**kwargs), filename, compress=compress)
+        bytesutils.atomic_write(
+            target=filename,
+            writer=lambda p: dump(
+                value=self.to_dict(**kwargs),
+                filename=p,
+                compress=compress,  # type: ignore
+            ),
+        )
         return filename
 
     @classmethod

{graphatoms-2.3.0 → graphatoms-2.3.2}/src/graphatoms/enterpoint/network/__init__.py

@@ -1,4 +1,5 @@
 from ._clsnetwork import ReactionNetwork
+from ._commands import main
 from ._metadata import MetaData
 from ._recorder import Recorder
 from ._scheduler import Scheduler
@@ -8,4 +9,5 @@ __all__ = [
     "Recorder",
     "Scheduler",
     "ReactionNetwork",
+    "main",
 ]

{graphatoms-2.3.0 → graphatoms-2.3.2}/src/graphatoms/enterpoint/network/_clsnetwork.py

@@ -1,12 +1,23 @@
 import pickle
 import time
+from collections.abc import Iterator, Mapping
 from pathlib import Path
-from typing import Literal, Self
+from typing import Literal, Self, override
 
 import numpy as np
 from ase import Atoms
 
 from graphatoms.enterpoint.config import Config, EventConfig
+from graphatoms.enterpoint.network._metadata import MetaData
+from graphatoms.enterpoint.network._metadata import (
+    _MetaDataBasic as MetaDataBasic,
+)
+from graphatoms.enterpoint.network._recorder import (
+    OldNewRecorder4Confidence,
+    Recorder,
+    RecorderInfo,
+)
+from graphatoms.enterpoint.network._scheduler import Scheduler
 from graphatoms.reaction import (
     Adsorption,
     Desorption,
@@ -16,11 +27,7 @@ from graphatoms.reaction import (
 )
 from graphatoms.system import Cluster, Gas, SysGraph, System
 from graphatoms.system.database import DatabaseABC, get_db
-
-from ._metadata import MetaData
-from ._metadata import _MetaDataBasic as MetaDataBasic
-from ._recorder import OldNewRecorder4Confidence, Recorder, RecorderInfo
-from ._scheduler import Scheduler
+from graphatoms.utils.bytestool import atomic_write, atomic_write_text
 
 __all__ = [
     "MetaData",
@@ -31,7 +38,7 @@ __all__ = [
 NETWORK_PATH_PREFIX = "event"
 
 
-class ReactionNetwork:
+class ReactionNetwork(Mapping[str, tuple[EventInfo, EventBase]]):
     DB_USE_POSITION_UUID_DICT: dict[str, bool] = {
         "ts": True,
         "minima": True,
@@ -57,8 +64,8 @@ class ReactionNetwork:
             assert format in (
                 "sqlite",
                 "directory",
-                "dir",
                 "folder",
+                "dir",
                 "h5",
                 "hdf5",
             ), f"The format of `{format}` is not supported for restart."
@@ -82,8 +89,9 @@ class ReactionNetwork:
                 + " Please delete it or use `restart=True`."
             )
             self.__path.mkdir(parents=True, exist_ok=True)
-            self.__path_exploration_recorder.write_text(
-                RecorderInfo.get_csv_title() + "\n"
+            atomic_write_text(
+                self.__path_exploration_recorder,
+                RecorderInfo.get_csv_title() + "\n",
             )
             self.__recorder = Recorder()
             self.__scheduler = Scheduler()
@@ -118,6 +126,171 @@ class ReactionNetwork:
         assert isinstance(self.__db_cluster, DatabaseABC)
         assert isinstance(self.__db_system, DatabaseABC)
 
+    @classmethod
+    def from_config(
+        cls,
+        config: Config,
+        *args,
+        restart: bool | None = None,
+        remote_retry_times: float = 2.0,
+        remote_mode: bool = False,
+        **kwargs,
+    ) -> Self:  # type: ignore
+        """Create a network from a config file."""
+        if remote_mode is True:
+            # When remote_mode is True, some files may not exist or in write.
+            # We need to try to create the network again.
+            err = None
+            for _ in range(10):
+                try:
+                    return cls(
+                        path=Path(config.outputs) / NETWORK_PATH_PREFIX,
+                        restart=restart
+                        if restart is not None
+                        else config.restart,
+                        format=config.event.db_format,
+                        remote_mode=remote_mode,
+                        config=config.event,
+                        **kwargs,
+                    )
+                    break
+                except Exception as e:
+                    time.sleep(abs(remote_retry_times))
+                    err = e
+            if err is not None:
+                raise RuntimeError(
+                    f"Failed to create the network in remote mode. {err}"
+                )
+        else:
+            return cls(
+                path=Path(config.outputs) / NETWORK_PATH_PREFIX,
+                restart=restart if restart is not None else config.restart,
+                format=config.event.db_format,
+                remote_mode=remote_mode,
+                config=config.event,
+                **kwargs,
+            )
+
+    @classmethod
+    def merge(
+        cls,
+        *networks: Self,
+        new_path: Path | str,
+        new_format: str | Literal["dir", "h5", "sqlite"] = "dir",
+        **kwargs,
+    ) -> Self:
+        """Merge the networks.
+
+        Note: the recorder will be set empty.
+        """
+        if len(networks) <= 1:
+            raise ValueError("At least two network is required.")
+        result = cls(
+            path=Path(new_path),
+            restart=False,
+            config=networks[0].metadata.basic,
+            format=new_format,
+        )
+        result.metadata.basic.db_format = new_format
+        for network in networks[1:]:
+            try:
+                network.metadata.basic.check_consistency(
+                    result.metadata.basic,
+                    exclude_keys={"db_format", "gas_sticking"},
+                )
+                for k, v in network.metadata.basic.gas_sticking.items():
+                    if k not in result.metadata.basic.gas_sticking:
+                        result.metadata.basic.gas_sticking[k] = v
+                    else:
+                        v0 = result.metadata.basic.gas_sticking[k]
+                        assert v0 == v, (
+                            f"Failed to merge the networks because the "
+                            f"gas sticking of {k} is not the same as "
+                            f"input. self={v0}, input={v}"
+                        )
+                    result.metadata.basic.gas_sticking[k] = v
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to merge the networks because "
+                    f"of check consistency failed: {e}"
+                )
+            for k, use_pos_uuid in cls.DB_USE_POSITION_UUID_DICT.items():
+                db_res: DatabaseABC = getattr(result, f"db_{k}")
+                db: DatabaseABC = getattr(network, f"db_{k}")
+                for _, v in db.items():
+                    graph = SysGraph.from_ase(v)
+                    graph_key = graph.get_key_for_metadata(use_pos_uuid)
+                    if graph_key not in db_res:
+                        db_res._save(graph_key, graph)
+            for i, rxn in enumerate(network.metadata.table.key_rxn):
+                if rxn not in result.metadata.table.key_rxn:
+                    key_r = network.metadata.table.key_r[i]
+                    key_p = network.metadata.table.key_p[i]
+                    key_g = network.metadata.table.key_g[i]
+                    key_ts = network.metadata.table.key_t[i]
+                    if key_r not in result.db_minima:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of reactant: {key_r}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_g is not None and key_g not in result.db_gas:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of gas: {key_g}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_ts is not None and key_ts not in result.db_ts:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of transition state: {key_ts}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_p is not None and key_p not in result.db_minima:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of product: {key_p}\n",
+                            flush=True,
+                        )
+                        continue
+                result.metadata.table.merge(  # Output duplicate info
+                    network.metadata.table, idxs=[i]
+                )
+        n = len(result.metadata.table.key_rxn)
+        print(f"Merge networks({n} events) done.", flush=True)
+        result.scheduler.clear()
+        result.recorder.clear()
+        result.persistence()
+        return result
+
+    @classmethod
+    def reformat_message(cls, msg: str) -> str:
+        return msg
+        __LOGURU_FORMAT_LENGTH: int = 37
+        __LOGURU_TOTAL_LENGTH: int = 120
+        len_msg = __LOGURU_TOTAL_LENGTH - __LOGURU_FORMAT_LENGTH
+        lst = wrap_line(msg, width_min=len_msg, width_max=len_msg + 20)
+        return ("\n" + " " * __LOGURU_FORMAT_LENGTH).join(lst)
+
+    @override
+    def __len__(self) -> int:
+        return len(self.metadata.table.key_rxn)
+
+    @override
+    def __contains__(self, key: str) -> bool:  # type: ignore
+        return key in self.metadata.table.key_rxn
+
+    @override
+    def __getitem__(self, key: str) -> tuple[EventInfo, EventBase]:
+        return self.read_event(key)
+
+    @override
+    def __iter__(self) -> Iterator[str]:
+        yield from self.metadata.table.key_rxn
+
     @property
     def path(self) -> Path:
         return self.__path
@@ -186,76 +359,6 @@ class ReactionNetwork:
             )
         return self.__db_ts
 
-    @classmethod
-    def from_config(
-        cls,
-        config: Config,
-        *args,
-        restart: bool | None = None,
-        remote_mode: bool = False,
-        **kwargs,
-    ) -> Self:  # type: ignore
-        """Create a network from a config file."""
-        if remote_mode is True:
-            # When remote_mode is True, some files may not exist or in write.
-            # We need to try to create the network again.
-            err = None
-            for _ in range(10):
-                try:
-                    return cls(
-                        path=Path(config.outputs) / NETWORK_PATH_PREFIX,
-                        restart=restart
-                        if restart is not None
-                        else config.restart,
-                        format=config.event.db_format,
-                        remote_mode=remote_mode,
-                        config=config.event,
-                        **kwargs,
-                    )
-                    break
-                except Exception as e:
-                    time.sleep(0.5)
-                    err = e
-            if err is not None:
-                raise RuntimeError(
-                    f"Failed to create the network in remote mode. {err}"
-                )
-        else:
-            return cls(
-                path=Path(config.outputs) / NETWORK_PATH_PREFIX,
-                restart=restart if restart is not None else config.restart,
-                format=config.event.db_format,
-                remote_mode=remote_mode,
-                config=config.event,
-                **kwargs,
-            )
-
-    @classmethod
-    def merge(
-        cls,
-        *networks: Self,
-        new_path: Path | str,
-        new_format: str | Literal["dir", "h5", "sqlite"] = "dir",
-        **kwargs,
-    ) -> Self:
-        """Merge the networks."""
-        raise NotImplementedError("Merge the networks.")
-        cls(
-            path=new_path,
-            restart=False,
-            config=networks[0].metadata.basic,
-            format=networks[0].__format,
-        )
-
-    @classmethod
-    def reformat_message(cls, msg: str) -> str:
-        return msg
-        __LOGURU_FORMAT_LENGTH: int = 37
-        __LOGURU_TOTAL_LENGTH: int = 120
-        len_msg = __LOGURU_TOTAL_LENGTH - __LOGURU_FORMAT_LENGTH
-        lst = wrap_line(msg, width_min=len_msg, width_max=len_msg + 20)
-        return ("\n" + " " * __LOGURU_FORMAT_LENGTH).join(lst)
-
     def exploration_can_be_finished(
         self,
         confidence: float,
@@ -311,7 +414,8 @@ class ReactionNetwork:
         msg += f"    #Minima    :{len(self.__db_minima)}\n"
         msg += f"    #Gas       :{len(self.__db_gas)}\n"
         msg += f"    #TS        :{len(self.__db_ts)}\n"
-        msg += f"#Event     :{len(self.__metadata.table)}\n"
+        msg += f"#Event         :{len(self.__metadata.table)}\n"
+        msg += f"Configuration  :{self.__metadata.basic.to_str(indent=4)}\n"
         return msg
 
     def persistence(self) -> None:
@@ -397,6 +501,7 @@ class ReactionNetwork:
         *,
         for_system: str | None = None,
         persist: bool = True,
+        env_hop: int = 1,  # TODO: make this into whole configuration
         **kwargs,
     ) -> Literal["new", "old", "fail"] | str:
         """Record the event as found.
@@ -425,13 +530,25 @@ class ReactionNetwork:
             simplified_threshold = self.__metadata.basic.simplified_threshold
             if simplified_threshold > 0:
                 try:
-                    event = event.simplify(simplified_threshold)
+                    event = event.simplify(
+                        env_radius=simplified_threshold,
+                        env_hop=env_hop,
+                    )
                 except Exception as e:
                     msg = f"Event {event._string()} failed "
                     msg += f"to simplify. because of {e}"
                     fname = self.__path / "event-simplify-fail.pkl"
-                    fname.write_bytes(pickle.dumps(event))
-                    fname.with_suffix(".err").write_text(msg)
+                    atomic_write_text(fname.with_suffix(".err"), msg)
+                    atomic_write(
+                        fname,
+                        writer=lambda p: p.write_bytes(pickle.dumps(event)),
+                    )
+                    event.R.write_npz(fname.with_suffix(".R.npz"))
+                    event.P.write_npz(fname.with_suffix(".P.npz"))
+                    if event.G is not None:
+                        event.G.write_npz(fname.with_suffix(".G.npz"))
+                    if event.T is not None:
+                        event.T.write_npz(fname.with_suffix(".T.npz"))
                     raise ValueError(msg)
             if self.write_event(
                 event,
@@ -659,3 +776,33 @@ def wrap_line(
             lines.pop()
 
     return lines
+
+
+if __name__ == "__main__":
+    import json
+    import shutil
+    from pathlib import Path
+
+    this_dir = Path(__file__).parent
+    root_path = this_dir.parent.parent.parent.parent
+    print(root_path)
+
+    new_path = root_path / "zzzz-merged" / "event"
+    shutil.rmtree(new_path.parent, ignore_errors=True)
+
+    network_lst: list[ReactionNetwork] = []
+    for zzzz_path in root_path.glob("zzzz-*"):
+        if "merge" not in zzzz_path.name:
+            p = zzzz_path / "event"
+            (p / "recorder.json").unlink(missing_ok=True)
+            atomic_write_text(
+                p / "recorder.json",
+                json.dumps({}, indent=4),
+            )
+            network_lst.append(
+                ReactionNetwork(
+                    zzzz_path / "event",
+                    restart=True,
+                )
+            )
+    new_network = ReactionNetwork.merge(*network_lst, new_path=new_path)

graphatoms-2.3.2/src/graphatoms/enterpoint/network/_commands.py

@@ -0,0 +1,139 @@
+import pathlib
+from typing import Annotated
+
+import pandas as pd
+import typer
+from ase import Atoms
+from ase.visualize import view as _ase_view
+
+from graphatoms.enterpoint.network import ReactionNetwork as Net
+from graphatoms.system import SysGraph
+
+__p_help__ = "Path to the network directory."
+Path = Annotated[str, typer.Option("--path", "-p", help=__p_help__)]
+pd.set_option("display.max_colwidth", None)  # don't truncate cell contents
+pd.set_option("display.max_columns", None)  # show all columns
+pd.set_option("display.max_rows", None)  # show all rows
+pd.set_option("display.width", None)  # don't wrap lines
+
+
+# --------------
+# Main command
+# --------------
+main = typer.Typer(no_args_is_help=True)
+
+
+@main.command()
+def summary(path: Path = ".") -> None:
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    print(net.summary())
+
+
+@main.command(no_args_is_help=True)
+def merge(
+    args: Annotated[
+        list[str],
+        typer.Argument(
+            help=f"{Net.__name__} directories to merge (one or more)"
+        ),
+    ],
+    path: Path = "./event",
+    db_format: Annotated[
+        str,
+        typer.Option(
+            "--db-format",
+            "-f",
+            help="Database format in the network.",
+        ),
+    ] = "dir",
+) -> None:
+    assert db_format == "dir", "Only `dir` format is supported now."
+    lst = [Net(p, restart=True, format=db_format) for p in args]
+    Net.merge(*lst, new_path=path)
+
+
+# ----------------
+# Table subcommand
+# ----------------
+show = typer.Typer(no_args_is_help=True)
+main.add_typer(show, name="show")
+
+
+@show.command(name="reaction")
+def show_reaction(arg: str, path: Path = ".") -> tuple[int, Net]:
+    net = Net(path, restart=True, format="dir")
+    df = net.metadata.table.dataframe
+    try:
+        i = int(arg)
+    except ValueError:
+        i = net.metadata.table.key_rxn.index(arg)
+    print(df.iloc[i])
+    return i, net
+
+
+@show.command()
+def table(path: Path = ".") -> None:
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    df = net.metadata.table.dataframe
+    col = [0, 5, 6, 7, 8, 11, 12]
+    print(df[df.columns[col]])
+
+
+# ----------------
+# View subcommand
+# ----------------
+view = typer.Typer(no_args_is_help=True)
+
+main.add_typer(view, name="view")
+
+
+@view.command(name="reaction")
+def view_reaction(
+    name: str,
+    path: Path = ".",
+    forward: bool = True,
+) -> None:
+    idx, net = show_reaction(name, path)
+    key_rxn = net.metadata.table.key_rxn[idx]
+    _, rxn = net.read_event(key_rxn)
+    if not forward:
+        rxn = rxn.reversed
+    return rxn.view()
+
+
+@view.command(name="structure")
+def view_structure(
+    name_or_path: str,
+    path: Path = ".",
+) -> None:
+    try:
+        fname = pathlib.Path(name_or_path)
+        if fname.name.count("*") == 0:
+            assert fname.exists() and fname.is_file()
+            return _ase_view(SysGraph.read_npz(fname).to_ase())
+        else:
+            return _ase_view(
+                [
+                    SysGraph.read_npz(i).to_ase()
+                    for i in fname.parent.glob(fname.name)
+                ]
+            )
+    except ValueError:
+        name = name_or_path
+
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    atoms: Atoms | None = None
+    for type in ("gas", "ts", "minima", "cluster", "system"):
+        if net.contain_sysgraph(name, type=type):
+            atoms = net.read_atoms(name, type=type)
+            break
+    if atoms is None:
+        raise ValueError(f"structure {name} is not in the database.")
+    return _ase_view(atoms)
+
+
+if __name__ == "__main__":
+    main()