effspm 0.1.6__cp313-cp313-macosx_10_13_universal2.whl → 0.1.9__cp313-cp313-macosx_10_13_universal2.whl

effspm/__init__.py

@@ -1,3 +1,3 @@
-from ._core import PrefixProjection
+from ._effspm import PrefixProjection, BTMiner
 
-__all__ = ['PrefixProjection']
+__all__ = ['PrefixProjection', 'BTMiner']

effspm/_effspm.cpp

@@ -0,0 +1,153 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+// PrefixProjection headers
+#include "freq_miner.hpp"
+#include "load_inst.hpp"
+#include "utility.hpp"
+
+// BTMiner (wrapped in its own namespace in source files)
+#include "btminer/src/freq_miner.hpp"
+#include "btminer/src/load_inst.hpp"
+#include "btminer/src/utility.hpp"
+#include "btminer/src/build_mdd.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_effspm, m) {
+    m.doc() = "Unified SPM library: PrefixProjection, BTMiner, and more";
+
+    // PrefixProjection
+    m.def("PrefixProjection",
+        [](py::object data,
+           double minsup,
+           unsigned int time_limit,
+           bool preproc,
+           bool use_dic,
+           bool verbose,
+           const std::string &out_file)
+        {
+            ::time_limit = time_limit;
+            ::pre_pro    = preproc;
+            ::use_dic    = use_dic;
+            ::use_list   = false;
+            ::b_disp     = verbose;
+            ::b_write    = !out_file.empty();
+            ::out_file   = out_file;
+
+            ClearCollected();
+            start_time = std::clock();
+
+            if (py::isinstance<py::str>(data)) {
+                std::string path = data.cast<std::string>();
+                if (!Load_instance(path, minsup))
+                    throw std::runtime_error("Failed to load file: " + path);
+            } else {
+                auto seqs = data.cast<std::vector<std::vector<int>>>();
+                items = std::move(seqs);
+                N = items.size();
+
+                int max_id = 0;
+                for (auto &seq : items)
+                    for (int x : seq)
+                        max_id = std::max(max_id, std::abs(x));
+                L = max_id;
+
+                theta = (minsup < 1.0) ? std::ceil(minsup * N) : minsup;
+
+                DFS.clear();
+                DFS.reserve(L);
+                for (unsigned int i = 0; i < L; ++i)
+                    DFS.emplace_back(-static_cast<int>(i) - 1);
+
+                M = 0;
+                E = 0;
+                for (auto &seq : items) {
+                    M = std::max<unsigned int>(M, seq.size());
+                    E += seq.size();
+                }
+            }
+
+            Freq_miner();
+
+            py::dict out;
+            out["patterns"] = GetCollected();
+            out["time"]     = give_time(std::clock() - start_time);
+            return out;
+        },
+        py::arg("data"),
+        py::arg("minsup") = 0.01,
+        py::arg("time_limit") = 36000,
+        py::arg("preproc") = false,
+        py::arg("use_dic") = false,
+        py::arg("verbose") = false,
+        py::arg("out_file") = ""
+    );
+
+    // BTMiner
+    m.def("BTMiner",
+        [](py::object data,
+           double minsup,
+           unsigned int time_limit,
+           bool preproc,
+           bool use_dic,
+           bool verbose,
+           const std::string &out_file)
+        {
+            btminer::time_limit = time_limit;
+            btminer::pre_pro    = preproc;
+            btminer::use_dic    = use_dic;
+            btminer::use_list   = false;
+            btminer::b_disp     = verbose;
+            btminer::b_write    = !out_file.empty();
+            btminer::out_file   = out_file;
+
+            btminer::ClearCollected();
+            btminer::start_time = std::clock();
+
+            if (py::isinstance<py::str>(data)) {
+                std::string path = data.cast<std::string>();
+                if (!btminer::Load_instance(path, minsup))
+                    throw std::runtime_error("Failed to load file: " + path);
+            } else {
+                auto seqs = data.cast<std::vector<std::vector<int>>>();
+                btminer::items = std::move(seqs);
+                btminer::N = btminer::items.size();
+
+                int max_id = 0;
+                for (auto &seq : btminer::items)
+                    for (int x : seq)
+                        max_id = std::max(max_id, std::abs(x));
+                btminer::L = max_id;
+
+                btminer::theta = (minsup < 1.0) ? std::ceil(minsup * btminer::N) : minsup;
+
+                btminer::DFS.clear();
+                btminer::DFS.reserve(btminer::L);
+                for (unsigned int i = 0; i < btminer::L; ++i)
+                    btminer::DFS.emplace_back(-static_cast<int>(i) - 1);
+
+                btminer::M = 0;
+                btminer::E = 0;
+                for (auto &seq : btminer::items) {
+                    btminer::M = std::max<unsigned int>(btminer::M, seq.size());
+                    btminer::E += seq.size();
+                }
+            }
+
+            btminer::Freq_miner();
+
+            py::dict out;
+            out["patterns"] = btminer::GetCollected();
+            out["time"]     = btminer::give_time(std::clock() - btminer::start_time);
+            return out;
+        },
+        py::arg("data"),
+        py::arg("minsup") = 0.01,
+        py::arg("time_limit") = 36000,
+        py::arg("preproc") = false,
+        py::arg("use_dic") = false,
+        py::arg("verbose") = false,
+        py::arg("out_file") = ""
+    );
+}

