submine 0.1.1__cp312-cp312-macosx_11_0_arm64.whl

submine/api.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable, Union, Sequence, Optional
+import networkx as nx
+
+import inspect
+from .utils.checks import assert_regular_file
+from .errors import SubmineInputError, ParameterValidationError
+
+
+from .core.graph import Graph
+from . import get_mining_algorithm as get_algorithm
+from .core.result import MiningResult, SubgraphPattern
+
+GraphLike = Union[Graph, nx.Graph]
+GraphSourceLike = Union[
+    Graph,
+    Iterable[Graph],
+    Sequence[Graph],
+    Path,
+    str,
+    # later: DB handles, etc.
+]
+
+
+def _accepted_kwargs(callable_obj):
+    sig = inspect.signature(callable_obj)
+    accepted = set()
+    has_var_kw = False
+    for name, p in sig.parameters.items():
+        if p.kind == inspect.Parameter.VAR_KEYWORD:
+            has_var_kw = True
+        elif p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            accepted.add(name)
+    return accepted, has_var_kw
+
+def _normalize_graph_source(source: GraphSourceLike) -> Iterable[Graph]:
+    # 1. Already an internal Graph → wrap in list
+    if isinstance(source, Graph):
+        return [source]
+
+    # 2. Path / str → load from file
+    if isinstance(source, (str, Path)):
+        from .io.transcode import load_graphs
+
+        return load_graphs(Path(source))
+
+    # 3. Iterable of Graphs → pass through
+    try:
+        it = iter(source)  # type: ignore
+    except TypeError:
+        pass
+    else:
+        # could be list[Graph], generator, GraphSource, etc.
+        #TODO:  sanity check items, but can be lazy.
+        return it
+
+    raise TypeError(f"Cannot interpret {type(source)} as a graph source")
+
+
+def mine_subgraphs(
+    data: GraphSourceLike,
+    algorithm: str,
+    min_support: int,
+    **algo_params,
+) -> MiningResult:
+    """High-level convenience function for users.
+
+    `data` can be:
+      - a single Graph
+      - an iterable of Graphs
+      - a path to a graph dataset on disk
+    """
+    AlgoCls = get_algorithm(algorithm)
+    # Split kwargs between __init__ and mine()
+    init_keys, init_var = _accepted_kwargs(AlgoCls.__init__)
+    mine_keys, mine_var = _accepted_kwargs(AlgoCls.mine)
+
+    init_params = {}
+    run_params = {}
+    unknown = {}
+
+    for k, v in algo_params.items():
+        in_init = (k in init_keys) or init_var
+        in_mine = (k in mine_keys) or mine_var
+
+        # Prefer explicit match if both accept (rare but possible)
+        if k in init_keys and k in mine_keys:
+            # Policy choice: treat as runtime override
+            run_params[k] = v
+        elif k in init_keys:
+            init_params[k] = v
+        elif k in mine_keys:
+            run_params[k] = v
+        else:
+            unknown[k] = v
+
+    if unknown:
+        raise ParameterValidationError(
+            f"Unsupported parameters for algorithm='{algorithm}': {sorted(unknown.keys())}"
+        )
+    miner = AlgoCls(**init_params)
+
+    if not isinstance(min_support, int) or min_support <= 0:
+        raise ParameterValidationError(f"min_support must be a positive integer; got {min_support!r}")
+
+    # If user provided a path, and the miner declares a native on-disk format,
+    # transcode directly to that format (only when needed) and call mine_native().
+    if isinstance(data, (str, Path)):
+        from .io.transcode import detect_format, transcode_path
+        from .io.common import temporary_directory
+
+        src_path = assert_regular_file(Path(data))
+        src_fmt: Optional[str]
+        try:
+            src_fmt = detect_format(src_path)
+        except Exception:
+            src_fmt = None
+
+        expected = getattr(miner, "expected_input_format", None)
+        if expected is not None:
+            if src_fmt == expected:
+                return miner.mine_native(src_path, min_support=min_support, **run_params)
+
+            # Not in the miner's native format: transcode once to native file.
+            with temporary_directory() as tmp:
+                suffix = ".lg" if expected == "lg" else ".data"
+                native_path = tmp / f"native{suffix}"
+                transcode_path(src_path, native_path, dst_fmt=expected, src_fmt=src_fmt)
+                return miner.mine_native(native_path, min_support=min_support, **run_params)
+
+    graphs = _normalize_graph_source(data)
+    return miner.mine(graphs, min_support=min_support,**run_params)

