okstra 0.114.0 → 0.116.0

package/runtime/python/okstra_vendor/networkx/classes/tests/test_multigraph.py

@@ -1,528 +0,0 @@
-from collections import UserDict
-
-import pytest
-
-import networkx as nx
-from networkx.utils import edges_equal
-
-from .test_graph import BaseAttrGraphTester
-from .test_graph import TestGraph as _TestGraph
-
-
-class BaseMultiGraphTester(BaseAttrGraphTester):
-    def test_has_edge(self):
-        G = self.K3
-        assert G.has_edge(0, 1)
-        assert not G.has_edge(0, -1)
-        assert G.has_edge(0, 1, 0)
-        assert not G.has_edge(0, 1, 1)
-
-    def test_get_edge_data(self):
-        G = self.K3
-        assert G.get_edge_data(0, 1) == {0: {}}
-        assert G[0][1] == {0: {}}
-        assert G[0][1][0] == {}
-        assert G.get_edge_data(10, 20) is None
-        assert G.get_edge_data(0, 1, 0) == {}
-
-    def test_adjacency(self):
-        G = self.K3
-        assert dict(G.adjacency()) == {
-            0: {1: {0: {}}, 2: {0: {}}},
-            1: {0: {0: {}}, 2: {0: {}}},
-            2: {0: {0: {}}, 1: {0: {}}},
-        }
-
-    def deepcopy_edge_attr(self, H, G):
-        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
-        G[1][2][0]["foo"].append(1)
-        assert G[1][2][0]["foo"] != H[1][2][0]["foo"]
-
-    def shallow_copy_edge_attr(self, H, G):
-        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
-        G[1][2][0]["foo"].append(1)
-        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
-
-    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][0] is H._adj[2][1][0]
-            assert G._adj[1][2][0] is G._adj[2][1][0]
-        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][0] is H._pred[2][1][0]
-            assert G._succ[1][2][0] is G._pred[2][1][0]
-
-    def same_attrdict(self, H, G):
-        # same attrdict in the edgedata
-        old_foo = H[1][2][0]["foo"]
-        H.adj[1][2][0]["foo"] = "baz"
-        assert G._adj == H._adj
-        H.adj[1][2][0]["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 different_attrdict(self, H, G):
-        # used by graph_equal_but_different
-        old_foo = H[1][2][0]["foo"]
-        H.adj[1][2][0]["foo"] = "baz"
-        assert G._adj != H._adj
-        H.adj[1][2][0]["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 test_to_undirected(self):
-        G = self.K3
-        self.add_attributes(G)
-        H = nx.MultiGraph(G)
-        self.is_shallow_copy(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.MultiDiGraph(G)
-        self.is_shallow_copy(H, G)
-        H = G.to_directed()
-        self.is_deepcopy(H, G)
-
-    def test_number_of_edges_selfloops(self):
-        G = self.K3
-        G.add_edge(0, 0)
-        G.add_edge(0, 0)
-        G.add_edge(0, 0, key="parallel edge")
-        G.remove_edge(0, 0, key="parallel edge")
-        assert G.number_of_edges(0, 0) == 2
-        G.remove_edge(0, 0)
-        assert G.number_of_edges(0, 0) == 1
-
-    def test_edge_lookup(self):
-        G = self.Graph()
-        G.add_edge(1, 2, foo="bar")
-        G.add_edge(1, 2, "key", foo="biz")
-        assert edges_equal(G.edges[1, 2, 0], {"foo": "bar"})
-        assert edges_equal(G.edges[1, 2, "key"], {"foo": "biz"})
-
-    def test_edge_attr(self):
-        G = self.Graph()
-        G.add_edge(1, 2, key="k1", foo="bar")
-        G.add_edge(1, 2, key="k2", foo="baz")
-        assert isinstance(G.get_edge_data(1, 2), G.edge_key_dict_factory)
-        assert all(
-            isinstance(d, G.edge_attr_dict_factory) for u, v, d in G.edges(data=True)
-        )
-        assert edges_equal(
-            G.edges(keys=True, data=True),
-            [(1, 2, "k1", {"foo": "bar"}), (1, 2, "k2", {"foo": "baz"})],
-        )
-        assert edges_equal(
-            G.edges(keys=True, data="foo"), [(1, 2, "k1", "bar"), (1, 2, "k2", "baz")]
-        )
-
-    def test_edge_attr4(self):
-        G = self.Graph()
-        G.add_edge(1, 2, key=0, data=7, spam="bar", bar="foo")
-        assert edges_equal(
-            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
-        )
-        G[1][2][0]["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][0]["data"] = 20
-        assert edges_equal(
-            G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
-        )
-        G.edges[1, 2, 0]["data"] = 21  # another spelling, "edge"
-        assert edges_equal(
-            G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
-        )
-        G.adj[1][2][0]["listdata"] = [20, 200]
-        G.adj[1][2][0]["weight"] = 20
-        assert edges_equal(
-            G.edges(data=True),
-            [
-                (
-                    1,
-                    2,
-                    {
-                        "data": 21,
-                        "spam": "bar",
-                        "bar": "foo",
-                        "listdata": [20, 200],
-                        "weight": 20,
-                    },
-                )
-            ],
-        )
-
-
-class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
-    def setup_method(self):
-        self.Graph = nx.MultiGraph
-        # build K3
-        ed1, ed2, ed3 = ({0: {}}, {0: {}}, {0: {}})
-        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_data_input(self):
-        G = self.Graph({1: [2], 2: [1]}, name="test")
-        assert G.name == "test"
-        expected = [(1, {2: {0: {}}}), (2, {1: {0: {}}})]
-        assert sorted(G.adj.items()) == expected
-
-    def test_data_multigraph_input(self):
-        # standard case with edge keys and edge data
-        edata0 = {"w": 200, "s": "foo"}
-        edata1 = {"w": 201, "s": "bar"}
-        keydict = {0: edata0, 1: edata1}
-        dododod = {"a": {"b": keydict}}
-
-        multiple_edge = [("a", "b", 0, edata0), ("a", "b", 1, edata1)]
-        single_edge = [("a", "b", 0, keydict)]
-
-        G = self.Graph(dododod, multigraph_input=True)
-        assert list(G.edges(keys=True, data=True)) == multiple_edge
-        G = self.Graph(dododod, multigraph_input=None)
-        assert list(G.edges(keys=True, data=True)) == multiple_edge
-        G = self.Graph(dododod, multigraph_input=False)
-        assert list(G.edges(keys=True, data=True)) == single_edge
-
-        # test round-trip to_dict_of_dict and MultiGraph constructor
-        G = self.Graph(dododod, multigraph_input=True)
-        H = self.Graph(nx.to_dict_of_dicts(G))
-        assert nx.is_isomorphic(G, H) is True  # test that default is True
-        for mgi in [True, False]:
-            H = self.Graph(nx.to_dict_of_dicts(G), multigraph_input=mgi)
-            assert nx.is_isomorphic(G, H) == mgi
-
-    # Set up cases for when incoming_graph_data is not multigraph_input
-    etraits = {"w": 200, "s": "foo"}
-    egraphics = {"color": "blue", "shape": "box"}
-    edata = {"traits": etraits, "graphics": egraphics}
-    dodod1 = {"a": {"b": edata}}
-    dodod2 = {"a": {"b": etraits}}
-    dodod3 = {"a": {"b": {"traits": etraits, "s": "foo"}}}
-    dol = {"a": ["b"]}
-
-    multiple_edge = [("a", "b", "traits", etraits), ("a", "b", "graphics", egraphics)]
-    single_edge = [("a", "b", 0, {})]  # type: ignore[var-annotated]
-    single_edge1 = [("a", "b", 0, edata)]
-    single_edge2 = [("a", "b", 0, etraits)]
-    single_edge3 = [("a", "b", 0, {"traits": etraits, "s": "foo"})]
-
-    cases = [  # (dod, mgi, edges)
-        (dodod1, True, multiple_edge),
-        (dodod1, False, single_edge1),
-        (dodod2, False, single_edge2),
-        (dodod3, False, single_edge3),
-        (dol, False, single_edge),
-    ]
-
-    @pytest.mark.parametrize("dod, mgi, edges", cases)
-    def test_non_multigraph_input(self, dod, mgi, edges):
-        G = self.Graph(dod, multigraph_input=mgi)
-        assert list(G.edges(keys=True, data=True)) == edges
-        G = nx.to_networkx_graph(dod, create_using=self.Graph, multigraph_input=mgi)
-        assert list(G.edges(keys=True, data=True)) == edges
-
-    mgi_none_cases = [
-        (dodod1, multiple_edge),
-        (dodod2, single_edge2),
-        (dodod3, single_edge3),
-    ]
-
-    @pytest.mark.parametrize("dod, edges", mgi_none_cases)
-    def test_non_multigraph_input_mgi_none(self, dod, edges):
-        # test constructor without to_networkx_graph for mgi=None
-        G = self.Graph(dod)
-        assert list(G.edges(keys=True, data=True)) == edges
-
-    raise_cases = [dodod2, dodod3, dol]
-
-    @pytest.mark.parametrize("dod", raise_cases)
-    def test_non_multigraph_input_raise(self, dod):
-        # cases where NetworkXError is raised
-        pytest.raises(nx.NetworkXError, self.Graph, dod, multigraph_input=True)
-        pytest.raises(
-            nx.NetworkXError,
-            nx.to_networkx_graph,
-            dod,
-            create_using=self.Graph,
-            multigraph_input=True,
-        )
-
-    def test_getitem(self):
-        G = self.K3
-        assert G[0] == {1: {0: {}}, 2: {0: {}}}
-        with pytest.raises(KeyError):
-            G.__getitem__("j")
-        with pytest.raises(TypeError):
-            G.__getitem__(["A"])
-
-    def test_remove_node(self):
-        G = self.K3
-        G.remove_node(0)
-        assert G.adj == {1: {2: {0: {}}}, 2: {1: {0: {}}}}
-        with pytest.raises(nx.NetworkXError):
-            G.remove_node(-1)
-
-    def test_add_edge(self):
-        G = self.Graph()
-        G.add_edge(0, 1)
-        assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
-        G = self.Graph()
-        G.add_edge(*(0, 1))
-        assert G.adj == {0: {1: {0: {}}}, 1: {0: {0: {}}}}
-        G = self.Graph()
-        with pytest.raises(ValueError):
-            G.add_edge(None, "anything")
-
-    def test_add_edge_conflicting_key(self):
-        G = self.Graph()
-        G.add_edge(0, 1, key=1)
-        G.add_edge(0, 1)
-        assert G.number_of_edges() == 2
-        G = self.Graph()
-        G.add_edges_from([(0, 1, 1, {})])
-        G.add_edges_from([(0, 1)])
-        assert G.number_of_edges() == 2
-
-    def test_add_edges_from(self):
-        G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})])
-        assert G.adj == {
-            0: {1: {0: {}, 1: {"weight": 3}}},
-            1: {0: {0: {}, 1: {"weight": 3}}},
-        }
-        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})], weight=2)
-        assert G.adj == {
-            0: {1: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
-            1: {0: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
-        }
-        G = self.Graph()
-        edges = [
-            (0, 1, {"weight": 3}),
-            (0, 1, (("weight", 2),)),
-            (0, 1, 5),
-            (0, 1, "s"),
-        ]
-        G.add_edges_from(edges)
-        keydict = {0: {"weight": 3}, 1: {"weight": 2}, 5: {}, "s": {}}
-        assert G._adj == {0: {1: keydict}, 1: {0: keydict}}
-
-        # too few in tuple
-        with pytest.raises(nx.NetworkXError):
-            G.add_edges_from([(0,)])
-        # too many in tuple
-        with pytest.raises(nx.NetworkXError):
-            G.add_edges_from([(0, 1, 2, 3, 4)])
-        # not a tuple
-        with pytest.raises(TypeError):
-            G.add_edges_from([0])
-
-    def test_multigraph_add_edges_from_four_tuple_misordered(self):
-        """add_edges_from expects 4-tuples of the format (u, v, key, data_dict).
-
-        Ensure 4-tuples of form (u, v, data_dict, key) raise exception.
-        """
-        G = nx.MultiGraph()
-        with pytest.raises(TypeError):
-            # key/data values flipped in 4-tuple
-            G.add_edges_from([(0, 1, {"color": "red"}, 0)])
-
-    def test_remove_edge(self):
-        G = self.K3
-        G.remove_edge(0, 1)
-        assert G.adj == {0: {2: {0: {}}}, 1: {2: {0: {}}}, 2: {0: {0: {}}, 1: {0: {}}}}
-
-        with pytest.raises(nx.NetworkXError):
-            G.remove_edge(-1, 0)
-        with pytest.raises(nx.NetworkXError):
-            G.remove_edge(0, 2, key=1)
-
-    def test_remove_edges_from(self):
-        G = self.K3.copy()
-        G.remove_edges_from([(0, 1)])
-        kd = {0: {}}
-        assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
-        G.remove_edges_from([(0, 0)])  # silent fail
-        self.K3.add_edge(0, 1)
-        G = self.K3.copy()
-        G.remove_edges_from(list(G.edges(data=True, keys=True)))
-        assert G.adj == {0: {}, 1: {}, 2: {}}
-        G = self.K3.copy()
-        G.remove_edges_from(list(G.edges(data=False, keys=True)))
-        assert G.adj == {0: {}, 1: {}, 2: {}}
-        G = self.K3.copy()
-        G.remove_edges_from(list(G.edges(data=False, keys=False)))
-        assert G.adj == {0: {}, 1: {}, 2: {}}
-        G = self.K3.copy()
-        G.remove_edges_from([(0, 1, 0), (0, 2, 0, {}), (1, 2)])
-        assert G.adj == {0: {1: {1: {}}}, 1: {0: {1: {}}}, 2: {}}
-
-    def test_remove_multiedge(self):
-        G = self.K3
-        G.add_edge(0, 1, key="parallel edge")
-        G.remove_edge(0, 1, key="parallel edge")
-        assert G.adj == {
-            0: {1: {0: {}}, 2: {0: {}}},
-            1: {0: {0: {}}, 2: {0: {}}},
-            2: {0: {0: {}}, 1: {0: {}}},
-        }
-        G.remove_edge(0, 1)
-        kd = {0: {}}
-        assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
-        with pytest.raises(nx.NetworkXError):
-            G.remove_edge(-1, 0)
-
-
-class TestEdgeSubgraph:
-    """Unit tests for the :meth:`MultiGraph.edge_subgraph` method."""
-
-    def setup_method(self):
-        # Create a doubly-linked path graph on five nodes.
-        G = nx.MultiGraph()
-        nx.add_path(G, range(5))
-        nx.add_path(G, range(5))
-        # Add some node, edge, and graph attributes.
-        for i in range(5):
-            G.nodes[i]["name"] = f"node{i}"
-        G.adj[0][1][0]["name"] = "edge010"
-        G.adj[0][1][1]["name"] = "edge011"
-        G.adj[3][4][0]["name"] = "edge340"
-        G.adj[3][4][1]["name"] = "edge341"
-        G.graph["name"] = "graph"
-        # Get the subgraph induced by one of the first edges and one of
-        # the last edges.
-        self.G = G
-        self.H = G.edge_subgraph([(0, 1, 0), (3, 4, 1)])
-
-    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, 0, "edge010"), (3, 4, 1, "edge341")] == sorted(
-            self.H.edges(keys=True, 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, k in self.H.edges(keys=True):
-            assert self.G._adj[u][v][k] == self.H._adj[u][v][k]
-        # Making a change to G should make a change in H and vice versa.
-        self.G._adj[0][1][0]["name"] = "foo"
-        assert self.G._adj[0][1][0]["name"] == self.H._adj[0][1][0]["name"]
-        self.H._adj[3][4][1]["name"] = "bar"
-        assert self.G._adj[3][4][1]["name"] == self.H._adj[3][4][1]["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
-
-
-class CustomDictClass(UserDict):
-    pass
-
-
-class MultiGraphSubClass(nx.MultiGraph):
-    node_dict_factory = CustomDictClass  # type: ignore[assignment]
-    node_attr_dict_factory = CustomDictClass  # type: ignore[assignment]
-    adjlist_outer_dict_factory = CustomDictClass  # type: ignore[assignment]
-    adjlist_inner_dict_factory = CustomDictClass  # type: ignore[assignment]
-    edge_key_dict_factory = CustomDictClass  # type: ignore[assignment]
-    edge_attr_dict_factory = CustomDictClass  # type: ignore[assignment]
-    graph_attr_dict_factory = CustomDictClass  # type: ignore[assignment]
-
-
-class TestMultiGraphSubclass(TestMultiGraph):
-    def setup_method(self):
-        self.Graph = MultiGraphSubClass
-        # build K3
-        self.k3edges = [(0, 1), (0, 2), (1, 2)]
-        self.k3nodes = [0, 1, 2]
-        self.K3 = self.Graph()
-        self.K3._adj = self.K3.adjlist_outer_dict_factory(
-            {
-                0: self.K3.adjlist_inner_dict_factory(),
-                1: self.K3.adjlist_inner_dict_factory(),
-                2: self.K3.adjlist_inner_dict_factory(),
-            }
-        )
-        self.K3._pred = {0: {}, 1: {}, 2: {}}
-        for u in self.k3nodes:
-            for v in self.k3nodes:
-                if u != v:
-                    d = {0: {}}
-                    self.K3._adj[u][v] = d
-                    self.K3._adj[v][u] = d
-        self.K3._node = self.K3.node_dict_factory()
-        self.K3._node[0] = self.K3.node_attr_dict_factory()
-        self.K3._node[1] = self.K3.node_attr_dict_factory()
-        self.K3._node[2] = self.K3.node_attr_dict_factory()