effspm/btminer/src/build_mdd.cpp

@@ -0,0 +1,63 @@
+#include <vector>
+#include <iostream>
+#include <unordered_map>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+
+namespace btminer {
+
+int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& ancest_map);
+std::vector<Arc> Tree;
+
+void Build_MDD(std::vector<int>& items) {
+    std::unordered_map<int, int> ancest_map;
+    int last_arc = 0, itmset = 0;
+    for (auto it = items.begin(); it != items.end(); ++it)
+        last_arc = Add_arc(*it, last_arc, itmset, ancest_map);
+}
+
+int Add_arc(int item, int last_arc, int& itmset, std::unordered_map<int, int>& ancest_map) {
+    int anct;
+    auto p = ancest_map.find(abs(item));
+    if (p == ancest_map.end())
+        anct = 0;
+    else
+        anct = p->second;
+
+    if (item < 0)
+        ++itmset;
+
+    int last_sibl = Tree[last_arc].chld;
+
+    if (last_sibl == -1) {
+        Tree.emplace_back(item, itmset, anct);
+        last_sibl = Tree.size() - 1;
+        Tree[last_arc].chld = last_sibl;
+        if (anct == 0)
+            DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+    } else {
+        while (Tree[last_sibl].item != item) {
+            if (Tree[last_sibl].sibl == -1) {
+                Tree.emplace_back(item, itmset, anct);
+                Tree[last_sibl].sibl = Tree.size() - 1;
+                last_sibl = Tree.size() - 1;
+                if (anct == 0)
+                    DFS[abs(item) - 1].str_pnt.push_back(last_sibl);
+                break;
+            }
+            last_sibl = Tree[last_sibl].sibl;
+        }
+    }
+
+    if (anct == 0)
+        ++DFS[abs(item) - 1].freq;
+
+    ++Tree[last_sibl].freq;
+    ancest_map[abs(item)] = last_sibl;
+
+    return last_sibl;
+}
+
+} // namespace btminer

effspm/btminer/src/build_mdd.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "load_inst.hpp"
+
+namespace btminer {
+
+void Build_MDD(std::vector<int>& items);
+
+class Arc {
+public:
+    int chld = -1;
+    int sibl = -1;
+    int freq = 0;
+    int anct;
+    int itmset;
+    int item;
+
+    Arc(int _itm, int _itmset, int _anc) {
+        itmset = _itmset;
+        anct = _anc;
+        item = _itm;
+    }
+
+    Arc(int _itm, int _anc) {
+        item = _itm;
+        anct = _anc;
+    }
+
+    Arc() {
+        chld = -1;
+        sibl = -1;
+        freq = 0;
+    }
+};
+
+extern std::vector<Arc> Tree;
+
+} 

effspm/btminer/src/freq_miner.cpp

