graph-id-core 0.1.0__tar.gz

graph_id_core-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.3
+Name: graph-id-core
+Version: 0.1.0
+Summary: 
+Author: Koki Muraoka
+Author-email: muraok_k@chemsys.t.u-tokyo.ac.jp
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pybind11 (==2.11.1)
+Requires-Dist: pymatgen (>=2025.4.20,<2026.0.0)
+Requires-Dist: scikit-learn (>=0.24.1)
+Description-Content-Type: text/markdown
+
+
+
+# Graph ID
+
+## Installation 
+### pypi
+```
+pip install graph-id-core
+```
+
+### GitHub
+```
+git clone https://github.com/kmu/graph-id-core.git
+git submodule init
+git submodule update
+pip install -e .
+```
+

graph_id_core-0.1.0/README.md

@@ -0,0 +1,17 @@
+
+
+# Graph ID
+
+## Installation 
+### pypi
+```
+pip install graph-id-core
+```
+
+### GitHub
+```
+git clone https://github.com/kmu/graph-id-core.git
+git submodule init
+git submodule update
+pip install -e .
+```

graph_id_core-0.1.0/build.py

@@ -0,0 +1,108 @@
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+
+# https://github.com/pybind/cmake_example/blob/master/setup.py
+
+# Convert distutils Windows platform specifiers to CMake -A arguments
+PLAT_TO_CMAKE = {
+    "win32": "Win32",
+    "win-amd64": "x64",
+    "win-arm32": "ARM",
+    "win-arm64": "ARM64",
+}
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+# The name must be the _single_ output extension from the CMake build.
+# If you need multiple extensions, see scikit-build.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)
+        extdir = ext_fullpath.parent.resolve()
+
+        # Using this requires trailing slash for auto-detection & inclusion of
+        # auxiliary "native" libs
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE={extdir}{os.sep}",
+            f"-DPYTHON_EXECUTABLE={sys.executable}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        # Pass in the version to C++.
+        cmake_args += [f"-DVERSION_INFO={self.distribution.get_version()}"]
+
+        if sys.platform.startswith("win32"):
+            build_args += ["--config", cfg]
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            # self.parallel is a Python 3 only way to set parallel jobs by hand
+            # using -j in the build_ext call, not supported by pip or PyPA-build.
+            if hasattr(self, "parallel") and self.parallel:
+                # CMake 3.12+ only.
+                build_args += [f"-j{self.parallel}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+        env = {**os.environ}
+        if "PYTHONPATH" in env:
+            # Google Colab など CMake が pip でインストールされている環境で、import cmake できなくなり build が失敗する
+            del env["PYTHONPATH"]
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args],
+            cwd=build_temp,
+            check=True,
+            env=env,
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args],
+            cwd=build_temp,
+            check=True,
+            env=env,
+        )
+
+
+def build(setup_kwargs):
+    ext_modules = [
+        CMakeExtension("graph_id_cpp"),
+    ]
+    setup_kwargs.update(
+        {
+            "ext_modules": ext_modules,
+            "cmdclass": {"build_ext": CMakeBuild},
+            "zip_safe": False,
+        }
+    )

graph_id_core-0.1.0/graph_id/__init__.py

@@ -0,0 +1 @@
+from graph_id.core.graph_id import GraphIDGenerator  # noqa

graph_id_core-0.1.0/graph_id/analysis/compositional_sequence.py

@@ -0,0 +1,75 @@
+from collections import Counter
+from hashlib import blake2b
+from typing import List
+
+from pymatgen.core.structure import Neighbor
+from pymatgen.util.string import formula_double_format
+
+
+def blake(s):
+    return blake2b(s.encode()).hexdigest()
+
+
+class CompositionalSequence:
+    def __init__(self, focused_site_i, starting_labels, hash_cs=False, use_previous_cs=False):
+        self.hash_cs = hash_cs
+        if hash_cs:
+            self.cs_for_hashing = ""
+        else:
+            self.compositional_seq = []
+
+        self.focused_site_i = focused_site_i
+        self.new_sites = [(focused_site_i, (0, 0, 0))]
+
+        self.seen_sites = set(self.new_sites)
+        self.use_previous_cs = use_previous_cs
+        self.labels = starting_labels
+        self.composition_counter: Counter = Counter()
+        self.first_element = starting_labels[focused_site_i]
+
+    def __str__(self):
+        if self.hash_cs:
+            return f"{self.first_element}-{self.cs_for_hashing}"  # type: ignore
+
+        else:
+            return f"{self.first_element}-{'-'.join(self.compositional_seq)}"  # type: ignore
+
+    def get_current_starting_sites(self):
+        new_sites = self.new_sites
+        self.new_sites = []
+        return [*new_sites]
+
+    def count_composition_for_neighbors(
+        self,
+        nsites: List[Neighbor],
+        # graph: nx.Graph,
+        # labels: List[str],
+    ) -> None:
+
+        for neighbor in nsites:
+            neighbor_info = (neighbor.index, neighbor.jimage)
+
+            if neighbor_info not in self.seen_sites:
+
+                self.seen_sites.add(neighbor_info)
+
+                self.new_sites.append(neighbor_info)
+
+                if self.use_previous_cs:
+                    cs = self.labels[neighbor.index]
+                    self.composition_counter[cs] += 1
+                else:
+                    self.composition_counter[self.labels[neighbor.index]] += 1
+
+    def finalize_this_depth(self):
+        formula = self.get_sorted_composition_list_from(self.composition_counter)
+
+        if self.hash_cs:
+            self.cs_for_hashing = blake(f"{self.cs_for_hashing}-{''.join(formula)}")
+        else:
+            self.compositional_seq.append("".join(formula))
+
+    def get_sorted_composition_list_from(self, composition_counter: Counter) -> List[str]:
+        sorted_symbols = sorted(composition_counter.keys())
+        formula = [s + str(formula_double_format(composition_counter[s], False)) for s in sorted_symbols]
+        return formula

