Пример #1
0
def __generate_motifs__(x=208):
    """ 
    Return the atlas of all connected graphs of 5 nodes or less.
    Uses networkx graph atlas, which returns all possible graphs with up to 7 nodes, based on https://networkx.github.io/documentation/stable/auto_examples/drawing/plot_atlas.html

    Parameters:
        x (int): which motifs of the graph atlas are returned
    Returns:
        graph atlas: contains all possible graphs of specified size as shown in the graph atlas
    """

    #uses networkx graph atlas, which returns all possible graphs with up to 6 nodes
    #based on https://networkx.github.io/documentation/stable/auto_examples/drawing/plot_atlas.html
    Atlas = graph_atlas_g()[0:x]
    # remove isolated nodes, only connected graphs are left
    U = nx.Graph()  # graph for union of all graphs in atlas
    for G in Atlas:
        zerodegree = [n for n in G if G.degree(n) == 0]
        for n in zerodegree:
            G.remove_node(n)
        U = nx.disjoint_union(U, G)

    # list of graphs of all connected components
    C = (U.subgraph(c) for c in nx.connected_components(U))

    UU = nx.Graph()
    # do quick isomorphic-like check, not a true isomorphism checker
    nlist = []  # list of nonisomorphic graphs
    for G in C:
        # check against all nonisomorphic graphs so far

        if not __iso__(G, nlist):
            nlist.append(G)
            UU = nx.disjoint_union(UU, G)  # union the nonisomorphic graphs
    return UU
Пример #2
0
def atlas6():
    """ Return the atlas of all connected graphs of 6 nodes or less.
        Attempt to check for isomorphisms and remove.
    """

    Atlas = graph_atlas_g()[0:208]  # 208
    # remove isolated nodes, only connected graphs are left
    U = nx.Graph()  # graph for union of all graphs in atlas
    for G in Atlas:
        zerodegree = [n for n in G if G.degree(n) == 0]
        for n in zerodegree:
            G.remove_node(n)
        U = nx.disjoint_union(U, G)

    # list of graphs of all connected components
    C = nx.connected_component_subgraphs(U)

    UU = nx.Graph()
    # do quick isomorphic-like check, not a true isomorphism checker
    nlist = []  # list of nonisomorphic graphs
    for G in C:
        # check against all nonisomorphic graphs so far
        if not iso(G, nlist):
            nlist.append(G)
            UU = nx.disjoint_union(UU, G)  # union the nonisomorphic graphs
    return UU
Пример #3
0
    def setup_class(cls):
        global atlas
        #        import platform
        #        if platform.python_implementation() == 'Jython':
        #            raise SkipTest('graph atlas not available under Jython.')
        import networkx.generators.atlas as atlas

        cls.GAG = atlas.graph_atlas_g()
Пример #4
0
    def setup_class(cls):
        global atlas
        import platform
        if platform.python_implementation() == 'Jython':
            pytest.mark.skip('graph atlas not available under Jython.')
        import networkx.generators.atlas as atlas

        cls.GAG = atlas.graph_atlas_g()
Пример #5
0
    def create_examples(self, file_base, file_name):
        """Generate some initial starting configs by generating them via the config_generator"""
        ex_curr = 0

        num_hosts = 1
        num_vlans = 2

        def get_serialno(*_args, **_kwargs):
            """"Return mock serial number"""
            self.serial += 1
            return self.serial

        def create_config(network_graph, stack=True):
            """Return topo object and a simple stack config generated from network_graph"""
            host_links = {}
            host_vlans = {}
            dp_options = {}
            host_n = 0
            for dp_i in network_graph.nodes():
                for _ in range(num_hosts):
                    for v_i in range(num_vlans):
                        host_links[host_n] = [dp_i]
                        host_vlans[host_n] = v_i
                        host_n += 1
                dp_options[dp_i] = {'hardware': 'GenericTFM'}
                if dp_i == 0 and stack:
                    dp_options[dp_i]['stack'] = {'priority': 1}
            switch_links = list(network_graph.edges()) * 2
            if stack:
                link_vlans = {link: None for link in switch_links}
            else:
                link_vlans = {link: list(range(num_vlans)) for link in switch_links}
            topo = FaucetFakeOFTopoGenerator(
                'ovstype', 'portsock', 'testname',
                len(network_graph.nodes()), False,
                host_links, host_vlans, switch_links, link_vlans,
                start_port=1, port_order=[0, 1, 2, 3],
                get_serialno=get_serialno)
            config = topo.get_config(num_vlans, dp_options=dp_options)
            return config

        configs = []
        topologies = graph_atlas_g()
        for graph in topologies:
            if not graph or not networkx.is_connected(graph):
                continue
            if len(graph.nodes()) > 4:
                break
            for stack in (True, False):
                configs.append(create_config((graph), stack=stack))
        for config in configs:
            ex_fn = os.path.join(file_base, '%s_%s' % (file_name, ex_curr))
            with open(ex_fn, 'w+') as ex_file:
                ex_file.write(config)
            ex_curr += 1