@@ -0,0 +1,176 @@
+#include <iostream>
+#include <time.h>
+#include <vector>
+#include <fstream>
+#include <cmath>
+#include "freq_miner.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+
+namespace btminer {
+
+void Out_patt(std::vector<int>& seq, int freq);
+void Extend_patt(Pattern _patt);
+
+int num_patt = 0;
+
+void Freq_miner() {
+    std::vector<int> islist;
+    for (int i = 0; i < L; ++i) {
+        if (DFS[i].freq >= theta)
+            islist.push_back(i);
+    }
+
+    for (int i = 0; i < DFS.size(); ++i) {
+        DFS[i].ilist = islist;
+        DFS[i].slist = islist;
+    }
+
+    while (!DFS.empty() && give_time(clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta)
+            Extend_patt(DFS.back());
+        else
+            DFS.pop_back();
+    }
+}
+
+void Extend_patt(Pattern _patt) {
+    DFS.pop_back();
+    std::vector<bool> slist(L, 0);
+    std::vector<bool> ilist(L, 0);
+
+    for (auto it : _patt.slist) slist[it] = 1;
+    for (auto it : _patt.ilist) ilist[it] = 1;
+
+    int itmset_size = 1;
+    int last_neg = _patt.seq.size() - 1;
+    while (_patt.seq[last_neg] > 0) {
+        --last_neg;
+        ++itmset_size;
+    }
+
+    std::vector<Pattern> pot_patt(2 * L);
+    std::vector<int> DFS_patt_init, DFS_patt, DFS_numfound, last_strpnt(L, 0);
+
+    for (int pnt = 0; pnt < _patt.str_pnt.size(); ++pnt) {
+        DFS_patt_init.push_back(_patt.str_pnt[pnt]);
+        while (!DFS_patt_init.empty()) {
+            int cur_sibl = Tree[DFS_patt_init.back()].chld;
+            DFS_patt_init.pop_back();
+            while (cur_sibl != -1) {
+                int cur_itm = Tree[cur_sibl].item;
+                if (cur_itm < 0) {
+                    cur_itm = -cur_itm;
+                    if (slist[cur_itm - 1]) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                    }
+                } else {
+                    if (ilist[cur_itm - 1]) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1)
+                        DFS_patt_init.push_back(cur_sibl);
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+
+        for (auto it : _patt.ilist)
+            last_strpnt[it] = pot_patt[it].str_pnt.size();
+
+        while (!DFS_patt.empty()) {
+            int cur_sibl = Tree[DFS_patt.back()].chld;
+            int num_found = DFS_numfound.back();
+            DFS_patt.pop_back();
+            DFS_numfound.pop_back();
+            while (cur_sibl != -1) {
+                int cur_itm = Tree[cur_sibl].item;
+                if (cur_itm > 0) {
+                    if (num_found == itmset_size && ilist[cur_itm - 1] &&
+                        (Tree[Tree[cur_sibl].anct].itmset < Tree[_patt.str_pnt[pnt]].itmset ||
+                         !check_parent(cur_sibl, _patt.str_pnt[pnt], last_strpnt[cur_itm - 1], pot_patt[cur_itm - 1].str_pnt))) {
+                        pot_patt[cur_itm - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (slist[cur_itm - 1] && Tree[Tree[cur_sibl].anct].itmset <= Tree[_patt.str_pnt[pnt]].itmset) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (!_patt.ilist.empty()) {
+                            DFS_numfound.push_back((num_found < itmset_size && cur_itm == abs(_patt.seq[last_neg + num_found])) ? num_found + 1 : num_found);
+                        }
+                    }
+                } else {
+                    cur_itm = -cur_itm;
+                    if (slist[cur_itm - 1] && Tree[Tree[cur_sibl].anct].itmset <= Tree[_patt.str_pnt[pnt]].itmset) {
+                        pot_patt[cur_itm + L - 1].freq += Tree[cur_sibl].freq;
+                        pot_patt[cur_itm + L - 1].str_pnt.push_back(cur_sibl);
+                    }
+                    if (Tree[cur_sibl].chld != -1) {
+                        DFS_patt.push_back(cur_sibl);
+                        if (!_patt.ilist.empty()) {
+                            DFS_numfound.push_back(cur_itm == -_patt.seq[last_neg] ? 1 : 0);
+                        }
+                    }
+                }
+                cur_sibl = Tree[cur_sibl].sibl;
+            }
+        }
+    }
+
+    std::vector<int> slistp, ilistp;
+    for (auto it : _patt.ilist) if (pot_patt[it].freq >= theta) ilistp.push_back(it);
+    for (auto it : _patt.slist) if (pot_patt[it + L].freq >= theta) slistp.push_back(it);
+
+    for (auto it : ilistp) {
+        pot_patt[it].str_pnt.shrink_to_fit();
+        DFS.push_back(pot_patt[it]);
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(it + 1);
+        DFS.back().seq.shrink_to_fit();
+        DFS.back().slist = slistp;
+        DFS.back().ilist = ilistp;
+        if (b_disp || b_write) Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+
+    for (auto it : slistp) {
+        pot_patt[it + L].str_pnt.shrink_to_fit();
+        DFS.push_back(pot_patt[it + L]);
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(-it - 1);
+        DFS.back().seq.shrink_to_fit();
+        DFS.back().slist = slistp;
+        DFS.back().ilist = slistp;
+        if (b_disp || b_write) Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+}
+
+void Out_patt(std::vector<int>& seq, int freq) {
+    std::ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    for (int ii = 0; ii < seq.size(); ii++) {
+        if (b_disp) std::cout << seq[ii] << " ";
+        if (b_write) file_o << seq[ii] << " ";
+    }
+    if (b_disp) std::cout << std::endl;
+    if (b_write) file_o << std::endl;
+
+    if (b_disp) std::cout << "************** Freq: " << freq << std::endl;
+    if (b_write) {
+        file_o << "************** Freq: " << freq << std::endl;
+        file_o.close();
+    }
+}
+
+} // namespace btminer

effspm/btminer/src/freq_miner.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <vector>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+
+namespace btminer {
+
+void Freq_miner();
+
+class Pattern {
+public:
+    std::vector<int> seq;
+    std::vector<int> str_pnt;
+    std::vector<int> slist;
+    std::vector<int> ilist;
+    int freq;
+
+    Pattern(std::vector<int>& _seq, int item) {
+        seq.swap(_seq);
+        seq.push_back(item);
+        freq = 0;
+    }
+
+    Pattern(int item) {
+        seq.push_back(item);
+        freq = 0;
+    }
+
+    Pattern() {
+        freq = 0;
+    }
+};
+
+extern int num_patt;
+extern int num_max_patt;
+extern std::vector<Pattern> DFS;
+
+} // namespace btminer

effspm/btminer/src/load_inst.cpp

@@ -0,0 +1,194 @@
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <cmath>
+#include <ctime>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include "load_inst.hpp"
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "freq_miner.hpp"
+
+namespace btminer {
+
+using namespace std;
+
+extern int num_nodes, cur_node;  // ✅ keep these if needed
+
+map<string, int> item_map;
+map<int, string> item_map_rev;
+vector<int> freq;
+vector<int> item_dic;
+
+
+void Load_items_pre(string& inst_name);
+bool Load_items(string& inst_name);
+bool Preprocess(string& inst, double thresh);
+
+bool Load_instance(string& items_file, double thresh) {
+    clock_t kk = clock();
+    Tree.emplace_back(0, 0, 0);
+
+    if (pre_pro) {
+        if (!Preprocess(items_file, thresh))
+            return false;
+
+        cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
+
+        DFS.reserve(L);
+        for (int i = 0; i < L; ++i)
+            DFS.emplace_back(-i - 1);
+
+        kk = clock();
+        Load_items_pre(items_file);
+    } else if (!Load_items(items_file))
+        return false;
+    else {
+        theta = (thresh < 1) ? ceil(thresh * N * N_mult) : thresh;
+    }
+
+    cout << "\nMDD Database built in " << give_time(clock() - kk) << " seconds\n\n";
+    cout << "Found " << N * N_mult << " sequence, with max line len " << M << ", and " << L << " items, and " << E << " enteries\n";
+    cout << "Total MDD nodes: " << Tree.size() << endl;
+
+    return true;
+}
+
+bool Preprocess(string& inst, double thresh) {
+    ifstream file(inst);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int size_m, ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        vector<bool> counted(L, 0);
+        istringstream word(line);
+        string itm;
+        while (word >> itm) {
+            ditem = stoi(itm);
+            if (L < abs(ditem)) L = abs(ditem);
+            while (freq.size() < L) {
+                freq.push_back(0);
+                counted.push_back(0);
+            }
+            if (!counted[abs(ditem) - 1]) {
+                ++freq[abs(ditem) - 1];
+                counted[abs(ditem) - 1] = 1;
+            }
+        }
+    }
+
+    theta = (thresh < 1) ? ceil(thresh * N * N_mult) : thresh;
+
+    int real_L = 0;
+    item_dic = vector<int>(L, -1);
+    for (int i = 0; i < L; ++i) {
+        if (freq[i] >= theta)
+            item_dic[i] = ++real_L;
+    }
+
+    cout << "Original number of items: " << L << " Reduced to: " << real_L << endl;
+    L = real_L;
+    N = 0;
+    return true;
+}
+
+void Load_items_pre(string& inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) return;
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        bool sgn = 0;
+        while (word >> itm) {
+            if (use_dic) {
+                auto it = item_map.find(itm);
+                if (it == item_map.end()) {
+                    item_map[itm] = ++L;
+                    item_map_rev[L] = itm;
+                    ditem = L;
+                } else {
+                    ditem = it->second;
+                }
+            } else {
+                ditem = stoi(itm);
+            }
+
+            if (freq[abs(ditem) - 1] < theta) {
+                if (!sgn)
+                    sgn = ditem < 0;
+                continue;
+            } else {
+                ditem = (ditem > 0) ? item_dic[ditem - 1] : -item_dic[-ditem - 1];
+            }
+
+            if (sgn && ditem > 0)
+                ditem = -ditem;
+            sgn = 0;
+
+            temp_vec.push_back(ditem);
+        }
+
+        if (temp_vec.empty()) continue;
+
+        ++N;
+        if (temp_vec.size() > M) M = temp_vec.size();
+
+        Build_MDD(temp_vec);
+    }
+}
+
+bool Load_items(string& inst_name) {
+    ifstream file(inst_name);
+    if (!file.good()) {
+        cout << "!!!!!! No such file exists: " << inst_name << " !!!!!!\n";
+        return false;
+    }
+
+    string line;
+    int ditem;
+    while (getline(file, line) && give_time(clock() - start_time) < time_limit) {
+        ++N;
+        istringstream word(line);
+        string itm;
+        vector<int> temp_vec;
+        while (word >> itm) {
+            if (use_dic) {
+                auto it = item_map.find(itm);
+                if (it == item_map.end()) {
+                    item_map[itm] = ++L;
+                    item_map_rev[L] = itm;
+                    ditem = L;
+                } else {
+                    ditem = it->second;
+                }
+            } else {
+                ditem = stoi(itm);
+                if (L < abs(ditem)) {
+                    L = abs(ditem);
+                    while (DFS.size() < L && !just_build) {
+                        DFS.reserve(L);
+                        DFS.emplace_back(-DFS.size() - 1);
+                    }
+                }
+            }
+            temp_vec.push_back(ditem);
+        }
+
+        if (temp_vec.size() > M) M = temp_vec.size();
+        Build_MDD(temp_vec);
+    }
+    return true;
+}
+
+} // namespace btminer

effspm/btminer/src/load_inst.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <ctime>
+
+namespace btminer {
+
+bool Load_instance(std::string& items_file, double thresh);
+
+extern std::string out_file, folder;
+
+extern bool b_disp, b_write, use_dic, just_build, pre_pro;
+
+extern int N, M, L, theta, num_nodes, M_mult, N_mult, time_limit, cur_node;
+
+extern clock_t start_time;
+
+} // namespace btminer

effspm/btminer/src/main.cpp

@@ -0,0 +1,92 @@
+#include <iostream>
+#include <ctime>
+#include <cstring>
+#include <string>
+#include "load_inst.hpp"
+#include "build_mdd.hpp"
+#include "utility.hpp"
+#include "freq_miner.hpp"
+
+namespace btminer {
+
+// These variables are declared in utility.hpp and defined in utility.cpp
+extern std::string out_file;
+extern bool b_disp, b_write, use_dic, just_build;
+extern clock_t start_time;
+
+bool pre_pro = true;              // This one is only used in main
+int N_mult = 1, M_mult = 1;       // Local to main
+int time_limit = 30 * 3600;       // Local to main
+std::string folder;
+
+int main(int argc, char* argv[]) {
+    std::string VV, attr;
+    double thresh = 0;
+
+    for (int i = 1; i < argc; i++) {
+        if (argv[i][0] != '-' || isdigit(argv[i][1]))
+            continue;
+        else if (strcmp(argv[i], "-thr") == 0)
+            thresh = std::stod(argv[i + 1]);
+        else if (strcmp(argv[i], "-file") == 0)
+            VV = argv[i + 1];
+        else if (strcmp(argv[i], "-N_mult") == 0)
+            N_mult = std::stoi(argv[i + 1]);
+        else if (strcmp(argv[i], "-M_mult") == 0)
+            M_mult = std::stoi(argv[i + 1]);
+        else if (strcmp(argv[i], "-time") == 0)
+            time_limit = std::stoi(argv[i + 1]);
+        else if (strcmp(argv[i], "-jbuild") == 0)
+            just_build = true;
+        else if (strcmp(argv[i], "-folder") == 0)
+            folder = argv[i + 1];
+        else if (strcmp(argv[i], "-npre") == 0)
+            pre_pro = false;
+        else if (strcmp(argv[i], "-dic") == 0)
+            use_dic = true;
+        else if (strcmp(argv[i], "-out") == 0) {
+            if (i + 1 == argc || argv[i + 1][0] == '-')
+                b_disp = true;
+            else if (argv[i + 1][0] == '+') {
+                b_disp = true;
+                b_write = true;
+                if (strlen(argv[i + 1]) > 1) {
+                    out_file = argv[i + 1];
+                    out_file = out_file.substr(1);
+                } else {
+                    out_file = VV;
+                }
+            } else {
+                b_write = true;
+                out_file = argv[i + 1];
+            }
+        } else {
+            std::cout << "Command " << argv[i] << " not recognized and skipped.\n";
+        }
+    }
+
+    std::cout << "\n********************** " << VV << " N_mult: " << N_mult << " M_mult: " << M_mult << "**********************\n";
+
+    std::string item_file = folder + VV + ".txt";
+
+    std::cout << "loading instances...\n";
+    start_time = clock();
+
+    if (!Load_instance(item_file, thresh)) {
+        std::cout << "Files invalid, exiting.\n";
+        std::cin.get();
+        return 0;
+    }
+
+    if (!just_build && give_time(clock() - start_time) < time_limit) {
+        Freq_miner();
+        if (give_time(clock() - start_time) >= time_limit)
+            std::cout << "TIME LIMIT REACHED\n";
+        std::cout << "Mining Complete\n\nFound a total of " << num_patt << " patterns\n";
+        std::cout << "\nTotal CPU time " << give_time(clock() - start_time) << " seconds\n\n";
+    }
+
+    return 0;
+}
+
+} // namespace btminer

effspm/btminer/src/utility.cpp

@@ -0,0 +1,63 @@
+#include "utility.hpp"
+#include "build_mdd.hpp"
+#include "load_inst.hpp"
+#include <iostream>
+
+namespace btminer {
+
+// === Global Variables ===
+std::vector<std::vector<int>> items;
+bool use_list = false;
+bool just_build = false;
+int E = 0, M = 0, N = 0, L = 0, theta = 0;
+std::vector<Pattern> DFS;
+clock_t start_time;
+bool b_disp = false, b_write = false;
+std::string out_file;
+int time_limit = 30 * 3600;  // ✅ This was missing before
+
+// === Function Definitions ===
+
+int find_ID(std::vector<int>& vec, int itm) {
+    int plc = 0;
+    while (plc < vec.size() && vec[plc] != itm)
+        ++plc;
+    return (plc == vec.size()) ? -1 : plc;
+}
+
+bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec) {
+    std::vector<int> ancestors;
+    int cur_anct = Tree[cur_arc].anct;
+
+    while (Tree[cur_anct].itmset > Tree[str_pnt].itmset) {
+        if (Tree[cur_anct].item > 0)
+            ancestors.push_back(cur_anct);
+        cur_anct = Tree[cur_anct].anct;
+    }
+
+    if (Tree[cur_anct].itmset == Tree[str_pnt].itmset)
+        return true;
+
+    for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+        for (int i = start; i < strpnt_vec.size(); ++i) {
+            if (strpnt_vec[i] == *it)
+                return true;
+        }
+    }
+
+    return false;
+}
+
+bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos) {
+    for (size_t i = pos; i < vec.size(); ++i) {
+        if (vec[i] == pnt)
+            return true;
+    }
+    return false;
+}
+
+float give_time(clock_t kk) {
+    return static_cast<float>(kk) / CLOCKS_PER_SEC;
+}
+
+} // namespace btminer