submine/backends/gspan/CMakeLists.txt

@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.16)
+project(gspan_cpp_bindings LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+include(FetchContent)
+find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
+
+# ---- pybind11 (vendored) ----
+
+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()
+
+
+
+set(GSPAN_SOURCES
+  dfs.cpp
+  graph.cpp
+  gspan.cpp
+  ismin.cpp
+  misc.cpp
+)
+
+add_executable(gspan_cli
+  main.cpp
+  ${GSPAN_SOURCES}
+)
+target_include_directories(gspan_cli PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+pybind11_add_module(gspan_cpp
+  python_bindings.cpp
+  ${GSPAN_SOURCES}
+)
+target_include_directories(gspan_cpp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+set_target_properties(gspan_cpp PROPERTIES PREFIX "")
+
+# Warnings
+if (MSVC)
+  target_compile_options(gspan_cli PRIVATE /W4)
+  target_compile_options(gspan_cpp PRIVATE /W4)
+else()
+  target_compile_options(gspan_cli PRIVATE -Wall -Wextra -Wformat)
+  target_compile_options(gspan_cpp PRIVATE -Wall -Wextra -Wformat)
+endif()
+
+# ---- Install into the wheel ----
+install(TARGETS gspan_cpp
+  LIBRARY DESTINATION "submine/algorithms"
+  RUNTIME DESTINATION "submine/algorithms"
+  ARCHIVE DESTINATION "submine/algorithms"
+)

submine/backends/gspan/dfs.cpp

@@ -0,0 +1,98 @@
+/*
+    $Id: dfs.cpp,v 1.3 2004/05/21 05:50:13 taku-ku Exp $;
+ 
+   Copyright (C) 2004 Taku Kudo, All rights reserved.
+     This is free software with ABSOLUTELY NO WARRANTY.
+  
+   This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+    
+   This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+    
+   You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+     02111-1307, USA
+*/
+#include "gspan.h"
+#include <cstring>
+#include <string>
+#include <iterator>
+#include <set>
+
+namespace GSPAN {
+
+/* Build a DFS code from a given graph.
+ */
+void
+DFSCode::fromGraph (Graph &g)
+{
+	clear ();
+
+	EdgeList edges;
+	for (unsigned int from = 0 ; from < g.size () ; ++from) {
+		if (get_forward_root (g, g[from], edges) == false)
+			continue;
+
+		for (EdgeList::iterator it = edges.begin () ; it != edges.end () ; ++it)
+			push (from, (*it)->to, g[(*it)->from].label, (*it)->elabel, g[(*it)->to].label);
+	}
+}
+
+bool DFSCode::toGraph (Graph &g)
+{
+	g.clear ();
+
+	for (DFSCode::iterator it = begin(); it != end(); ++it) {
+		g.resize (std::max (it->from, it->to) + 1);
+
+		if (it->fromlabel != -1)
+			g[it->from].label = it->fromlabel;
+		if (it->tolabel != -1)
+			g[it->to].label = it->tolabel;
+
+		g[it->from].push (it->from, it->to, it->elabel);
+		if (g.directed == false)
+			g[it->to].push (it->to, it->from, it->elabel);
+	}
+
+	g.buildEdge ();
+
+	return (true);
+}
+
+unsigned int
+DFSCode::nodeCount (void)
+{
+	unsigned int nodecount = 0;
+
+	for (DFSCode::iterator it = begin() ; it != end() ; ++it)
+		nodecount = std::max (nodecount, (unsigned int) (std::max (it->from, it->to) + 1));
+
+	return (nodecount);
+}
+
+
+std::ostream &DFSCode::write (std::ostream &os)
+{
+	if (size() == 0) return os;
+
+	os << "(" << (*this)[0].fromlabel << ") " << (*this)[0].elabel << " (0f" << (*this)[0].tolabel << ")";
+
+	for (unsigned int i = 1; i < size(); ++i) {
+		if ((*this)[i].from < (*this)[i].to) {
+			os << " " << (*this)[i].elabel << " (" << (*this)[i].from << "f" << (*this)[i].tolabel << ")";
+		} else {
+			os << " " << (*this)[i].elabel << " (b" << (*this)[i].to << ")";
+		}
+	}
+
+	return os;
+}
+}
+

submine/backends/gspan/graph.cpp

@@ -0,0 +1,165 @@
+/*
+    $Id: graph.cpp,v 1.4 2004/05/21 05:50:13 taku-ku Exp $;
+ 
+   Copyright (C) 2004 Taku Kudo, All rights reserved.
+     This is free software with ABSOLUTELY NO WARRANTY.
+  
+   This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+    
+   This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+    
+   You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+     02111-1307, USA
+*/
+#include "gspan.h"
+#include <cstring>
+#include <string>
+#include <iterator>
+#include <strstream>
+#include <set>
+
+#include <assert.h>
+
+
+namespace GSPAN {
+
+template <class T, class Iterator>
+void tokenize (const char *str, Iterator iterator)
+{
+	std::istrstream is (str, std::strlen(str));
+	std::copy (std::istream_iterator <T> (is), std::istream_iterator <T> (), iterator);
+}
+
+void Graph::buildEdge ()
+{
+	char buf[512];
+	std::map <std::string, unsigned int> tmp;
+
+	unsigned int id = 0;
+	for (int from = 0; from < (int)size (); ++from) {
+		for (Vertex::edge_iterator it = (*this)[from].edge.begin ();
+				it != (*this)[from].edge.end (); ++it)
+		{
+			if (directed || from <= it->to)
+				std::sprintf (buf, "%d %d %d", from, it->to, it->elabel);
+			else
+				std::sprintf (buf, "%d %d %d", it->to, from, it->elabel);
+
+			// Assign unique id's for the edges.
+			if (tmp.find (buf) == tmp.end()) {
+				it->id = id;
+				tmp[buf] = id;
+				++id;
+			} else {
+				it->id = tmp[buf];
+			}
+		}
+	}
+
+	edge_size_ = id;
+}
+
+std::istream &Graph::read (std::istream &is)
+{
+	std::vector <std::string> result;
+	char line[1024];
+
+	clear ();
+
+	while (true) {
+
+		unsigned int pos = is.tellg ();
+		if (! is.getline (line, 1024))
+			break;
+		result.clear ();
+		tokenize<std::string>(line, std::back_inserter (result));
+
+		if (result.empty()) {
+			// do nothing
+		} else if (result[0] == "t") {
+			if (! empty()) { // use as delimiter
+				is.seekg (pos, std::ios_base::beg);
+				break;
+			} else {
+				/*
+				 * y = atoi (result[3].c_str());
+				 */
+			}
+		} else if (result[0] == "v" && result.size() >= 3) {
+			unsigned int id    = atoi (result[1].c_str());
+			this->resize (id + 1);
+			(*this)[id].label = atoi (result[2].c_str());
+		} else if (result[0] == "e" && result.size() >= 4) {
+			int from   = atoi (result[1].c_str());
+			int to     = atoi (result[2].c_str());
+			int elabel = atoi (result[3].c_str());
+
+			if ((int)size () <= from || (int)size () <= to) {
+				std::cerr << "Format Error:  define vertex lists before edges" << std::endl;
+				exit (-1);
+			}
+
+			(*this)[from].push (from, to, elabel);
+			if (directed == false)
+				(*this)[to].push (to, from, elabel);
+		}
+	}
+
+	buildEdge ();
+
+	return is;
+}
+
+std::ostream &Graph::write (std::ostream &os)
+{
+	char buf[512];
+	std::set <std::string> tmp;
+
+	for (int from = 0; from < (int)size (); ++from) {
+		os << "v " << from << " " << (*this)[from].label << std::endl;
+
+		for (Vertex::edge_iterator it = (*this)[from].edge.begin ();
+				it != (*this)[from].edge.end (); ++it) {
+			if (directed || from <= it->to) {
+				std::sprintf (buf, "%d %d %d", from, it->to,   it->elabel);
+			} else {
+				std::sprintf (buf, "%d %d %d", it->to,   from, it->elabel);
+			}
+			tmp.insert (buf);
+		}
+	}
+
+	for (std::set<std::string>::iterator it = tmp.begin(); it != tmp.end(); ++it) {
+			os << "e " << *it << std::endl;
+		}
+
+	return os;
+}
+
+void Graph::check (void)
+{
+	/* Check all indices
+	 */
+	for (int from = 0 ; from < (int)size () ; ++from) {
+		//mexPrintf ("check vertex %d, label %d\n", from, (*this)[from].label);
+
+		for (Vertex::edge_iterator it = (*this)[from].edge.begin ();
+			it != (*this)[from].edge.end (); ++it)
+		{
+			//mexPrintf ("   check edge from %d to %d, label %d\n", it->from, it->to, it->elabel);
+			assert (it->from >= 0 && it->from < size ());
+			assert (it->to >= 0 && it->to < size ());
+		}
+	}
+}
+
+}
+