Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/networkx/tests/test_relabel.py @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
| author | shellac |
|---|---|
| date | Mon, 22 Mar 2021 18:12:50 +0000 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| -1:000000000000 | 0:4f3585e2f14b |
|---|---|
| 1 import pytest | |
| 2 import networkx as nx | |
| 3 from networkx.generators.classic import empty_graph | |
| 4 from networkx.testing import assert_nodes_equal, assert_edges_equal | |
| 5 | |
| 6 | |
| 7 class TestRelabel: | |
| 8 def test_convert_node_labels_to_integers(self): | |
| 9 # test that empty graph converts fine for all options | |
| 10 G = empty_graph() | |
| 11 H = nx.convert_node_labels_to_integers(G, 100) | |
| 12 assert list(H.nodes()) == [] | |
| 13 assert list(H.edges()) == [] | |
| 14 | |
| 15 for opt in ["default", "sorted", "increasing degree", "decreasing degree"]: | |
| 16 G = empty_graph() | |
| 17 H = nx.convert_node_labels_to_integers(G, 100, ordering=opt) | |
| 18 assert list(H.nodes()) == [] | |
| 19 assert list(H.edges()) == [] | |
| 20 | |
| 21 G = empty_graph() | |
| 22 G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 23 H = nx.convert_node_labels_to_integers(G) | |
| 24 degH = (d for n, d in H.degree()) | |
| 25 degG = (d for n, d in G.degree()) | |
| 26 assert sorted(degH) == sorted(degG) | |
| 27 | |
| 28 H = nx.convert_node_labels_to_integers(G, 1000) | |
| 29 degH = (d for n, d in H.degree()) | |
| 30 degG = (d for n, d in G.degree()) | |
| 31 assert sorted(degH) == sorted(degG) | |
| 32 assert_nodes_equal(H.nodes(), [1000, 1001, 1002, 1003]) | |
| 33 | |
| 34 H = nx.convert_node_labels_to_integers(G, ordering="increasing degree") | |
| 35 degH = (d for n, d in H.degree()) | |
| 36 degG = (d for n, d in G.degree()) | |
| 37 assert sorted(degH) == sorted(degG) | |
| 38 assert H.degree(0) == 1 | |
| 39 assert H.degree(1) == 2 | |
| 40 assert H.degree(2) == 2 | |
| 41 assert H.degree(3) == 3 | |
| 42 | |
| 43 H = nx.convert_node_labels_to_integers(G, ordering="decreasing degree") | |
| 44 degH = (d for n, d in H.degree()) | |
| 45 degG = (d for n, d in G.degree()) | |
| 46 assert sorted(degH) == sorted(degG) | |
| 47 assert H.degree(0) == 3 | |
| 48 assert H.degree(1) == 2 | |
| 49 assert H.degree(2) == 2 | |
| 50 assert H.degree(3) == 1 | |
| 51 | |
| 52 H = nx.convert_node_labels_to_integers( | |
| 53 G, ordering="increasing degree", label_attribute="label" | |
| 54 ) | |
| 55 degH = (d for n, d in H.degree()) | |
| 56 degG = (d for n, d in G.degree()) | |
| 57 assert sorted(degH) == sorted(degG) | |
| 58 assert H.degree(0) == 1 | |
| 59 assert H.degree(1) == 2 | |
| 60 assert H.degree(2) == 2 | |
| 61 assert H.degree(3) == 3 | |
| 62 | |
| 63 # check mapping | |
| 64 assert H.nodes[3]["label"] == "C" | |
| 65 assert H.nodes[0]["label"] == "D" | |
| 66 assert H.nodes[1]["label"] == "A" or H.nodes[2]["label"] == "A" | |
| 67 assert H.nodes[1]["label"] == "B" or H.nodes[2]["label"] == "B" | |
| 68 | |
| 69 def test_convert_to_integers2(self): | |
| 70 G = empty_graph() | |
| 71 G.add_edges_from([("C", "D"), ("A", "B"), ("A", "C"), ("B", "C")]) | |
| 72 H = nx.convert_node_labels_to_integers(G, ordering="sorted") | |
| 73 degH = (d for n, d in H.degree()) | |
| 74 degG = (d for n, d in G.degree()) | |
| 75 assert sorted(degH) == sorted(degG) | |
| 76 | |
| 77 H = nx.convert_node_labels_to_integers( | |
| 78 G, ordering="sorted", label_attribute="label" | |
| 79 ) | |
| 80 assert H.nodes[0]["label"] == "A" | |
| 81 assert H.nodes[1]["label"] == "B" | |
| 82 assert H.nodes[2]["label"] == "C" | |
| 83 assert H.nodes[3]["label"] == "D" | |
| 84 | |
| 85 def test_convert_to_integers_raise(self): | |
| 86 with pytest.raises(nx.NetworkXError): | |
| 87 G = nx.Graph() | |
| 88 H = nx.convert_node_labels_to_integers(G, ordering="increasing age") | |
| 89 | |
| 90 def test_relabel_nodes_copy(self): | |
| 91 G = nx.empty_graph() | |
| 92 G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 93 mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"} | |
| 94 H = nx.relabel_nodes(G, mapping) | |
| 95 assert_nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"]) | |
| 96 | |
| 97 def test_relabel_nodes_function(self): | |
| 98 G = nx.empty_graph() | |
| 99 G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 100 # function mapping no longer encouraged but works | |
| 101 | |
| 102 def mapping(n): | |
| 103 return ord(n) | |
| 104 | |
| 105 H = nx.relabel_nodes(G, mapping) | |
| 106 assert_nodes_equal(H.nodes(), [65, 66, 67, 68]) | |
| 107 | |
| 108 def test_relabel_nodes_graph(self): | |
| 109 G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 110 mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"} | |
| 111 H = nx.relabel_nodes(G, mapping) | |
| 112 assert_nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"]) | |
| 113 | |
| 114 def test_relabel_nodes_orderedgraph(self): | |
| 115 G = nx.OrderedGraph() | |
| 116 G.add_nodes_from([1, 2, 3]) | |
| 117 G.add_edges_from([(1, 3), (2, 3)]) | |
| 118 mapping = {1: "a", 2: "b", 3: "c"} | |
| 119 H = nx.relabel_nodes(G, mapping) | |
| 120 assert list(H.nodes) == ["a", "b", "c"] | |
| 121 | |
| 122 def test_relabel_nodes_digraph(self): | |
| 123 G = nx.DiGraph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 124 mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"} | |
| 125 H = nx.relabel_nodes(G, mapping, copy=False) | |
| 126 assert_nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"]) | |
| 127 | |
| 128 def test_relabel_nodes_multigraph(self): | |
| 129 G = nx.MultiGraph([("a", "b"), ("a", "b")]) | |
| 130 mapping = {"a": "aardvark", "b": "bear"} | |
| 131 G = nx.relabel_nodes(G, mapping, copy=False) | |
| 132 assert_nodes_equal(G.nodes(), ["aardvark", "bear"]) | |
| 133 assert_edges_equal(G.edges(), [("aardvark", "bear"), ("aardvark", "bear")]) | |
| 134 | |
| 135 def test_relabel_nodes_multidigraph(self): | |
| 136 G = nx.MultiDiGraph([("a", "b"), ("a", "b")]) | |
| 137 mapping = {"a": "aardvark", "b": "bear"} | |
| 138 G = nx.relabel_nodes(G, mapping, copy=False) | |
| 139 assert_nodes_equal(G.nodes(), ["aardvark", "bear"]) | |
| 140 assert_edges_equal(G.edges(), [("aardvark", "bear"), ("aardvark", "bear")]) | |
| 141 | |
| 142 def test_relabel_isolated_nodes_to_same(self): | |
| 143 G = nx.Graph() | |
| 144 G.add_nodes_from(range(4)) | |
| 145 mapping = {1: 1} | |
| 146 H = nx.relabel_nodes(G, mapping, copy=False) | |
| 147 assert_nodes_equal(H.nodes(), list(range(4))) | |
| 148 | |
| 149 def test_relabel_nodes_missing(self): | |
| 150 with pytest.raises(KeyError): | |
| 151 G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")]) | |
| 152 mapping = {0: "aardvark"} | |
| 153 G = nx.relabel_nodes(G, mapping, copy=False) | |
| 154 | |
| 155 def test_relabel_copy_name(self): | |
| 156 G = nx.Graph() | |
| 157 H = nx.relabel_nodes(G, {}, copy=True) | |
| 158 assert H.graph == G.graph | |
| 159 H = nx.relabel_nodes(G, {}, copy=False) | |
| 160 assert H.graph == G.graph | |
| 161 G.name = "first" | |
| 162 H = nx.relabel_nodes(G, {}, copy=True) | |
| 163 assert H.graph == G.graph | |
| 164 H = nx.relabel_nodes(G, {}, copy=False) | |
| 165 assert H.graph == G.graph | |
| 166 | |
| 167 def test_relabel_toposort(self): | |
| 168 K5 = nx.complete_graph(4) | |
| 169 G = nx.complete_graph(4) | |
| 170 G = nx.relabel_nodes(G, {i: i + 1 for i in range(4)}, copy=False) | |
| 171 nx.is_isomorphic(K5, G) | |
| 172 G = nx.complete_graph(4) | |
| 173 G = nx.relabel_nodes(G, {i: i - 1 for i in range(4)}, copy=False) | |
| 174 nx.is_isomorphic(K5, G) | |
| 175 | |
| 176 def test_relabel_selfloop(self): | |
| 177 G = nx.DiGraph([(1, 1), (1, 2), (2, 3)]) | |
| 178 G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False) | |
| 179 assert_nodes_equal(G.nodes(), ["One", "Three", "Two"]) | |
| 180 G = nx.MultiDiGraph([(1, 1), (1, 2), (2, 3)]) | |
| 181 G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False) | |
| 182 assert_nodes_equal(G.nodes(), ["One", "Three", "Two"]) | |
| 183 G = nx.MultiDiGraph([(1, 1)]) | |
| 184 G = nx.relabel_nodes(G, {1: 0}, copy=False) | |
| 185 assert_nodes_equal(G.nodes(), [0]) | |
| 186 | |
| 187 def test_relabel_multidigraph_inout_merge_nodes(self): | |
| 188 for MG in (nx.MultiGraph, nx.MultiDiGraph): | |
| 189 for cc in (True, False): | |
| 190 G = MG([(0, 4), (1, 4), (4, 2), (4, 3)]) | |
| 191 G[0][4][0]["value"] = "a" | |
| 192 G[1][4][0]["value"] = "b" | |
| 193 G[4][2][0]["value"] = "c" | |
| 194 G[4][3][0]["value"] = "d" | |
| 195 G.add_edge(0, 4, key="x", value="e") | |
| 196 G.add_edge(4, 3, key="x", value="f") | |
| 197 mapping = {0: 9, 1: 9, 2: 9, 3: 9} | |
| 198 H = nx.relabel_nodes(G, mapping, copy=cc) | |
| 199 # No ordering on keys enforced | |
| 200 assert {"value": "a"} in H[9][4].values() | |
| 201 assert {"value": "b"} in H[9][4].values() | |
| 202 assert {"value": "c"} in H[4][9].values() | |
| 203 assert len(H[4][9]) == 3 if G.is_directed() else 6 | |
| 204 assert {"value": "d"} in H[4][9].values() | |
| 205 assert {"value": "e"} in H[9][4].values() | |
| 206 assert {"value": "f"} in H[4][9].values() | |
| 207 assert len(H[9][4]) == 3 if G.is_directed() else 6 | |
| 208 | |
| 209 def test_relabel_multigraph_merge_inplace(self): | |
| 210 G = nx.MultiGraph([(0, 1), (0, 2), (0, 3), (0, 1), (0, 2), (0, 3)]) | |
| 211 G[0][1][0]["value"] = "a" | |
| 212 G[0][2][0]["value"] = "b" | |
| 213 G[0][3][0]["value"] = "c" | |
| 214 mapping = {1: 4, 2: 4, 3: 4} | |
| 215 nx.relabel_nodes(G, mapping, copy=False) | |
| 216 # No ordering on keys enforced | |
| 217 assert {"value": "a"} in G[0][4].values() | |
| 218 assert {"value": "b"} in G[0][4].values() | |
| 219 assert {"value": "c"} in G[0][4].values() | |
| 220 | |
| 221 def test_relabel_multidigraph_merge_inplace(self): | |
| 222 G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)]) | |
| 223 G[0][1][0]["value"] = "a" | |
| 224 G[0][2][0]["value"] = "b" | |
| 225 G[0][3][0]["value"] = "c" | |
| 226 mapping = {1: 4, 2: 4, 3: 4} | |
| 227 nx.relabel_nodes(G, mapping, copy=False) | |
| 228 # No ordering on keys enforced | |
| 229 assert {"value": "a"} in G[0][4].values() | |
| 230 assert {"value": "b"} in G[0][4].values() | |
| 231 assert {"value": "c"} in G[0][4].values() | |
| 232 | |
| 233 def test_relabel_multidigraph_inout_copy(self): | |
| 234 G = nx.MultiDiGraph([(0, 4), (1, 4), (4, 2), (4, 3)]) | |
| 235 G[0][4][0]["value"] = "a" | |
| 236 G[1][4][0]["value"] = "b" | |
| 237 G[4][2][0]["value"] = "c" | |
| 238 G[4][3][0]["value"] = "d" | |
| 239 G.add_edge(0, 4, key="x", value="e") | |
| 240 G.add_edge(4, 3, key="x", value="f") | |
| 241 mapping = {0: 9, 1: 9, 2: 9, 3: 9} | |
| 242 H = nx.relabel_nodes(G, mapping, copy=True) | |
| 243 # No ordering on keys enforced | |
| 244 assert {"value": "a"} in H[9][4].values() | |
| 245 assert {"value": "b"} in H[9][4].values() | |
| 246 assert {"value": "c"} in H[4][9].values() | |
| 247 assert len(H[4][9]) == 3 | |
| 248 assert {"value": "d"} in H[4][9].values() | |
| 249 assert {"value": "e"} in H[9][4].values() | |
| 250 assert {"value": "f"} in H[4][9].values() | |
| 251 assert len(H[9][4]) == 3 | |
| 252 | |
| 253 def test_relabel_multigraph_merge_copy(self): | |
| 254 G = nx.MultiGraph([(0, 1), (0, 2), (0, 3)]) | |
| 255 G[0][1][0]["value"] = "a" | |
| 256 G[0][2][0]["value"] = "b" | |
| 257 G[0][3][0]["value"] = "c" | |
| 258 mapping = {1: 4, 2: 4, 3: 4} | |
| 259 H = nx.relabel_nodes(G, mapping, copy=True) | |
| 260 assert {"value": "a"} in H[0][4].values() | |
| 261 assert {"value": "b"} in H[0][4].values() | |
| 262 assert {"value": "c"} in H[0][4].values() | |
| 263 | |
| 264 def test_relabel_multidigraph_merge_copy(self): | |
| 265 G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)]) | |
| 266 G[0][1][0]["value"] = "a" | |
| 267 G[0][2][0]["value"] = "b" | |
| 268 G[0][3][0]["value"] = "c" | |
| 269 mapping = {1: 4, 2: 4, 3: 4} | |
| 270 H = nx.relabel_nodes(G, mapping, copy=True) | |
| 271 assert {"value": "a"} in H[0][4].values() | |
| 272 assert {"value": "b"} in H[0][4].values() | |
| 273 assert {"value": "c"} in H[0][4].values() | |
| 274 | |
| 275 def test_relabel_multigraph_nonnumeric_key(self): | |
| 276 for MG in (nx.MultiGraph, nx.MultiDiGraph): | |
| 277 for cc in (True, False): | |
| 278 G = nx.MultiGraph() | |
| 279 G.add_edge(0, 1, key="I", value="a") | |
| 280 G.add_edge(0, 2, key="II", value="b") | |
| 281 G.add_edge(0, 3, key="II", value="c") | |
| 282 mapping = {1: 4, 2: 4, 3: 4} | |
| 283 nx.relabel_nodes(G, mapping, copy=False) | |
| 284 assert {"value": "a"} in G[0][4].values() | |
| 285 assert {"value": "b"} in G[0][4].values() | |
| 286 assert {"value": "c"} in G[0][4].values() | |
| 287 assert 0 in G[0][4] | |
| 288 assert "I" in G[0][4] | |
| 289 assert "II" in G[0][4] |