def test_graph_is_subgraph_with_labels(self):
        G = nx.Graph()
        G.add_edges_from(
            [
                (1, 2, {'label': 'a'}),
                (2, 3, {'label': 'c'}),
                (3, 4, {'label': 'd'}),
                (2, 4, {'label': 'b'})
            ]
        )

        valid_subgraph_a = nx.Graph()
        valid_subgraph_a.add_edge(1, 2, label='a')

        valid_subgraph_b = nx.Graph()
        valid_subgraph_b.add_edge(3, 4, label='d')

        valid_subgraph_c = nx.Graph()
        valid_subgraph_c.add_edge(2, 1, label='a')

        invalid_subgraph_a = nx.Graph()
        invalid_subgraph_a.add_edge(1, 2, label='b')

        invalid_subgraph_b = nx.Graph()
        invalid_subgraph_b.add_edge(1, 4, label='a')

        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_a))
        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_b))
        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_c))

        self.assertFalse(ParsemisMiner.is_subgraph(G, invalid_subgraph_a))
        self.assertFalse(ParsemisMiner.is_subgraph(G, invalid_subgraph_b))
    def test_graph_is_subgraph_without_labels(self):
        G = nx.Graph()
        G.add_edges_from(
            [
                (1, 2),
                (2, 3),
                (3, 4),
                (2, 4)
            ]
        )

        valid_subgraph_a = nx.Graph()
        valid_subgraph_a.add_edge(1, 2)

        valid_subgraph_b = nx.Graph()
        valid_subgraph_b.add_edge(3, 4)

        valid_subgraph_c = nx.Graph()
        valid_subgraph_c.add_edge(4, 3)

        invalid_subgraph_b = nx.Graph()
        invalid_subgraph_b.add_edge(1, 4)

        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_a))
        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_b))
        self.assertTrue(ParsemisMiner.is_subgraph(G, valid_subgraph_c))

        self.assertFalse(ParsemisMiner.is_subgraph(G, invalid_subgraph_b))
    def test_similarity_when_same(self):
        super_graph = nx.Graph()
        super_graph.add_edge(1, 2, label='a')
        super_graph.add_edge(2, 3, label='b')

        sub_graph = super_graph.copy()

        self.assertEqual(ParsemisMiner.calculate_dot_product_similarity(super_graph, sub_graph), 1, 'Dot Product')
        self.assertEqual(ParsemisMiner.calculate_jaccard_similarity(super_graph, sub_graph), 1, 'Jaccard Similarity')
    def test_similarity_when_different(self):
        super_graph = nx.Graph()
        super_graph.add_edge(1, 2, label='a')
        super_graph.add_edge(2, 3, label='b')

        sub_graph = nx.Graph()
        sub_graph.add_edge(4, 5, label='c')
        sub_graph.add_edge(5, 6, label='d')

        self.assertEqual(ParsemisMiner.calculate_dot_product_similarity(super_graph, sub_graph), 0, 'Dot Product')
        self.assertEqual(ParsemisMiner.calculate_jaccard_similarity(super_graph, sub_graph), 0, 'Jaccard Similarity')
This short example shows how you can mine frequent graphs using the wrapper
"""
from parsemis.parsemis_wrapper import ParsemisMiner
import networkx as nx
import os

# Load our graphs
graph_folder = "example_dataset"
graphs = []
for f in os.listdir(graph_folder):
    path = "%s/%s" % (graph_folder, f)
    graphs.append(nx.read_gml(path))

frequent_graphs = ParsemisMiner("data",
                                minimum_frequency="1%",
                                close_graph=True,
                                store_embeddings=False,
                                debug=True,
                                mine_undirected=True).mine_graphs(graphs)

# Count our subgraphs
frequent_graph_counts = []
for frequent_graph in frequent_graphs:
    count = 0
    for graph in graphs:
        if graph.graph['id'] in frequent_graph.appears_in:
            count += 1
    frequent_graph_counts.append((count, frequent_graph))

for frequent_graph in sorted(frequent_graph_counts,
                             key=lambda subgraph: subgraph[0],
                             reverse=True):