graphatoms 1.1.0__tar.gz

graphatoms-1.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.3
+Name: graphatoms
+Version: 1.1.0
+Summary: The Chemical Core Class for Graph Theory Analysis.
+Author: LiuGaoyong
+Author-email: LiuGaoyong <liugaoyong_88@163.com>
+Requires-Dist: ase
+Requires-Dist: pymatgen>2023.6
+Requires-Dist: rdkit>=2025
+Requires-Dist: scikit-learn>=1.5
+Requires-Dist: pyarrow
+Requires-Dist: igraph>=0.11
+Requires-Dist: hydra-core
+Requires-Dist: numpydantic
+Requires-Dist: pydantic>=2.11
+Requires-Dist: python-snappy>=0.7.3
+Requires-Dist: tomli ; python_full_version < '3.11'
+Requires-Dist: tomli-w
+Requires-Dist: typing-extensions
+Requires-Dist: loguru
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# graphatoms
+
+The Chemical Core Class for Graph Theory Analysis & Graph Neural Network.

graphatoms-1.1.0/README.md

@@ -0,0 +1,3 @@
+# graphatoms
+
+The Chemical Core Class for Graph Theory Analysis & Graph Neural Network.

graphatoms-1.1.0/pyproject.toml

@@ -0,0 +1,125 @@
+[build-system]
+requires = ["uv_build>=0.11.15,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "graphatoms"
+version = "1.1.0"
+readme = "README.md"
+description = "The Chemical Core Class for Graph Theory Analysis."
+authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    # Chemoinformatics
+    "ase",
+    "pymatgen>2023.6",
+    "rdkit>=2025",
+
+    # Scientific Computing
+    # numpy pandas, scipy
+    "scikit-learn>=1.5",
+    "pyarrow",
+
+    # Graph Theory
+    "igraph>=0.11", # high performance graph library based on C
+
+    # Data Model
+    'hydra-core',
+    "numpydantic",
+    "pydantic>=2.11",
+    "python-snappy>=0.7.3",           # More Fase Data Compression
+    "tomli; python_version < '3.11'", # use tomllib in python>=3.11
+    "tomli-w",                        # TOML writer
+    "typing-extensions",
+    'loguru',
+]
+[dependency-groups]
+dev = [
+    "ruff>=0.11",
+    "pytest>=8.3",
+    "pytest-xdist",
+    "jupyter",
+    "sqlmodel",        # SQL + pydantic
+    'openbabel-wheel',
+]
+
+# uv config
+[tool.uv]
+package = true
+[[tool.uv.index]]
+url = "https://mirrors.cernet.edu.cn/pypi/web/simple" # CERNET
+default = true
+# [[tool.uv.index]]
+# name = "pytorch-cpu"
+# url = "https://mirrors.nju.edu.cn/pytorch/whl/cpu/"
+# explicit = true
+# format = "flat"
+# [tool.uv.sources]
+# torch = [{ index = "pytorch-cpu" }]
+
+# pytest config
+[tool.pytest.ini_options]
+filterwarnings = [
+    "error", # All other warnings are transformed into errors.
+    # ignore the following warnings that matching a regex
+    # example: 'ignore:function ham\(\) is deprecated:DeprecationWarning',
+    "ignore::RuntimeWarning",
+
+]
+addopts = '--maxfail=1 -rf' # exit after 1 failures, report fail info
+testpaths = [
+    "src/graphatoms/dataclasses",
+    "src/graphatoms/geometry",
+    'src/graphatoms/system',
+    'src/tests',
+]
+
+# ruff config
+[tool.ruff]
+line-length = 80
+indent-width = 4
+select = ["F", "E", "W", "UP", "D"]
+ignore = ["F722", "D100"]
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.pixi.package]
+name = 'graphatoms'
+version = '1.1.0'
+
+[tool.pixi.package.build]
+backend = { name = "pixi-build-python", version = "*" }
+channels = ["https://prefix.dev/conda-forge"]
+
+[tool.pixi.workspace]
+preview = ["pixi-build"]
+channels = ["conda-forge"]
+platforms = ["win-64", "linux-64", "osx-arm64"]
+
+[tool.pixi.pypi-dependencies]
+graphatoms = { path = ".", editable = true }
+
+[tool.pixi.environments]
+default = { solve-group = "default" }
+dev = { features = ["dev"], solve-group = "default" }
+
+[tool.pixi.tasks]
+test = "pytest -s -vv"
+benchmark = 'pytest -s graphatoms/system/_test_speed.py'
+
+[tool.pixi.dependencies]
+python = ">=3.12"
+pytest = ">=9.0.3,<10"
+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"
+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"

