804 lines
26 KiB
Python
804 lines
26 KiB
Python
|
import pickle
|
||
|
|
import gc
|
||
|
|
|
||
|
|
import networkx as nx
|
||
|
|
from networkx.testing.utils import (
|
||
|
|
assert_graphs_equal,
|
||
|
|
assert_edges_equal,
|
||
|
|
assert_nodes_equal,
|
||
|
|
)
|
||
|
|
|
||
|
|
import pytest
|
||
|
|
|
||
|
|
|
||
|
|
class BaseGraphTester:
|
||
|
|
""" Tests for data-structure independent graph class features."""
|
||
|
|
|
||
|
|
def test_contains(self):
|
||
|
|
G = self.K3
|
||
|
|
assert 1 in G
|
||
|
|
assert 4 not in G
|
||
|
|
assert "b" not in G
|
||
|
|
assert [] not in G # no exception for nonhashable
|
||
|
|
assert {1: 1} not in G # no exception for nonhashable
|
||
|
|
|
||
|
|
def test_order(self):
|
||
|
|
G = self.K3
|
||
|
|
assert len(G) == 3
|
||
|
|
assert G.order() == 3
|
||
|
|
assert G.number_of_nodes() == 3
|
||
|
|
|
||
|
|
def test_nodes(self):
|
||
|
|
G = self.K3
|
||
|
|
assert sorted(G.nodes()) == self.k3nodes
|
||
|
|
assert sorted(G.nodes(data=True)) == [(0, {}), (1, {}), (2, {})]
|
||
|
|
|
||
|
|
def test_has_node(self):
|
||
|
|
G = self.K3
|
||
|
|
assert G.has_node(1)
|
||
|
|
assert not G.has_node(4)
|
||
|
|
assert not G.has_node([]) # no exception for nonhashable
|
||
|
|
assert not G.has_node({1: 1}) # no exception for nonhashable
|
||
|
|
|
||
|
|
def test_has_edge(self):
|
||
|
|
G = self.K3
|
||
|
|
assert G.has_edge(0, 1)
|
||
|
|
assert not G.has_edge(0, -1)
|
||
|
|
|
||
|
|
def test_neighbors(self):
|
||
|
|
G = self.K3
|
||
|
|
assert sorted(G.neighbors(0)) == [1, 2]
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.neighbors(-1)
|
||
|
|
|
||
|
|
def test_memory_leak(self):
|
||
|
|
G = self.Graph()
|
||
|
|
|
||
|
|
def count_objects_of_type(_type):
|
||
|
|
return sum(1 for obj in gc.get_objects() if isinstance(obj, _type))
|
||
|
|
|
||
|
|
gc.collect()
|
||
|
|
before = count_objects_of_type(self.Graph)
|
||
|
|
G.copy()
|
||
|
|
gc.collect()
|
||
|
|
after = count_objects_of_type(self.Graph)
|
||
|
|
assert before == after
|
||
|
|
|
||
|
|
# test a subgraph of the base class
|
||
|
|
class MyGraph(self.Graph):
|
||
|
|
pass
|
||
|
|
|
||
|
|
gc.collect()
|
||
|
|
G = MyGraph()
|
||
|
|
before = count_objects_of_type(MyGraph)
|
||
|
|
G.copy()
|
||
|
|
gc.collect()
|
||
|
|
after = count_objects_of_type(MyGraph)
|
||
|
|
assert before == after
|
||
|
|
|
||
|
|
def test_edges(self):
|
||
|
|
G = self.K3
|
||
|
|
assert_edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)])
|
||
|
|
assert_edges_equal(G.edges(0), [(0, 1), (0, 2)])
|
||
|
|
assert_edges_equal(G.edges([0, 1]), [(0, 1), (0, 2), (1, 2)])
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.edges(-1)
|
||
|
|
|
||
|
|
def test_degree(self):
|
||
|
|
G = self.K3
|
||
|
|
assert sorted(G.degree()) == [(0, 2), (1, 2), (2, 2)]
|
||
|
|
assert dict(G.degree()) == {0: 2, 1: 2, 2: 2}
|
||
|
|
assert G.degree(0) == 2
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.degree(-1) # node not in graph
|
||
|
|
|
||
|
|
def test_size(self):
|
||
|
|
G = self.K3
|
||
|
|
assert G.size() == 3
|
||
|
|
assert G.number_of_edges() == 3
|
||
|
|
|
||
|
|
def test_nbunch_iter(self):
|
||
|
|
G = self.K3
|
||
|
|
assert_nodes_equal(G.nbunch_iter(), self.k3nodes) # all nodes
|
||
|
|
assert_nodes_equal(G.nbunch_iter(0), [0]) # single node
|
||
|
|
assert_nodes_equal(G.nbunch_iter([0, 1]), [0, 1]) # sequence
|
||
|
|
# sequence with none in graph
|
||
|
|
assert_nodes_equal(G.nbunch_iter([-1]), [])
|
||
|
|
# string sequence with none in graph
|
||
|
|
assert_nodes_equal(G.nbunch_iter("foo"), [])
|
||
|
|
# node not in graph doesn't get caught upon creation of iterator
|
||
|
|
bunch = G.nbunch_iter(-1)
|
||
|
|
# but gets caught when iterator used
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
list(bunch)
|
||
|
|
# unhashable doesn't get caught upon creation of iterator
|
||
|
|
bunch = G.nbunch_iter([0, 1, 2, {}])
|
||
|
|
# but gets caught when iterator hits the unhashable
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
list(bunch)
|
||
|
|
|
||
|
|
def test_nbunch_iter_node_format_raise(self):
|
||
|
|
# Tests that a node that would have failed string formatting
|
||
|
|
# doesn't cause an error when attempting to raise a
|
||
|
|
# :exc:`nx.NetworkXError`.
|
||
|
|
|
||
|
|
# For more information, see pull request #1813.
|
||
|
|
G = self.Graph()
|
||
|
|
nbunch = [("x", set())]
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
list(G.nbunch_iter(nbunch))
|
||
|
|
|
||
|
|
def test_selfloop_degree(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(1, 1)
|
||
|
|
assert sorted(G.degree()) == [(1, 2)]
|
||
|
|
assert dict(G.degree()) == {1: 2}
|
||
|
|
assert G.degree(1) == 2
|
||
|
|
assert sorted(G.degree([1])) == [(1, 2)]
|
||
|
|
assert G.degree(1, weight="weight") == 2
|
||
|
|
|
||
|
|
def test_selfloops(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.add_edge(0, 0)
|
||
|
|
assert_nodes_equal(nx.nodes_with_selfloops(G), [0])
|
||
|
|
assert_edges_equal(nx.selfloop_edges(G), [(0, 0)])
|
||
|
|
assert nx.number_of_selfloops(G) == 1
|
||
|
|
G.remove_edge(0, 0)
|
||
|
|
G.add_edge(0, 0)
|
||
|
|
G.remove_edges_from([(0, 0)])
|
||
|
|
G.add_edge(1, 1)
|
||
|
|
G.remove_node(1)
|
||
|
|
G.add_edge(0, 0)
|
||
|
|
G.add_edge(1, 1)
|
||
|
|
G.remove_nodes_from([0, 1])
|
||
|
|
|
||
|
|
|
||
|
|
class BaseAttrGraphTester(BaseGraphTester):
|
||
|
|
""" Tests of graph class attribute features."""
|
||
|
|
|
||
|
|
def test_weighted_degree(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(1, 2, weight=2, other=3)
|
||
|
|
G.add_edge(2, 3, weight=3, other=4)
|
||
|
|
assert sorted(d for n, d in G.degree(weight="weight")) == [2, 3, 5]
|
||
|
|
assert dict(G.degree(weight="weight")) == {1: 2, 2: 5, 3: 3}
|
||
|
|
assert G.degree(1, weight="weight") == 2
|
||
|
|
assert_nodes_equal((G.degree([1], weight="weight")), [(1, 2)])
|
||
|
|
|
||
|
|
assert_nodes_equal((d for n, d in G.degree(weight="other")), [3, 7, 4])
|
||
|
|
assert dict(G.degree(weight="other")) == {1: 3, 2: 7, 3: 4}
|
||
|
|
assert G.degree(1, weight="other") == 3
|
||
|
|
assert_edges_equal((G.degree([1], weight="other")), [(1, 3)])
|
||
|
|
|
||
|
|
def add_attributes(self, G):
|
||
|
|
G.graph["foo"] = []
|
||
|
|
G.nodes[0]["foo"] = []
|
||
|
|
G.remove_edge(1, 2)
|
||
|
|
ll = []
|
||
|
|
G.add_edge(1, 2, foo=ll)
|
||
|
|
G.add_edge(2, 1, foo=ll)
|
||
|
|
|
||
|
|
def test_name(self):
|
||
|
|
G = self.Graph(name="")
|
||
|
|
assert G.name == ""
|
||
|
|
G = self.Graph(name="test")
|
||
|
|
assert G.__str__() == "test"
|
||
|
|
assert G.name == "test"
|
||
|
|
|
||
|
|
def test_graph_chain(self):
|
||
|
|
G = self.Graph([(0, 1), (1, 2)])
|
||
|
|
DG = G.to_directed(as_view=True)
|
||
|
|
SDG = DG.subgraph([0, 1])
|
||
|
|
RSDG = SDG.reverse(copy=False)
|
||
|
|
assert G is DG._graph
|
||
|
|
assert DG is SDG._graph
|
||
|
|
assert SDG is RSDG._graph
|
||
|
|
|
||
|
|
def test_copy(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_node(0)
|
||
|
|
G.add_edge(1, 2)
|
||
|
|
self.add_attributes(G)
|
||
|
|
# copy edge datadict but any container attr are same
|
||
|
|
H = G.copy()
|
||
|
|
self.graphs_equal(H, G)
|
||
|
|
self.different_attrdict(H, G)
|
||
|
|
self.shallow_copy_attrdict(H, G)
|
||
|
|
|
||
|
|
def test_class_copy(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_node(0)
|
||
|
|
G.add_edge(1, 2)
|
||
|
|
self.add_attributes(G)
|
||
|
|
# copy edge datadict but any container attr are same
|
||
|
|
H = G.__class__(G)
|
||
|
|
self.graphs_equal(H, G)
|
||
|
|
self.different_attrdict(H, G)
|
||
|
|
self.shallow_copy_attrdict(H, G)
|
||
|
|
|
||
|
|
def test_fresh_copy(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_node(0)
|
||
|
|
G.add_edge(1, 2)
|
||
|
|
self.add_attributes(G)
|
||
|
|
# copy graph structure but use fresh datadict
|
||
|
|
H = G.__class__()
|
||
|
|
H.add_nodes_from(G)
|
||
|
|
H.add_edges_from(G.edges())
|
||
|
|
assert len(G.nodes[0]) == 1
|
||
|
|
ddict = G.adj[1][2][0] if G.is_multigraph() else G.adj[1][2]
|
||
|
|
assert len(ddict) == 1
|
||
|
|
assert len(H.nodes[0]) == 0
|
||
|
|
ddict = H.adj[1][2][0] if H.is_multigraph() else H.adj[1][2]
|
||
|
|
assert len(ddict) == 0
|
||
|
|
|
||
|
|
def is_deepcopy(self, H, G):
|
||
|
|
self.graphs_equal(H, G)
|
||
|
|
self.different_attrdict(H, G)
|
||
|
|
self.deep_copy_attrdict(H, G)
|
||
|
|
|
||
|
|
def deep_copy_attrdict(self, H, G):
|
||
|
|
self.deepcopy_graph_attr(H, G)
|
||
|
|
self.deepcopy_node_attr(H, G)
|
||
|
|
self.deepcopy_edge_attr(H, G)
|
||
|
|
|
||
|
|
def deepcopy_graph_attr(self, H, G):
|
||
|
|
assert G.graph["foo"] == H.graph["foo"]
|
||
|
|
G.graph["foo"].append(1)
|
||
|
|
assert G.graph["foo"] != H.graph["foo"]
|
||
|
|
|
||
|
|
def deepcopy_node_attr(self, H, G):
|
||
|
|
assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
|
||
|
|
G.nodes[0]["foo"].append(1)
|
||
|
|
assert G.nodes[0]["foo"] != H.nodes[0]["foo"]
|
||
|
|
|
||
|
|
def deepcopy_edge_attr(self, H, G):
|
||
|
|
assert G[1][2]["foo"] == H[1][2]["foo"]
|
||
|
|
G[1][2]["foo"].append(1)
|
||
|
|
assert G[1][2]["foo"] != H[1][2]["foo"]
|
||
|
|
|
||
|
|
def is_shallow_copy(self, H, G):
|
||
|
|
self.graphs_equal(H, G)
|
||
|
|
self.shallow_copy_attrdict(H, G)
|
||
|
|
|
||
|
|
def shallow_copy_attrdict(self, H, G):
|
||
|
|
self.shallow_copy_graph_attr(H, G)
|
||
|
|
self.shallow_copy_node_attr(H, G)
|
||
|
|
self.shallow_copy_edge_attr(H, G)
|
||
|
|
|
||
|
|
def shallow_copy_graph_attr(self, H, G):
|
||
|
|
assert G.graph["foo"] == H.graph["foo"]
|
||
|
|
G.graph["foo"].append(1)
|
||
|
|
assert G.graph["foo"] == H.graph["foo"]
|
||
|
|
|
||
|
|
def shallow_copy_node_attr(self, H, G):
|
||
|
|
assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
|
||
|
|
G.nodes[0]["foo"].append(1)
|
||
|
|
assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
|
||
|
|
|
||
|
|
def shallow_copy_edge_attr(self, H, G):
|
||
|
|
assert G[1][2]["foo"] == H[1][2]["foo"]
|
||
|
|
G[1][2]["foo"].append(1)
|
||
|
|
assert G[1][2]["foo"] == H[1][2]["foo"]
|
||
|
|
|
||
|
|
def same_attrdict(self, H, G):
|
||
|
|
old_foo = H[1][2]["foo"]
|
||
|
|
H.adj[1][2]["foo"] = "baz"
|
||
|
|
assert G.edges == H.edges
|
||
|
|
H.adj[1][2]["foo"] = old_foo
|
||
|
|
assert G.edges == H.edges
|
||
|
|
|
||
|
|
old_foo = H.nodes[0]["foo"]
|
||
|
|
H.nodes[0]["foo"] = "baz"
|
||
|
|
assert G.nodes == H.nodes
|
||
|
|
H.nodes[0]["foo"] = old_foo
|
||
|
|
assert G.nodes == H.nodes
|
||
|
|
|
||
|
|
def different_attrdict(self, H, G):
|
||
|
|
old_foo = H[1][2]["foo"]
|
||
|
|
H.adj[1][2]["foo"] = "baz"
|
||
|
|
assert G._adj != H._adj
|
||
|
|
H.adj[1][2]["foo"] = old_foo
|
||
|
|
assert G._adj == H._adj
|
||
|
|
|
||
|
|
old_foo = H.nodes[0]["foo"]
|
||
|
|
H.nodes[0]["foo"] = "baz"
|
||
|
|
assert G._node != H._node
|
||
|
|
H.nodes[0]["foo"] = old_foo
|
||
|
|
assert G._node == H._node
|
||
|
|
|
||
|
|
def graphs_equal(self, H, G):
|
||
|
|
assert G._adj == H._adj
|
||
|
|
assert G._node == H._node
|
||
|
|
assert G.graph == H.graph
|
||
|
|
assert G.name == H.name
|
||
|
|
if not G.is_directed() and not H.is_directed():
|
||
|
|
assert H._adj[1][2] is H._adj[2][1]
|
||
|
|
assert G._adj[1][2] is G._adj[2][1]
|
||
|
|
else: # at least one is directed
|
||
|
|
if not G.is_directed():
|
||
|
|
G._pred = G._adj
|
||
|
|
G._succ = G._adj
|
||
|
|
if not H.is_directed():
|
||
|
|
H._pred = H._adj
|
||
|
|
H._succ = H._adj
|
||
|
|
assert G._pred == H._pred
|
||
|
|
assert G._succ == H._succ
|
||
|
|
assert H._succ[1][2] is H._pred[2][1]
|
||
|
|
assert G._succ[1][2] is G._pred[2][1]
|
||
|
|
|
||
|
|
def test_graph_attr(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.graph["foo"] = "bar"
|
||
|
|
assert G.graph["foo"] == "bar"
|
||
|
|
del G.graph["foo"]
|
||
|
|
assert G.graph == {}
|
||
|
|
H = self.Graph(foo="bar")
|
||
|
|
assert H.graph["foo"] == "bar"
|
||
|
|
|
||
|
|
def test_node_attr(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.add_node(1, foo="bar")
|
||
|
|
assert_nodes_equal(G.nodes(), [0, 1, 2])
|
||
|
|
assert_nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "bar"}), (2, {})])
|
||
|
|
G.nodes[1]["foo"] = "baz"
|
||
|
|
assert_nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "baz"}), (2, {})])
|
||
|
|
assert_nodes_equal(G.nodes(data="foo"), [(0, None), (1, "baz"), (2, None)])
|
||
|
|
assert_nodes_equal(
|
||
|
|
G.nodes(data="foo", default="bar"), [(0, "bar"), (1, "baz"), (2, "bar")]
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_node_attr2(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
a = {"foo": "bar"}
|
||
|
|
G.add_node(3, **a)
|
||
|
|
assert_nodes_equal(G.nodes(), [0, 1, 2, 3])
|
||
|
|
assert_nodes_equal(
|
||
|
|
G.nodes(data=True), [(0, {}), (1, {}), (2, {}), (3, {"foo": "bar"})]
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_edge_lookup(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(1, 2, foo="bar")
|
||
|
|
assert_edges_equal(G.edges[1, 2], {"foo": "bar"})
|
||
|
|
|
||
|
|
def test_edge_attr(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(1, 2, foo="bar")
|
||
|
|
assert_edges_equal(G.edges(data=True), [(1, 2, {"foo": "bar"})])
|
||
|
|
assert_edges_equal(G.edges(data="foo"), [(1, 2, "bar")])
|
||
|
|
|
||
|
|
def test_edge_attr2(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edges_from([(1, 2), (3, 4)], foo="foo")
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"foo": "foo"}), (3, 4, {"foo": "foo"})]
|
||
|
|
)
|
||
|
|
assert_edges_equal(G.edges(data="foo"), [(1, 2, "foo"), (3, 4, "foo")])
|
||
|
|
|
||
|
|
def test_edge_attr3(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edges_from([(1, 2, {"weight": 32}), (3, 4, {"weight": 64})], foo="foo")
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True),
|
||
|
|
[
|
||
|
|
(1, 2, {"foo": "foo", "weight": 32}),
|
||
|
|
(3, 4, {"foo": "foo", "weight": 64}),
|
||
|
|
],
|
||
|
|
)
|
||
|
|
|
||
|
|
G.remove_edges_from([(1, 2), (3, 4)])
|
||
|
|
G.add_edge(1, 2, data=7, spam="bar", bar="foo")
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_edge_attr4(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(1, 2, data=7, spam="bar", bar="foo")
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
|
||
|
|
)
|
||
|
|
G[1][2]["data"] = 10 # OK to set data like this
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"data": 10, "spam": "bar", "bar": "foo"})]
|
||
|
|
)
|
||
|
|
|
||
|
|
G.adj[1][2]["data"] = 20
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
|
||
|
|
)
|
||
|
|
G.edges[1, 2]["data"] = 21 # another spelling, "edge"
|
||
|
|
assert_edges_equal(
|
||
|
|
G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
|
||
|
|
)
|
||
|
|
G.adj[1][2]["listdata"] = [20, 200]
|
||
|
|
G.adj[1][2]["weight"] = 20
|
||
|
|
dd = {
|
||
|
|
"data": 21,
|
||
|
|
"spam": "bar",
|
||
|
|
"bar": "foo",
|
||
|
|
"listdata": [20, 200],
|
||
|
|
"weight": 20,
|
||
|
|
}
|
||
|
|
assert_edges_equal(G.edges(data=True), [(1, 2, dd)])
|
||
|
|
|
||
|
|
def test_to_undirected(self):
|
||
|
|
G = self.K3
|
||
|
|
self.add_attributes(G)
|
||
|
|
H = nx.Graph(G)
|
||
|
|
self.is_shallow_copy(H, G)
|
||
|
|
self.different_attrdict(H, G)
|
||
|
|
H = G.to_undirected()
|
||
|
|
self.is_deepcopy(H, G)
|
||
|
|
|
||
|
|
def test_to_directed(self):
|
||
|
|
G = self.K3
|
||
|
|
self.add_attributes(G)
|
||
|
|
H = nx.DiGraph(G)
|
||
|
|
self.is_shallow_copy(H, G)
|
||
|
|
self.different_attrdict(H, G)
|
||
|
|
H = G.to_directed()
|
||
|
|
self.is_deepcopy(H, G)
|
||
|
|
|
||
|
|
def test_subgraph(self):
|
||
|
|
G = self.K3
|
||
|
|
self.add_attributes(G)
|
||
|
|
H = G.subgraph([0, 1, 2, 5])
|
||
|
|
self.graphs_equal(H, G)
|
||
|
|
self.same_attrdict(H, G)
|
||
|
|
self.shallow_copy_attrdict(H, G)
|
||
|
|
|
||
|
|
H = G.subgraph(0)
|
||
|
|
assert H.adj == {0: {}}
|
||
|
|
H = G.subgraph([])
|
||
|
|
assert H.adj == {}
|
||
|
|
assert G.adj != {}
|
||
|
|
|
||
|
|
def test_selfloops_attr(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.add_edge(0, 0)
|
||
|
|
G.add_edge(1, 1, weight=2)
|
||
|
|
assert_edges_equal(
|
||
|
|
nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, {"weight": 2})]
|
||
|
|
)
|
||
|
|
assert_edges_equal(
|
||
|
|
nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)]
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
class TestGraph(BaseAttrGraphTester):
|
||
|
|
"""Tests specific to dict-of-dict-of-dict graph data structure"""
|
||
|
|
|
||
|
|
def setup_method(self):
|
||
|
|
self.Graph = nx.Graph
|
||
|
|
# build dict-of-dict-of-dict K3
|
||
|
|
ed1, ed2, ed3 = ({}, {}, {})
|
||
|
|
self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
|
||
|
|
self.k3edges = [(0, 1), (0, 2), (1, 2)]
|
||
|
|
self.k3nodes = [0, 1, 2]
|
||
|
|
self.K3 = self.Graph()
|
||
|
|
self.K3._adj = self.k3adj
|
||
|
|
self.K3._node = {}
|
||
|
|
self.K3._node[0] = {}
|
||
|
|
self.K3._node[1] = {}
|
||
|
|
self.K3._node[2] = {}
|
||
|
|
|
||
|
|
def test_pickle(self):
|
||
|
|
G = self.K3
|
||
|
|
pg = pickle.loads(pickle.dumps(G, -1))
|
||
|
|
self.graphs_equal(pg, G)
|
||
|
|
pg = pickle.loads(pickle.dumps(G))
|
||
|
|
self.graphs_equal(pg, G)
|
||
|
|
|
||
|
|
def test_data_input(self):
|
||
|
|
G = self.Graph({1: [2], 2: [1]}, name="test")
|
||
|
|
assert G.name == "test"
|
||
|
|
assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
|
||
|
|
G = self.Graph({1: [2], 2: [1]}, name="test")
|
||
|
|
assert G.name == "test"
|
||
|
|
assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
|
||
|
|
|
||
|
|
def test_adjacency(self):
|
||
|
|
G = self.K3
|
||
|
|
assert dict(G.adjacency()) == {
|
||
|
|
0: {1: {}, 2: {}},
|
||
|
|
1: {0: {}, 2: {}},
|
||
|
|
2: {0: {}, 1: {}},
|
||
|
|
}
|
||
|
|
|
||
|
|
def test_getitem(self):
|
||
|
|
G = self.K3
|
||
|
|
assert G[0] == {1: {}, 2: {}}
|
||
|
|
with pytest.raises(KeyError):
|
||
|
|
G.__getitem__("j")
|
||
|
|
with pytest.raises(TypeError):
|
||
|
|
G.__getitem__(["A"])
|
||
|
|
|
||
|
|
def test_add_node(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_node(0)
|
||
|
|
assert G.adj == {0: {}}
|
||
|
|
# test add attributes
|
||
|
|
G.add_node(1, c="red")
|
||
|
|
G.add_node(2, c="blue")
|
||
|
|
G.add_node(3, c="red")
|
||
|
|
assert G.nodes[1]["c"] == "red"
|
||
|
|
assert G.nodes[2]["c"] == "blue"
|
||
|
|
assert G.nodes[3]["c"] == "red"
|
||
|
|
# test updating attributes
|
||
|
|
G.add_node(1, c="blue")
|
||
|
|
G.add_node(2, c="red")
|
||
|
|
G.add_node(3, c="blue")
|
||
|
|
assert G.nodes[1]["c"] == "blue"
|
||
|
|
assert G.nodes[2]["c"] == "red"
|
||
|
|
assert G.nodes[3]["c"] == "blue"
|
||
|
|
|
||
|
|
def test_add_nodes_from(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_nodes_from([0, 1, 2])
|
||
|
|
assert G.adj == {0: {}, 1: {}, 2: {}}
|
||
|
|
# test add attributes
|
||
|
|
G.add_nodes_from([0, 1, 2], c="red")
|
||
|
|
assert G.nodes[0]["c"] == "red"
|
||
|
|
assert G.nodes[2]["c"] == "red"
|
||
|
|
# test that attribute dicts are not the same
|
||
|
|
assert G.nodes[0] is not G.nodes[1]
|
||
|
|
# test updating attributes
|
||
|
|
G.add_nodes_from([0, 1, 2], c="blue")
|
||
|
|
assert G.nodes[0]["c"] == "blue"
|
||
|
|
assert G.nodes[2]["c"] == "blue"
|
||
|
|
assert G.nodes[0] is not G.nodes[1]
|
||
|
|
# test tuple input
|
||
|
|
H = self.Graph()
|
||
|
|
H.add_nodes_from(G.nodes(data=True))
|
||
|
|
assert H.nodes[0]["c"] == "blue"
|
||
|
|
assert H.nodes[2]["c"] == "blue"
|
||
|
|
assert H.nodes[0] is not H.nodes[1]
|
||
|
|
# specific overrides general
|
||
|
|
H.add_nodes_from([0, (1, {"c": "green"}), (3, {"c": "cyan"})], c="red")
|
||
|
|
assert H.nodes[0]["c"] == "red"
|
||
|
|
assert H.nodes[1]["c"] == "green"
|
||
|
|
assert H.nodes[2]["c"] == "blue"
|
||
|
|
assert H.nodes[3]["c"] == "cyan"
|
||
|
|
|
||
|
|
def test_remove_node(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.remove_node(0)
|
||
|
|
assert G.adj == {1: {2: {}}, 2: {1: {}}}
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.remove_node(-1)
|
||
|
|
|
||
|
|
# generator here to implement list,set,string...
|
||
|
|
|
||
|
|
def test_remove_nodes_from(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.remove_nodes_from([0, 1])
|
||
|
|
assert G.adj == {2: {}}
|
||
|
|
G.remove_nodes_from([-1]) # silent fail
|
||
|
|
|
||
|
|
def test_add_edge(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(0, 1)
|
||
|
|
assert G.adj == {0: {1: {}}, 1: {0: {}}}
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edge(*(0, 1))
|
||
|
|
assert G.adj == {0: {1: {}}, 1: {0: {}}}
|
||
|
|
|
||
|
|
def test_add_edges_from(self):
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edges_from([(0, 1), (0, 2, {"weight": 3})])
|
||
|
|
assert G.adj == {
|
||
|
|
0: {1: {}, 2: {"weight": 3}},
|
||
|
|
1: {0: {}},
|
||
|
|
2: {0: {"weight": 3}},
|
||
|
|
}
|
||
|
|
G = self.Graph()
|
||
|
|
G.add_edges_from([(0, 1), (0, 2, {"weight": 3}), (1, 2, {"data": 4})], data=2)
|
||
|
|
assert G.adj == {
|
||
|
|
0: {1: {"data": 2}, 2: {"weight": 3, "data": 2}},
|
||
|
|
1: {0: {"data": 2}, 2: {"data": 4}},
|
||
|
|
2: {0: {"weight": 3, "data": 2}, 1: {"data": 4}},
|
||
|
|
}
|
||
|
|
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.add_edges_from([(0,)]) # too few in tuple
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.add_edges_from([(0, 1, 2, 3)]) # too many in tuple
|
||
|
|
with pytest.raises(TypeError):
|
||
|
|
G.add_edges_from([0]) # not a tuple
|
||
|
|
|
||
|
|
def test_remove_edge(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.remove_edge(0, 1)
|
||
|
|
assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.remove_edge(-1, 0)
|
||
|
|
|
||
|
|
def test_remove_edges_from(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.remove_edges_from([(0, 1)])
|
||
|
|
assert G.adj == {0: {2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
|
||
|
|
G.remove_edges_from([(0, 0)]) # silent fail
|
||
|
|
|
||
|
|
def test_clear(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.graph["name"] = "K3"
|
||
|
|
G.clear()
|
||
|
|
assert list(G.nodes) == []
|
||
|
|
assert G.adj == {}
|
||
|
|
assert G.graph == {}
|
||
|
|
|
||
|
|
def test_clear_edges(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.graph["name"] = "K3"
|
||
|
|
nodes = list(G.nodes)
|
||
|
|
G.clear_edges()
|
||
|
|
assert list(G.nodes) == nodes
|
||
|
|
assert G.adj == {0: {}, 1: {}, 2: {}}
|
||
|
|
assert list(G.edges) == []
|
||
|
|
assert G.graph["name"] == "K3"
|
||
|
|
|
||
|
|
def test_edges_data(self):
|
||
|
|
G = self.K3
|
||
|
|
all_edges = [(0, 1, {}), (0, 2, {}), (1, 2, {})]
|
||
|
|
assert_edges_equal(G.edges(data=True), all_edges)
|
||
|
|
assert_edges_equal(G.edges(0, data=True), [(0, 1, {}), (0, 2, {})])
|
||
|
|
assert_edges_equal(G.edges([0, 1], data=True), all_edges)
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
G.edges(-1, True)
|
||
|
|
|
||
|
|
def test_get_edge_data(self):
|
||
|
|
G = self.K3.copy()
|
||
|
|
assert G.get_edge_data(0, 1) == {}
|
||
|
|
assert G[0][1] == {}
|
||
|
|
assert G.get_edge_data(10, 20) is None
|
||
|
|
assert G.get_edge_data(-1, 0) is None
|
||
|
|
assert G.get_edge_data(-1, 0, default=1) == 1
|
||
|
|
|
||
|
|
def test_update(self):
|
||
|
|
# specify both edgees and nodes
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.update(nodes=[3, (4, {"size": 2})], edges=[(4, 5), (6, 7, {"weight": 2})])
|
||
|
|
nlist = [
|
||
|
|
(0, {}),
|
||
|
|
(1, {}),
|
||
|
|
(2, {}),
|
||
|
|
(3, {}),
|
||
|
|
(4, {"size": 2}),
|
||
|
|
(5, {}),
|
||
|
|
(6, {}),
|
||
|
|
(7, {}),
|
||
|
|
]
|
||
|
|
assert sorted(G.nodes.data()) == nlist
|
||
|
|
if G.is_directed():
|
||
|
|
elist = [
|
||
|
|
(0, 1, {}),
|
||
|
|
(0, 2, {}),
|
||
|
|
(1, 0, {}),
|
||
|
|
(1, 2, {}),
|
||
|
|
(2, 0, {}),
|
||
|
|
(2, 1, {}),
|
||
|
|
(4, 5, {}),
|
||
|
|
(6, 7, {"weight": 2}),
|
||
|
|
]
|
||
|
|
else:
|
||
|
|
elist = [
|
||
|
|
(0, 1, {}),
|
||
|
|
(0, 2, {}),
|
||
|
|
(1, 2, {}),
|
||
|
|
(4, 5, {}),
|
||
|
|
(6, 7, {"weight": 2}),
|
||
|
|
]
|
||
|
|
assert sorted(G.edges.data()) == elist
|
||
|
|
assert G.graph == {}
|
||
|
|
|
||
|
|
# no keywords -- order is edges, nodes
|
||
|
|
G = self.K3.copy()
|
||
|
|
G.update([(4, 5), (6, 7, {"weight": 2})], [3, (4, {"size": 2})])
|
||
|
|
assert sorted(G.nodes.data()) == nlist
|
||
|
|
assert sorted(G.edges.data()) == elist
|
||
|
|
assert G.graph == {}
|
||
|
|
|
||
|
|
# update using only a graph
|
||
|
|
G = self.Graph()
|
||
|
|
G.graph["foo"] = "bar"
|
||
|
|
G.add_node(2, data=4)
|
||
|
|
G.add_edge(0, 1, weight=0.5)
|
||
|
|
GG = G.copy()
|
||
|
|
H = self.Graph()
|
||
|
|
GG.update(H)
|
||
|
|
assert_graphs_equal(G, GG)
|
||
|
|
H.update(G)
|
||
|
|
assert_graphs_equal(H, G)
|
||
|
|
|
||
|
|
# update nodes only
|
||
|
|
H = self.Graph()
|
||
|
|
H.update(nodes=[3, 4])
|
||
|
|
assert H.nodes ^ {3, 4} == set()
|
||
|
|
assert H.size() == 0
|
||
|
|
|
||
|
|
# update edges only
|
||
|
|
H = self.Graph()
|
||
|
|
H.update(edges=[(3, 4)])
|
||
|
|
assert sorted(H.edges.data()) == [(3, 4, {})]
|
||
|
|
assert H.size() == 1
|
||
|
|
|
||
|
|
# No inputs -> exception
|
||
|
|
with pytest.raises(nx.NetworkXError):
|
||
|
|
nx.Graph().update()
|
||
|
|
|
||
|
|
|
||
|
|
class TestEdgeSubgraph:
|
||
|
|
"""Unit tests for the :meth:`Graph.edge_subgraph` method."""
|
||
|
|
|
||
|
|
def setup_method(self):
|
||
|
|
# Create a path graph on five nodes.
|
||
|
|
G = nx.path_graph(5)
|
||
|
|
# Add some node, edge, and graph attributes.
|
||
|
|
for i in range(5):
|
||
|
|
G.nodes[i]["name"] = f"node{i}"
|
||
|
|
G.edges[0, 1]["name"] = "edge01"
|
||
|
|
G.edges[3, 4]["name"] = "edge34"
|
||
|
|
G.graph["name"] = "graph"
|
||
|
|
# Get the subgraph induced by the first and last edges.
|
||
|
|
self.G = G
|
||
|
|
self.H = G.edge_subgraph([(0, 1), (3, 4)])
|
||
|
|
|
||
|
|
def test_correct_nodes(self):
|
||
|
|
"""Tests that the subgraph has the correct nodes."""
|
||
|
|
assert [0, 1, 3, 4] == sorted(self.H.nodes())
|
||
|
|
|
||
|
|
def test_correct_edges(self):
|
||
|
|
"""Tests that the subgraph has the correct edges."""
|
||
|
|
assert [(0, 1, "edge01"), (3, 4, "edge34")] == sorted(self.H.edges(data="name"))
|
||
|
|
|
||
|
|
def test_add_node(self):
|
||
|
|
"""Tests that adding a node to the original graph does not
|
||
|
|
affect the nodes of the subgraph.
|
||
|
|
|
||
|
|
"""
|
||
|
|
self.G.add_node(5)
|
||
|
|
assert [0, 1, 3, 4] == sorted(self.H.nodes())
|
||
|
|
|
||
|
|
def test_remove_node(self):
|
||
|
|
"""Tests that removing a node in the original graph does
|
||
|
|
affect the nodes of the subgraph.
|
||
|
|
|
||
|
|
"""
|
||
|
|
self.G.remove_node(0)
|
||
|
|
assert [1, 3, 4] == sorted(self.H.nodes())
|
||
|
|
|
||
|
|
def test_node_attr_dict(self):
|
||
|
|
"""Tests that the node attribute dictionary of the two graphs is
|
||
|
|
the same object.
|
||
|
|
|
||
|
|
"""
|
||
|
|
for v in self.H:
|
||
|
|
assert self.G.nodes[v] == self.H.nodes[v]
|
||
|
|
# Making a change to G should make a change in H and vice versa.
|
||
|
|
self.G.nodes[0]["name"] = "foo"
|
||
|
|
assert self.G.nodes[0] == self.H.nodes[0]
|
||
|
|
self.H.nodes[1]["name"] = "bar"
|
||
|
|
assert self.G.nodes[1] == self.H.nodes[1]
|
||
|
|
|
||
|
|
def test_edge_attr_dict(self):
|
||
|
|
"""Tests that the edge attribute dictionary of the two graphs is
|
||
|
|
the same object.
|
||
|
|
|
||
|
|
"""
|
||
|
|
for u, v in self.H.edges():
|
||
|
|
assert self.G.edges[u, v] == self.H.edges[u, v]
|
||
|
|
# Making a change to G should make a change in H and vice versa.
|
||
|
|
self.G.edges[0, 1]["name"] = "foo"
|
||
|
|
assert self.G.edges[0, 1]["name"] == self.H.edges[0, 1]["name"]
|
||
|
|
self.H.edges[3, 4]["name"] = "bar"
|
||
|
|
assert self.G.edges[3, 4]["name"] == self.H.edges[3, 4]["name"]
|
||
|
|
|
||
|
|
def test_graph_attr_dict(self):
|
||
|
|
"""Tests that the graph attribute dictionary of the two graphs
|
||
|
|
is the same object.
|
||
|
|
|
||
|
|
"""
|
||
|
|
assert self.G.graph is self.H.graph
|