submine 0.1.0__cp311-cp311-musllinux_1_2_x86_64.whl

submine/backends/gspan/python_bindings.cpp

@@ -0,0 +1,133 @@
+#include <./pybind11/pybind11.h>
+#include <./pybind11/stl.h>
+
+#include <sstream>
+#include <unordered_set>
+#include <vector>
+#include <utility>
+#include <cstdint>
+#include <algorithm>
+
+#include "gspan.h"
+
+namespace py = pybind11;
+
+// Hash for pair<int,int>
+struct PairHash {
+    std::size_t operator()(const std::pair<int,int>& p) const noexcept {
+        return (static_cast<std::size_t>(p.first) << 32) ^ static_cast<std::size_t>(p.second);
+    }
+};
+
+static py::dict graph_to_dict(const GSPAN::Graph& g,
+                              unsigned int support,
+                              const GSPAN::Projected* projected,
+                              bool directed)
+{
+    py::dict d;
+    const int n = static_cast<int>(g.size());
+
+    std::vector<int> nodes;
+    nodes.reserve(n);
+
+    std::vector<int> node_labels;
+    node_labels.reserve(n);
+
+    for (int i = 0; i < n; ++i) {
+        nodes.push_back(i);
+        node_labels.push_back(static_cast<int>(g[i].label));
+    }
+
+    std::vector<std::pair<int,int>> edges;
+    std::vector<int> edge_labels;
+
+    // IMPORTANT: raw extraction, no dedup
+    for (int u = 0; u < n; ++u) {
+        for (const auto& e : g[u].edge) {
+            edges.emplace_back(u, static_cast<int>(e.to));
+            edge_labels.push_back(static_cast<int>(e.elabel));
+        }
+    }
+
+
+    d["nodes"] = std::move(nodes);
+    d["edges"] = std::move(edges);
+    d["node_labels"] = std::move(node_labels);
+    d["edge_labels"] = std::move(edge_labels);
+    d["support"] = support;
+
+    // Graph IDs (gid) where pattern occurs.
+    // In your code: PDFS.id is "ID of the original input graph"
+    if (projected) {
+        std::unordered_set<unsigned int> uniq;
+        uniq.reserve(projected->size());
+
+        std::vector<unsigned int> gids;
+        gids.reserve(projected->size());
+
+        for (const auto& p : *projected) {
+            unsigned int gid = p.id;   // <-- this is your gid
+            if (uniq.insert(gid).second) gids.push_back(gid);
+        }
+
+        std::sort(gids.begin(), gids.end());
+        d["graph_ids"] = std::move(gids);
+    } else {
+        d["graph_ids"] = py::none();
+    }
+
+    return d;
+}
+
+
+static std::vector<py::dict> mine_from_string(const std::string& gspan_data,
+                                              unsigned int minsup,
+                                              unsigned int maxpat_min,
+                                              unsigned int maxpat_max,
+                                              bool enc,
+                                              bool where,
+                                              bool directed)
+{
+    std::istringstream is(gspan_data);
+    std::ostringstream null_out; // discard textual output by default
+
+    GSPAN::gSpan miner;
+    std::vector<py::dict> results;
+    results.reserve(1024);
+
+    miner.set_callback([&](const GSPAN::Graph& pattern,
+                           unsigned int sup,
+                           const GSPAN::Projected* projected)
+    {
+       results.push_back(graph_to_dict(pattern, sup, projected, directed));
+
+    });
+
+    miner.run(is, null_out, minsup, maxpat_min, maxpat_max, enc, where, directed);
+    return results;
+}
+
+PYBIND11_MODULE(gspan_cpp, m) {
+    m.doc() = "Pure C++ gSpan bindings (structured results)";
+
+    m.def("mine_from_string",
+          &mine_from_string,
+          py::arg("gspan_data"),
+          py::arg("minsup") = 1,
+          py::arg("maxpat_min") = 0,
+          py::arg("maxpat_max") = 0xffffffffu,
+          py::arg("enc") = false,
+          py::arg("where") = false,
+          py::arg("directed") = false,
+          R"pbdoc(
+Mine frequent subgraphs from a gSpan text dataset passed as a string.
+
+Returns: list of dicts:
+  - nodes: [0..n-1]
+  - edges: list of (u,v)
+  - node_labels: list aligned to nodes
+  - edge_labels: list aligned to edges
+  - support: int
+  - graph_ids: list of graph IDs where pattern occurs, or None
+)pbdoc");
+}