graph_id_core-0.1.0/graph_id/analysis/graphs.py

@@ -0,0 +1,404 @@
+import functools
+
+import networkx as nx
+import numpy as np
+from graph_id.analysis.compositional_sequence import CompositionalSequence
+from networkx.algorithms.distance_measures import diameter
+from pymatgen.analysis.graphs import StructureGraph as PmgStructureGraph
+from pymatgen.core import Element
+from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
+from itertools import combinations
+from hashlib import blake2b
+
+
+def standardize_loop(lst):
+    lst2 = list(reversed(lst))
+    starting_point = lst2.pop(-1)
+    lst2.insert(0, starting_point)
+
+    return sorted([lst, lst2], key=lambda x: "".join(x))[-1]
+
+
+class SiteOnlySpeciesString:
+    def __init__(self, species_string):
+        self.species_string = species_string
+
+
+class ConnectedSiteLight:
+    def __init__(
+        self,
+        site,
+        jimage,
+        index,
+        weight,
+        dist,
+    ):
+        self.site = SiteOnlySpeciesString(site.species_string)
+        self.jimage = jimage
+        self.index = index
+        self.weight = weight
+        self.dist = dist
+
+
+class StructureGraph(PmgStructureGraph):  # type: ignore
+    @staticmethod
+    def from_pymatgen_structure_graph(sg: PmgStructureGraph):
+        graph_data = sg.as_dict()["graphs"]
+
+        return StructureGraph(sg.structure, graph_data)
+
+    # Copied from original pymatgen with modifications
+    @staticmethod
+    def with_local_env_strategy(structure, strategy, weights=False):
+        """
+        Constructor for StructureGraph, using a strategy
+        from :Class: `pymatgen.analysis.local_env`.
+
+        :param structure: Structure object
+        :param strategy: an instance of a
+            :Class: `pymatgen.analysis.local_env.NearNeighbors` object
+        :param weights: if True, use weights from local_env class
+            (consult relevant class for their meaning)
+        :return:
+        """
+
+        if not strategy.structures_allowed:
+            raise ValueError(
+                "Chosen strategy is not designed for use with structures! " "Please choose another strategy."
+            )
+
+        sg = StructureGraph.from_empty_graph(structure, name="bonds")
+
+        for n, neighbors in enumerate(strategy.get_all_nn_info(structure)):
+            for neighbor in neighbors:
+                # local_env will always try to add two edges
+                # for any one bond, one from site u to site v
+                # and another form site v to site u: this is
+                # harmless, so warn_duplicates=False
+                sg.add_edge(
+                    from_index=n,
+                    from_jimage=(0, 0, 0),
+                    to_index=neighbor["site_index"],
+                    to_jimage=neighbor["image"],
+                    weight=neighbor["weight"] if weights else None,
+                    warn_duplicates=False,
+                )
+
+        return sg
+    
+    @staticmethod
+    def with_indivisual_state_comp_strategy(structure, strategy, _sg, n, weights=False, rank_k=1, cutoff=6.0):
+        """
+        Constructor for StructureGraph, using a StateCompNN strategy
+        from :Class: `chemsys.pymatgen.analysis.local_env`.
+        :param structure: Structure object
+        :param strategy: an instance of StateCompNN
+        :param n: (int) an index of focused site
+        :param weights: if True, use weights from local_env class
+            (consult relevant class for their meaning)
+        :rank_k: (int) cluster_idx
+        :cutoff: (float)
+        :return:
+        """
+
+        if not strategy.structures_allowed:
+            raise ValueError(  # noqa: TRY003
+                "Chosen strategy is not designed for use with structures!",  # noqa: EM101
+            )
+
+        nn_info = strategy.get_nn_info(structure, n, rank_k, cutoff)
+
+        for neighbor in nn_info:
+            # local_env will always try to add two edges
+            # for any one bond, one from site u to site v
+            # and another form site v to site u: this is
+            # harmless, so warn_duplicates=False
+            _sg.add_edge(
+                from_index=n,
+                from_jimage=(0, 0, 0),
+                to_index=neighbor["site_index"],
+                to_jimage=neighbor["image"],
+                weight=neighbor["weight"] if weights else None,
+                warn_duplicates=False,
+                edge_properties=neighbor["edge_properties"],
+            )
+
+        return _sg
+
+    def set_elemental_labels(self):
+        self.starting_labels = [site.species_string for site in self.structure]
+
+    def get_connected_sites_light(self, n, jimage=(0, 0, 0)):
+        """
+        A light version of get_connected_sites.
+        periodic_site -> SiteOnlySpeciesString
+        """
+
+        connected_sites = set()
+        connected_site_images = set()
+
+        out_edges = [(u, v, d, "out") for u, v, d in self.graph.out_edges(n, data=True)]
+        in_edges = [(u, v, d, "in") for u, v, d in self.graph.in_edges(n, data=True)]
+
+        for u, v, d, dir in out_edges + in_edges:
+
+            to_jimage = d["to_jimage"]
+
+            if dir == "in":
+                u, v = v, u
+                to_jimage = np.multiply(-1, to_jimage)
+
+            to_jimage = tuple(map(int, np.add(to_jimage, jimage)))
+
+            if (v, to_jimage) not in connected_site_images:
+                connected_site = ConnectedSiteLight(
+                    site=self.structure[v], jimage=to_jimage, index=v, weight=None, dist=None
+                )
+
+                connected_sites.add(connected_site)
+                connected_site_images.add((v, to_jimage))
+
+        _connected_sites = list(connected_sites)
+
+        return _connected_sites
+
+    def set_wyckoffs(self, symmetry_tol: float = 0.1) -> None:
+        siteless_strc = self.structure.copy()
+
+        for site_i in range(len(self.structure)):
+            siteless_strc.replace(site_i, Element("H"))
+
+        sga = SpacegroupAnalyzer(siteless_strc)
+        sym_dataset = sga.get_symmetry_dataset()
+
+        if sym_dataset is None:
+            self.set_elemental_labels()
+            return None
+
+        wyckoffs = sym_dataset["wyckoffs"]
+        number = sym_dataset["number"]
+
+        attribute_values = {}
+
+        self.starting_labels = []
+        for site_i, w in enumerate(wyckoffs):
+            attribute_values[site_i] = f"{self.structure[site_i].species_string}_{w}_{number}"
+            self.starting_labels.append(f"{self.structure[site_i].species_string}_{w}_{number}")
+
+    def set_compositional_sequence_node_attr(
+        self,
+        hash_cs: bool = False,
+        wyckoff: bool = False,
+        additional_depth: int = 0,
+        depth_factor: int = 2,
+        use_previous_cs: bool = False,
+    ) -> None:
+
+        node_attributes = {}
+        self.cc_cs = []
+        get_connected_sites_light = functools.lru_cache(maxsize=None)(self.get_connected_sites_light)
+
+        ug = self.graph.to_undirected()
+
+        for cc in nx.connected_components(ug):
+            cs_list = []
+
+            d = diameter(ug.subgraph(cc))
+
+            for focused_site_i in cc:
+
+                depth = depth_factor * d + additional_depth
+
+                cs = CompositionalSequence(
+                    focused_site_i=focused_site_i,
+                    starting_labels=self.starting_labels,
+                    hash_cs=hash_cs,
+                    use_previous_cs=use_previous_cs or wyckoff,
+                )
+
+                for _ in range(depth):
+                    for c_site in cs.get_current_starting_sites():
+                        nsites = get_connected_sites_light(c_site[0], c_site[1])
+                        cs.count_composition_for_neighbors(nsites)
+
+                    cs.finalize_this_depth()
+
+                this_cs = str(cs)
+
+                node_attributes[focused_site_i] = self.starting_labels[focused_site_i] + "_" + this_cs
+                cs_list.append(this_cs)
+
+            self.cc_cs.append({"site_i": cc, "cs_list": cs_list})
+
+        nx.set_node_attributes(self.graph, values=node_attributes, name="compositional_sequence")
+
+    def get_loops(self, depth: int, index: int, shortest: bool = True):  # noqa: C901
+        """
+        各原子を起点としてループを計算し、そのインデックス情報を返す。
+
+        Parameters:
+            indices: ループの起点としたいインデックス
+            depth: ループの最大の大きさ
+
+        Returns:
+            [[(index, image), ...], ...]
+        """
+
+        get_connected_sites = functools.lru_cache(maxsize=None)(self.get_connected_sites)
+
+        def find_all_rings(index, ring_list):
+            neighbors = get_connected_sites(index, (0, 0, 0))
+            for n0, n1 in combinations(neighbors, 2):
+                found = False
+                for ring in ring_list:
+                    term0 = ring[1]
+                    term1 = ring[-2]
+
+                    if all(
+                        (
+                            n0.index == term0[0],
+                            n0.jimage == term0[1],
+                            n1.index == term1[0],
+                            n1.jimage == term1[1],
+                        ),
+                    ):
+                        found = True
+                        break
+
+                    if all(
+                        (
+                            n1.index == term0[0],
+                            n1.jimage == term0[1],
+                            n0.index == term1[0],
+                            n0.jimage == term1[1],
+                        ),
+                    ):
+                        found = True
+                        break
+
+                if found is False:
+                    return False
+
+            return True
+
+        def get_further_lines_from_lines(lines):
+            new_lines = []
+            for line in lines:
+                ind, image = line[-1]
+                neighbors = get_connected_sites(ind, image)
+
+                for n in neighbors:
+                    new_line = [*line, (n.index, n.jimage)]
+
+                    # 戻らない場合のみ。
+                    if len(new_line[:-1]) == len(set(new_line[:-1])):
+                        new_lines.append(new_line)
+
+            return new_lines
+
+        lines = []
+        lines.append([(index, (0, 0, 0))])
+
+        ring_list = []
+
+        for depth_i in range(depth):
+            next_lines = []
+            lines = get_further_lines_from_lines(lines)
+
+            for line in lines:
+                # 前と後ろが同じ
+                if line[0] == line[-1]:
+                    if depth_i > 1 and list(reversed(line)) not in ring_list:
+                        ring_list.append(line)
+                else:
+                    next_lines.append(line)
+
+            lines = next_lines
+
+            # ここで理論上の値に達したら探索を打ち切る
+            if shortest and find_all_rings(index, ring_list):
+                return ring_list
+
+        return list(ring_list)
+
+    def set_loops(self, depth_factor: int, additional_depth: int) -> None:
+        self.starting_labels = []
+
+        undirected_graph = self.graph.to_undirected()
+
+        max_diameter = 0
+        for cc in nx.connected_components(undirected_graph):
+            d = diameter(undirected_graph.subgraph(cc))
+            if d > max_diameter:
+                max_diameter = d
+
+        depth = max_diameter * depth_factor + additional_depth
+
+        for site_i in range(len(self.graph.nodes)):
+            all_loops = self.get_loops(depth=depth, index=site_i)
+            all_loop_strings = []
+            # print(all_loops)
+            for loop in all_loops:
+                loop_elements = []
+                for site_i_jimage in loop:
+                    loop_species_string = self.structure[site_i_jimage[0]].species_string
+                    # print(loop_species_string)
+                    loop_elements.append(loop_species_string)
+
+                loop_elements = standardize_loop(loop_elements)
+
+                seed_str = "-".join(loop_elements)
+                hashed_loop = blake2b(seed_str.encode(), digest_size=8).hexdigest()
+
+                all_loop_strings.append(hashed_loop)
+
+            seed_str_all_loops = ":".join(sorted(all_loop_strings))
+            hashed_all_loops = blake2b(seed_str_all_loops.encode(), digest_size=8).hexdigest()
+
+            self.starting_labels.append(hashed_all_loops)
+
+    def set_indivisual_compositional_sequence_node_attr(
+        self,
+        n: int,
+        hash_cs: bool = False,
+        wyckoff: bool = False,
+        additional_depth: int = 0,
+        depth_factor: int = 2,
+        use_previous_cs: bool = False,
+    ) -> None:
+        node_attributes = {}
+        self.cc_cs = []
+        get_connected_sites_light = functools.lru_cache(maxsize=None)(self.get_connected_sites_light)
+
+        ug = self.graph.to_undirected()
+
+        for cc in nx.connected_components(ug):
+            cs_list = []
+
+            d = diameter(ug.subgraph(cc))
+
+            if n in cc:
+                depth = depth_factor * d + additional_depth
+
+                cs = CompositionalSequence(
+                    focused_site_i=n,
+                    starting_labels=self.starting_labels,
+                    hash_cs=hash_cs,
+                    use_previous_cs=use_previous_cs or wyckoff,
+                )
+
+                for _this_depth in range(depth):
+                    for c_site in cs.get_current_starting_sites():
+                        nsites = get_connected_sites_light(c_site[0], c_site[1])
+                        cs.count_composition_for_neighbors(nsites)
+
+                    cs.finalize_this_depth()
+
+                this_cs = str(cs)
+
+                node_attributes[n] = self.starting_labels[n] + "_" + this_cs
+                cs_list.append(this_cs)
+
+                self.cc_cs.append({"site_i": cc, "cs_list": cs_list})
+
+        nx.set_node_attributes(self.graph, values=node_attributes, name="compositional_sequence")