effspm/btminer/src/utility.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <vector>
+#include <ctime>
+#include <string>
+#include "build_mdd.hpp"
+#include "freq_miner.hpp" // Required for Pattern
+#include "load_inst.hpp"  // Ensures consistency across global usage
+
+namespace btminer {
+
+// === Utility function declarations ===
+bool find_pnt(Arc* pnt, std::vector<Arc*>& vec, int pos);
+int find_ID(std::vector<int>& vec, int itm);
+float give_time(clock_t kk);
+bool check_parent(int cur_arc, int str_pnt, int start, std::vector<int>& strpnt_vec);
+
+// === Global variables for Python binding support ===
+extern std::vector<std::vector<int>> items;
+extern bool use_list;
+extern bool just_build;
+extern int E, M, N, L, theta;
+extern std::vector<Pattern> DFS;
+extern clock_t start_time;
+extern bool b_disp, b_write;
+extern std::string out_file;
+
+// === Python-friendly accessors ===
+inline void ClearCollected() {
+    DFS.clear();
+}
+
+inline std::vector<std::vector<int>> GetCollected() {
+    std::vector<std::vector<int>> patterns;
+    for (const auto& p : DFS) {
+        patterns.push_back(p.seq);
+    }
+    return patterns;
+}
+
+} // namespace btminer