graphatoms-1.1.0/src/graphatoms/__init__.py

@@ -0,0 +1,8 @@
+# ruff: noqa
+# from .system import Cluster, Gas, System
+
+# __all__ = [
+#     "Cluster",
+#     "Gas",
+#     "System",
+# ]

graphatoms-1.1.0/src/graphatoms/dataclasses/__init__.py

@@ -0,0 +1,13 @@
+"""The extended dataclasses by pydantic & numpydantic."""
+
+from ._numpydantic import NDArray, numpy_validator
+from ._pydantic2pyarrow import get_pyarrow_schema
+from ._pydanticModel import OurBaseModel, OurFrozenModel
+
+__all__ = [
+    "NDArray",
+    "numpy_validator",
+    "get_pyarrow_schema",
+    "OurFrozenModel",
+    "OurBaseModel",
+]

graphatoms-1.1.0/src/graphatoms/dataclasses/_numpydantic.py

@@ -0,0 +1,62 @@
+from collections.abc import Sequence
+from functools import partial
+from typing import TYPE_CHECKING, Annotated, Any
+
+import numpy as np
+from numpydantic import NDArray as _NDArray
+from pydantic import (
+    BeforeValidator,
+    PlainSerializer,
+    WithJsonSchema,
+    validate_call,
+)
+
+__all__ = ["NDArray", "numpy_validator"]
+_ENCODING = "latin1"
+
+NDArray = Annotated[
+    _NDArray,
+    PlainSerializer(lambda x: x.tobytes().decode(_ENCODING), return_type=str),
+    # for pyarrow compatibility, we need to convert bytes to str
+    #                   for numpy.ndarray before serialization.
+    WithJsonSchema({"type": str}, mode="serialization"),
+]
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+
+@validate_call
+def __convert2numpy(
+    x: Any,
+    dtype: Any = "float",
+    shape: Sequence[int] = (-1,),
+) -> _NDArray:
+    """Convert a string or bytes or array-like object to a numpy array.
+
+    Raises:
+        KeyError: If the input value is a scalar number.
+    """
+    if isinstance(x, bytes | str):
+        x = x.encode(_ENCODING) if isinstance(x, str) else x
+        return np.frombuffer(x, np.dtype(dtype)).reshape(shape)
+    elif np.isscalar(x):
+        raise KeyError(
+            f"Invalid input value: {x}({type(x)})."
+            " The scalar value is not supported."
+        )
+    else:
+        return np.asarray(x, dtype=dtype).reshape(shape)
+
+
+def numpy_validator(
+    dtype: Any = "float",
+    shape: Sequence[int] = (-1,),
+) -> BeforeValidator:
+    """Create pydantic validator in `before` mode for numpy array."""
+    return BeforeValidator(
+        partial(
+            __convert2numpy,
+            shape=shape,
+            dtype=dtype,
+        )
+    )

graphatoms-1.1.0/src/graphatoms/dataclasses/_pydantic2pyarrow.py