graph_id_core-0.1.0/graph_id/analysis/local_env.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from pymatgen.analysis.local_env import NearNeighbors
+from pymatgen.core import IStructure, Structure
+from sklearn.cluster import DBSCAN
+
+def _get_original_site(structure, site):
+    """Private convenience method for get_nn_info,
+    gives original site index from ProvidedPeriodicSite.
+    """
+
+    if isinstance(structure, IStructure | Structure):
+        site_fcoords = site.frac_coords
+        strc_fcoords = structure.frac_coords
+        tol = 1e-8  # threshold in Site.is_periodic_image
+        # sort to reduce the iteration
+        nearest_i = np.argsort(-(np.abs(strc_fcoords - site_fcoords) < tol).sum(axis=1))
+
+        for i in nearest_i:
+            if site.is_periodic_image(structure[i]):
+                return i
+    else:
+        for i, s in enumerate(structure):
+            if site == s:
+                return i
+    raise Exception("Site not found!")  # noqa: TRY002, TRY003, EM101
+
+
+class DistanceClusteringNN(NearNeighbors):
+    # 結合長のクラスタリングによって原子に近いクラスター順に番号を振る
+    # その番号と元素記号を使ってGraph IDを計算する
+    def __init__(self) -> None:
+        """ """
+
+    @property
+    def structures_allowed(self) -> bool:
+        """
+        Boolean property: can this NearNeighbors class be used with Structure
+        objects?
+        """
+        return True
+
+    def get_nn_info(self, structure: Structure, n: int, rank_k: int, cutoff: float = 6.0) -> list[dict[str, Any]]:
+        """
+        Args:
+            structure (Structure): input structure.
+            n (int): index of site for which to determine near
+                neighbors.
+            cutoff (float): distance cutoff parameter.
+        Returns:
+            siw (list[dict]): dicts with (Site, array, float) each one of which represents a
+                neighbor site, its image location, and its weight.
+        """
+
+        site = structure[n]
+        cutoff_cluster_list = self.get_cutoff_cluster(structure, n, cutoff)
+        if len(cutoff_cluster_list) <= rank_k:
+            return []
+
+        neighs_dists = structure.get_neighbors(site, cutoff_cluster_list[rank_k])
+        max_weight = round(cutoff_cluster_list[rank_k], 3)
+        # is_periodic = isinstance(structure, Structure | IStructure) # Python 3.10 以降でのみサポート
+        is_periodic = isinstance(structure, Structure) or isinstance(structure, IStructure)
+        siw = []
+
+        for nn in neighs_dists:
+            weight = round(nn.nn_distance, 3)
+            if (rank_k > 0 and weight <= max_weight and weight > round(cutoff_cluster_list[rank_k - 1], 3)) or (
+                rank_k == 0 and weight <= max_weight
+            ):
+                siw.append(
+                    {
+                        "site": nn,
+                        "image": self._get_image(structure, nn) if is_periodic else None,
+                        "weight": weight,
+                        "site_index": self._get_original_site(structure, nn),
+                        "edge_properties": {"cluster_idx": rank_k + 1},
+                    },
+                )
+
+        return siw
+
+    def get_cutoff_cluster(self, structure: Structure, n: int, cutoff: float = 6.0) -> list:
+        """
+        DBSCANによって得られた距離のクラスターから結合判定の閾値を決定する
+        """
+
+        # # スーパーセルを作成し、6.0angまでの結合長を数え上げる
+        # copy_structure = structure.copy()
+        # supercell = copy_structure.make_supercell([3, 3, 3])
+        # site_i = structure[n]
+
+        # site_index = None
+        # for idx, site in enumerate(supercell):
+        #     # Siteのdistanceメソッドを使うとなぜか正しく距離が計算されない
+        #     if float(np.linalg.norm(site_i.coords - site.coords)) < 0.01:
+        #         site_index = idx
+        #         break
+
+        distance_list = []
+        neighbors = structure.get_sites_in_sphere(structure[n].coords, cutoff)
+        for neighbor in neighbors:
+            dist = neighbor.nn_distance
+            distance_list.append([dist, 0])
+
+        dbscan = DBSCAN(eps=0.5, min_samples=2)
+        dbscan.fit(distance_list)
+        labels = dbscan.labels_
+
+        max_dist_list = [0 for _ in range(max(labels) + 1)]
+        for label_number in range(max(labels) + 1):
+            max_dist = 0
+            for label, distance in zip(labels, distance_list):
+                if label == label_number:
+                    max_dist = max(max_dist, distance[0])
+
+            max_dist_list[label_number] = max_dist
+
+        return sorted(max_dist_list)