Пример #6
0
    def test_graph_atlas(self):
        """Test saving and loading all the graphs in the networkx graph
        atlas.

        """
        for g in graph_atlas_g():
            print(g.name)
            gormg = self.engine.new_graph(g.name, g)
            for n in g.node:
                self.assertIn(n, gormg.node)
                self.assertEqual(g.node[n], gormg.node[n])
            for u in g.edge:
                for v in g.edge[u]:
                    self.assertIn(u, gormg.edge)
                    self.assertIn(v, gormg.edge[u])
                    self.assertEqual(g.edge[u][v], gormg.edge[u][v])
Пример #7
0
def get_graphlet_dict(k):
    """
    Generate a dict of lists of all graphlets of size up to 'k', keyed by
    size of graphlet. Uses networkx atlas.
    """
    from networkx.generators.atlas import graph_atlas_g
    assert k > 0
    atlas = graph_atlas_g()[1:]
    graphlet_dict = {i: [] for i in range(1, k + 1)}
    for graph in atlas:
        n = graph.number_of_nodes()
        if n > k:
            break
        if nx.is_connected(graph):
            graphlet_dict[n].append(graph)
    return graphlet_dict
Пример #8
0
def graphlet_list(k):
    """
    Generate list of all graphlets of size 'k'.
    List is taken from graph_atlas of networkx.
    """
    from networkx.generators.atlas import graph_atlas_g
    assert k > 0
    atlas = graph_atlas_g()[1:]
    graphlet_list = []
    for G in atlas:
        n = G.number_of_nodes()
        if n < k:
            continue
        if n > k:
            break
        if nx.is_connected(G):
            graphlet_list.append(G)
    return graphlet_list
Пример #9
0
def isomorphism_checker(g, graph_list=None):
    """ Finds the name of the graph by checking for isomorphism with the graphs in the graph_list.

    Notes
    -----
    If g is a MultiGraph, a DiGraph or a MultiDiGraph, the isomorphism is run against the underlying Graph.
    In other words, all the edge annotations (including directions) are ignored.

    Parameters
    ----------
    g : A networkx Graph.
    graph_list :
        A list of networkx.Graph objects against which to check for isomorphism.
        If the graphs in the list do not have names, then their index will be returned as a string

    Returns
    -------
    iso_name : str, or None
        The name of the graph from the graph_list that is isomorphic to g.
        If the graph does not have a 'name' attribute, its index in the list will be returned as a string.
        None if no such isomorph is found in the list_of_graphs.

    """
    if graph_list is None:
        graph_list = graph_atlas_g()
    # run isomorphism check on the Graph of g (i.e. not the DiGraph or MultiGraph).
    h = graph_to_plain_graph(g)
    isomorph = next(filter(lambda x: networkx.is_isomorphic(h, x), graph_list),
                    None)
    if isomorph is None:
        return
    else:
        iso_name = isomorph.name
        if iso_name is None:
            iso_name = str(graph_list.index(isomorph))
    return iso_name
Пример #10
0
                                       int(dst_dpid),
                                       port=dst_port)


def test_generator(param):
    """Return the function that will start testing the topology/topologies"""
    def test(self):
        """Setup & test topology"""
        self.set_up(param)

    return test


if __name__ == '__main__':
    GRAPHS = {}
    GRAPH_ATLAS = graph_atlas_g()
    for graph in GRAPH_ATLAS:
        if (not graph or len(graph.nodes()) < 2
                or not networkx.is_connected(graph)):
            continue
        GRAPHS.setdefault(graph.number_of_nodes(), [])
        GRAPHS[graph.number_of_nodes()].append(graph)
        for test_class in (ValveTopologyVLANTest, ValveTopologyTableTest):
            test_name = 'test_%s' % graph.name
            test_func = test_generator(graph)
            setattr(test_class, test_name, test_func)
    for num_dps, nl in GRAPHS.items():
        chunk = 50
        batch = 1
        for test_class in (ValveTopologyRestartTest, ):
            for i in range(0, len(nl), chunk):
Пример #11
0
 def atlas_graphs(self):
     graph_list = graph_atlas_g()
     return graph_list
Пример #12
0
 def setUp(self):
     self.GAG = atlas.graph_atlas_g()
Пример #13
0
======

Write first 20 graphs from the graph atlas as graphviz dot files
Gn.dot where n=0,19.
"""
# Author: Aric Hagberg ([email protected])
# Date: 2005-05-19 14:23:02 -0600 (Thu, 19 May 2005)

#    Copyright (C) 2006-2019 by
#    Aric Hagberg <*****@*****.**>
#    Dan Schult <*****@*****.**>
#    Pieter Swart <*****@*****.**>
#    All rights reserved.
#    BSD license.

import networkx as nx
from networkx.generators.atlas import graph_atlas_g

atlas = graph_atlas_g()[0:20]

for G in atlas:
    print("graph %s has %d nodes with %d edges"
          % (G.name, nx.number_of_nodes(G), nx.number_of_edges(G)))
    A = nx.nx_agraph.to_agraph(G)
    A.graph_attr['label'] = G.name
    # set default node attributes
    A.node_attr['color'] = 'red'
    A.node_attr['style'] = 'filled'
    A.node_attr['shape'] = 'circle'
    A.write(G.name + '.dot')
Пример #14
0
    def setup_class(cls):
        global atlas
        import networkx.generators.atlas as atlas

        cls.GAG = atlas.graph_atlas_g()
Пример #15
0
 def setUp(self):
     self.GAG=atlas.graph_atlas_g()
Пример #16
0
"""
======
Atlas2
======

