simulation-alg 0.1.0__tar.gz

simulation_alg-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+
+    steps:
+    - uses: actions/checkout@v2
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install maturin pytest
+    
+    - name: Build and install
+      run: |
+        maturin develop
+    
+    - name: Run tests
+      run: |
+        pytest tests/

simulation_alg-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+/target
+/.vscode

simulation_alg-0.1.0/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/graph-simulation"]
+	path = lib/graph-simulation
+	url = https://github.com/RaVincentHuang/graph-simulation.git

simulation_alg-0.1.0/Cargo.lock

@@ -0,0 +1,240 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "either"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7914353092ddf589ad78f25c5c1c21b7f80b0ff8621e7c814c3485b5306da9d"
+
+[[package]]
+name = "graph-base"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97818a84e65f02545f38aae643f16779e54c186b442f084f138c53e1c981e32c"
+
+[[package]]
+name = "graph-simulation"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b06d26f28d2b6d5504d69507ed5460c55a4368e66dcd767e7c8f189615c3643"
+dependencies = [
+ "graph-base",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
+[[package]]
+name = "libc"
+version = "0.2.169"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.23.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "simulation"
+version = "0.1.0"
+dependencies = [
+ "graph-base",
+ "graph-simulation",
+ "pyo3",
+ "rayon",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
+
+[[package]]
+name = "unindent"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"

simulation_alg-0.1.0/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "simulation"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+description = "A Python package for simulation algorithms"
+homepage = "https://github.com/RaVincentHuang/simulation"
+repository = "https://github.com/RaVincentHuang/simulation"
+
+
+[lib]
+name = "simulation"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.23", features = ["extension-module"] }
+graph-simulation = "0.1.2"
+graph-base = "0.1.2"
+rayon = "1.10.0"
+# [tool.maturin]
+# include-pyi = true  # 自动打包生成的 .pyi 文件
+# python-source = "python"
+
+[package.metadata.maturin]
+bindings = "pyo3"

simulation_alg-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zixiao Huang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simulation_alg-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: simulation-alg
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+Summary: A Python package for simulation algorithms
+Home-Page: https://github.com/RaVincentHuang/simulation
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/RaVincentHuang/simulation
+
+# Python Simulation Package 
+
+
+**Install** 
+```bash
+git submodule update --init --recursive
+pip install maturin
+pip install -r requirements.txt
+maturin develop --release
+```
+
+**How to use**
+```python
+import networkx as nx
+import simulation
+
+def random_graph_gen(n, p, k):
+    G: DiGraph = nx.fast_gnp_random_graph(n, p, directed=True)
+    for node in G.nodes:
+        G.nodes[node]['label'] = random.randint(1, k)
+    return G
+
+def graph_permutation(g: DiGraph) -> DiGraph:
+    nodes = list(g.nodes)
+    random.shuffle(nodes)
+    mapping = dict(zip(g.nodes, nodes))
+    g_perm = nx.relabel_nodes(g, mapping)
+    return g_perm
+
+def attr_same(attr1: dict, attr2: dict):
+    label1 = attr1.get("label")
+    label2 = attr2.get("label")
+    return label1 == label2
+
+n, p = ...
+g1 = random_graph_gen(n, p, directed=True)
+g2 = graph_permutation(g1)
+print(simulation.is_simulation_isomorphic_fn(g1, g2, attr_same))
+```
+

simulation_alg-0.1.0/README.md

@@ -0,0 +1,39 @@
+# Python Simulation Package 
+
+
+**Install** 
+```bash
+git submodule update --init --recursive
+pip install maturin
+pip install -r requirements.txt
+maturin develop --release
+```
+
+**How to use**
+```python
+import networkx as nx
+import simulation
+
+def random_graph_gen(n, p, k):
+    G: DiGraph = nx.fast_gnp_random_graph(n, p, directed=True)
+    for node in G.nodes:
+        G.nodes[node]['label'] = random.randint(1, k)
+    return G
+
+def graph_permutation(g: DiGraph) -> DiGraph:
+    nodes = list(g.nodes)
+    random.shuffle(nodes)
+    mapping = dict(zip(g.nodes, nodes))
+    g_perm = nx.relabel_nodes(g, mapping)
+    return g_perm
+
+def attr_same(attr1: dict, attr2: dict):
+    label1 = attr1.get("label")
+    label2 = attr2.get("label")
+    return label1 == label2
+
+n, p = ...
+g1 = random_graph_gen(n, p, directed=True)
+g2 = graph_permutation(g1)
+print(simulation.is_simulation_isomorphic_fn(g1, g2, attr_same))
+```

simulation_alg-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "simulation-alg"
+version = "0.1.0"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]

simulation_alg-0.1.0/requirements.txt

@@ -0,0 +1 @@
+networkx = 3.4.2

simulation_alg-0.1.0/simulation.pyi

@@ -0,0 +1,34 @@
+
+from typing import Callable, Dict
+import networkx
+
+
+def get_simulation_inter(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, is_label_cached=False) -> Dict: 
+    """
+    Get the simulation between two graphs.
+    """
+
+def is_simulation_isomorphic(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, is_label_cached=False) -> bool:
+    """
+    Check if two graphs are isomorphic by graph simulation.
+    """
+
+def get_simulation_inter_fn(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, compare_fn: Callable, is_label_cached=False) -> Dict: 
+    """
+    Get the simulation between two graphs.
+    """
+    
+def is_simulation_isomorphic_fn(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, compare_fn: Callable, is_label_cached=False) -> bool:
+    """
+    Check if two graphs are isomorphic by graph simulation.
+    """
+
+def is_simulation_isomorphic_of_node_edge_fn(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, node_compare_fn: Callable,  edge_compare_fn: Callable, is_label_cached=False) -> bool:
+    """
+    Check if two graphs are isomorphic by graph simulation.
+    """
+
+def is_simulation_isomorphic_of_edge_fn(nx_graph1: networkx.DiGraph, nx_graph2: networkx.DiGraph, node_edge_compare_fn: Callable, is_label_cached=False) -> bool:
+    """
+    Check if two graphs are isomorphic by graph simulation.
+    """

simulation_alg-0.1.0/src/graph/mod.rs

@@ -0,0 +1,13 @@
+
+pub mod networkx_graph;
+
+use pyo3::prelude::*;
+
+#[pymodule]
+pub fn register_graph_module(parent_module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let child_module = PyModule::new(parent_module.py(), "graph")?;
+    child_module.add_class::<networkx_graph::NetworkXGraph>()?;
+    child_module.add_function(wrap_pyfunction!(networkx_graph::get_simulation_inter, &child_module)?)?;
+    child_module.add_function(wrap_pyfunction!(networkx_graph::is_simulation_isomorphic, &child_module)?)?;
+    parent_module.add_submodule(&child_module)
+}

simulation_alg-0.1.0/src/graph/networkx_graph.rs

@@ -0,0 +1,609 @@
+use graph_simulation::algorithm::simulation::Simulation;
+use pyo3::types::PySet;
+use pyo3::{prelude::*, types::PyDict};
+use graph_base::interfaces::labeled::{Label, Labeled, LabeledAdjacency};
+use graph_base::interfaces::graph::{Graph, Directed, Adjacency, AdjacencyInv, SingleId, IdPair};
+
+use pyo3::prelude::*;
+use std::collections::{HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::path::Display;
+use std::sync::Arc;
+
+type SharedRustFn = Arc<dyn Fn(&Attributes, &Attributes) -> bool + Send + Sync>;
+
+
+// 自定义图结构
+
+#[derive(Debug)]
+struct Attributes(HashMap<String, Py<PyAny>>);
+
+impl Clone for Attributes {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| {
+            let cloned_map = self.0.iter()
+                .map(|(k, v)| (k.clone(), v.clone_ref(py)))
+                .collect();
+            Attributes(cloned_map)
+        })
+    }
+}
+
+impl std::fmt::Display for Attributes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut entries: Vec<_> = self.0.iter().collect();
+        entries.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+
+        write!(f, "{{")?;
+        for (key, value) in entries {
+            write!(f, "{}: {}, ", key, value)?;
+        }
+        write!(f, "}}")
+    }
+}
+
+impl PartialEq for Attributes {
+    fn eq(&self, other: &Self) -> bool {
+        // 首先比较长度
+        if self.0.len() != other.0.len() {
+            return false;
+        }
+
+        Python::with_gil(|py| {
+            self.0.iter().all(|(key, value)| {
+                match other.0.get(key) {
+                    Some(other_value) => {
+                        match value.call_method1(py, "__eq__", (other_value,)) {
+                            Ok(result) => result.extract::<bool>(py).unwrap_or(false),
+                            Err(_) => false,
+                        }
+                    },
+                    None => false,
+                }
+            })
+        })
+    }
+}
+
+impl Eq for Attributes {}
+
+impl Hash for Attributes {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // 确保相同的字典产生相同的哈希值
+        let mut entries: Vec<_> = self.0.iter().collect();
+        entries.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+
+        Python::with_gil(|py| {
+            for (key, value) in entries {
+                key.hash(state);
+                // 使用 Python 对象的 __hash__ 方法
+                match value.call_method0(py, "__hash__") {
+                    Ok(hash_result) => {
+                        if let Ok(hash_value) = hash_result.extract::<isize>(py) {
+                            hash_value.hash(state);
+                        }
+                    },
+                    Err(_) => {
+                        // 如果对象不可哈希，使用默认值
+                        0isize.hash(state);
+                    }
+                }
+            }
+        });
+    }
+}
+
+impl Label for Attributes {
+    fn label(&self) -> &str {
+        ""
+    }
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Node {
+    id: usize,
+    attributes: Attributes,
+}
+
+impl std::fmt::Display for Node {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Node({})", self.id)
+    }
+}
+
+impl SingleId for Node {
+    fn id(&self) -> usize {
+        self.id
+    }
+}
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Edge {
+    source: usize,
+    target: usize,
+    attributes: Attributes,
+}
+
+impl IdPair for Edge {
+    fn pair(&self) -> (usize, usize) {
+        (self.source, self.target)
+    }
+}
+
+#[pyclass]
+pub struct NetworkXGraph {
+    nodes: Vec<Node>,
+    edges: Vec<Edge>,
+    node_indices: HashMap<String, usize>,
+    same_label_fn: Option<Py<PyAny>>,
+    same_edge_fn: Option<Py<PyAny>>,
+    same_node_edge_fn: Option<Py<PyAny>>,
+    same_label_cache: Option<HashSet<(usize, usize)>>
+}
+
+impl Clone for NetworkXGraph {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| {
+            NetworkXGraph {
+                nodes: self.nodes.clone(),
+                edges: self.edges.clone(),
+                node_indices: self.node_indices.clone(),
+                same_label_fn: self.same_label_fn.as_ref().map(|f| f.clone_ref(py)),
+                same_edge_fn: self.same_edge_fn.as_ref().map(|f| f.clone_ref(py)),
+                same_node_edge_fn: self.same_node_edge_fn.as_ref().map(|f| f.clone_ref(py)),
+                same_label_cache: self.same_label_cache.clone(),
+            }
+        })
+    }
+}
+
+fn convert_to_string(obj: &PyObject) -> PyResult<String> {
+    Python::with_gil(|py| {
+        // Try direct conversion first
+        obj.call_method0(py, "__str__")?.extract::<String>(py)
+            .or_else(|_| {
+                // If that fails, try to convert to a string using repr
+                obj.call_method0(py, "__repr__")?.extract::<String>(py)
+            })
+    })
+}
+
+#[pymethods]
+impl NetworkXGraph {
+    #[new]
+    fn new() -> Self {
+        NetworkXGraph {
+            nodes: Vec::new(),
+            edges: Vec::new(),
+            node_indices: HashMap::new(),
+            same_label_fn: None,
+            same_edge_fn: None,
+            same_node_edge_fn: None, 
+            same_label_cache: None,
+        }
+    }
+
+    // 从NetworkX图转换的静态方法
+    #[staticmethod]
+    fn from_networkx(nx_graph: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let nodes = nx_graph.getattr("nodes")?.call_method1("items", ())?;
+        let edges = nx_graph.getattr("edges")?.call_method1("data", ())?;
+
+        let mut graph = NetworkXGraph::new();
+
+        for node in nodes.try_iter()? {
+            let node = node?;
+            let id = node.call_method1("__getitem__", (0, ))?.extract::<PyObject>()?;
+            let id = convert_to_string(&id)?;
+            let attrs = node.call_method1("__getitem__", (1, ))?.extract::<HashMap<String, PyObject>>()?;
+            graph.add_node(id, attrs);
+        }
+        for edge in edges.try_iter()? {
+            let edge = edge?;
+            let source = edge.call_method1("__getitem__", (0, ))?.extract::<PyObject>()?;
+            let source = convert_to_string(&source)?;
+            let target = edge.call_method1("__getitem__", (1, ))?.extract::<PyObject>()?;
+            let target = convert_to_string(&target)?;
+            let attrs = edge.call_method1("__getitem__", (2, ))?.extract::<HashMap<String, PyObject>>()?;
+            graph.add_edge(source, target, attrs);
+        }
+        
+        Ok(graph)
+    }
+
+    // 转回NetworkX图的方法
+    fn to_networkx(&self, py: Python) -> PyResult<PyObject> {
+        let nx = py.import("networkx")?;
+        let graph = nx.getattr("Graph")?.call0()?;
+
+        // 添加节点
+        for node in &self.nodes {
+            let attrs_dict = PyDict::new(py);
+            for (k, v) in &node.attributes.0 {
+                attrs_dict.set_item(k, v.clone_ref(py))?;
+            }
+            graph.call_method1(
+                "add_node",
+                (node.id.clone(), attrs_dict),
+            )?;
+        }
+
+        // 添加边
+        for edge in &self.edges {
+            let attrs_dict = PyDict::new(py);
+            for (k, v) in &edge.attributes.0 {
+                attrs_dict.set_item(k, v.clone_ref(py))?;
+            }
+            graph.call_method1(
+                "add_edge",
+                (
+                    edge.source.clone(),
+                    edge.target.clone(),
+                    attrs_dict,
+                ),
+            )?;
+        }
+
+        Ok(graph.into())
+    }
+
+    // 其他有用的方法
+    fn add_node(&mut self, id: String, attributes: HashMap<String, PyObject>) {
+        let index = self.nodes.len();
+        self.node_indices.insert(id.clone(), index);
+        let attributes = Attributes(attributes);
+        self.nodes.push(Node { id: index, attributes });
+    }
+
+    fn add_edge(
+        &mut self,
+        source: String,
+        target: String,
+        attributes: HashMap<String, PyObject>,
+    ) {
+        let attributes = Attributes(attributes);
+        let source = *self.node_indices.get(&source).unwrap();
+        let target = *self.node_indices.get(&target).unwrap();
+        self.edges.push(Edge {
+            source,
+            target,
+            attributes,
+        });
+    }
+
+    fn node_count(&self) -> usize {
+        self.nodes.len()
+    }
+
+    fn edge_count(&self) -> usize {
+        self.edges.len()
+    }
+
+    // 获取节点属性
+    fn get_node_attributes(&self, node_id: &str) -> Option<HashMap<String, PyObject>> {
+        self.node_indices.get(node_id).map(|&index| {
+            Python::with_gil(|py| {
+                self.nodes[index].attributes.0.iter()
+                    .map(|(k, v)| (k.clone(), v.clone_ref(py)))
+                    .collect()
+            })
+        })
+    }
+
+    // 获取边属性
+    fn get_edge_attributes(
+        &self,
+        source: &str,
+        target: &str,
+    ) -> Option<HashMap<String, PyObject>> {
+        self.edges
+            .iter()
+            .find(|e| e.source == *self.node_indices.get(source).unwrap() 
+                            && e.target == *self.node_indices.get(target).unwrap())
+            .map(|e| Python::with_gil(|py| {
+                e.attributes.0.iter()
+                    .map(|(k, v)| (k.clone(), v.clone_ref(py)))
+                    .collect()
+            }))
+    }
+
+    fn register_compare_fn(&mut self, compare: Py<PyAny>) {
+        self.same_label_fn = Some(compare);
+    }
+
+    fn register_edge_compare_fn(&mut self, compare: Py<PyAny>) {
+        self.same_edge_fn = Some(compare);
+    }
+
+    fn register_node_edge_compare_fn(&mut self, compare: Py<PyAny>) {
+        self.same_node_edge_fn = Some(compare);
+    }
+
+    fn build_compare_cache(&mut self, other: &NetworkXGraph) {
+        // use rayon::prelude::*;
+        // let cache: HashSet<_> = self.nodes.par_iter().flat_map(|node1| {
+        //     let local: HashSet<_> = other.nodes.par_iter().filter_map(|node2| {
+        //         if self.label_same(node1, node2) {
+        //             Some((node1.id, node2.id))
+        //         } else {
+        //             None
+        //         }
+        //     }).collect();
+        //     local
+        // }).collect();
+
+        let cache: HashSet<_> = self.nodes.iter().flat_map(|node1| {
+            other.nodes.iter().filter_map(|node2| {
+                if self.label_same(node1, node2) {
+                    Some((node1.id, node2.id))
+                } else {
+                    None
+                }
+            }).collect::<HashSet<_>>()
+        }).collect();
+
+        self.same_label_cache = Some(cache);
+    }
+}
+
+impl<'a> Graph<'a> for NetworkXGraph {
+    type Node = Node;
+
+    type Edge = Edge;
+
+    fn nodes(&'a self) -> impl Iterator<Item = &'a Self::Node> {
+        self.nodes.iter()
+    }
+
+    fn edges(&'a self) -> impl Iterator<Item = &'a Self::Edge> {
+        self.edges.iter()
+    }
+
+    fn get_edges_pair(&'a self) -> impl Iterator<Item = (&'a Self::Node, &'a Self::Node)> {
+        let id_map: HashMap<_, _, std::collections::hash_map::RandomState> = HashMap::from_iter(self.nodes.iter().map(|node| (node.id, node)));
+        self.edges.iter().map(|edge| (id_map.get(&edge.source).unwrap().clone(), id_map.get(&edge.target).unwrap().clone()) ).collect::<Vec<_>>().into_iter()
+    }
+
+    fn add_node(&mut self, node: Self::Node) {
+        let index = self.nodes.len();
+        self.node_indices.insert(format!("Node{}.", index), index);
+        self.nodes.push(node);
+    }
+
+    fn add_edge(&mut self, edge: Self::Edge) {
+        self.edges.push(edge);
+    }
+}
+
+fn test_eq(a: &Py<PyAny>, b: &Py<PyAny>) -> bool {
+    Python::with_gil(|py| {
+        match a.call_method1(py, "__eq__", (b,)) {
+            Ok(result) => result.extract::<bool>(py).unwrap_or(false),
+            Err(_) => false
+        }
+    })
+}
+
+fn native_same_label_fn(a: &Attributes, b: &Attributes) -> bool {
+    for (k, v) in &a.0 {
+        if let Some(other_v) = b.0.get(k) {
+            if test_eq(v, other_v) {
+                continue;
+            }
+        } else {
+            return false;
+        }
+    }
+    true
+}
+
+impl<'a> Labeled<'a> for NetworkXGraph {
+    fn label_same(&self, node: &Self::Node, label: &Self::Node) -> bool {
+
+        if let Some(cache) = self.same_label_cache.as_ref() {
+            return cache.contains(&(node.id, label.id));
+        }
+
+        if let Some(compare_fn) = self.same_label_fn.as_ref() {
+            Python::with_gil(|py| {
+                let attr1 = node.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let attr2 = label.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                compare_fn.call1(py,(attr1, attr2)).unwrap().extract::<bool>(py).unwrap()
+            })
+        } else {
+            return native_same_label_fn(&node.attributes, &label.attributes);
+        }
+    }
+
+    fn get_label(&'a self, node: &'a Self::Node) -> &'a impl Label {
+        &node.attributes
+    }
+
+    fn get_edges_pair_label(&'a self) -> impl Iterator<Item = (&'a Self::Node, &'a Self::Node, &'a impl Label)> {
+        let id_map: HashMap<_, _, std::collections::hash_map::RandomState> = HashMap::from_iter(self.nodes.iter().map(|node| (node.id, node)));
+        self.edges.iter().map(move |edge| (id_map.get(&edge.source).unwrap().clone(), id_map.get(&edge.target).unwrap().clone(), &edge.attributes)).collect::<Vec<_>>().into_iter()
+    }
+
+    fn edge_label_same(&self, edge1: &Self::Edge, edge2: &Self::Edge) -> bool {
+        if let Some(compare_fn) = self.same_edge_fn.as_ref() {
+            Python::with_gil(|py| {
+                let attr1 = edge1.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let attr2 = edge2.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                compare_fn.call1(py,(attr1, attr2)).unwrap().extract::<bool>(py).unwrap()
+            })
+        } else {
+            native_same_label_fn(&edge1.attributes, &edge2.attributes)
+        }
+    }
+
+    fn edge_node_label_same(&self, src1: &Self::Node, edge1: &Self::Edge, dst1: &Self::Node, src2: &Self::Node, edge2: &Self::Edge, dst2: &Self::Node) -> bool {
+        if let Some(compare_fn) = self.same_node_edge_fn.as_ref() {
+            Python::with_gil(|py| {
+                let src1_attr = src1.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let dst1_attr = dst1.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let edge1_attr = edge1.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let src2_attr = src2.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let dst2_attr = dst2.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                let edge2_attr = edge2.attributes.0.iter().map(|(k, v)| (k.clone(), v.clone_ref(py))).collect::<HashMap<_, _>>();
+                compare_fn.call1(py,(src1_attr, edge1_attr, dst1_attr, src2_attr, edge2_attr, dst2_attr)).unwrap().extract::<bool>(py).unwrap()
+            })
+        } else {
+            native_same_label_fn(&src1.attributes, &src2.attributes) 
+                && native_same_label_fn(&dst1.attributes, &dst2.attributes) 
+                && native_same_label_fn(&edge1.attributes, &edge2.attributes)
+        }
+    }
+}
+
+impl LabeledAdjacency<'_> for NetworkXGraph {}
+
+impl std::fmt::Display for NetworkXGraph {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "NetworkXGraph(\n")?;
+        write!(f, "Nodes: [\n")?;
+        for node in &self.nodes {
+            write!(f, "  {},\n", node)?;
+        }
+        write!(f, "],\n")?;
+        write!(f, "Edges: [\n")?;
+        for edge in &self.edges {
+            write!(f, "{} -> {}, ", edge.source, edge.target)?;
+        }
+        write!(f, "]\n")?;
+        write!(f, ")")
+    }
+}
+
+fn to_nx_node(py: Python, node: &Node) -> PyResult<PyObject> {
+    let attrs_dict = PyDict::new(py);
+    for (k, v) in &node.attributes.0 {
+        attrs_dict.set_item(k, v.clone_ref(py))?;
+    }
+    let nx = py.import("networkx")?;
+    let node = nx.getattr("Node")?.call1((node.id.clone(), attrs_dict))?;
+    Ok(node.into())
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, is_label_cached = false))]
+pub fn get_simulation_inter(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, is_label_cached: bool) -> PyResult<PyObject> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    let sim = graph1.get_simulation_inter(&graph2);
+    
+
+    // Convert simulation to a list of pairs (i, j) where i is a node in graph1, j is a node in graph2
+    Python::with_gil(|py| {
+        let map = PyDict::new(py);
+        
+        for (node, set) in sim.iter() {
+            let py_set = PySet::new(py, set.iter().map(|node| to_nx_node(py, node)).collect::<PyResult<Vec<_>>>()?)?;
+            map.set_item(to_nx_node(py, node)?, py_set)?;
+        }
+    
+        Ok(map.into())
+    })
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, is_label_cached = false))]
+pub fn is_simulation_isomorphic(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, is_label_cached: bool) -> PyResult<bool> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    Ok(NetworkXGraph::has_simulation(graph1.get_simulation_inter(&graph2)))
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, compare, is_label_cached = false))]
+pub fn get_simulation_inter_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, compare: Py<PyAny>, is_label_cached: bool) -> PyResult<PyObject> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+
+    graph1.register_compare_fn(compare);
+    
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    let sim = graph1.get_simulation_inter(&graph2);
+
+    Python::with_gil(|py| {
+        let map = PyDict::new(py);
+        
+        for (node, set) in sim.iter() {
+            let py_set = PySet::new(py, set.iter().map(|node| to_nx_node(py, node)).collect::<PyResult<Vec<_>>>()?)?;
+            map.set_item(to_nx_node(py, node)?, py_set)?;
+        }
+    
+        Ok(map.into())
+    })
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, compare, is_label_cached = false))]
+pub fn is_simulation_isomorphic_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, compare: Py<PyAny>, is_label_cached: bool) -> PyResult<bool> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+    
+    graph1.register_compare_fn(compare);
+
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    Ok(NetworkXGraph::has_simulation(graph1.get_simulation_inter(&graph2)))
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, node_compare, edge_compare, is_label_cached = false))]
+pub fn is_simulation_isomorphic_of_node_edge_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, node_compare: Py<PyAny>, edge_compare: Py<PyAny>, is_label_cached: bool) -> PyResult<bool> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+    
+    graph1.register_compare_fn(node_compare);
+    graph1.register_edge_compare_fn(edge_compare);
+
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    Ok(NetworkXGraph::has_simulation(graph1.get_simulation_of_node_edge(&graph2)))
+}
+
+#[pyfunction]
+#[pyo3(signature = (nx_graph1, nx_graph2, node_edge_compare, is_label_cached = false))]
+pub fn is_simulation_isomorphic_of_edge_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, node_edge_compare: Py<PyAny>, is_label_cached: bool) -> PyResult<bool> {
+    let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
+    let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
+    
+    graph1.register_node_edge_compare_fn(node_edge_compare);
+
+    if is_label_cached {
+        graph1.build_compare_cache(&graph2);
+    }
+
+    Ok(NetworkXGraph::has_simulation(graph1.get_simulation_of_edge(&graph2)))
+}
+
+impl Directed for NetworkXGraph {}
+
+impl Adjacency<'_> for NetworkXGraph {}
+
+impl AdjacencyInv<'_> for NetworkXGraph {}
+
+// 模块定义
+// #[pymodule]
+// pub fn networkx_graph(_py: Python, m: &PyModule) -> PyResult<()> {
+//     m.add_class::<NetworkXGraph>()?;
+//     Ok(())
+// }