graph_id_core-0.1.0/graph_id/commands/gid.py

@@ -0,0 +1,44 @@
+import argparse
+import csv
+from datetime import datetime
+
+from graph_id import GraphIDGenerator
+from pymatgen.core import Structure
+from tabulate import tabulate
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Graph ID: graph-based ID for materails")
+
+    parser.add_argument(
+        dest="filenames",
+        metavar="filename",
+        nargs="+",
+        help="List of structure files.",
+        default=[],
+    )
+
+    parser.add_argument("-p", "--parallel", help="parallel execution", action="store_true")
+
+    gid = GraphIDGenerator()
+    args = parser.parse_args()
+
+    table = []
+
+    for fname in args.filenames:
+        s = Structure.from_file(fname)
+        s.merge_sites(mode="delete")
+
+        my_id = gid.get_id(s)
+
+        table.append([my_id, fname])
+
+    t_headers = ["GraphIDGenerator", "Filename"]
+
+    print(tabulate(table, headers=t_headers))
+
+    now = datetime.now()
+    now_str = now.strftime("%Y%m%d-%H%M%S")
+
+    with open(f"graph_id_{now_str}.csv", "w") as f:
+        writer = csv.writer(f)
+        writer.writerows(table)

graph_id_core-0.1.0/graph_id/core/distance_clustering_graph_id.py

