simulation-alg 0.1.7__tar.gz → 0.1.9__tar.gz

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/Cargo.lock

@@ -177,9 +177,9 @@ dependencies = [
 
 [[package]]
 name = "graph-base"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "985b3629de3172005640f8f4ba46b738c605682db2776ecf4dd73a42ce55325f"
+checksum = "1c337eeba84f9bf9bd65f89631119a34215bf46251e751abc1a6819195d71287"
 dependencies = [
  "lazy_static",
  "rand",
@@ -188,9 +188,9 @@ dependencies = [
 
 [[package]]
 name = "graph-simulation"
-version = "0.1.20"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c2137012fbaf6b3428ea73e32e93e1f7c90c13d6edbfd687f6cc1021b8ab83a"
+checksum = "3744a0d1d724cad58fef5eee7383bcdc3cd318952f4611ca9f3916fe0bf01e46"
 dependencies = [
  "bincode",
  "env_logger",
@@ -543,7 +543,7 @@ dependencies = [
 
 [[package]]
 name = "simulation"
-version = "0.1.7"
+version = "0.1.8"
 dependencies = [
  "graph-base",
  "graph-simulation",

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/Cargo.toml

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

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/PKG-INFO

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

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/pyproject.toml

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

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/simulation.pyi

@@ -49,7 +49,17 @@ class Hyperedge:
     def id_set(self) -> set[int]: ...
     def desc(self) -> str: ...
     
+class Event:
+    """
+    Event class.
+    """
+    phrase: str
+    sc_id: int
+    binary_relation: set[tuple[int, int]]
+    
+    def __init__(self, phrase: str, sc_id: int, binary_relation: set[tuple[int, int]]): ...
 
+# (cluster_u, cluster_v)
 class DMatch:
     """
     D-Match for hyper simulation 
@@ -62,13 +72,16 @@ class DMatch:
     For a sematic cluster pair by `id`, we set map[(id, id)] = R as the relation, where (u_id, v_id) in R, are node's id.
     """
 
-class Delta:
+class Delta: # Delta(u, v) 
     def __init__(self) -> None: ...
     def add_sematic_cluster_pair(self, u: Node, v: Node, cluster_u: list[Hyperedge], cluster_v: list[Hyperedge]) -> int: ...
     """
     Add a sematic of (u, v), register a id of the pair that, (cluster_u, id) and (cluster_v, id) 
     """
 
+# (u, v) (cluster_u, cluster_v)
+# (u', v') 
+
 class Hypergraph:
     """
     Hypergraph class.
@@ -88,6 +101,11 @@ class Hypergraph:
     
     def get_node_desc_by_id(self, node_id: int) -> Optional[str]: ...
     
+    def get_hyper_simulation_trace(self) -> list[Event]: 
+        """
+        Get trace events of last time hyper simulation.
+        """
+    
     @staticmethod
     def hyper_simulation(query: 'Hypergraph', data: 'Hypergraph', l_match_fn: Callable[[Hyperedge, Hyperedge], dict[int, set[int]]]) -> dict[int, set[int]]:
         """
@@ -105,3 +123,4 @@ class Hypergraph:
         """
         Hyper Simulation
         """
+

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/src/graph/hypergraph.rs

@@ -1,8 +1,9 @@
 use std::{collections::{HashMap, HashSet}, fmt::Display, hash::Hash};
 
 use pyo3::{prelude::*, types::PyList};
-use graph_simulation::algorithm::hyper_simulation::{DMatch, Delta, HyperSimulation, LMatch, LPredicate, SematicCluster};
+use graph_simulation::{algorithm::hyper_simulation::{DMatch, Delta, HSEvent, HyperSimulation, HyperSimulationTrace, LMatch, LPredicate, SematicCluster}, utils::logger::TraceLog};
 use graph_base::interfaces::{edge, graph::{self, SingleId}, hypergraph::{self, ContainedHyperedge}, typed, vertex};
+
 // use graph_base::interfaces::hypergraph;
 
 #[derive(Clone, Debug, Eq)]
@@ -86,6 +87,25 @@ pub struct Hypergraph {
     l_predicate_fn: Option<Py<PyAny>>, // (Hyperedge, Hyperedge) -> bool
 }
 
+#[pyclass(name = "Event")]
+pub struct Event {
+    pub phrase: String,
+    pub sc_id: usize,
+    pub binary_relation: HashSet<(usize, usize)>
+}
+
+#[pymethods]
+impl Event {
+    #[new]
+    pub fn new(phrase: String, sc_id: usize, binary_relation: HashSet<(usize, usize)>) -> Self {
+        Event {
+            phrase,
+            sc_id,
+            binary_relation,
+        }
+    }
+}
+
 #[pymethods]
 impl Hypergraph {
     #[new]
@@ -153,6 +173,25 @@ impl Hypergraph {
             .map(|(k, v)| (k.id(), v.into_iter().map(|n| n.id()).collect()))
             .collect()
     }
+
+    pub fn get_hyper_simulation_trace(&self) -> Vec<Event> {
+        let trace = HyperSimulationTrace::get_trace("hyper_simulation.trace").unwrap();
+        let events = trace.into_iter().map(|event| {
+            match event {
+                HSEvent::Base(sc_id, relation) => Event {
+                    phrase: "base".to_string(),
+                    sc_id,
+                    binary_relation: relation
+                },
+                HSEvent::Derivation(sc_id, relation) => Event {
+                    phrase: "derivation".to_string(),
+                    sc_id,
+                    binary_relation: relation
+                }
+            }
+        }).collect();
+        events
+    }
 }
 
 impl Display for Node {
@@ -381,9 +420,8 @@ impl DMatchImpl {
     }
 }
 
-// #[pyclass(name = "Delta")]
 struct DeltaImpl<'a> {
-    sematic_cluster: HashMap<(&'a Node, &'a Node), Vec<(SematicCluster<'a, Hyperedge>, SematicCluster<'a, Hyperedge>)>>
+    sematic_cluster: HashMap<(&'a Node, &'a Node), Vec<(SematicCluster<'a, Hyperedge>, SematicCluster<'a, Hyperedge>)>>,
 }
 
 impl<'a> Delta<'a> for DeltaImpl<'a> {
@@ -414,12 +452,16 @@ impl<'a> DeltaImpl<'a> {
 
                 let sc_q = SematicCluster::new(q_id, q_edges);
                 let sc_d = SematicCluster::new(d_id, d_edges);
+                // Update sematic_cluster_cache
 
+                // sematic_cluster_cache.insert((&sc_q, &sc_d), q_id);
+                
                 pair_map.entry((u, v)).or_default().push((sc_q, sc_d));
             }
         } 
+
         let res = DeltaImpl {
-            sematic_cluster: pair_map
+            sematic_cluster: pair_map,
         };
 
         return res;
@@ -431,7 +473,7 @@ impl<'a> DeltaImpl<'a> {
 #[derive(Clone)]
 #[pyclass(name = "Delta")]
 pub struct DeltaPy {
-    sematic_cluster_cache: HashMap<(usize, usize), Vec<((Vec<usize>, usize), (Vec<usize>, usize))>>,
+    sematic_cluster_cache: HashMap<(usize, usize), Vec<((Vec<usize>, usize), (Vec<usize>, usize))>>, // (u_id, v_id) -> Vec<((q_edge_ids, sc_id), (d_edge_ids, sc_id))>
     global_cnt: usize
 }
 

{simulation_alg-0.1.7 → simulation_alg-0.1.9}/src/lib.rs

@@ -11,6 +11,10 @@ fn simulation(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<graph::hypergraph::Node>()?;
     m.add_class::<graph::hypergraph::Hyperedge>()?;
     m.add_class::<graph::hypergraph::LMatchImpl>()?;
+    m.add_class::<graph::hypergraph::DeltaPy>()?;
+    m.add_class::<graph::hypergraph::DMatchImpl>()?;
+    m.add_class::<graph::hypergraph::Event>()?;
+
     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)?)?;

simulation_alg-0.1.9/test.py

@@ -0,0 +1,57 @@
+import simulation
+
+from simulation import *
+query = Hypergraph()
+query.add_node("a") # id 0
+query.add_node("b") # id 1
+query.add_node("c") # id 2
+query.add_hyperedge(Hyperedge({0, 1}, "e1", 0))
+query.add_hyperedge(Hyperedge({1, 2}, "e2", 1))
+query.add_hyperedge(Hyperedge({0, 2}, "e3", 2))
+
+data = Hypergraph()
+data.add_node("a")
+data.add_node("b")
+data.add_node("c")
+data.add_hyperedge(Hyperedge({0, 1}, "e1", 0))
+data.add_hyperedge(Hyperedge({1, 2}, "e2", 1))
+data.add_hyperedge(Hyperedge({0, 2}, "e3", 2))
+
+# register type_same
+
+query_vertices = []
+data_vertices = []
+
+m1= {}
+
+for u in query_vertices:
+    for v in data_vertices:
+        # nli,
+        m1[u, v] = True
+
+query.set_type_same_fn(lambda x_id, y_id: m1[x_id, y_id])
+
+delta = Delta()
+
+likely_vertices = []
+m2 = {}
+
+for (u, v) in likely_vertices:
+    pairs = []
+    for pair in pairs:
+        delta.add_sematic_cluster_pair(u, v, pair[0], pair[1])
+        
+
+
+
+matches = {}
+for (u, v), pair in m2.items():
+    matches[u, v] = [(1, 2)]
+    
+d_match = DMatch.from_dict(matches)
+
+
+
+sim = Hypergraph.get_hyper_simulation(query, data, delta, d_match)
+
+# set[tuple[int, int]]