Write first 20 graphs from the graph atlas as graphviz dot files
Gn.dot where n=0,19.
"""

import networkx as nx
from networkx.generators.atlas import graph_atlas_g

atlas = graph_atlas_g()[0:20]

for G in atlas:
    print(G)
    A = nx.nx_agraph.to_agraph(G)
    A.graph_attr["label"] = G.name
    # set default node attributes
    A.node_attr["color"] = "red"
    A.node_attr["style"] = "filled"
    A.node_attr["shape"] = "circle"
    A.write(G.name + ".dot")
Пример #17
0
class ClassGenerator:
    """Generates the required classes for the integration tests"""

    GRAPH_ATLAS = graph_atlas_g()

    MAX_TESTS = 150

    graphs = None

    def __init__(self):
        """Initialize the graph atlas"""
        self.graphs = {}
        for graph in self.GRAPH_ATLAS:
            if not graph or len(
                    graph.nodes()) < 2 or not networkx.is_connected(graph):
                continue
            self.graphs.setdefault(graph.number_of_nodes(), [])
            self.graphs[graph.number_of_nodes()].append(graph)

    @staticmethod
    def setup_generator(func):
        """Returns the class set_up function"""
        def set_up(self, graphs):
            self.graphs = graphs
            self.topo, self.CONFIG = self.create_topo_config(graphs[0])
            self.setup_valves(self.CONFIG)
            func(self)

        return set_up

    @staticmethod
    def test_generator(graphs):
        """Returns the test set_up function"""
        def test(self):
            self.set_up(graphs)

        return test

    @staticmethod
    def sums(length, total_sum):
        """Returns the permutations of `length` numbers that sum to `total_sum`"""
        if length == 1:
            yield (total_sum, )
        else:
            for value in range(total_sum + 1):
                for permutation in ClassGenerator.sums(length - 1,
                                                       total_sum - value):
                    yield (value, ) + permutation

    def generate_atlas_class(self, class_name, verify_name, constants):
        """Return a class type generated as each test generated from the graph atlas"""
        test_class = type(class_name, (ValveGenerativeBase, ), {**constants})
        verify_func = getattr(test_class, verify_name)
        set_up = self.setup_generator(verify_func)
        setattr(test_class, 'set_up', set_up)
        for graphs in self.graphs.values():
            for graph in graphs:
                test_func = self.test_generator([graph])
                test_name = 'test_%s' % graph.name
                setattr(test_class, test_name, test_func)
        return test_class

    def generate_atlas_size_class(self, class_name, verify_name, constants):
        """Return a class type as each test generated from a set of tests in the graph atlas"""
        test_class = type(class_name, (ValveGenerativeBase, ), {**constants})
        verify_func = getattr(test_class, verify_name)
        set_up = self.setup_generator(verify_func)
        setattr(test_class, 'set_up', set_up)
        for num_dps, graph_list in self.graphs.items():
            test_func = self.test_generator(graph_list)
            test_name = 'test_reconfigure_topologies_%s_dps' % num_dps
            setattr(test_class, test_name, test_func)
        return test_class

    def generate_spine_and_leaf_class(self, class_name, verify_name,
                                      constants):
        """Return a class type as each test generated from a set of tests in the graph atlas"""
        test_class = type(class_name, (ValveGenerativeBase, ), {**constants})
        verify_func = getattr(test_class, verify_name)
        set_up = self.setup_generator(verify_func)
        setattr(test_class, 'set_up', set_up)
        curr_nodes = 8
        curr_tests = 0
        # Iteratively generate spine & leaf networks until `MAX_TESTS` stopping point
        # By testing all non-isomorphic topologies up to (and including) 7 nodes,
        #   SPINE_NODES + LEAF_NODES <= 7 are already tested
        # Loop until we have reached a desired number of tests
        while curr_tests <= self.MAX_TESTS:
            # Get permutations of numbers that sum to the current number of nodes
            # The current number of nodes will be split between the two partites of the topology
            for nodes in ClassGenerator.sums(2, curr_nodes):
                if 0 in nodes or nodes[0] > nodes[1]:
                    # Ignore empty partites or inverse solutions
                    continue
                test_name = 'test_%s_%s_spine_and_%s_leaf_topology' % (
                    curr_tests, nodes[0], nodes[1])
                graph = networkx.complete_multipartite_graph(*nodes)
                test_func = self.test_generator([graph])
                setattr(test_class, test_name, test_func)
                curr_tests += 1
                if curr_tests > self.MAX_TESTS:
                    break
            # Increase current number of nodes
            curr_nodes += 1
        return test_class