@@ -0,0 +1,402 @@
+# ruff: noqa: E501
+import datetime
+import types
+import uuid
+from decimal import Decimal
+from enum import EnumMeta
+from typing import (
+    Annotated,
+    Any,
+    Literal,
+    NamedTuple,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
+
+import pyarrow as pa  # type: ignore
+from annotated_types import Ge, Gt
+from pyarrow import Schema, field, schema
+from pydantic import AwareDatetime, BaseModel, NaiveDatetime, WithJsonSchema
+from pydantic.fields import FieldInfo
+
+BaseModelType = TypeVar("BaseModelType", bound=BaseModel)
+EnumType = TypeVar("EnumType", bound=EnumMeta)
+__all__ = ["get_pyarrow_schema"]
+
+
+class SchemaCreationError(Exception):
+    """Error when creating pyarrow schema."""
+
+
+class Settings(NamedTuple):
+    allow_losing_tz: bool
+    by_alias: bool
+    exclude_fields: bool
+
+
+FIELD_MAP = {
+    str: pa.string(),
+    bytes: pa.binary(),
+    bool: pa.bool_(),
+    float: pa.float64(),
+    datetime.date: pa.date32(),
+    NaiveDatetime: pa.timestamp("ms", tz=None),
+    datetime.time: pa.time64("us"),
+}
+
+# Timezone aware datetimes will lose their timezone information
+# (but be correctly converted to UTC) when converted to pyarrow.
+# Pyarrow does support having an entire column in a single timezone,
+# but these bare types cannot guarantee that.
+LOSING_TZ_TYPES = {
+    datetime.datetime: pa.timestamp("ms", tz=None),
+    AwareDatetime: pa.timestamp("ms", tz=None),
+}
+
+
+def _get_int_type(metadata: list[Any]) -> pa.DataType:
+    min_value: int | None = None
+    for el in metadata:
+        if isinstance(el, Gt):
+            if el.gt is not None and not isinstance(el.gt, int):
+                raise SchemaCreationError("Gt metadata must be int")
+            min_value = el.gt
+        elif isinstance(el, Ge):
+            if el.ge is not None and not isinstance(el.ge, int):
+                raise SchemaCreationError("Ge metadata must be int")
+            min_value = el.ge
+
+    if min_value is not None and min_value >= 0:
+        return pa.uint64()
+    return pa.int64()
+
+
+def _get_decimal_type(metadata: list[Any]) -> pa.DataType:
+    general_metadata = None
+    for el in metadata:
+        if hasattr(el, "max_digits") and hasattr(el, "decimal_places"):
+            general_metadata = el
+    if general_metadata is None:
+        raise SchemaCreationError(
+            "Decimal type needs annotation setting max_digits and decimal_places"
+        )
+
+    return pa.decimal128(
+        general_metadata.max_digits, general_metadata.decimal_places
+    )
+
+
+TYPES_WITH_METADATA = {
+    Decimal: _get_decimal_type,
+    int: _get_int_type,
+}
+
+
+def _get_literal_type(
+    field_type: type[Any],
+    _metadata: list[Any],
+    _settings: Settings,
+) -> pa.DataType:
+    values = get_args(field_type)
+    if all(isinstance(value, str) for value in values):
+        return pa.dictionary(pa.int32(), pa.string())
+    elif all(isinstance(value, int) for value in values):
+        # Dictionary of (int, int) is converted to just int when
+        # written into parquet.
+        return pa.int64()
+    else:
+        msg = "Literal type is only supported with all int or string values. "
+        raise SchemaCreationError(msg)
+
+
+def _get_list_type(
+    field_type: type[Any],
+    metadata: list[Any],
+    settings: Settings,
+) -> pa.DataType:
+    sub_type = get_args(field_type)[0]
+    if _is_optional(sub_type):
+        # pyarrow lists can have null elements in them
+        sub_type = list(set(get_args(sub_type)) - {type(None)})[0]
+    return pa.list_(_get_pyarrow_type(sub_type, metadata, settings))
+
+
+def _get_annotated_type(
+    field_type: type[Any],
+    metadata: list[Any],
+    settings: Settings,
+) -> pa.DataType:
+    # ???: fix / clean up / understand why / if this works in all cases
+    args = get_args(field_type)[1:]
+    metadatas = [
+        item.metadata if hasattr(item, "metadata") else [item] for item in args
+    ]
+    metadata = [item for sublist in metadatas for item in sublist]
+    field_type = cast(type[Any], get_args(field_type)[0])
+    return _get_pyarrow_type(field_type, metadata, settings)
+
+
+def _get_dict_type(
+    field_type: type[Any],
+    metadata: list[Any],
+    settings: Settings,
+) -> pa.DataType:
+    key_type, value_type = get_args(field_type)
+    return pa.map_(
+        _get_pyarrow_type(key_type, metadata, settings),
+        _get_pyarrow_type(value_type, metadata, settings),
+    )
+
+
+FIELD_TYPES = {
+    Literal: _get_literal_type,
+    list: _get_list_type,
+    Annotated: _get_annotated_type,
+    dict: _get_dict_type,
+}
+
+
+def _get_enum_type(field_type: type[Any]) -> pa.DataType:
+    is_str = [
+        isinstance(enum_value.value, str)  #
+        for enum_value in field_type  # type: ignore
+    ]
+    if all(is_str):
+        return pa.dictionary(pa.int32(), pa.string())
+
+    is_int = [
+        isinstance(enum_value.value, int)  #
+        for enum_value in field_type  # type: ignore
+    ]
+    if all(is_int):
+        return pa.int64()
+
+    msg = "Enums only allowed if all str or all int"
+    raise SchemaCreationError(msg)
+
+
+def _get_uuid_type() -> pa.DataType:
+    # Different branches will execute depending on the pyarrow version
+    # This is tested through nox and python versions, but each one
+    # won't cover both branches. Hence, excluding from coverage.
+    if hasattr(pa, "uuid"):  # pragma: no cover
+        return pa.uuid()
+    else:  # pragma: no cover
+        msg = f"pyarrow version {pa.__version__} does not support pa.uuid() type, "
+        msg += "needs version 18.0 or higher"
+        raise SchemaCreationError(msg)
+
+
+def _is_optional(field_type: type[Any]) -> bool:
+    origin = get_origin(field_type)
+    is_python_39_union = origin is Union
+    is_python_310_union = (
+        hasattr(types, "UnionType") and origin is types.UnionType
+    )
+
+    if not is_python_39_union and not is_python_310_union:
+        return False
+
+    return type(None) in get_args(field_type)
+
+
+# noqa: PLR0911 - ignore until a refactoring can reduce the number of
+# return statements.
+def _get_pyarrow_type(  # noqa: PLR0911
+    field_type: type[Any],
+    metadata: list[Any],
+    settings: Settings,
+) -> pa.DataType:
+    if field_type in FIELD_MAP:
+        return FIELD_MAP[field_type]
+
+    if field_type is uuid.UUID:
+        return _get_uuid_type()
+
+    if settings.allow_losing_tz and field_type in LOSING_TZ_TYPES:
+        return LOSING_TZ_TYPES[field_type]
+
+    if not settings.allow_losing_tz and field_type in LOSING_TZ_TYPES:
+        raise SchemaCreationError(
+            f"{field_type} only allowed if ok losing timezone information"
+        )
+
+    if isinstance(field_type, EnumMeta):
+        return _get_enum_type(field_type)
+
+    if field_type in TYPES_WITH_METADATA:
+        return TYPES_WITH_METADATA[field_type](metadata)
+
+    if get_origin(field_type) in FIELD_TYPES:
+        return FIELD_TYPES[get_origin(field_type)](  # type: ignore
+            field_type,
+            metadata,
+            settings,
+        )
+
+    # isinstance(filed_type, type) checks whether it's a class
+    # otherwise eg Deque[int] would casue an exception on issubclass
+    if isinstance(field_type, type) and issubclass(field_type, BaseModel):
+        return _get_pyarrow_schema(field_type, settings, as_schema=False)
+
+    raise SchemaCreationError(f"Unknown type: {field_type}")
+
+
+def _get_pyarrow_schema(
+    pydantic_class: type[BaseModelType],
+    settings: Settings,
+    as_schema: bool = True,
+) -> pa.Schema:
+    fields = []
+    for name, field_info in pydantic_class.model_fields.items():
+        if field_info.exclude and settings.exclude_fields:
+            continue
+        field_type = field_info.annotation
+        metadata = field_info.metadata
+
+        if field_type is None:
+            # Not sure how to get here through pydantic, hence nocover
+            raise SchemaCreationError(
+                f"Missing type for field {name}"
+            )  # pragma: no cover
+
+        try:
+            nullable = False
+            if _is_optional(field_type):
+                nullable = True
+                types_under_union = list(
+                    set(get_args(field_type)) - {type(None)}
+                )
+                # mypy infers field_type as Type[Any] | None here, hence casting
+                field_type = cast(type[Any], types_under_union[0])
+
+            pa_field = _get_pyarrow_type(field_type, metadata, settings)
+        except Exception as err:  # noqa: BLE001 - ignore blind exception
+            raise SchemaCreationError(
+                f"Error processing field {name}: {field_type}, {err}"
+            ) from err
+
+        serialized_name = name
+        if settings.by_alias and field_info.serialization_alias is not None:
+            serialized_name = field_info.serialization_alias
+        fields.append(pa.field(serialized_name, pa_field, nullable=nullable))
+
+    if as_schema:
+        return pa.schema(fields)
+    return pa.struct(fields)
+
+
+# def get_pyarrow_schema(
+#     pydantic_class: Type[BaseModelType],
+#     allow_losing_tz: bool = False,
+#     exclude_fields: bool = False,
+#     by_alias: bool = False,
+# ) -> pa.Schema:
+#     """
+#     Converts a Pydantic model into a PyArrow schema.
+#
+#     Args:
+#         pydantic_class (Type[BaseModelType]): The Pydantic model class to convert.
+#         allow_losing_tz (bool, optional): Whether to allow losing timezone information
+#             when converting datetime fields. Defaults to False.
+#         exclude_fields (bool, optional): If True, will exclude fields in the pydantic
+#             model that have `Field(exclude=True)`. Defaults to False.
+#         by_alias (bool, optional): If True, will create the pyarrow schema using the
+#             (serialization) alias in the pydantic model. Defaults to False.
+#
+#     Returns:
+#         pa.Schema: The PyArrow schema representing the Pydantic model.
+#     """
+#     settings = Settings(
+#         allow_losing_tz=allow_losing_tz,
+#         by_alias=by_alias,
+#         exclude_fields=exclude_fields,
+#     )
+#     return _get_pyarrow_schema(pydantic_class, settings)
+############################################################################
+# The code above is copied from https://github.com/simw/pydantic-to-pyarrow.
+############################################################################
+
+
+def get_pyarrow_schema(
+    pydantic_class: type[BaseModel],
+    allow_losing_tz: bool = False,
+    exclude_fields: bool = False,
+    by_alias: bool = False,
+) -> Schema:
+    """Convert a Pydantic model to a PyArrow schema.
+
+    Args:
+        pydantic_class: Pydantic model class to convert.
+        allow_losing_tz: Allow losing timezone info in datetime fields.
+        exclude_fields: Exclude fields with Field(exclude=True).
+        by_alias: Use serialization alias for field names.
+
+    Returns:
+        PyArrow schema representing the Pydantic model.
+    """
+    fields = []
+    settings = Settings(
+        allow_losing_tz=allow_losing_tz,
+        by_alias=by_alias,
+        exclude_fields=exclude_fields,
+    )
+    for name, field_info in pydantic_class.model_fields.items():
+        if field_info.exclude and settings.exclude_fields:
+            continue
+        field_type = field_info.annotation
+        metadata = field_info.metadata
+        if field_type is None:
+            # Not sure how to get here through pydantic, hence nocover
+            raise SchemaCreationError(
+                f"Missing type for field {name}"
+            )  # pragma: no cover
+        serialized_name = name
+        if settings.by_alias and field_info.serialization_alias is not None:
+            serialized_name = field_info.serialization_alias
+
+        nullable = False
+        if _is_optional(field_type):
+            nullable = True
+            types_under_union = list(set(get_args(field_type)) - {type(None)})
+            # mypy infers field_type as Type[Any] | None here, hence casting
+            field_type = cast(type[Any], types_under_union[0])
+            if get_origin(field_type) is Annotated:
+                f = FieldInfo.from_annotation(field_type)
+                field_type, metadata = f.annotation, f.metadata
+
+        for metadata_item in metadata:
+            if isinstance(metadata_item, WithJsonSchema):
+                break
+        else:
+            metadata_item = None
+        if (
+            metadata_item is not None
+            and metadata_item.mode == "serialization"
+            and metadata_item.json_schema is not None
+        ):
+            fdtp = metadata_item.json_schema.get("type", None)
+            if fdtp is not None and type(fdtp) is type:
+                try:
+                    tp = _get_pyarrow_type(fdtp, [], settings)
+                    f = field(serialized_name, tp, nullable=nullable)
+                    fields.append(f)
+                    continue
+                except Exception:
+                    pass
+        try:
+            pa_field = _get_pyarrow_type(
+                field_type=field_type,  # type: ignore
+                settings=settings,
+                metadata=metadata,
+            )
+            f = field(serialized_name, pa_field, nullable=nullable)
+            fields.append(f)
+        except Exception as err:  # noqa: BLE001 - ignore blind exception
+            raise SchemaCreationError(
+                f"Error processing field {name}: {field_type}, {err}"
+            ) from err
+    return schema(fields)