GraphAtoms 0.0.2__tar.gz → 0.0.3__tar.gz

{graphatoms-0.0.2 → graphatoms-0.0.3}/GraphAtoms/common/abc.py

@@ -1,13 +1,27 @@
 # ruff: noqa: D100 D102
+import sys
 from collections.abc import Sequence
-from typing import override
+from pickle import dumps, loads
+from typing import Annotated, override
 
 import numpy as np
 import pydantic
+import tomli_w as toml_w
+import yaml
 from joblib import dump, load
 from numpy.typing import ArrayLike
 from typing_extensions import Self
 
+from GraphAtoms.common.string import (
+    SUPPORTED_COMPRESS_FORMATS,
+    compress,
+    decompress,
+)
+
+if sys.version_info < (3, 11):
+    import tomli as tomllib
+else:
+    import tomllib
 __all__ = [
     "BaseModel",
     "NpzPklBaseModel",
@@ -15,6 +29,8 @@ __all__ = [
 
 
 class BaseMixin:
+    """The base mixin class which provides some useful classmethods."""
+
     @staticmethod
     def get_mask_or_index(k: ArrayLike, n: int) -> np.ndarray:
         if np.isscalar(k):
@@ -89,6 +105,35 @@ class BaseModel(pydantic.BaseModel):
         f = getattr(self, f"write_{self.__get_format(fname)}")
         return f(fname, **kwargs)
 
+    @pydantic.validate_call
+    def as_bytes(
+        self,
+        compressformat: SUPPORTED_COMPRESS_FORMATS = "snappy",
+        compresslevel: Annotated[int, pydantic.Field(ge=0, le=9)] = 0,
+    ) -> bytes:
+        """Return the json bytes of this object."""
+        return compress(
+            dumps(self.model_dump(exclude_none=True)),
+            format=compressformat,  # type: ignore
+            compresslevel=compresslevel,
+        )
+
+    @classmethod
+    @pydantic.validate_call
+    def from_bytes(
+        cls,
+        data: bytes,
+        compressformat: SUPPORTED_COMPRESS_FORMATS = "snappy",
+    ) -> Self:
+        return cls.model_validate(
+            loads(
+                decompress(
+                    data,
+                    format=compressformat,  # type: ignore
+                )
+            )
+        )
+
     @pydantic.validate_call
     def write_json(
         self,
@@ -97,7 +142,11 @@ class BaseModel(pydantic.BaseModel):
         **kwargs,
     ) -> pydantic.FilePath:
         filename.write_text(
-            self.model_dump_json(indent=indent, **kwargs),
+            self.model_dump_json(
+                indent=indent,
+                exclude_none=True,
+                **kwargs,
+            ),
             encoding="utf-8",
         )
         return filename
@@ -113,6 +162,64 @@ class BaseModel(pydantic.BaseModel):
         return f(fname, **kwargs)
 
 
+class ExtendedBaseModel(BaseModel):
+    """A extended base class for creating Pydantic models.
+
+    This class support many file formats:
+        json        by `pydantic`
+        yaml/yml    by `pyyaml`
+        toml        by `tomli_w`, `tomli`, & `toml`
+    """
+
+    @pydantic.validate_call
+    def write_toml(
+        self,
+        filename: pydantic.FilePath | pydantic.NewPath,
+        indent: int = 4,
+        **kwargs,
+    ) -> pydantic.FilePath:
+        kwargs["exclude_none"] = True
+        with filename.open("wb") as f:
+            toml_w.dump(
+                self.model_dump(mode="python", **kwargs),
+                f,
+                indent=indent,
+                multiline_strings=True,
+            )
+        return filename
+
+    @pydantic.validate_call
+    def write_yaml(
+        self,
+        filename: pydantic.FilePath | pydantic.NewPath,
+        indent: int | None = 2,
+        **kwargs,
+    ) -> pydantic.FilePath:
+        with filename.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(
+                self.model_dump(mode="python", **kwargs),
+                f,
+                encoding="utf-8",
+                default_flow_style=False,
+                indent=indent,
+            )
+        return filename
+
+    @classmethod
+    @pydantic.validate_call
+    def read_yaml(cls, filename: pydantic.FilePath, **kwargs) -> Self:
+        with filename.open(encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        return cls.model_validate(data, **kwargs)
+
+    @classmethod
+    @pydantic.validate_call
+    def read_toml(cls, filename: pydantic.FilePath, **kwargs) -> Self:
+        with filename.open("rb") as f:
+            data = tomllib.load(f)
+        return cls.model_validate(data, **kwargs)
+
+
 class NpzPklBaseModel(BaseModel):
     """A extended base class for creating Pydantic models.
 

graphatoms-0.0.3/GraphAtoms/common/string.py

@@ -0,0 +1,138 @@
+"""The utils for strings."""
+
+import bz2  # Added in Python 3.3
+import gzip  # Added in Python 3.2
+import zlib  # Added in Python 3.0
+from collections.abc import Callable
+from functools import partial
+from hashlib import blake2b
+from random import sample
+from string import ascii_lowercase
+from typing import Annotated, Literal
+
+import pydantic
+import snappy
+from ase.db.core import convert_str_to_int_float_bool_or_str
+
+SUPPORTED_COMPRESS_FORMATS = Literal["z", "gz", "bz2", "snappy"]
+
+
+class CompressorAndDecompressor:
+    """The Compressor and Decompressor."""
+
+    @pydantic.validate_call
+    def __init__(  # noqa: D107
+        self,
+        format: SUPPORTED_COMPRESS_FORMATS = "snappy",
+        compresslevel: Annotated[int, pydantic.Field(ge=0, le=9)] = 0,
+    ) -> None:
+        if format == "z":
+            self.__func_compress: Callable[..., bytes] = partial(
+                zlib.compress,
+                level=compresslevel if compresslevel != 0 else -1,
+            )
+            self.__func_decompress: Callable[..., bytes] = zlib.decompress
+        elif format == "gz":
+            self.__func_compress: Callable[..., bytes] = partial(
+                gzip.compress,
+                compresslevel=compresslevel if compresslevel != 0 else 9,
+            )
+            self.__func_decompress: Callable[..., bytes] = gzip.decompress
+        elif format == "bz2":
+            self.__func_compress: Callable[..., bytes] = partial(
+                bz2.compress,
+                compresslevel=compresslevel if compresslevel != 0 else 9,
+            )
+            self.__func_decompress: Callable[..., bytes] = bz2.decompress
+        elif format == "snappy":
+            self.__func_compress: Callable[..., bytes] = snappy.compress
+            self.__func_decompress: Callable[..., bytes] = partial(
+                snappy.uncompress, decoding=None
+            )  # type: ignore
+        else:
+            import lzma
+
+            self.__func_compress: Callable[..., bytes] = partial(
+                lzma.compress,
+                format=lzma.FORMAT_XZ if format == "xz" else lzma.FORMAT_ALONE,
+            )
+            self.__func_decompress: Callable[..., bytes] = lzma.decompress
+
+    @pydantic.validate_call
+    def compress(self, value: bytes) -> bytes:
+        """Return the compressed bytes of the given bytes."""
+        return self.__func_compress(value)
+
+    @pydantic.validate_call
+    def decompress(self, value: bytes) -> bytes:
+        """Return the decompressed bytes of the given bytes."""
+        return self.__func_decompress(value)
+
+
+def compress(
+    value: bytes,
+    format: SUPPORTED_COMPRESS_FORMATS = "snappy",
+    compresslevel: int = 0,
+) -> bytes:
+    """Return the compressed bytes of the given bytes."""
+    return CompressorAndDecompressor(
+        format=format,
+        compresslevel=compresslevel,
+    ).compress(value)
+
+
+def compress_string(
+    str_value: str,
+    format: SUPPORTED_COMPRESS_FORMATS = "snappy",
+    encoding: str = "utf-8",
+    compresslevel: int = 0,
+) -> bytes:
+    """Return the compressed bytes of the given string."""
+    return compress(
+        str_value.encode(encoding),
+        format=format,
+        compresslevel=compresslevel,
+    )
+
+
+def decompress(
+    value: bytes,
+    format: SUPPORTED_COMPRESS_FORMATS = "snappy",
+) -> bytes:
+    """Return the decompressed bytes of the given bytes."""
+    return CompressorAndDecompressor(format=format).decompress(value)
+
+
+def decompress_string(
+    value: bytes,
+    format: SUPPORTED_COMPRESS_FORMATS = "snappy",
+    encoding: str = "utf-8",
+) -> str:
+    """Return the decompressed string of the given bytes."""
+    return decompress(value, format=format).decode(encoding)
+
+
+def random_string(length: int = 6) -> str:
+    """Return the random string that has the given length."""
+    return "".join(sample(ascii_lowercase, int(length)))
+
+
+def _hash(str_value: str, digest_size: int = 6) -> str:
+    obj = blake2b(
+        str_value.encode("ascii"),
+        digest_size=int(digest_size / 2),
+    )
+    return obj.hexdigest()
+
+
+def hash_string(str_value: str, digest_size: int = 6) -> str:
+    """Return the hashing string of the given string.
+
+    Note: ensure the result cannot be convert to bool, int and float.
+    """
+    result: str = _hash(str_value, digest_size=digest_size)
+    value = convert_str_to_int_float_bool_or_str(result)
+    while not isinstance(value, str):
+        result = _hash(f"{value}_{result}", digest_size)
+        value = convert_str_to_int_float_bool_or_str(result)
+    return result

{graphatoms-0.0.2 → graphatoms-0.0.3}/GraphAtoms.egg-info/PKG-INFO

@@ -1,28 +1,37 @@
 Metadata-Version: 2.4
 Name: GraphAtoms
-Version: 0.0.2
+Version: 0.0.3
 Summary: The Chemical Core Class for Graph Theory Analysis & Graph Neural Network.
 Author-email: LiuGaoyong <liugaoyong_88@163.com>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ase
+Requires-Dist: pymatgen>=2025
+Requires-Dist: rdkit>=2025
+Requires-Dist: dscribe>=2.1
+Requires-Dist: vesin
+Requires-Dist: ase-extension>=0.5; sys_platform != "win32"
+Requires-Dist: numba>=0.61
+Requires-Dist: numpy>=2.0
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: torch
+Requires-Dist: scikit-learn>=1.5
+Requires-Dist: sparse
+Requires-Dist: torch_geometric
 Requires-Dist: igraph>=0.11
 Requires-Dist: networkit==11.1; sys_platform != "linux"
 Requires-Dist: networkit==11.1.post1; sys_platform == "linux"
 Requires-Dist: networkx>=3.3
-Requires-Dist: numpy
-Requires-Dist: numba>=0.61
+Requires-Dist: rustworkx>=0.16
 Requires-Dist: numpydantic
-Requires-Dist: pandas
 Requires-Dist: pydantic>=2.11
-Requires-Dist: rdkit>=2024.9
-Requires-Dist: rustworkx>=0.16
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: sparse
-Requires-Dist: torch_geometric
-Requires-Dist: torch
+Requires-Dist: python-snappy>=0.7.3
+Requires-Dist: pyyaml
+Requires-Dist: sqlmodel
+Requires-Dist: tomli-w
+Requires-Dist: tomli; python_version < "3.11"
 Requires-Dist: typing-extensions
 Dynamic: license-file
 

{graphatoms-0.0.2 → graphatoms-0.0.3}/GraphAtoms.egg-info/SOURCES.txt

@@ -33,4 +33,5 @@ GraphAtoms/containner/_system.py
 tests/test_abc.py
 tests/test_container.py
 tests/test_mRDKit.py
+tests/test_rotation.py
 tests/test_utils.py

{graphatoms-0.0.2 → graphatoms-0.0.3}/GraphAtoms.egg-info/requires.txt

@@ -1,22 +1,35 @@
 ase
-igraph>=0.11
-networkx>=3.3
-numpy
+pymatgen>=2025
+rdkit>=2025
+dscribe>=2.1
+vesin
 numba>=0.61
-numpydantic
+numpy>=2.0
 pandas
-pydantic>=2.11
-rdkit>=2024.9
-rustworkx>=0.16
-scikit-learn
 scipy
+torch
+scikit-learn>=1.5
 sparse
 torch_geometric
-torch
+igraph>=0.11
+networkx>=3.3
+rustworkx>=0.16
+numpydantic
+pydantic>=2.11
+python-snappy>=0.7.3
+pyyaml
+sqlmodel
+tomli-w
 typing-extensions
 
+[:python_version < "3.11"]
+tomli
+
 [:sys_platform != "linux"]
 networkit==11.1
 
+[:sys_platform != "win32"]
+ase-extension>=0.5
+
 [:sys_platform == "linux"]
 networkit==11.1.post1

{graphatoms-0.0.2 → graphatoms-0.0.3}/PKG-INFO

@@ -1,28 +1,37 @@
 Metadata-Version: 2.4
 Name: GraphAtoms
-Version: 0.0.2
+Version: 0.0.3
 Summary: The Chemical Core Class for Graph Theory Analysis & Graph Neural Network.
 Author-email: LiuGaoyong <liugaoyong_88@163.com>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ase
+Requires-Dist: pymatgen>=2025
+Requires-Dist: rdkit>=2025
+Requires-Dist: dscribe>=2.1
+Requires-Dist: vesin
+Requires-Dist: ase-extension>=0.5; sys_platform != "win32"
+Requires-Dist: numba>=0.61
+Requires-Dist: numpy>=2.0
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: torch
+Requires-Dist: scikit-learn>=1.5
+Requires-Dist: sparse
+Requires-Dist: torch_geometric
 Requires-Dist: igraph>=0.11
 Requires-Dist: networkit==11.1; sys_platform != "linux"
 Requires-Dist: networkit==11.1.post1; sys_platform == "linux"
 Requires-Dist: networkx>=3.3
-Requires-Dist: numpy
-Requires-Dist: numba>=0.61
+Requires-Dist: rustworkx>=0.16
 Requires-Dist: numpydantic
-Requires-Dist: pandas
 Requires-Dist: pydantic>=2.11
-Requires-Dist: rdkit>=2024.9
-Requires-Dist: rustworkx>=0.16
-Requires-Dist: scikit-learn
-Requires-Dist: scipy
-Requires-Dist: sparse
-Requires-Dist: torch_geometric
-Requires-Dist: torch
+Requires-Dist: python-snappy>=0.7.3
+Requires-Dist: pyyaml
+Requires-Dist: sqlmodel
+Requires-Dist: tomli-w
+Requires-Dist: tomli; python_version < "3.11"
 Requires-Dist: typing-extensions
 Dynamic: license-file
 

{graphatoms-0.0.2 → graphatoms-0.0.3}/pyproject.toml

@@ -4,29 +4,46 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GraphAtoms"
-version = "0.0.2"
+version = "0.0.3"
 description = "The Chemical Core Class for Graph Theory Analysis & Graph Neural Network."
 readme = "README.md"
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
 requires-python = ">=3.10"
 dependencies = [
+
+    # Chemoinformatics
     "ase",
+    "pymatgen>=2025",
+    "rdkit>=2025",
+    "dscribe>=2.1",                                # transforming atomic structures into fixed-size numerical fingerprints
+    "vesin",                                       # fast neighbor lists for atomistic systems (C++ & TorchScript)
+    "ase-extension>=0.5; sys_platform != 'win32'", # fast neighborlist(Rust)
+
+    # Scientific Computing
+    "numba>=0.61",
+    "numpy>=2.0",
+    "pandas",
+    "scipy",
+    "torch",
+    "scikit-learn>=1.5",
+    "sparse",
+
+    # Graph Theory
+    "torch_geometric",                                # PyTorch Based Graph Neural Network Library
     "igraph>=0.11",                                   # high performance graph library based on C
     "networkit==11.1; sys_platform != 'linux'",       # high performance graph library based on C++
     "networkit==11.1.post1; sys_platform == 'linux'", # high performance graph library based on C++
     "networkx>=3.3",                                  # General-purpose graph library by pure Python
-    "numpy",
-    "numba>=0.61",
+    "rustworkx>=0.16",                                # NetworkX-like graph library based on Rust
+
+    # Data Model
     "numpydantic",
-    "pandas",
     "pydantic>=2.11",
-    "rdkit>=2024.9",
-    "rustworkx>=0.16",                                # NetworkX-like graph library based on Rust
-    "scikit-learn",
-    "scipy",
-    "sparse",
-    "torch_geometric",
-    "torch",
+    "python-snappy>=0.7.3",
+    "pyyaml",                         # YAML parser & writer
+    "sqlmodel",                       # SQL + pydantic
+    "tomli-w",                        # TOML writer
+    "tomli; python_version < '3.11'", # use tomllib in python>=3.11
     "typing-extensions",
 ]
 [dependency-groups]
@@ -36,6 +53,7 @@ dev = ["ruff>=0.11", "pytest>=8.3", "pytest-xdist", "ipython"]
 [tool.uv]
 package = true
 [[tool.uv.index]]
+name = 'tuna'
 url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple" # TUNA
 default = true
 

{graphatoms-0.0.2 → graphatoms-0.0.3}/tests/test_abc.py

@@ -1,4 +1,5 @@
 # ruff: noqa: D100, D101, D102, D103
+import itertools
 import warnings
 from pathlib import Path
 from pprint import pprint
@@ -7,7 +8,7 @@ from tempfile import TemporaryDirectory
 import numpy as np
 import pytest
 
-from GraphAtoms.common.abc import BaseModel, NpzPklBaseModel
+from GraphAtoms.common.abc import BaseModel, ExtendedBaseModel, NpzPklBaseModel
 from GraphAtoms.common.ndarray import NDArray
 
 
@@ -16,6 +17,11 @@ class MockNpzBaseModel(NpzPklBaseModel):
     v: float = 5
 
 
+class MockExtendedBaseModel(ExtendedBaseModel):
+    arr: list[str] = ["1", "sd"]
+    v: float = 5
+
+
 class Test_ABC_Pydantic_Model:
     def test_json_schema(self):
         print()
@@ -38,10 +44,37 @@ class Test_ABC_Pydantic_Model:
             np.testing.assert_array_equal(obj.arr, new_obj.arr)  # type: ignore
             assert new_obj == obj
 
+    @pytest.mark.parametrize("format", ["yaml", "toml", "json"])
+    def test_convert(self, format: str) -> None:
+        self.__run(MockExtendedBaseModel(), MockExtendedBaseModel, format)
+
     @pytest.mark.parametrize("format", ["pkl", "npz", "json"])
     def test_convert_numpy(self, format: str) -> None:
         self.__run(MockNpzBaseModel(), MockNpzBaseModel, format)
 
 
+@pytest.mark.parametrize("cls", [MockExtendedBaseModel, MockNpzBaseModel])
+@pytest.mark.parametrize(
+    "fmt,level",
+    [
+        # ("xz", 0),
+        # ("lzma", 0),
+        ("snappy", 0),
+    ]
+    + sorted(
+        itertools.product(
+            ["z", "gz", "bz2"],
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+        )
+    ),
+)
+def test_compress(fmt, level: int, cls: type[BaseModel]) -> None:
+    obj = cls()
+    b = obj.as_bytes(compressformat=fmt, compresslevel=level)
+    obj2 = cls.from_bytes(b, compressformat=fmt)
+    print(fmt, level, len(b), sep="\t")
+    assert obj == obj2
+
+
 if __name__ == "__main__":
-    pytest.main([__file__, "-vv", "-s", "--maxfail=1"])
+    pytest.main([__file__, "-s", "--maxfail=1"])

graphatoms-0.0.3/tests/test_rotation.py

@@ -0,0 +1,44 @@
+import numpy as np
+import pytest
+from ase.build import molecule
+
+from GraphAtoms.common.rotation import Rot, kabsch, rotate
+
+
+def test_rotation() -> None:  # noqa: D103
+    ben = molecule("C6H6")
+    points = ben.positions + np.random.random(3)
+    center = points.mean(axis=0)
+    print(f"Points center: {center}")
+
+    rotation = Rot.random()
+    print(f"Random rotation:\n{rotation.as_quat()}")
+
+    rotated = rotate(points, rotation, center=[0, 0, 0])
+    print(f"Rotated points around zero point:\n{rotated}")
+    assert pytest.approx(rotated.mean(axis=0)) != center
+
+    rotated = rotate(points, rotation, center)
+    print(f"Rotated points around center point:\n{rotated}")
+    assert pytest.approx(rotated.mean(axis=0)) == center
+
+    # Default center point as the geometry center:
+    rotated = rotate(points, rotation)
+    print(f"Rotated points around center point:\n{rotated}")
+    assert pytest.approx(rotated.mean(axis=0)) == center
+
+
+def test_kabsch() -> None:  # noqa: D103
+    B = molecule("C6H6").positions + np.random.random(3)
+    R, T = Rot.random(), np.random.random(3)
+
+    A = rotate(B, R) + T
+    assert pytest.approx((A - T).mean(axis=0)) == B.mean(axis=0)
+
+    R0, T0, rmsd = kabsch(A, B)
+    assert isinstance(T0, np.ndarray)
+    assert pytest.approx(T0) == T
+    assert isinstance(R0, Rot)
+    assert pytest.approx(R0.as_matrix()) == R.as_matrix()
+    assert rmsd <= 1e-5
+    assert pytest.approx(rotate(B, R0) + T0) == A

graphatoms-0.0.2/GraphAtoms/common/string.py

@@ -1,33 +0,0 @@
-"""The utils for strings."""
-
-from hashlib import blake2b
-from random import sample
-from string import ascii_lowercase
-
-from ase.db.core import convert_str_to_int_float_bool_or_str
-
-
-def random_string(length: int = 6) -> str:
-    """Return the random string that has the given length."""
-    return "".join(sample(ascii_lowercase, int(length)))
-
-
-def _hash(str_value: str, digest_size: int = 6) -> str:
-    obj = blake2b(
-        str_value.encode("ascii"),
-        digest_size=int(digest_size / 2),
-    )
-    return obj.hexdigest()
-
-
-def hash_string(str_value: str, digest_size: int = 6) -> str:
-    """Return the hashing string of the given string.
-
-    Note: ensure the result cannot be convert to bool, int and float.
-    """
-    result: str = _hash(str_value, digest_size=digest_size)
-    value = convert_str_to_int_float_bool_or_str(result)
-    while not isinstance(value, str):
-        result = _hash(f"{value}_{result}", digest_size)
-        value = convert_str_to_int_float_bool_or_str(result)
-    return result