@@ -0,0 +1,138 @@
+from copy import deepcopy
+from hashlib import blake2b
+
+import networkx as nx
+import numpy as np
+from graph_id.analysis.local_env import DistanceClusteringNN
+from pymatgen.analysis.local_env import MinimumDistanceNN
+from graph_id.analysis.graphs import StructureGraph
+from graph_id.core.graph_id import GraphIDGenerator
+from pymatgen.core import Element
+
+__version__ = "0.1.0"
+
+
+def blake(s):
+    return blake2b(s.encode()).hexdigest()
+
+
+class DistanceClusteringGraphID(GraphIDGenerator):
+    def __init__(  # noqa: PLR0913
+        self,
+        nn=None,
+        wyckoff=False,
+        depth_factor=2,
+        additional_depth=1,
+        symmetry_tol=0.1,
+        topology_only=False,
+        loop=False,
+        rank_k=3,
+        cutoff=6.0,
+        digest_size=8,
+    ) -> None:
+        super().__init__(
+            nn,
+            wyckoff,
+            depth_factor,
+            additional_depth,
+            symmetry_tol,
+            topology_only,
+            loop,
+            digest_size,
+        )
+
+        self.rank_k = rank_k
+        self.cutoff = cutoff
+        self.digest_size = digest_size
+
+        if nn is None:
+            self.nn = DistanceClusteringNN()
+        else:
+            self.nn = nn
+
+    def get_id(self, structure):
+        gid_list = []
+        _sg = StructureGraph.with_local_env_strategy(structure, MinimumDistanceNN())
+        for cluster_idx in range(self.rank_k):
+            long_str_list = []
+            # _sg = StructureGraph.with_local_env_strategy(structure, MinimumDistanceNN())
+            for idx in range(len(structure)):
+                copied_sg = deepcopy(_sg)
+                # まず原子idxが含まれる結合を削除する
+                for from_index, to_index, dct in _sg.graph.edges(keys=False, data=True):
+                    if from_index == idx or to_index == idx:
+                        copied_sg.break_edge(from_index, to_index, dct["to_jimage"], allow_reverse=True)
+                sg = self.prepare_structure_graph(structure, copied_sg, idx, cluster_idx)
+                n = len(sg.cc_cs)
+                array = np.empty(
+                    [
+                        n,
+                    ],
+                    dtype=object,
+                )
+                for i, component in enumerate(sg.cc_cs):
+                    array[i] = blake("-".join(sorted(component["cs_list"])))
+                    # array[i] = blake2b("-".join(sorted(component["cs_list"])).encode("ascii"), digest_size=16).hexdigest()
+                long_str_tmp = ":".join(np.sort(array))
+                # long_str_tmp = blake2b(":".join(np.sort(array)).encode("ascii"), digest_size=16).hexdigest()
+                long_str_list.append(long_str_tmp)
+            long_str = ":".join(np.sort(long_str_list))
+            gid = blake2b(long_str.encode("ascii"), digest_size=self.digest_size).hexdigest()
+            gid_list.append(gid)
+
+        long_gid = "".join(gid_list)
+        # return self.elaborate_comp_dim(sg, blake2b(long_gid.encode("ascii"), digest_size=16).hexdigest())
+        return blake2b(long_gid.encode("ascii"), digest_size=self.digest_size).hexdigest()
+
+    def prepare_structure_graph(self, structure, _sg, n, rank_k):
+        
+        sg = StructureGraph.with_indivisual_state_comp_strategy(
+            structure=structure,
+            strategy=self.nn,
+            _sg=_sg,
+            n=n,
+            rank_k=rank_k,
+            cutoff=self.cutoff,
+        )
+
+        use_previous_cs = False
+
+        compound = sg.structure
+        prev_num_uniq = len(compound.composition)
+
+        if self.topology_only:
+            for site_i in range(len(sg.structure)):
+                sg.structure.replace(site_i, Element("H"))
+
+        if self.wyckoff:
+            sg.set_wyckoffs(symmetry_tol=self.symmetry_tol)
+            prev_num_uniq = len(list(set(nx.get_node_attributes(sg.graph, "compositional_sequence").values())))
+
+        elif self.loop:
+            sg.set_loops_as_starting_labels(
+                depth_factor=self.depth_factor,
+                additional_depth=self.additional_depth,
+            )
+
+        else:
+            sg.set_elemental_labels()
+
+        while True:
+            sg.set_indivisual_compositional_sequence_node_attr(
+                n=n,
+                hash_cs=False,
+                wyckoff=self.wyckoff,
+                additional_depth=self.additional_depth,
+                depth_factor=self.depth_factor,
+                use_previous_cs=use_previous_cs or self.wyckoff,
+            )
+
+            num_unique_nodes = len(list(set(nx.get_node_attributes(sg.graph, "compositional_sequence").values())))
+            use_previous_cs = True
+
+            if prev_num_uniq == num_unique_nodes:
+                break
+
+            prev_num_uniq = num_unique_nodes
+
+        return sg

