okstra 0.107.2 → 0.109.0

package/runtime/python/okstra_vendor/networkx/algorithms/tree/tests/test_coding.py

@@ -0,0 +1,114 @@
+"""Unit tests for the :mod:`~networkx.algorithms.tree.coding` module."""
+
+from itertools import product
+
+import pytest
+
+import networkx as nx
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestPruferSequence:
+    """Unit tests for the Prüfer sequence encoding and decoding
+    functions.
+
+    """
+
+    def test_nontree(self):
+        with pytest.raises(nx.NotATree):
+            G = nx.cycle_graph(3)
+            nx.to_prufer_sequence(G)
+
+    def test_null_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.to_prufer_sequence(nx.null_graph())
+
+    def test_trivial_graph(self):
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.to_prufer_sequence(nx.trivial_graph())
+
+    def test_bad_integer_labels(self):
+        with pytest.raises(KeyError):
+            T = nx.Graph(nx.utils.pairwise("abc"))
+            nx.to_prufer_sequence(T)
+
+    def test_encoding(self):
+        """Tests for encoding a tree as a Prüfer sequence using the
+        iterative strategy.
+
+        """
+        # Example from Wikipedia.
+        tree = nx.Graph([(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)])
+        sequence = nx.to_prufer_sequence(tree)
+        assert sequence == [3, 3, 3, 4]
+
+    def test_decoding(self):
+        """Tests for decoding a tree from a Prüfer sequence."""
+        # Example from Wikipedia.
+        sequence = [3, 3, 3, 4]
+        tree = nx.from_prufer_sequence(sequence)
+        assert nodes_equal(list(tree), list(range(6)))
+        edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)]
+        assert edges_equal(list(tree.edges()), edges)
+
+    def test_decoding2(self):
+        # Example from "An Optimal Algorithm for Prufer Codes".
+        sequence = [2, 4, 0, 1, 3, 3]
+        tree = nx.from_prufer_sequence(sequence)
+        assert nodes_equal(list(tree), list(range(8)))
+        edges = [(0, 1), (0, 4), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)]
+        assert edges_equal(list(tree.edges()), edges)
+
+    def test_inverse(self):
+        """Tests that the encoding and decoding functions are inverses."""
+        for T in nx.nonisomorphic_trees(4):
+            T2 = nx.from_prufer_sequence(nx.to_prufer_sequence(T))
+            assert nodes_equal(list(T), list(T2))
+            assert edges_equal(list(T.edges()), list(T2.edges()))
+
+        for seq in product(range(4), repeat=2):
+            seq2 = nx.to_prufer_sequence(nx.from_prufer_sequence(seq))
+            assert list(seq) == seq2
+
+
+class TestNestedTuple:
+    """Unit tests for the nested tuple encoding and decoding functions."""
+
+    def test_nontree(self):
+        with pytest.raises(nx.NotATree):
+            G = nx.cycle_graph(3)
+            nx.to_nested_tuple(G, 0)
+
+    def test_unknown_root(self):
+        with pytest.raises(nx.NodeNotFound):
+            G = nx.path_graph(2)
+            nx.to_nested_tuple(G, "bogus")
+
+    def test_encoding(self):
+        T = nx.full_rary_tree(2, 2**3 - 1)
+        expected = (((), ()), ((), ()))
+        actual = nx.to_nested_tuple(T, 0)
+        assert nodes_equal(expected, actual)
+
+    def test_canonical_form(self):
+        T = nx.Graph()
+        T.add_edges_from([(0, 1), (0, 2), (0, 3)])
+        T.add_edges_from([(1, 4), (1, 5)])
+        T.add_edges_from([(3, 6), (3, 7)])
+        root = 0
+        actual = nx.to_nested_tuple(T, root, canonical_form=True)
+        expected = ((), ((), ()), ((), ()))
+        assert actual == expected
+
+    def test_decoding(self):
+        balanced = (((), ()), ((), ()))
+        expected = nx.full_rary_tree(2, 2**3 - 1)
+        actual = nx.from_nested_tuple(balanced)
+        assert nx.is_isomorphic(expected, actual)
+
+    def test_sensible_relabeling(self):
+        balanced = (((), ()), ((), ()))
+        T = nx.from_nested_tuple(balanced, sensible_relabeling=True)
+        edges = [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)]
+        assert nodes_equal(list(T), list(range(2**3 - 1)))
+        assert edges_equal(list(T.edges()), edges)

package/runtime/python/okstra_vendor/networkx/algorithms/tree/tests/test_decomposition.py