effspm/main.cpp

@@ -0,0 +1,103 @@
+#include <iostream>
+#include <time.h>
+#include <string.h>
+#include <string>
+#include "load_inst.hpp"
+#include "freq_miner.hpp"
+#include "utility.hpp"
+
+using namespace std;
+
+string out_file;
+
+bool  b_disp = 0, b_write = 0, use_dic = 0, use_list = 0, pre_pro = 0;
+
+unsigned int time_limit = 10 * 3600;
+
+clock_t start_time;
+
+int main(int argc, char* argv[]) {
+
+        double thresh = 0;
+        string VV, folder;
+        for (int i = 1; i < argc; ++i){
+		if (argv[i][0] !='-')
+			continue;
+		else if (strcmp(argv[i], "-thr") == 0)
+			thresh = stof(argv[i + 1]);
+                else if (strcmp(argv[i], "-file") == 0)
+                        VV = argv[i + 1];
+		else if (strcmp(argv[i], "-folder") == 0)
+                        folder = argv[i + 1];
+		else if (strcmp(argv[i], "-time") == 0)
+			time_limit = stoi(argv[i + 1]);
+		else if (strcmp(argv[i], "-uselist") == 0)
+			use_list = 1;
+		else if (strcmp(argv[i], "-preproc") == 0)
+			pre_pro = 1;
+		else if (strcmp(argv[i], "-dic") == 0)
+			use_dic = 1;
+		else if (strcmp(argv[i], "-out") == 0){
+			if (i + 1 == argc || argv[i + 1][0] == '-')
+				b_disp = 1;
+			else if (argv[i + 1][0] == '+') {
+				b_disp = 1; 
+				b_write = 1;
+				out_file = argv[i + 1];
+				out_file = out_file.substr(1,out_file.size()-1);
+			}
+			else {
+				b_write = 1;
+				out_file = argv[i + 1];
+			}
+		}
+		else
+			cout << "Command " << argv[i] << " not recognized and skipped.\n";
+        }
+
+	if (thresh == 0){	
+		cout << "No Threshold given, using threshold deafult of 1%\n";
+		thresh = 0.01;
+	}
+	if (folder.back() != '/'){
+		folder += '/';
+	}
+
+
+   	cout << "\n********************** " << VV << "**********************\n";
+
+	string item_file = folder + VV + ".txt";
+	//out_file = folder + VV + "_result.txt";
+	cout << "loading instances...\n";
+
+	start_time = clock();
+
+	if(!Load_instance(item_file, thresh)){
+		cout << "Files invalid, exiting.\n";
+		return 0;
+	}
+
+	cout << "Instances loaded\n";
+
+	if (give_time(clock() - start_time) < time_limit) {
+		cout << "\nRunning mining algorithm...\n";
+		Freq_miner();
+		if (give_time(clock() - start_time) >= time_limit)
+			cout << "TIME LIMIT REACHED\n";
+		cout << "Mining Complete\n\nFound a total of " << num_patt << " patterns\n";
+	}
+
+	cout << "Total CPU time is: ";
+	cout << give_time(clock() - start_time) << "\n";
+
+	if (b_write){
+		ofstream file;
+		file.open(out_file, std::ios::app);
+		file << "\nMining completed in " << give_time(clock() - start_time) << " seconds\n";
+		//file << "Found a total of " << num_max_patt << " maximal patterns\n";
+		file.close();
+	}
+
+
+	return 0;
+}