graph_id_core-0.1.0/graph_id/core/graph_id.py

@@ -0,0 +1,209 @@
+import multiprocessing as multi
+from copy import deepcopy
+from hashlib import blake2b
+from multiprocessing import Pool
+
+import networkx as nx
+import numpy as np
+from graph_id.analysis.graphs import StructureGraph
+from pymatgen.analysis.dimensionality import get_dimensionality_larsen
+from pymatgen.analysis.local_env import MinimumDistanceNN
+from pymatgen.core import Element
+from tqdm import tqdm
+
+__version__ = "0.1.0"
+
+
+def blake(s):
+    return blake2b(s.encode()).hexdigest()
+
+
+class GraphIDGenerator:
+    def __init__(
+        self,
+        nn=None,
+        wyckoff=False,
+        depth_factor=2,
+        additional_depth=1,
+        symmetry_tol=0.1,
+        topology_only=False,
+        loop=False,
+        digest_size=8,
+    ):
+        """
+        comp_dim: include composition and dimensionality as the prefix
+        """
+
+        if wyckoff and loop:
+            raise ValueError("wyckoff and loop cannot be True at the same time")
+
+        if loop and topology_only:
+            raise ValueError("loop and topology_only cannot be True at the same time")
+
+        if nn is None:
+            self.nn = MinimumDistanceNN()
+        else:
+            self.nn = nn
+
+        self.wyckoff = wyckoff
+        self.additional_depth = additional_depth
+        self.depth_factor = depth_factor
+        self.symmetry_tol = symmetry_tol
+        self.topology_only = topology_only
+        self.loop = loop
+        self.digest_size = digest_size
+
+    # def get_graph_I#
+
+    def get_id(self, structure):
+        sg = self.prepare_structure_graph(structure)
+        n = len(sg.cc_cs)
+        array = np.empty(
+            [
+                n,
+            ],
+            dtype=object,
+        )
+        for i, component in enumerate(sg.cc_cs):
+            array[i] = blake("-".join(sorted(component["cs_list"])))
+        long_str = ":".join(np.sort(array))
+        gid = blake2b(long_str.encode("ascii"), digest_size=self.digest_size).hexdigest()
+
+        gid = self.elaborate_comp_dim(sg, gid)
+
+        return gid
+
+    def elaborate_comp_dim(self, sg, gid):
+        dim = get_dimensionality_larsen(sg)
+        gid = f"{dim}D-{gid}"
+
+        if not self.topology_only:
+            gid = f"{sg.structure.composition.reduced_formula}-{gid}"
+
+        return gid
+
+    @property
+    def version(self):
+        return __version__
+
+    def get_id_catch_error(self, structure):
+        try:
+            return self.get_id(structure)
+        except Exception:
+            return ""
+
+    def get_many_ids(self, structures, parallel=False):
+        if parallel:
+            n_cores = multi.cpu_count()
+            # ctx = multi.get_context("spawn")
+            # p = ctx.Pool(n_cores)
+            p = Pool(n_cores)
+            imap = p.imap(self.get_id_catch_error, structures)
+            # ids = p.map(self.get_id, structures)
+            ids = list(tqdm(imap, total=len(structures)))
+            return ids
+
+        return [self.get_id(s) for s in structures]
+
+    def get_component_ids(self, structure):
+        sg = self.prepare_structure_graph(structure)
+        cc_gid = np.empty(
+            [
+                len(sg.cc_cs),
+            ],
+            dtype=object,
+        )
+        for i, component in enumerate(sg.cc_cs):
+            each_long_str = blake("-".join(sorted(component["cs_list"])))
+            gid = blake2b(each_long_str.encode("ascii"), digest_size=16).hexdigest()
+            # cc_gid[] = gid
+            cc_gid[i] = {"site_i": component["site_i"], "graph_id": gid}
+
+        return cc_gid
+
+    def are_same(self, structure1, structure2):
+        return self.get_id(structure1) == self.get_id(structure2)
+
+    def expand_for_low_dimensionality(self, sg):
+        dimensionality = get_dimensionality_larsen(sg)
+
+        if dimensionality < 3:
+            if len(list(nx.weakly_connected_components(sg.graph))) == 1:
+                supercell = sg.structure.copy()
+                supercell.make_supercell([[2, 2, 2]])
+                sg = StructureGraph.with_local_env_strategy(supercell, self.nn)
+
+        return sg
+
+    def expand_for_multi_bonds(self, sg):
+        _sg = deepcopy(sg)
+        factor = 2
+
+        while self.has_multi_bonds(_sg):
+            _strc = sg.structure.copy()
+            _strc.make_supercell([factor, factor, factor])
+
+            _sg = StructureGraph.with_local_env_strategy(_strc, self.nn)
+            factor += 1
+            # sg.expand
+        # for site_i in range(len(sg.structure)):
+        #     sites = sg.get_connected_sites_light(site_i)
+        #     for site in sites:
+        #         print(site.index)
+        #     # print(sites )
+
+        return _sg
+
+    def has_multi_bonds(self, sg):
+        # g = sg.graph.to_undirected()
+        for edge in sg.graph.edges:
+            if edge[2] != 0:
+                return True
+            # print(edge)
+
+        return False
+
+    def prepare_structure_graph(self, structure):
+        sg = StructureGraph.with_local_env_strategy(structure, self.nn)
+        use_previous_cs = False
+
+        compound = sg.structure
+        prev_num_uniq = len(compound.composition)
+
+        if self.topology_only:
+            for site_i in range(len(sg.structure)):
+                sg.structure.replace(site_i, Element("H"))
+
+        if self.wyckoff:
+            sg.set_wyckoffs(symmetry_tol=self.symmetry_tol)
+
+            # TODO: remove nx
+            prev_num_uniq = len(list(set(nx.get_node_attributes(sg.graph, "compositional_sequence").values())))
+
+        elif self.loop:
+            sg.set_loops(
+                depth_factor=self.depth_factor,
+                additional_depth=self.additional_depth,
+            )
+
+        else:
+            sg.set_elemental_labels()
+
+        while True:
+            sg.set_compositional_sequence_node_attr(
+                hash_cs=True,
+                wyckoff=self.wyckoff,
+                additional_depth=self.additional_depth,
+                depth_factor=self.depth_factor,
+                use_previous_cs=use_previous_cs or self.wyckoff,
+            )
+
+            num_unique_nodes = len(list(set(nx.get_node_attributes(sg.graph, "compositional_sequence").values())))
+            use_previous_cs = True
+
+            if prev_num_uniq == num_unique_nodes:
+                break
+
+            prev_num_uniq = num_unique_nodes
+
+        return sg

