def setUp(self):
     self.P4 = nx.path_graph(4)
     self.K3 = nx.complete_bipartite_graph(3,3)
     self.C4 = nx.cycle_graph(4)
     self.davis = nx.davis_southern_women_graph()
     self.top_nodes = [n for n,d in self.davis.nodes(data=True) 
                       if d['bipartite']==0]

 def test_davis_southern_women_graph(self):
     G = nx.davis_southern_women_graph()
     nx.set_edge_attributes(G, 1, 'capacity')
     for flow_func in flow_funcs:
         T = nx.gomory_hu_tree(G, flow_func=flow_func)
         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 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 GraphType(num_nodes, str, p=0.05, m=3):
    """
    :param num_nodes: the number of nodes of the graph (if that option is available)
    :param str: the type of graph that is used. We have
                'erdos'         an erdos renyi graph
                'powerlaw'      a graph with powerlaw degree distribution
                'enron'         a social network graph loaded from
                                http://snap.stanford.edu/data/email-Enron.html. (36692 nodes)
                'karateclub'    some karate club graph
                'women'         women social network
    :return: the graph
    """
    if str == 'erdos':
        graph = nx.erdos_renyi_graph(num_nodes, p)
    elif str == 'powerlaw':
        graph = nx.powerlaw_cluster_graph(num_nodes, m, p)
    elif str == 'enron':
        graph = nx.Graph()
        edges = np.loadtxt('Enron.txt',skiprows=4)
        graph.add_edges_from(edges)
    elif str == 'karateclub':
        graph = nx.karate_club_graph()
    elif str == 'women':
        graph = nx.davis_southern_women_graph()
    elif str == 'pair':
        graph = nx.DiGraph()
        graph.add_edge(0,1)
        graph.add_edge(1,0)
    elif str == 'star':
        graph = nx.star_graph(num_nodes)
    elif str == 'cycle':
        graph = nx.cycle_graph(num_nodes)
    elif str == 'config':
        max_degree = int(num_nodes/5)
        #Create some degrees
        degrees = np.asarray(np.round(np.exp(np.log(max_degree) * np.random.uniform(size=num_nodes))), np.int)
        #Ensure the total number of degrees is even
        if sum(degrees) % 2 != 0:
            degrees[np.random.randint(num_nodes)] += 2 * np.random.randint(2) - 1
        #Create a graph and apply the configuration model
        graph = nx.Graph()
        graph = nx.configuration_model(degrees, graph)
        graph = graph.to_directed()

    return graph

def test_generalized_similarity():
    """
    Calculate the generalized similarities between events and women 
    in the "classical" Southern Women graph.
    """

    graph = nx.davis_southern_women_graph()
    women, events, eps, iters = generalized.generalized_similarity(graph)

    print("Number of iterations:", iters)
    print("Attained precision:", eps)
    print("Event network:", len(events), "nodes")
    print("Least similar events:", 
          sorted(events.edges(data=True), key=lambda x: x[2]['weight'])[0][0:2])
    print("Women network:", len(women), "nodes")
    print("Least similar women:", 
          sorted(women.edges(data=True), key=lambda x: x[2]['weight'])[0][0:2])
    with open("examples/women.graphml","wb") as ofile:
        nx.write_graphml(women, ofile)
    with open("examples/events.graphml","wb") as ofile:
        nx.write_graphml(events, ofile)

def main():
    g = nx.Graph()
    nodes = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,32]
    edges= [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 10), (1, 2), (1, 3), (1, 7),
            (2, 3), (2, 32), (2, 7), (2, 8), (2, 9),(3, 7),(4, 10), (4, 6),(5, 10), (5, 6)]
    g.add_nodes_from(nodes)
    g.add_edges_from(edges)
    source = 0
    
    #the default method delivered from the networkx
    print list(nx.bfs_edges(g,0))
    
    #call to the bfs
    final_edges = bfs(g,source)
    display_graph(final_edges)
    print "bfs done"
    #Call to the pivot random walk
    pivot_random_walk(g,source,20)
    print "pivot random done"
    #Call to the pivot random walk
    g= nx.davis_southern_women_graph()
    weighted_independence(g,25)
    print "completion"