effspm-0.1.9.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: effspm
+Version: 0.1.9
+Summary: Prefix‑Projection and other sequential pattern mining algorithms
+Author: Yeswanth Vootla
+Author-email: yeshu999 <vootlayeswanth20@gmail.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship, whether in Source or
+              Object form, made available under the License, as indicated by a
+              copyright notice that is included in or attached to the work
+              (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean any work of authorship, including
+              the original version of the Work and any modifications or additions
+              to that Work or Derivative Works thereof, that is intentionally
+              submitted to Licensor for inclusion in the Work by the copyright owner
+              or by an individual or Legal Entity authorized to submit on behalf of
+              the copyright owner. For the purposes of this definition, "submitted"
+              means any form of electronic, verbal, or written communication sent
+              to the Licensor or its representatives, including but not limited to
+              communication on electronic mailing lists, source code control systems,
+              and issue tracking systems that are managed by, or on behalf of, the
+              Licensor for the purpose of discussing and improving the Work, but
+              excluding communication that is conspicuously marked or otherwise
+              designated in writing by the copyright owner as "Not a Contribution."
+        
+              "Contributor" shall mean Licensor and any individual or Legal Entity
+              on behalf of whom a Contribution has been received by Licensor and
+              subsequently incorporated within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a
+              cross-claim or counterclaim in a lawsuit) alleging that the Work
+              or a Contribution incorporated within the Work constitutes direct
+              or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate
+              as of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or
+                  Derivative Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, then any Derivative Works that You distribute must
+                  include a readable copy of the attribution notices contained
+                  within such NOTICE file, excluding those notices that do not
+                  pertain to any part of the Derivative Works, in at least one
+                  of the following places: within a NOTICE text file distributed
+                  as part of the Derivative Works; within the Source form or
+                  documentation, if provided along with the Derivative Works; or,
+                  within a display generated by the Derivative Works, if and
+                  wherever such third-party notices normally appear. The contents
+                  of the NOTICE file are for informational purposes only and
+                  do not modify the License. You may add Your own attribution
+                  notices within Derivative Works that You distribute, alongside
+                  or as an addendum to the NOTICE text from the Work, provided
+                  that such additional attribution notices cannot be construed
+                  as modifying the License.
+        
+              You may add Your own copyright statement to Your modifications and
+              may provide additional or different license terms and conditions
+              for use, reproduction, or distribution of Your modifications, or
+              for any such Derivative Works as a whole, provided Your use,
+              reproduction, and distribution of the Work otherwise complies with
+              the conditions stated in this License.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or redistributing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or consequential damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or any and all
+              other commercial damages or losses), even if such Contributor
+              has been advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may act only
+              on Your own behalf and on Your sole responsibility, not on behalf
+              of any other Contributor, and only if You agree to indemnify,
+              defend, and hold each Contributor harmless for any liability
+              incurred by, or claims asserted against, such Contributor by reason
+              of your accepting any such warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           APPENDIX: How to apply the Apache License to your work.
+        
+              To apply the Apache License to your work, attach the following
+              boilerplate notice, with the fields enclosed by brackets "[]"
+              replaced with your own identifying information. (Don't include
+              the brackets!)  The text should be enclosed in the appropriate
+              comment syntax for the file format. We also recommend that a
+              file or class name and description of purpose be included on the
+              same "printed page" as the copyright notice for easier
+              identification within third-party archives.
+        
+           Copyright [yyyy] [name of copyright owner]
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+Project-URL: Homepage, https://github.com/yeshu999/effspm
+Project-URL: Source, https://github.com/yeshu999/effspm
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pybind11>=2.6
+Dynamic: author
+Dynamic: license-file
+
+# effspm
+
+**Efficient Sequential Pattern Mining via Prefix‑Projection**
+
+This library provides a Python interface to mine sequential patterns using the prefix‑projection algorithm, implemented in C++ for performance and exposed via pybind11.
+
+## Installation
+
+```bash
+pip install effspm

effspm-0.1.9.dist-info/RECORD

@@ -0,0 +1,25 @@
+effspm/__init__.py,sha256=P2BlW2-xTmfF2KK0ZMaTbw_yHpVX-Ue0wmhBL1FMIGA,90
+effspm/_core.cpp,sha256=S6UsUcl0HQLMQUTy2tMJxcrbLGJo8tjkLskyHqESYyI,3675
+effspm/_effspm.cpp,sha256=3paU981ioLFGYG4XtQLcWPXCoU-L1AMWrKvU-OU2WQU,5029
+effspm/_effspm.cpython-313-darwin.so,sha256=DGzTt51WtrKnmRUPperj0b1pJ560pUfhuEjcHJEl1oc,575600
+effspm/freq_miner.cpp,sha256=9K-nO_c-vVzbFlmh511vmvypA2fu1TXpiJhyx03owDU,4642
+effspm/freq_miner.hpp,sha256=jA-ZCT12Z0YNjLoAiY9sniFTP6g-ITTDuWtlOdHXkMQ,744
+effspm/load_inst.cpp,sha256=804fvkfdtYqFMP9Jla6dM2romWWPJmSeCwLm0wEZE5M,4517
+effspm/load_inst.hpp,sha256=cR-iZG95mUN62ZLCnPNQsKUINtkwhUzMTLlH81wmyt0,906
+effspm/main.cpp,sha256=aMyPwuTn5dPIlLAZ_XfWL8Z6cXfQS7EaJ0tEQPqpA8I,2558
+effspm/utility.cpp,sha256=luWwBNy7OVWRmam9gz2RjhtrRmx6c37oOobFJaDWqcA,1403
+effspm/utility.hpp,sha256=Y_MQVk9AmJWjguKyuyk0LraTi_6VzZFg0StsmVOCkNc,744
+effspm/btminer/src/build_mdd.cpp,sha256=LWfH_23cTExfOeK3evO46C8Di2_hmu7uCbmutOxj4Fw,1727
+effspm/btminer/src/build_mdd.hpp,sha256=CvowY9TxxnMh3_bIy0HZ9eZmnCm45z5A6Xz5hxHcwfg,567
+effspm/btminer/src/freq_miner.cpp,sha256=D1ofcP9_6QFskmMcvnUZ-Ck5CZWRsFrFw0yyArpsjYs,6476
+effspm/btminer/src/freq_miner.hpp,sha256=x-c7BpMdNqYiDFM49I7VDJXeb1tIruTOeD-3MXJ2g0A,626
+effspm/btminer/src/load_inst.cpp,sha256=nSRwJf3B5ueQeT3vgHGGo-eStRWIK1Vhzsr4iVBC0bU,5194
+effspm/btminer/src/load_inst.hpp,sha256=yxKcglYf3Zbi0BWqQ_BFaTTKy1rFC9FGOo2urO76YEE,460
+effspm/btminer/src/main.cpp,sha256=Jj7pUpkvoAkY2SlsKHc8MImDP-RlOIAyqSxEz1rmd5g,3059
+effspm/btminer/src/utility.cpp,sha256=LnxXQsV4t02bFHASX6MZvpDn8J1mXPyvuExcBEk63gM,1593
+effspm/btminer/src/utility.hpp,sha256=fZIJVq1WFXFmcgPvA9akdydilTQBT3I69WMCiJhTi_8,1093
+effspm-0.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+effspm-0.1.9.dist-info/METADATA,sha256=vdScIwPIzNEZessmkHIKuwWQBLkd8LjSKXYU---5Ag8,14227
+effspm-0.1.9.dist-info/WHEEL,sha256=ndSQSyKfEb4-QYoSqR9pmJeIy6hpNbwBzv_4vZGKDVo,115
+effspm-0.1.9.dist-info/top_level.txt,sha256=2O-AuI0nw0pDmJMo2jzM1wvV2rj48AmkjskkAnsuuQk,7
+effspm-0.1.9.dist-info/RECORD,,

{effspm-0.1.6.dist-info → effspm-0.1.9.dist-info}/WHEEL

@@ -1,6 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_10_13_universal2
-Generator: delocate 0.13.0
 

effspm-0.1.6.dist-info/METADATA

@@ -1,38 +0,0 @@
-Metadata-Version: 2.4
-Name: effspm
-Version: 0.1.6
-Summary: Prefix‑Projection sequential pattern mining
-Home-page: https://github.com/yeshu999/effspm
-Author: yeshu999
-Author-email: yeshu999 <vootlayeswanth20@gmail.com>
-Project-URL: Homepage, https://github.com/yeshu999/effspm
-Project-URL: Source, https://github.com/yeshu999/effspm
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: C++
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pybind11>=2.6
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-python
-
-# effspm
-
-**Efficient Sequential Pattern Mining via Prefix‑Projection**
-
-This library provides a Python interface to mine sequential patterns using the prefix‑projection algorithm, implemented in C++ for performance and exposed via pybind11.
-
-## Installation
-
-```bash
-pip install effspm

