simulation-alg 0.1.5__tar.gz → 0.1.6__tar.gz

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/Cargo.lock

@@ -188,9 +188,9 @@ dependencies = [
 
 [[package]]
 name = "graph-simulation"
-version = "0.1.14"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b87bfc6e277b4022afe3108e71a374642b0aaceb42ea3dbeedfdd2aeb5e6ea59"
+checksum = "3c2137012fbaf6b3428ea73e32e93e1f7c90c13d6edbfd687f6cc1021b8ab83a"
 dependencies = [
  "bincode",
  "env_logger",
@@ -297,9 +297,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.20.2"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "once_cell_polyfill"
@@ -342,11 +342,10 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.5"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+checksum = "37a6df7eab65fc7bee654a421404947e10a0f7085b6951bf2ea395f4659fb0cf"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -360,19 +359,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.5"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+checksum = "f77d387774f6f6eec64a004eac0ed525aab7fa1966d94b42f743797b3e395afb"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.5"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+checksum = "2dd13844a4242793e02df3e2ec093f540d948299a6a77ea9ce7afd8623f542be"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -380,9 +378,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.5"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+checksum = "eaf8f9f1108270b90d3676b8679586385430e5c0bb78bb5f043f95499c821a71"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -392,9 +390,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.5"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+checksum = "70a3b2274450ba5288bc9b8c1b69ff569d1d61189d4bff38f8d22e03d17f932b"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -545,7 +543,7 @@ dependencies = [
 
 [[package]]
 name = "simulation"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "graph-base",
  "graph-simulation",
@@ -566,9 +564,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
 
 [[package]]
 name = "unicode-ident"

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "simulation"
-version = "0.1.4"
+version = "0.1.6"
 edition = "2021"
 license = "MIT"
 description = "A Python package for simulation algorithms"
@@ -13,8 +13,8 @@ name = "simulation"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.23", features = ["extension-module"] }
-graph-simulation = "0.1.14"
+pyo3 = { version = "0.27.1", features = ["extension-module"] }
+graph-simulation = "0.1.20"
 graph-base = "0.1.13"
 rayon = "1.10.0"
 # [tool.maturin]

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulation-alg
-Version: 0.1.5
+Version: 0.1.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "simulation-alg"
-version = "0.1.5"
+version = "0.1.6"
 requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Rust",

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/simulation.pyi

@@ -48,6 +48,19 @@ class Hyperedge:
     def __init__(self, id_set: set[int], desc: str, id: int): ...
     def id_set(self) -> set[int]: ...
     def desc(self) -> str: ...
+    
+
+class DMatch:
+    """
+    D-Match for hyper simulation 
+    """
+    def __init__(self) -> None: ...
+    @staticmethod
+    def from_dict(d_match_by_sc_id: dict[tuple[int, int], set[tuple[int, int]]]) -> 'DMatch': ...
+
+class Delta:
+    def __init__(self) -> None: ...
+    def add_sematic_cluster_pair(self, u: Node, v: Node, cluster_u: list[Hyperedge], cluster_v: list[Hyperedge]) -> int: ...
 
 class Hypergraph:
     """
@@ -74,5 +87,11 @@ class Hypergraph:
     @staticmethod
     def soft_hyper_simulation(query: 'Hypergraph', data: 'Hypergraph', l_match_fn: Callable[[Hyperedge, Hyperedge], dict[int, set[int]]]) -> dict[int, set[int]]:
         """
-        Hyper simulation.
+        Soft hyper simulation.
+        """
+        
+    @staticmethod
+    def get_hyper_simulation(query: 'Hypergraph', data: 'Hypergraph', delta: Delta, d_match: DMatch) -> dict[int, set[int]]:
+        """
+        Hyper Simulation
         """

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/src/graph/hypergraph.rs

@@ -1,7 +1,7 @@
 use std::{collections::{HashMap, HashSet}, fmt::Display, hash::Hash};
 
-use pyo3::prelude::*;
-use graph_simulation::algorithm::hyper_simulation::{HyperSimulation, LMatch, LPredicate};
+use pyo3::{prelude::*, types::PyList};
+use graph_simulation::algorithm::hyper_simulation::{DMatch, Delta, HyperSimulation, LMatch, LPredicate, SematicCluster};
 use graph_base::interfaces::{edge, graph::{self, SingleId}, hypergraph::{self, ContainedHyperedge}, typed, vertex};
 // use graph_base::interfaces::hypergraph;
 
@@ -144,6 +144,15 @@ impl Hypergraph {
             .map(|(k, v)| (k.id(), v.into_iter().map(|n| n.id()).collect()))
             .collect()
     }
+
+    #[staticmethod]
+    pub fn get_hyper_simulation(query: PyRef<Hypergraph>, data: PyRef<Hypergraph>, delta: PyRef<DeltaPy>, d_match: PyRef<DMatchImpl>) -> HashMap<usize, HashSet<usize>> {
+        let delta_inner = DeltaImpl::from(delta.clone(), &*query, &*data);
+        let sim = HyperSimulation::get_hyper_simulation_naive(&*query, &*data, &delta_inner, &*d_match);
+        sim.into_iter()
+            .map(|(k, v)| (k.id(), v.into_iter().map(|n| n.id()).collect()))
+            .collect()
+    }
 }
 
 impl Display for Node {
@@ -216,8 +225,8 @@ impl<'a> typed::Typed<'a> for Hypergraph {
             // You cannot pass Rust trait objects directly to Python.
             // Instead, you need to define what data you want to compare and pass only that.
             // For example, if your Type trait has an id() method, you could do:
-            Python::with_gil(|py| {
-                type_same_fn.call1(py, (&x.desc, &y.desc)).map_or(false, |result| {
+            Python::attach(|py| {
+                type_same_fn.call1(py, (&x.id, &y.id)).map_or(false, |result| {
                     result.extract::<bool>(py).unwrap_or(false)
                 })
             })
@@ -229,6 +238,8 @@ impl<'a> typed::Typed<'a> for Hypergraph {
 
 impl<'a> ContainedHyperedge<'a> for Hypergraph {}
 
+
+
 #[pyclass(name = "LMatch")]
 pub struct LMatchImpl {
     l_match_fn: Option<Py<PyAny>>, // (Hyperedge, Hyperedge) -> dict[int, set[int]]
@@ -275,7 +286,7 @@ impl LMatch for LMatchImpl {
     fn l_match_with_node_mut(&mut self, e: &Self::Edge, e_prime: &Self::Edge, u: usize) -> &HashSet<usize> {
         let l_match = self.l_match_cache.entry((e.id, e_prime.id)).or_insert_with(|| {
             if let Some(l_match_fn) = self.l_match_fn.as_ref() {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 l_match_fn.call1(py, (e.clone(), e_prime.clone())).map_or_else(
                     |_| HashMap::new(),
                     |result| result.extract::<HashMap<usize, HashSet<usize>>>(py).unwrap_or_default(),
@@ -315,7 +326,7 @@ impl<'a> LPredicate<'a> for Hypergraph {
 
     fn l_predicate_edge(&'a self, e: &'a Self::Edge, e_prime: &'a Self::Edge) -> bool {
         if let Some(l_predicate_fn) = self.l_predicate_fn.as_ref() {
-            Python::with_gil(|py| {
+            Python::attach(|py| {
                 l_predicate_fn.call1(py, (e.clone(), e_prime.clone())).map_or(false, |result| {
                     result.extract::<bool>(py).unwrap_or(false)
                 })
@@ -331,6 +342,123 @@ impl<'a> LPredicate<'a> for Hypergraph {
     }
 }
 
+#[pyclass(name = "DMatch")]
+pub struct DMatchImpl {
+    d_match_cache: HashMap<(usize, usize), HashSet<(usize, usize)>>,
+}
+
+impl<'a> DMatch<'a> for DMatchImpl {
+    type Edge = Hyperedge;
+
+    fn d_match(&self, e: &SematicCluster<'a, Self::Edge>, e_prime: &SematicCluster<'a, Self::Edge>) -> &HashSet<(usize, usize)> {
+        if let Some(set) = self.d_match_cache.get(&(e.id(), e_prime.id())) {
+            return set;
+        }
+        unreachable!("D-Match not exist at ({}, {})", e.id(), e_prime.id())
+    }
+
+    // fn d_match_mut(&mut self, e: &SematicCluster<'a, Self::Edge>, e_prime: &SematicCluster<'a, Self::Edge>) -> &HashSet<(usize, usize)> {
+    //     todo!()
+    // }
+}
+
+
+
+#[pymethods]
+impl DMatchImpl {
+    #[new]
+    fn new() -> Self {
+        DMatchImpl {
+            d_match_cache: HashMap::new()
+        }
+    }
+
+    #[staticmethod]
+    fn from_dict(d_match_by_sc_id: HashMap<(usize, usize), HashSet<(usize, usize)>>) -> Self {
+        DMatchImpl {
+            d_match_cache: d_match_by_sc_id
+        }
+    }
+}
+
+// #[pyclass(name = "Delta")]
+struct DeltaImpl<'a> {
+    sematic_cluster: HashMap<(&'a Node, &'a Node), Vec<(SematicCluster<'a, Hyperedge>, SematicCluster<'a, Hyperedge>)>>
+}
+
+impl<'a> Delta<'a> for DeltaImpl<'a> {
+    type Edge = Hyperedge;
+    type Node = Node;
+
+    fn get_sematic_clusters(&'a self, u: &'a Self::Node, v: &'a Self::Node) -> &'a Vec<(SematicCluster<'a, Self::Edge>, SematicCluster<'a, Self::Edge>)> {
+        if let Some(pairs) = self.sematic_cluster.get(&(u, v)) {
+            return pairs;
+        }
+        unreachable!("Have no sematic_clusters between {} to {}", u, v)
+    }
+}
+
+impl<'a> DeltaImpl<'a> {
+    fn from(delta: DeltaPy, query: &'a Hypergraph, data: &'a Hypergraph) -> Self {
+        let mut pair_map: HashMap<(&Node, &Node), Vec<(SematicCluster<'a, Hyperedge>, SematicCluster<'a, Hyperedge>)>> = HashMap::new();
+        for ((u_id, v_id), pairs) in delta.sematic_cluster_cache {
+            let u = query.nodes.get(u_id).unwrap();
+            let v = data.nodes.get(v_id).unwrap();
+            for ((q_edges_ids, q_id), (d_edges_ids, d_id)) in pairs {
+                let q_edges: Vec<&Hyperedge> = q_edges_ids.iter().map(|id| {
+                    query.hyperedges.get(*id).unwrap()
+                }).collect();
+                let d_edges: Vec<&Hyperedge> = d_edges_ids.iter().map(|id| {
+                    data.hyperedges.get(*id).unwrap()
+                }).collect();
+
+                let sc_q = SematicCluster::new(q_id, q_edges);
+                let sc_d = SematicCluster::new(d_id, d_edges);
+
+                pair_map.entry((u, v)).or_default().push((sc_q, sc_d));
+            }
+        } 
+        let res = DeltaImpl {
+            sematic_cluster: pair_map
+        };
+
+        return res;
+    }
+
+
+}
+
+#[derive(Clone)]
+#[pyclass(name = "Delta")]
+pub struct DeltaPy {
+    sematic_cluster_cache: HashMap<(usize, usize), Vec<((Vec<usize>, usize), (Vec<usize>, usize))>>,
+    global_cnt: usize
+}
+
+#[pymethods]
+impl DeltaPy {
+    #[new]
+    fn new() -> Self {
+        DeltaPy {
+            sematic_cluster_cache: HashMap::new(),
+            global_cnt: 0
+        }
+    }
+
+    fn add_sematic_cluster_pair(&mut self, u: PyRef<Node>, v: PyRef<Node>, cluster_u: Vec<PyRef<Hyperedge>>, cluster_v: Vec<PyRef<Hyperedge>>) -> usize {
+        let id = self.global_cnt;
+        self.global_cnt += 1;
+        let u_ids: Vec<_> = cluster_u.iter().map(|e_ref| {
+            e_ref.id
+        }).collect();
+        let v_ids: Vec<_> = cluster_v.iter().map(|e_ref| {
+            e_ref.id
+        }).collect();
+        self.sematic_cluster_cache.entry((u.id, v.id)).or_default().push(((u_ids, id), (v_ids, id)));
+        return id;
+    }
+}
+
 // fn test_sim(g: &Hypergraph, h: &Hypergraph)  {
 //     let mut l_match = LMatchImpl::new();
 //     let sim = HyperSimulation::get_simulation_naive(g, h, &mut l_match);

{simulation_alg-0.1.5 → simulation_alg-0.1.6}/src/graph/networkx_graph.rs

@@ -8,10 +8,10 @@ use graph_base::interfaces::graph::{Graph, Directed, Adjacency, AdjacencyInv, Si
 use pyo3::prelude::*;
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
-use std::path::Display;
-use std::sync::Arc;
+// use std::path::Display;
+// use std::sync::Arc;
 
-type SharedRustFn = Arc<dyn Fn(&Attributes, &Attributes) -> bool + Send + Sync>;
+// type SharedRustFn = Arc<dyn Fn(&Attributes, &Attributes) -> bool + Send + Sync>;
 
 
 // 自定义图结构
@@ -21,7 +21,7 @@ struct Attributes(HashMap<String, Py<PyAny>>);
 
 impl Clone for Attributes {
     fn clone(&self) -> Self {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let cloned_map = self.0.iter()
                 .map(|(k, v)| (k.clone(), v.clone_ref(py)))
                 .collect();
@@ -50,7 +50,7 @@ impl PartialEq for Attributes {
             return false;
         }
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             self.0.iter().all(|(key, value)| {
                 match other.0.get(key) {
                     Some(other_value) => {
@@ -74,7 +74,7 @@ impl Hash for Attributes {
         let mut entries: Vec<_> = self.0.iter().collect();
         entries.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             for (key, value) in entries {
                 key.hash(state);
                 // 使用 Python 对象的 __hash__ 方法
@@ -144,7 +144,7 @@ pub struct NetworkXGraph {
 
 impl Clone for NetworkXGraph {
     fn clone(&self) -> Self {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             NetworkXGraph {
                 nodes: self.nodes.clone(),
                 edges: self.edges.clone(),
@@ -158,8 +158,8 @@ impl Clone for NetworkXGraph {
     }
 }
 
-fn convert_to_string(obj: &PyObject) -> PyResult<String> {
-    Python::with_gil(|py| {
+fn convert_to_string(obj: &Py<PyAny>) -> PyResult<String> {
+    Python::attach(|py| {
         // Try direct conversion first
         obj.call_method0(py, "__str__")?.extract::<String>(py)
             .or_else(|_| {
@@ -391,7 +391,7 @@ impl<'a> Graph<'a> for NetworkXGraph {
 }
 
 fn test_eq(a: &Py<PyAny>, b: &Py<PyAny>) -> bool {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         match a.call_method1(py, "__eq__", (b,)) {
             Ok(result) => result.extract::<bool>(py).unwrap_or(false),
             Err(_) => false
@@ -420,7 +420,7 @@ impl<'a> Labeled<'a> for NetworkXGraph {
         }
 
         if let Some(compare_fn) = self.same_label_fn.as_ref() {
-            Python::with_gil(|py| {
+            Python::attach(|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()
@@ -441,7 +441,7 @@ impl<'a> Labeled<'a> for NetworkXGraph {
 
     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| {
+            Python::attach(|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()
@@ -453,7 +453,7 @@ impl<'a> Labeled<'a> for NetworkXGraph {
 
     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| {
+            Python::attach(|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<_, _>>();
@@ -489,7 +489,7 @@ impl std::fmt::Display for NetworkXGraph {
     }
 }
 
-fn to_nx_node(py: Python, node: &Node) -> PyResult<PyObject> {
+fn to_nx_node(py: Python, node: &Node) -> PyResult<Py<PyAny>> {
     let attrs_dict = PyDict::new(py);
     for (k, v) in &node.attributes.0 {
         attrs_dict.set_item(k, v.clone_ref(py))?;
@@ -501,7 +501,7 @@ fn to_nx_node(py: Python, node: &Node) -> PyResult<PyObject> {
 
 #[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> {
+pub fn get_simulation_inter(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, is_label_cached: bool) -> PyResult<Py<PyAny>> {
     let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
     let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
 
@@ -513,7 +513,7 @@ pub fn get_simulation_inter(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_,
     
 
     // 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| {
+    Python::attach(|py| {
         let map = PyDict::new(py);
         
         for (node, set) in sim.iter() {
@@ -540,7 +540,7 @@ pub fn is_simulation_isomorphic(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<
 
 #[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> {
+pub fn get_simulation_inter_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'_, PyAny>, compare: Py<PyAny>, is_label_cached: bool) -> PyResult<Py<PyAny>> {
     let mut graph1 = NetworkXGraph::from_networkx(nx_graph1)?;
     let graph2 = NetworkXGraph::from_networkx(nx_graph2)?;
 
@@ -552,7 +552,7 @@ pub fn get_simulation_inter_fn(nx_graph1: &Bound<'_, PyAny>, nx_graph2: &Bound<'
 
     let sim = graph1.get_simulation_inter(&graph2);
 
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let map = PyDict::new(py);
         
         for (node, set) in sim.iter() {