okstra 0.114.0 → 0.116.0

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

@@ -1,114 +0,0 @@
-"""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

@@ -1,79 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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)