effspm-0.1.6.dist-info/RECORD

@@ -1,14 +0,0 @@
-effspm/utility.hpp,sha256=Y_MQVk9AmJWjguKyuyk0LraTi_6VzZFg0StsmVOCkNc,744
-effspm/_core.cpython-313-darwin.so,sha256=147sIggZxYEJaOK9DLopbwxiB6WwJLSUKTnxDj-_7yQ,480176
-effspm/_core.cpp,sha256=S6UsUcl0HQLMQUTy2tMJxcrbLGJo8tjkLskyHqESYyI,3675
-effspm/load_inst.hpp,sha256=cR-iZG95mUN62ZLCnPNQsKUINtkwhUzMTLlH81wmyt0,906
-effspm/__init__.py,sha256=3fTJ432t0_vjUMnkw4d8I3Jgots4YKVHWnDSHKs_qb4,68
-effspm/freq_miner.cpp,sha256=9K-nO_c-vVzbFlmh511vmvypA2fu1TXpiJhyx03owDU,4642
-effspm/load_inst.cpp,sha256=804fvkfdtYqFMP9Jla6dM2romWWPJmSeCwLm0wEZE5M,4517
-effspm/freq_miner.hpp,sha256=jA-ZCT12Z0YNjLoAiY9sniFTP6g-ITTDuWtlOdHXkMQ,744
-effspm/utility.cpp,sha256=luWwBNy7OVWRmam9gz2RjhtrRmx6c37oOobFJaDWqcA,1403
-effspm-0.1.6.dist-info/RECORD,,
-effspm-0.1.6.dist-info/WHEEL,sha256=7D3G_jWHhJAoFy5YHKW8Aevt7D0Y-GToB74dVA7ZWh0,142
-effspm-0.1.6.dist-info/top_level.txt,sha256=2O-AuI0nw0pDmJMo2jzM1wvV2rj48AmkjskkAnsuuQk,7
-effspm-0.1.6.dist-info/METADATA,sha256=XwJN4eG2oOWfowNsNQhKxcWRfV7zjiHRWwyDYixwpUk,1311
-effspm-0.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357