submine/backends/sopagrami/cpp/CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.15)
+project(SopaGrami LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+add_library(alg STATIC src/alg.cpp)
+target_sources(alg PRIVATE
+    src/alg.cpp
+    src/dump.cpp
+)
+
+target_include_directories(alg PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+set_target_properties(alg PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+include(FetchContent)
+
+# Try system / vcpkg / conda / installed pybind11 first
+find_package(pybind11 CONFIG QUIET)
+
+if (NOT pybind11_FOUND)
+  message(STATUS "pybind11 not found via find_package; fetching with FetchContent...")
+
+  FetchContent_Declare(
+    pybind11
+    GIT_REPOSITORY https://github.com/pybind/pybind11.git
+    GIT_TAG        v2.12.0
+  )
+  FetchContent_MakeAvailable(pybind11)
+endif()
+
+pybind11_add_module(sopagrami_cpp src/python_bindings.cpp)
+
+target_include_directories(sopagrami_cpp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+target_link_libraries(sopagrami_cpp PRIVATE alg)
+set_target_properties(sopagrami_cpp PROPERTIES PREFIX "")
+
+# Install into scikit-build-core wheel
+install(TARGETS sopagrami_cpp
+  LIBRARY DESTINATION "submine/algorithms"
+  RUNTIME DESTINATION "submine/algorithms"
+  ARCHIVE DESTINATION "submine/algorithms"
+)

submine/backends/sopagrami/cpp/include/alg.hpp

@@ -0,0 +1,150 @@
+#pragma once
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <optional>
+#include <tuple>
+#include <limits>
+#include <bitset>
+#include <cstdint>
+namespace algo {
+
+
+
+// --- portable popcount64 ---
+#if defined(_MSC_VER)
+  #include <intrin.h>
+  static inline int popcount64(unsigned long long x) {
+  #if defined(_M_X64) || defined(_M_ARM64)
+      return (int)__popcnt64(x);
+  #else
+      // 32-bit: split into two 32-bit halves
+      return (int)(__popcnt((unsigned int)(x)) +
+                   __popcnt((unsigned int)(x >> 32)));
+  #endif
+  }
+#else
+  static inline int popcount64(unsigned long long x) {
+      return __builtin_popcountll(x);
+  }
+#endif
+
+
+// ---------- DataGraph (your spec) ----------
+struct Edge { int u, v; std::string label; };
+struct Bitset {
+    std::vector<uint64_t> w;
+    void init(int n){ w.assign((n+63)>>6, 0ull); }
+    inline void set(int i){ w[i>>6] |= (1ull<<(i&63)); }
+    inline void reset(int i){ w[i>>6] &= ~(1ull<<(i&63)); }
+    inline bool test(int i) const { return (w[i>>6] >> (i&63)) & 1ull; }
+    inline bool any() const { for (auto x: w) if (x) return true; return false; }
+    inline size_t count() const { size_t c=0; for (auto x: w) c += popcount64((unsigned long long)x); return c; }
+
+    // this &= other
+    inline void and_inplace(const Bitset& o){
+        size_t m = w.size(); for (size_t i=0;i<m;++i) w[i] &= o.w[i];
+    }
+    // this &= ~other
+    inline void andnot_inplace(const Bitset& o){
+        size_t m = w.size(); for (size_t i=0;i<m;++i) w[i] &= ~o.w[i];
+    }
+    // (this & other).any() without allocating
+    inline bool any_and(const Bitset& o) const {
+        size_t m = w.size(); for (size_t i=0;i<m;++i) if (w[i] & o.w[i]) return true; return false;
+    }
+
+    // make a copy intersected with 'o'
+    inline Bitset copy_and(const Bitset& o) const {
+        Bitset t; t.w.resize(w.size());
+        for (size_t i=0;i<w.size();++i) t.w[i] = w[i] & o.w[i];
+        return t;
+    }
+};
+struct DataGraph {
+    bool directed = false;
+    std::vector<std::string> vlabels; // node labels
+    std::vector<std::vector<std::pair<int,std::string>>> adj, rev; // (nbr, label)
+    std::vector<std::unordered_map<int, std::unordered_set<std::string>>> adj_set, rev_set; // fast has_edge
+    std::unordered_map<std::string, std::unordered_set<int>> lab2nodes; // node-label -> nodes
+    std::vector<std::unordered_map<std::string, std::vector<int>>> out_by_el, in_by_el;
+    // Bitset indices (speedup for undirected and directed)
+    std::unordered_map<std::string, Bitset> label_bits;                 // label -> nodes
+    std::vector<std::unordered_map<std::string, Bitset>> adj_el_bits;   // per u: el -> bitset(neighbors via el)
+        
+    void load_from_lg(const std::string& path, bool as_directed);
+
+    bool has_edge(int u, int v, const std::string& label) const {
+        auto it = adj_set[u].find(v);
+        if(it==adj_set[u].end()) return false;
+        if(label.empty()) return !it->second.empty();
+        return it->second.count(label)>0;
+    }
+
+    // Edge type key for frequent 1-edge seeds (SoGraMi)
+    struct EdgeTypeKey {
+        std::string lu, lv, el; int dirflag; // 0 undirected, 1 u->v
+        bool operator==(EdgeTypeKey const& o) const {
+            return lu==o.lu && lv==o.lv && el==o.el && dirflag==o.dirflag;
+        }
+        bool operator<(EdgeTypeKey const& o) const {
+            if(lu!=o.lu) return lu<o.lu;
+            if(lv!=o.lv) return lv<o.lv;
+            if(el!=o.el) return el<o.el;
+            return dirflag<o.dirflag;
+        }
+    };
+
+    struct EdgeTypeStat { EdgeTypeKey key; int count; };
+
+    // Python-parity: counts in FIRST-SEEN INSERTION ORDER while scanning adjacency
+    std::vector<EdgeTypeStat> edge_type_counts_insertion_order() const;
+};
+
+// ---------- Algorithm API ----------
+struct Params {
+    int tau = 2;                 // frequency threshold
+    bool directed = false;       // interpret graph as directed?
+    bool sorted_seeds = true;    // SoGraMi ordering
+    int num_threads = 0;         // 0 => use hardware_concurrency
+    bool compute_full_support = true; // if false, use MNI only
+};
+
+struct Pattern {
+    // Compact labeled pattern
+    // nodes have labels; edges as (i,j,el,dirflag) with i<->j in [0..k-1]
+    std::vector<std::string> vlab; // per pattern-node label
+    struct PEdge { int a,b; std::string el; int dir; }; // dir: 0 undirected, 1 a->b
+    std::vector<PEdge> pedges;
+
+    // canonical key for de-duplication (label seq + sorted edges)
+    std::string key() const;
+    // in Pattern:
+    std::vector<int> parent;   // parent[new_vertex] = anchor on RMP for forward edges, -1 for seed
+    int rightmost;             // index of the last-added vertex
+
+};
+
+struct Found {
+    Pattern pat;
+    long long full_support = 0; // number of isomorphisms (or MNI if compute_full_support=false)
+};
+
+struct Output {
+    std::vector<Found> frequent_patterns;
+};
+void dump_patterns_to_dir(
+    const Output& out,
+    const std::string& dump_dir,
+    bool directed,
+    const DataGraph& G,
+    bool dump_images_csv,
+    int  max_images_per_vertex,
+    bool dump_sample_embeddings,
+    int  sample_limit
+);
+Output run_sopagrami(const DataGraph& G, const Params& p);
+
+} // namespace algo

submine/backends/sopagrami/cpp/include/common/timer.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <chrono>
+
+namespace common {
+
+class Timer {
+public:
+    using clock = std::chrono::steady_clock;
+    void start() { t0_ = clock::now(); }
+    double ms() const {
+        auto t1 = clock::now();
+        return std::chrono::duration<double, std::milli>(t1 - t0_).count();
+    }
+private:
+    clock::time_point t0_;
+};
+
+} // namespace common