def test_edge_num_attribute(self):

        g = nx.karate_club_graph()
        attr = {(u, v): {"even": int((u+v) % 10)} for (u, v) in g.edges()}
        nx.set_edge_attributes(g, attr)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.EdgeNumericalAttribute("even", value=0, op="==", probability=1)
        model.add_rule("Susceptible", "Infected", c)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(10)
        self.assertEqual(len(iterations), 10)

        model = gc.CompositeModel(g)
        model.add_status("Susceptible")
        model.add_status("Infected")

        c = cpm.EdgeNumericalAttribute("even", value=[3, 10], op="IN", probability=1)
        model.add_rule("Susceptible", "Infected", c)

        config = mc.Configuration()
        config.add_model_parameter('percentage_infected', 0.1)

        model.set_initial_status(config)
        iterations = model.iteration_bunch(10)
        self.assertEqual(len(iterations), 10)

def main():
    # Load the karate.GraphML and store that into a g
    g =nx.karate_club_graph()
    data = json_graph.node_link_data(g)

    with open ('graph.json' , 'w') as f:
        json.dump(data, f, indent=1)

 def test_nodes_all_labeled(self):
     G = nx.karate_club_graph()
     label_name = 'club'
     predicted = node_classification.local_and_global_consistency(
         G, alpha=0, label_name=label_name)
     for i in range(len(G)):
         assert_equal(predicted[i], G.node[i][label_name])

 def test_run(self):
     karate = nx.karate_club_graph()
     louvain = wm.LouvainCommunityDetection(karate)
     final_partitions = louvain.run()
     self.assertEqual(final_partitions[-1].modularity() > .38,
                      True)
     self.assertEqual(len(final_partitions), 2)

 def test_clustering_integer_nodes(self):
     # This tests an error that would happen when a node had an integer value
     # greater than the size of the graph
     orig_club = nx.karate_club_graph()
     club = nx.relabel_nodes(orig_club, { n: n + 5 for n in orig_club.nodes() })
     dendrogram = GreedyAgglomerativeClusterer().cluster(club)
     dendrogram.clusters() # This would crash

 def test_nodes_all_labeled(self):
     G = nx.karate_club_graph()
     label_name = 'club'
     predicted = node_classification.harmonic_function(
         G, label_name=label_name)
     for i in range(len(G)):
         assert_equal(predicted[i], G.node[i][label_name])

def test_graphs_karate():
    G = nx.karate_club_graph()
    nx.draw(G, with_labels=True, node_color="lightblue", edge_color="grey")
    plt.show()
    # plt.savefig("karate.pdf")
    print(G.number_of_edges())
    print(G.number_of_nodes())
    print(G.degree(0) is G.degree()[0])

    def test_net_load(self):
        base = os.path.dirname(os.path.abspath(__file__))

        g = nx.karate_club_graph()
        fname = "%s/edge.txt" % base
        nx.write_edgelist(g, fname)

        query = "LOAD_NETWORK g1 FROM %s\n" \
                "\n" \
                "MODEL model1\n" \
                "\n" \
                "STATUS Susceptible\n" \
                "\n" \
                "STATUS Infected\n" \
                "\n" \
                "STATUS Removed\n" \
                "\n" \
                "COMPARTMENT c1\n" \
                "TYPE NodeStochastic\n" \
                "PARAM rate 0.1\n" \
                "TRIGGER Infected\n" \
                "\n" \
                "COMPARTMENT c2\n" \
                "TYPE NodeStochastic\n" \
                "PARAM rate 0.1\n" \
                "COMPOSE c1\n" \
                "TRIGGER Infected\n" \
                "\n" \
                "COMPARTMENT c3\n" \
                "TYPE NodeStochastic\n" \
                "PARAM rate 0.1\n" \
                "\n" \
                "RULE\n" \
                "FROM Susceptible\n" \
                "TO Infected\n" \
                "USING c2\n" \
                "\n" \
                "RULE\n" \
                "FROM Infected\n" \
                "TO Removed\n" \
                "USING c3\n" \
                "\n" \
                "INITIALIZE\n" \
                "SET Infected 0.1\n" \
                "\n" \
                "EXECUTE model1 ON g1 FOR 10" % fname

        parser = ep.ExperimentParser()
        parser.set_query(query)
        parser.parse()
        iterations = parser.execute_query()

        try:
            os.remove("%s/edge.txt" % base)
        except OSError:
            pass

        self.assertIn('trends', iterations[0])