graph_id_core-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.poetry]
+name = "graph-id-core"
+version = "0.1.0"
+description = ""
+authors = ["Koki Muraoka <muraok_k@chemsys.t.u-tokyo.ac.jp>"]
+readme = "README.md"
+packages = [{include = "graph_id"}]
+
+[tool.poetry.build]
+script = "build.py"
+generate-setup-file = true
+
+[tool.poetry.dependencies]
+pybind11 = "2.11.1"
+python = ">=3.10,<3.14"
+pymatgen = "^2025.4.20"
+scikit-learn = ">=0.24.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "graph_id"]
+norecursedirs = ["library", "build", "dist", ".git", ".venv", "__pycache__"]
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "pybind11~=2.11.1", "setuptools"]
+build-backend = "poetry.core.masonry.api"
+

graph_id_core-0.1.0/setup.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['graph_id', 'graph_id.analysis', 'graph_id.commands', 'graph_id.core']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['pybind11==2.11.1', 'pymatgen>=2025.4.20,<2026.0.0', 'scikit-learn>=0.24.1']
+
+setup_kwargs = {
+    'name': 'graph-id-core',
+    'version': '0.1.0',
+    'description': '',
+    'long_description': '\n\n# Graph ID\n\n## Installation \n### pypi\n```\npip install graph-id-core\n```\n\n### GitHub\n```\ngit clone https://github.com/kmu/graph-id-core.git\ngit submodule init\ngit submodule update\npip install -e .\n```\n',
+    'author': 'Koki Muraoka',
+    'author_email': 'muraok_k@chemsys.t.u-tokyo.ac.jp',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.10,<3.14',
+}
+from build import *
+build(setup_kwargs)
+
+setup(**setup_kwargs)