@@ -0,0 +1,79 @@
+import networkx as nx
+from networkx.algorithms.tree.decomposition import junction_tree
+
+
+def test_junction_tree_directed_confounders():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "C"), ("B", "C"), ("C", "D"), ("C", "E")])
+
+    G = junction_tree(B)
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("C", "E"), ("C",)),
+            (("C",), ("A", "B", "C")),
+            (("A", "B", "C"), ("C",)),
+            (("C",), ("C", "D")),
+        ]
+    )
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_unconnected_nodes():
+    B = nx.DiGraph()
+    B.add_nodes_from([("A", "B", "C", "D")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_nodes_from([("A", "B", "C", "D")])
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_cascade():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "B"), ("B", "C"), ("C", "D")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("A", "B"), ("B",)),
+            (("B",), ("B", "C")),
+            (("B", "C"), ("C",)),
+            (("C",), ("C", "D")),
+        ]
+    )
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_directed_unconnected_edges():
+    B = nx.DiGraph()
+    B.add_edges_from([("A", "B"), ("C", "D"), ("E", "F")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_nodes_from([("A", "B"), ("C", "D"), ("E", "F")])
+
+    assert nx.is_isomorphic(G, J)
+
+
+def test_junction_tree_undirected():
+    B = nx.Graph()
+    B.add_edges_from([("A", "C"), ("A", "D"), ("B", "C"), ("C", "E")])
+    G = junction_tree(B)
+
+    J = nx.Graph()
+    J.add_edges_from(
+        [
+            (("A", "D"), ("A",)),
+            (("A",), ("A", "C")),
+            (("A", "C"), ("C",)),
+            (("C",), ("B", "C")),
+            (("B", "C"), ("C",)),
+            (("C",), ("C", "E")),
+        ]
+    )
+
+    assert nx.is_isomorphic(G, J)

package/runtime/python/okstra_vendor/networkx/algorithms/tree/tests/test_distance_measures.py

@@ -0,0 +1,99 @@
+import math
+
+import pytest
+
+import networkx as nx
+
+
+class TestCenter:
+    @pytest.mark.parametrize("graph_type", (nx.Graph, nx.MultiGraph))
+    def test_center_simple_tree(self, graph_type):
+        G = nx.Graph([(1, 2), (1, 3), (2, 4), (2, 5)], create_using=graph_type)
+        assert set(nx.tree.center(G)) == {1, 2}
+
+    @pytest.mark.parametrize("r", range(2, 5))
+    @pytest.mark.parametrize("h", range(1, 5))
+    def test_center_balanced_tree(self, r, h):
+        G = nx.balanced_tree(r, h)
+        assert nx.tree.center(G) == [0]
+
+    @pytest.mark.parametrize("n", [1, 2, 99, 100])
+    def test_center_path_graph(self, n):
+        G = nx.path_graph(n)
+        expected = {(n - 1) // 2, math.ceil((n - 1) / 2)}
+        assert set(nx.tree.center(G)) == expected
+
+    @pytest.mark.parametrize("n", [0, 2, 3, 5, 99, 100])
+    def test_center_star_graph(self, n):
+        G = nx.star_graph(n)
+        assert nx.tree.center(G) == [0]
+
+    @pytest.mark.parametrize(
+        "G",
+        (
+            nx.cycle_graph(5),
+            nx.complete_graph(5),
+            nx.Graph([(0, 1), (2, 3)]),
+            nx.empty_graph(2),
+            nx.Graph(),
+            nx.MultiGraph([(0, 1), (0, 1)]),
+            nx.Graph([(0, 1), (1, 2), (3, 4)]),
+            nx.Graph([(0, 1), (1, 2), (3, 4), (4, 5)]),
+            pytest.param(
+                nx.Graph([(0, 0)]),
+                marks=pytest.mark.xfail(reason="no check for self-loops"),
+            ),
+        ),
+    )
+    def test_center_non_tree(self, G):
+        with pytest.raises(nx.NotATree, match=r"not a tree"):
+            nx.tree.center(G)
+
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiDiGraph))
+    def test_center_directed(self, graph_type):
+        G = nx.path_graph(4, create_using=graph_type)
+        with pytest.raises(
+            nx.NetworkXNotImplemented, match=r"not implemented for directed"
+        ):
+            nx.tree.center(G)
+
+
+class TestDistance:
+    @pytest.mark.parametrize("n", [1, 2, 99, 100])
+    def test_tree_centroid_path_graphs(self, n):
+        G = nx.path_graph(n)
+        expected = {(n - 1) // 2, math.ceil((n - 1) / 2)}
+        assert set(nx.tree.centroid(G)) == expected
+
+    @pytest.mark.parametrize("r", range(2, 5))
+    @pytest.mark.parametrize("h", range(1, 5))
+    def test_tree_centroid_balanced_tree(self, r, h):
+        G = nx.balanced_tree(r, h)
+        assert nx.tree.centroid(G) == [0]
+
+    def test_tree_centroid_multiple_centroids(self):
+        G = nx.full_rary_tree(2, 8)
+        assert nx.tree.centroid(G) == [0, 1]
+
+    def test_tree_centroid_different_from_graph_center(self):
+        G = nx.star_graph(6)
+        nx.add_path(G, [6, 7, 8, 9, 10])
+        # nx.center(G) would be [7]
+        assert nx.tree.centroid(G) == [0]
+
+    def test_tree_centroid_not_a_tree(self):
+        G = nx.cycle_graph(3)
+        with pytest.raises(nx.NotATree, match=r"not a tree"):
+            nx.tree.centroid(G)
+
+    @pytest.mark.parametrize("G", [nx.DiGraph([(0, 1)]), nx.MultiDiGraph([(0, 1)])])
+    def test_tree_centroid_direct_raises(self, G):
+        with pytest.raises(
+            nx.NetworkXNotImplemented, match=r"not implemented for directed type"
+        ):
+            nx.tree.centroid(G)
+
+    def test_tree_centroid_empty(self):
+        G = nx.Graph()
+        with pytest.raises(nx.NetworkXPointlessConcept, match=r"has no nodes"):
+            nx.tree.centroid(G)