def test_karate_1():
    karate_k_num = {0: 4, 1: 4, 2: 4, 3: 4, 4: 3, 5: 3, 6: 3, 7: 4, 8: 4, 9: 2,
                    10: 3, 11: 1, 12: 2, 13: 4, 14: 2, 15: 2, 16: 2, 17: 2, 18: 2,
                    19: 3, 20: 2, 21: 2, 22: 2, 23: 3, 24: 3, 25: 3, 26: 2, 27: 3,
                    28: 3, 29: 3, 30: 4, 31: 3, 32: 4, 33: 4}
    G = nx.karate_club_graph()
    k_comps = k_components(G)
    k_num = build_k_number_dict(k_comps)
    assert_equal(karate_k_num, k_num)

 def test_karate_club_graph_cutset(self):
     G = nx.karate_club_graph()
     nx.set_edge_attributes(G, 1, 'capacity')
     T = nx.gomory_hu_tree(G)
     assert_true(nx.is_tree(T))
     u, v = 0, 33
     cut_value, edge = self.minimum_edge_weight(T, u, v)
     cutset = self.compute_cutset(G, T, edge)
     assert_equal(cut_value, len(cutset))

 def test_default_flow_function_karate_club_graph(self):
     G = nx.karate_club_graph()
     nx.set_edge_attributes(G, 1, 'capacity')
     T = nx.gomory_hu_tree(G)
     assert_true(nx.is_tree(T))
     for u, v in combinations(G, 2):
         cut_value, edge = self.minimum_edge_weight(T, u, v)
         assert_equal(nx.minimum_cut_value(G, u, v),
                      cut_value)

def main():
    G = nx.karate_club_graph()
    N = NewmanGreedy(G)
    print N.quality_history
    try:
        N.plot_dendrogram()
        N.plot_quality_history("Karate", os.path.join(os.path.dirname(__file__), "pics", "karate"))
    except:
        pass

def test_biconnected_karate():
    K = nx.karate_club_graph()
    answer = [{0, 1, 2, 3, 7, 8, 9, 12, 13, 14, 15, 17, 18, 19,
               20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33},
              {0, 4, 5, 6, 10, 16},
              {0, 11}]
    bcc = list(nx.biconnected_components(K))
    assert_components_equal(bcc, answer)
    assert_equal(set(nx.articulation_points(K)), {0})

def test_biconnected_karate():
    K = nx.karate_club_graph()
    answer = [set([0, 1, 2, 3, 7, 8, 9, 12, 13, 14, 15, 17, 18, 19,
                20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33]),
                set([0, 4, 5, 6, 10, 16]),
                set([0, 11])]
    bcc = list(biconnected.biconnected_components(K))
    bcc.sort(key=len, reverse=True)
    assert_true(list(biconnected.biconnected_components(K)) == answer)
    assert_equal(list(biconnected.articulation_points(K)),[0])

def main():
    graph = nx.karate_club_graph();
    dendrogram = GreedyAgglomerativeClusterer().cluster(graph)
    print dendrogram.quality_history
    print dendrogram.clusters()
    try:
        dendrogram.plot(os.path.join(os.path.dirname(__file__), '..', 'pics', 'karate_dend.png'), show=False)
        dendrogram.plot_quality_history('Karate', os.path.join(os.path.dirname(__file__), '..', 'pics', 'karate'), show=False)
    except:
        pass

def main():
    graph = nx.karate_club_graph();
    newman = NewmanGreedy(graph)
    print newman.quality_history
    print newman.get_clusters()
    try:
        newman.plot_dendrogram(os.path.join(os.path.dirname(__file__), '..', 'pics', 'karate_dend.png'), show=False)
        newman.plot_quality_history('Karate', os.path.join(os.path.dirname(__file__), '..', 'pics', 'karate'), show=False)
    except:
        pass

def write_karate_adj_mat_by_nx():
	g = nx.karate_club_graph()
	mat = np.zeros((34, 34))
	for edge in nx.edges(g):
		node0 = int(edge[0])
		node1 = int(edge[1])
		mat[node0][node1] = 1
		mat[node1][node0] = 1

	np.savetxt("karate_adj_mat.csv", mat, fmt="%.0f", delimiter=",")

def test_postprocessing():
    G = nx.karate_club_graph()
    prediction_all_links = CommonNeighbours(G)()
    prediction_only_new_links = CommonNeighbours(G, excluded=G.edges())()

    for link, score in six.iteritems(prediction_all_links):
        if G.has_edge(*link):
            assert_not_in(link, prediction_only_new_links)
        else:
            assert_equal(score, prediction_only_new_links[link])

 def setUp(self):
     self.Gnp = nx.gnp_random_graph(20, 0.8)
     self.Anp = _AntiGraph(nx.complement(self.Gnp))
     self.Gd = nx.davis_southern_women_graph()
     self.Ad = _AntiGraph(nx.complement(self.Gd))
     self.Gk = nx.karate_club_graph()
     self.Ak = _AntiGraph(nx.complement(self.Gk))
     self.GA = [(self.Gnp, self.Anp),
                (self.Gd, self.Ad),
                (self.Gk, self.Ak)]

def loadData(nameGraph):
    global gt
    global problem_name
    problem_name=nameGraph
    if (nameGraph==karate_club):
        graph=nx.karate_club_graph()  #standard graph in networkx
        gt=ksgt
    elif (nameGraph==dolphins):
        graph=nx.read_gml('..\data\dolphins\dolphins.gml')
        gt=dgt
    return graph