def test_davis_southern_women_detail_3_and_4():
    solution = {
        3: [{
            'Nora Fayette',
            'E10',
            'Myra Liddel',
            'E12',
            'E14',
            'Frances Anderson',
            'Evelyn Jefferson',
            'Ruth DeSand',
            'Helen Lloyd',
            'Eleanor Nye',
            'E9',
            'E8',
            'E5',
            'E4',
            'E7',
            'E6',
            'E1',
            'Verne Sanderson',
            'E3',
            'E2',
            'Theresa Anderson',
            'Pearl Oglethorpe',
            'Katherina Rogers',
            'Brenda Rogers',
            'E13',
            'Charlotte McDowd',
            'Sylvia Avondale',
            'Laura Mandeville',
            },
        ],
        4: [{
            'Nora Fayette',
            'E10',
            'Verne Sanderson',
            'E12',
            'Frances Anderson',
            'Evelyn Jefferson',
            'Ruth DeSand',
            'Helen Lloyd',
            'Eleanor Nye',
            'E9',
            'E8',
            'E5',
            'E4',
            'E7',
            'E6',
            'Myra Liddel',
            'E3',
            'Theresa Anderson',
            'Katherina Rogers',
            'Brenda Rogers',
            'Charlotte McDowd',
            'Sylvia Avondale',
            'Laura Mandeville',
            },
        ],
    }
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    for k, components in result.items():
        if k < 3:
            continue
        assert_true(len(components) == len(solution[k]))
        for component in components:
            assert_true(component in solution[k])

def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    _check_connectivity(G)

        adj_iter : iterator
           An iterator of (node, adjacency set) for all nodes in
           the graph.

        """
        for n in self.adj:
            yield (n, set(self.adj) - set(self.adj[n]) - set([n]))


if __name__ == '__main__':
    # Build several pairs of graphs, a regular graph
    # and the AntiGraph of it's complement, which behaves
    # as if it were the original graph.
    Gnp = nx.gnp_random_graph(20,0.8)
    Anp = AntiGraph(nx.complement(Gnp))
    Gd = nx.davis_southern_women_graph()
    Ad = AntiGraph(nx.complement(Gd))
    Gk = nx.karate_club_graph()
    Ak = AntiGraph(nx.complement(Gk))
    pairs = [(Gnp, Anp), (Gd, Ad), (Gk, Ak)]
    # test connected components
    for G, A in pairs:
        gc = [set(c) for c in nx.connected_components(G)]
        ac = [set(c) for c in nx.connected_components(A)]
        for comp in ac:
            assert comp in gc
    # test biconnected components
    for G, A in pairs:
        gc = [set(c) for c in nx.biconnected_components(G)]
        ac = [set(c) for c in nx.biconnected_components(A)]
        for comp in ac:

def test_is_aperiodic_bipartite():
    # Bipartite graph
    G = nx.DiGraph(nx.davis_southern_women_graph())
    assert_false(nx.is_aperiodic(G))

def test_biconnected_davis():
    D = nx.davis_southern_women_graph()
    bcc = list(biconnected.biconnected_components(D))[0]
    assert_true(set(D) == bcc) # All nodes in a giant bicomponent
    # So no articulation points
    assert_equal(list(biconnected.articulation_points(D)),[])

def test_davis_southern_women():
    G = nx.davis_southern_women_graph()
    result = nx.k_components(G)
    _check_connectivity(G, result)

def test_ra_clustering_davis():
    G = nx.davis_southern_women_graph()
    cc4 = round(bipartite.robins_alexander_clustering(G), 3)
    assert_equal(cc4, 0.468)

import networkx as nx
import matplotlib.pylab as plt
from plot_multigraph import plot_multigraph

graphs = [
  ('karate_club_graph', nx.karate_club_graph()),
  ('davis_southern_women_graph', nx.davis_southern_women_graph()),
  ('florentine_families_graph', nx.florentine_families_graph()),
]

plot_multigraph(graphs, 2, 2, node_size=50)
plt.savefig('graphs/social.png')