simulation_alg-0.1.0/src/lib.rs

@@ -0,0 +1,17 @@
+pub mod graph;
+pub mod utils;
+
+use pyo3::prelude::*;
+
+
+#[pymodule]
+fn simulation(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    graph::register_graph_module(m)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::get_simulation_inter, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::get_simulation_inter_fn, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_fn, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_of_edge_fn, m)?)?;
+    m.add_function(wrap_pyfunction!(graph::networkx_graph::is_simulation_isomorphic_of_node_edge_fn, m)?)?;
+    Ok(())
+}

simulation_alg-0.1.0/src/utils.rs

@@ -0,0 +1,2 @@
+use pyo3::prelude::*;
+

simulation_alg-0.1.0/tests/test_simulation.py

@@ -0,0 +1,75 @@
+from math import e
+import time
+import simulation
+import networkx as nx
+import os
+
+# Get the directory where the current file is located
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+simulation_test_path = os.path.join(current_dir, "lib/graph-simulation/data/label_graph/simulation_test")
+# Read all files in simulation_test_path
+files = []
+if os.path.exists(simulation_test_path):
+    for file_name in os.listdir(simulation_test_path):
+        file_path = os.path.join(simulation_test_path, file_name)
+        if os.path.isfile(file_path):
+            files.append(file_path)
+
+def attr_same(attr1: dict, attr2: dict):
+    label1 = attr1.get("label")
+    label2 = attr2.get("label")
+    return label1 == label2
+
+times_cost = 0
+
+for path in files:
+    with open(path, "r") as f:
+        lines = f.readlines()
+        # Get the first line of the file
+        is_isomorphic = True if lines[0].strip() == "t" else False
+        
+        index = 1
+        # Get the first graph
+        graph1 = nx.DiGraph()
+        graph1_nodes, graph1_edges, graph1_labels = map(int, lines[index].strip().split())
+        index += 1
+        for i in range(index, index + graph1_nodes):
+            idx, label = lines[i].strip().split()
+            graph1.add_node(idx, label=label)
+            
+        index += graph1_nodes
+        
+        for i in range(index, index + graph1_edges):
+            u, v = map(int, lines[i].strip().split())
+            graph1.add_edge(u, v)
+        
+        index += graph1_edges
+        
+        # Get the second graph
+        
+        graph2 = nx.DiGraph()
+        
+        graph2_nodes, graph2_edges, graph2_labels = map(int, lines[index].strip().split())
+        index += 1
+        for i in range(index, index + graph2_nodes):
+            idx, label = lines[i].strip().split()
+            graph2.add_node(idx, label=label)
+            
+        index += graph2_nodes
+        
+        for i in range(index, index + graph2_edges):
+            u, v = map(int, lines[i].strip().split())
+            graph2.add_edge(u, v)
+            
+        
+        start = time.time()
+        is_simulation = simulation.is_simulation_isomorphic_fn(graph1, graph2, attr_same)
+        end = time.time()
+        times_cost += end - start
+        
+        if is_isomorphic != is_simulation and is_isomorphic:
+            print("Test failed for file", path)
+
+
+print("Time taken:", times_cost)