okstra 0.107.2 → 0.109.0

package/runtime/python/okstra_vendor/networkx/tests/test_lazy_imports.py

@@ -0,0 +1,96 @@
+import sys
+import types
+
+import pytest
+
+import networkx.lazy_imports as lazy
+
+
+def test_lazy_import_basics():
+    math = lazy._lazy_import("math")
+    anything_not_real = lazy._lazy_import("anything_not_real")
+
+    # Now test that accessing attributes does what it should
+    assert math.sin(math.pi) == pytest.approx(0, 1e-6)
+    # poor-mans pytest.raises for testing errors on attribute access
+    try:
+        anything_not_real.pi
+        assert False  # Should not get here
+    except ModuleNotFoundError:
+        pass
+    assert isinstance(anything_not_real, lazy.DelayedImportErrorModule)
+    # see if it changes for second access
+    try:
+        anything_not_real.pi
+        assert False  # Should not get here
+    except ModuleNotFoundError:
+        pass
+
+
+def test_lazy_import_impact_on_sys_modules():
+    math = lazy._lazy_import("math")
+    anything_not_real = lazy._lazy_import("anything_not_real")
+
+    assert isinstance(math, types.ModuleType)
+    assert "math" in sys.modules
+    assert type(anything_not_real) is lazy.DelayedImportErrorModule
+    assert "anything_not_real" not in sys.modules
+
+    # only do this if numpy is installed
+    np_test = pytest.importorskip("numpy")
+    np = lazy._lazy_import("numpy")
+    assert isinstance(np, types.ModuleType)
+    assert "numpy" in sys.modules
+
+    np.pi  # trigger load of numpy
+
+    assert isinstance(np, types.ModuleType)
+    assert "numpy" in sys.modules
+
+
+def test_lazy_import_nonbuiltins():
+    sp = lazy._lazy_import("scipy")
+    np = lazy._lazy_import("numpy")
+    if isinstance(sp, lazy.DelayedImportErrorModule):
+        try:
+            sp.special.erf
+            assert False
+        except ModuleNotFoundError:
+            pass
+    elif isinstance(np, lazy.DelayedImportErrorModule):
+        try:
+            np.sin(np.pi)
+            assert False
+        except ModuleNotFoundError:
+            pass
+    else:
+        assert sp.special.erf(np.pi) == pytest.approx(1, 1e-4)
+
+
+def test_lazy_attach():
+    name = "mymod"
+    submods = ["mysubmodule", "anothersubmodule"]
+    myall = {"not_real_submod": ["some_var_or_func"]}
+
+    locls = {
+        "attach": lazy.attach,
+        "name": name,
+        "submods": submods,
+        "myall": myall,
+    }
+    s = "__getattr__, __lazy_dir__, __all__ = attach(name, submods, myall)"
+
+    exec(s, {}, locls)
+    expected = {
+        "attach": lazy.attach,
+        "name": name,
+        "submods": submods,
+        "myall": myall,
+        "__getattr__": None,
+        "__lazy_dir__": None,
+        "__all__": None,
+    }
+    assert locls.keys() == expected.keys()
+    for k, v in expected.items():
+        if v is not None:
+            assert locls[k] == v

package/runtime/python/okstra_vendor/networkx/tests/test_relabel.py

@@ -0,0 +1,349 @@
+import pytest
+
+import networkx as nx
+from networkx.generators.classic import empty_graph
+from networkx.utils import edges_equal, nodes_equal
+
+
+class TestRelabel:
+    def test_convert_node_labels_to_integers(self):
+        # test that empty graph converts fine for all options
+        G = empty_graph()
+        H = nx.convert_node_labels_to_integers(G, 100)
+        assert list(H.nodes()) == []
+        assert list(H.edges()) == []
+
+        for opt in ["default", "sorted", "increasing degree", "decreasing degree"]:
+            G = empty_graph()
+            H = nx.convert_node_labels_to_integers(G, 100, ordering=opt)
+            assert list(H.nodes()) == []
+            assert list(H.edges()) == []
+
+        G = empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        H = nx.convert_node_labels_to_integers(G)
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+
+        H = nx.convert_node_labels_to_integers(G, 1000)
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert nodes_equal(H.nodes(), [1000, 1001, 1002, 1003])
+
+        H = nx.convert_node_labels_to_integers(G, ordering="increasing degree")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 1
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 3
+
+        H = nx.convert_node_labels_to_integers(G, ordering="decreasing degree")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 3
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 1
+
+        H = nx.convert_node_labels_to_integers(
+            G, ordering="increasing degree", label_attribute="label"
+        )
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+        assert H.degree(0) == 1
+        assert H.degree(1) == 2
+        assert H.degree(2) == 2
+        assert H.degree(3) == 3
+
+        # check mapping
+        assert H.nodes[3]["label"] == "C"
+        assert H.nodes[0]["label"] == "D"
+        assert H.nodes[1]["label"] == "A" or H.nodes[2]["label"] == "A"
+        assert H.nodes[1]["label"] == "B" or H.nodes[2]["label"] == "B"
+
+    def test_convert_to_integers2(self):
+        G = empty_graph()
+        G.add_edges_from([("C", "D"), ("A", "B"), ("A", "C"), ("B", "C")])
+        H = nx.convert_node_labels_to_integers(G, ordering="sorted")
+        degH = (d for n, d in H.degree())
+        degG = (d for n, d in G.degree())
+        assert sorted(degH) == sorted(degG)
+
+        H = nx.convert_node_labels_to_integers(
+            G, ordering="sorted", label_attribute="label"
+        )
+        assert H.nodes[0]["label"] == "A"
+        assert H.nodes[1]["label"] == "B"
+        assert H.nodes[2]["label"] == "C"
+        assert H.nodes[3]["label"] == "D"
+
+    def test_convert_to_integers_raise(self):
+        with pytest.raises(nx.NetworkXError):
+            G = nx.Graph()
+            H = nx.convert_node_labels_to_integers(G, ordering="increasing age")
+
+    def test_relabel_nodes_copy(self):
+        G = nx.empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_function(self):
+        G = nx.empty_graph()
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        # function mapping no longer encouraged but works
+
+        def mapping(n):
+            return ord(n)
+
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), [65, 66, 67, 68])
+
+    def test_relabel_nodes_callable_type(self):
+        G = nx.path_graph(4)
+        H = nx.relabel_nodes(G, str)
+        assert nodes_equal(H.nodes, ["0", "1", "2", "3"])
+
+    @pytest.mark.parametrize("non_mc", ("0123", ["0", "1", "2", "3"]))
+    def test_relabel_nodes_non_mapping_or_callable(self, non_mc):
+        """If `mapping` is neither a Callable or a Mapping, an exception
+        should be raised."""
+        G = nx.path_graph(4)
+        with pytest.raises(AttributeError):
+            nx.relabel_nodes(G, non_mc)
+
+    def test_relabel_nodes_graph(self):
+        G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_orderedgraph(self):
+        G = nx.Graph()
+        G.add_nodes_from([1, 2, 3])
+        G.add_edges_from([(1, 3), (2, 3)])
+        mapping = {1: "a", 2: "b", 3: "c"}
+        H = nx.relabel_nodes(G, mapping)
+        assert list(H.nodes) == ["a", "b", "c"]
+
+    def test_relabel_nodes_digraph(self):
+        G = nx.DiGraph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {"A": "aardvark", "B": "bear", "C": "cat", "D": "dog"}
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(H.nodes(), ["aardvark", "bear", "cat", "dog"])
+
+    def test_relabel_nodes_multigraph(self):
+        G = nx.MultiGraph([("a", "b"), ("a", "b")])
+        mapping = {"a": "aardvark", "b": "bear"}
+        G = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes(), ["aardvark", "bear"])
+        assert edges_equal(G.edges(), [("aardvark", "bear"), ("aardvark", "bear")])
+
+    def test_relabel_nodes_multidigraph(self):
+        G = nx.MultiDiGraph([("a", "b"), ("a", "b")])
+        mapping = {"a": "aardvark", "b": "bear"}
+        G = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes(), ["aardvark", "bear"])
+        assert edges_equal(
+            G.edges(), [("aardvark", "bear"), ("aardvark", "bear")], directed=True
+        )
+
+    def test_relabel_isolated_nodes_to_same(self):
+        G = nx.Graph()
+        G.add_nodes_from(range(4))
+        mapping = {1: 1}
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(H.nodes(), list(range(4)))
+
+    def test_relabel_nodes_missing(self):
+        G = nx.Graph([("A", "B"), ("A", "C"), ("B", "C"), ("C", "D")])
+        mapping = {0: "aardvark"}
+        # copy=True
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert nodes_equal(H.nodes, G.nodes)
+        # copy=False
+        GG = G.copy()
+        nx.relabel_nodes(G, mapping, copy=False)
+        assert nodes_equal(G.nodes, GG.nodes)
+
+    def test_relabel_copy_name(self):
+        G = nx.Graph()
+        H = nx.relabel_nodes(G, {}, copy=True)
+        assert H.graph == G.graph
+        H = nx.relabel_nodes(G, {}, copy=False)
+        assert H.graph == G.graph
+        G.name = "first"
+        H = nx.relabel_nodes(G, {}, copy=True)
+        assert H.graph == G.graph
+        H = nx.relabel_nodes(G, {}, copy=False)
+        assert H.graph == G.graph
+
+    def test_relabel_toposort(self):
+        K5 = nx.complete_graph(4)
+        G = nx.complete_graph(4)
+        G = nx.relabel_nodes(G, {i: i + 1 for i in range(4)}, copy=False)
+        assert nx.is_isomorphic(K5, G)
+        G = nx.complete_graph(4)
+        G = nx.relabel_nodes(G, {i: i - 1 for i in range(4)}, copy=False)
+        assert nx.is_isomorphic(K5, G)
+
+    def test_relabel_selfloop(self):
+        G = nx.DiGraph([(1, 1), (1, 2), (2, 3)])
+        G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False)
+        assert nodes_equal(G.nodes(), ["One", "Three", "Two"])
+        G = nx.MultiDiGraph([(1, 1), (1, 2), (2, 3)])
+        G = nx.relabel_nodes(G, {1: "One", 2: "Two", 3: "Three"}, copy=False)
+        assert nodes_equal(G.nodes(), ["One", "Three", "Two"])
+        G = nx.MultiDiGraph([(1, 1)])
+        G = nx.relabel_nodes(G, {1: 0}, copy=False)
+        assert nodes_equal(G.nodes(), [0])
+
+    def test_relabel_multidigraph_inout_merge_nodes(self):
+        for MG in (nx.MultiGraph, nx.MultiDiGraph):
+            for cc in (True, False):
+                G = MG([(0, 4), (1, 4), (4, 2), (4, 3)])
+                G[0][4][0]["value"] = "a"
+                G[1][4][0]["value"] = "b"
+                G[4][2][0]["value"] = "c"
+                G[4][3][0]["value"] = "d"
+                G.add_edge(0, 4, key="x", value="e")
+                G.add_edge(4, 3, key="x", value="f")
+                mapping = {0: 9, 1: 9, 2: 9, 3: 9}
+                H = nx.relabel_nodes(G, mapping, copy=cc)
+                # No ordering on keys enforced
+                assert {"value": "a"} in H[9][4].values()
+                assert {"value": "b"} in H[9][4].values()
+                assert {"value": "c"} in H[4][9].values()
+                assert len(H[4][9]) == 3 if G.is_directed() else 6
+                assert {"value": "d"} in H[4][9].values()
+                assert {"value": "e"} in H[9][4].values()
+                assert {"value": "f"} in H[4][9].values()
+                assert len(H[9][4]) == 3 if G.is_directed() else 6
+
+    def test_relabel_multigraph_merge_inplace(self):
+        G = nx.MultiGraph([(0, 1), (0, 2), (0, 3), (0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        nx.relabel_nodes(G, mapping, copy=False)
+        # No ordering on keys enforced
+        assert {"value": "a"} in G[0][4].values()
+        assert {"value": "b"} in G[0][4].values()
+        assert {"value": "c"} in G[0][4].values()
+
+    def test_relabel_multidigraph_merge_inplace(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        nx.relabel_nodes(G, mapping, copy=False)
+        # No ordering on keys enforced
+        assert {"value": "a"} in G[0][4].values()
+        assert {"value": "b"} in G[0][4].values()
+        assert {"value": "c"} in G[0][4].values()
+
+    def test_relabel_multidigraph_inout_copy(self):
+        G = nx.MultiDiGraph([(0, 4), (1, 4), (4, 2), (4, 3)])
+        G[0][4][0]["value"] = "a"
+        G[1][4][0]["value"] = "b"
+        G[4][2][0]["value"] = "c"
+        G[4][3][0]["value"] = "d"
+        G.add_edge(0, 4, key="x", value="e")
+        G.add_edge(4, 3, key="x", value="f")
+        mapping = {0: 9, 1: 9, 2: 9, 3: 9}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        # No ordering on keys enforced
+        assert {"value": "a"} in H[9][4].values()
+        assert {"value": "b"} in H[9][4].values()
+        assert {"value": "c"} in H[4][9].values()
+        assert len(H[4][9]) == 3
+        assert {"value": "d"} in H[4][9].values()
+        assert {"value": "e"} in H[9][4].values()
+        assert {"value": "f"} in H[4][9].values()
+        assert len(H[9][4]) == 3
+
+    def test_relabel_multigraph_merge_copy(self):
+        G = nx.MultiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert {"value": "a"} in H[0][4].values()
+        assert {"value": "b"} in H[0][4].values()
+        assert {"value": "c"} in H[0][4].values()
+
+    def test_relabel_multidigraph_merge_copy(self):
+        G = nx.MultiDiGraph([(0, 1), (0, 2), (0, 3)])
+        G[0][1][0]["value"] = "a"
+        G[0][2][0]["value"] = "b"
+        G[0][3][0]["value"] = "c"
+        mapping = {1: 4, 2: 4, 3: 4}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        assert {"value": "a"} in H[0][4].values()
+        assert {"value": "b"} in H[0][4].values()
+        assert {"value": "c"} in H[0][4].values()
+
+    def test_relabel_multigraph_nonnumeric_key(self):
+        for MG in (nx.MultiGraph, nx.MultiDiGraph):
+            for cc in (True, False):
+                G = nx.MultiGraph()
+                G.add_edge(0, 1, key="I", value="a")
+                G.add_edge(0, 2, key="II", value="b")
+                G.add_edge(0, 3, key="II", value="c")
+                mapping = {1: 4, 2: 4, 3: 4}
+                nx.relabel_nodes(G, mapping, copy=False)
+                assert {"value": "a"} in G[0][4].values()
+                assert {"value": "b"} in G[0][4].values()
+                assert {"value": "c"} in G[0][4].values()
+                assert 0 in G[0][4]
+                assert "I" in G[0][4]
+                assert "II" in G[0][4]
+
+    def test_relabel_circular(self):
+        G = nx.path_graph(3)
+        mapping = {0: 1, 1: 0}
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        with pytest.raises(nx.NetworkXUnfeasible):
+            H = nx.relabel_nodes(G, mapping, copy=False)
+
+    def test_relabel_preserve_node_order_full_mapping_with_copy_true(self):
+        G = nx.path_graph(3)
+        original_order = list(G.nodes())
+        mapping = {2: "a", 1: "b", 0: "c"}  # dictionary keys out of order on purpose
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        new_order = list(H.nodes())
+        assert [mapping.get(i, i) for i in original_order] == new_order
+
+    def test_relabel_preserve_node_order_full_mapping_with_copy_false(self):
+        G = nx.path_graph(3)
+        original_order = list(G)
+        mapping = {2: "a", 1: "b", 0: "c"}  # dictionary keys out of order on purpose
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        new_order = list(H)
+        assert [mapping.get(i, i) for i in original_order] == new_order
+
+    def test_relabel_preserve_node_order_partial_mapping_with_copy_true(self):
+        G = nx.path_graph(3)
+        original_order = list(G)
+        mapping = {1: "a", 0: "b"}  # partial mapping and keys out of order on purpose
+        H = nx.relabel_nodes(G, mapping, copy=True)
+        new_order = list(H)
+        assert [mapping.get(i, i) for i in original_order] == new_order
+
+    def test_relabel_preserve_node_order_partial_mapping_with_copy_false(self):
+        G = nx.path_graph(3)
+        original_order = list(G)
+        mapping = {1: "a", 0: "b"}  # partial mapping and keys out of order on purpose
+        H = nx.relabel_nodes(G, mapping, copy=False)
+        new_order = list(H)
+        assert [mapping.get(i, i) for i in original_order] != new_order

package/runtime/python/okstra_vendor/networkx/tests/test_removed_functions_exception_messages.py

@@ -0,0 +1,8 @@
+import pytest
+
+import networkx as nx
+
+
+def test_random_tree():
+    with pytest.raises(AttributeError, match=".*Use `nx.random_labeled_tree` instead"):
+        nx.random_tree(3)

package/runtime/python/okstra_vendor/networkx/utils/__init__.py

@@ -0,0 +1,8 @@
+from networkx.utils.misc import *
+from networkx.utils.decorators import *
+from networkx.utils.random_sequence import *
+from networkx.utils.union_find import *
+from networkx.utils.rcm import *
+from networkx.utils.heaps import *
+from networkx.utils.configs import *
+from networkx.utils.backends import *