okstra 0.114.0 → 0.115.0

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

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

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

@@ -1,8 +0,0 @@
-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/tests/test__init.py

@@ -1,11 +0,0 @@
-import pytest
-
-
-def test_utils_namespace():
-    """Ensure objects are not unintentionally exposed in utils namespace."""
-    with pytest.raises(ImportError):
-        from networkx.utils import nx
-    with pytest.raises(ImportError):
-        from networkx.utils import sys
-    with pytest.raises(ImportError):
-        from networkx.utils import defaultdict, deque

package/runtime/python/okstra_vendor/networkx/utils/tests/test_backends.py

@@ -1,225 +0,0 @@
-import pickle
-
-import pytest
-
-import networkx as nx
-
-sp = pytest.importorskip("scipy")
-pytest.importorskip("numpy")
-
-
-@nx._dispatchable(implemented_by_nx=False)
-def _stub_func(G):
-    raise NotImplementedError("_stub_func is a stub")
-
-
-def test_dispatch_kwds_vs_args():
-    G = nx.path_graph(4)
-    nx.pagerank(G)
-    nx.pagerank(G=G)
-    with pytest.raises(TypeError):
-        nx.pagerank()
-
-
-def test_pickle():
-    count = 0
-    for name, func in nx.utils.backends._registered_algorithms.items():
-        pickled = pickle.dumps(func.__wrapped__)
-        assert pickle.loads(pickled) is func.__wrapped__
-        try:
-            # Some functions can't be pickled, but it's not b/c of _dispatchable
-            pickled = pickle.dumps(func)
-        except pickle.PicklingError:
-            continue
-        assert pickle.loads(pickled) is func
-        count += 1
-    assert count > 0
-    assert pickle.loads(pickle.dumps(nx.inverse_line_graph)) is nx.inverse_line_graph
-
-
-@pytest.mark.skipif(
-    "not nx.config.backend_priority.algos "
-    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
-)
-def test_graph_converter_needs_backend():
-    # When testing, `nx.from_scipy_sparse_array` will *always* call the backend
-    # implementation if it's implemented. If `backend=` isn't given, then the result
-    # will be converted back to NetworkX via `convert_to_nx`.
-    # If not testing, then calling `nx.from_scipy_sparse_array` w/o `backend=` will
-    # always call the original version. `backend=` is *required* to call the backend.
-    from networkx.classes.tests.dispatch_interface import (
-        LoopbackBackendInterface,
-        LoopbackGraph,
-    )
-
-    A = sp.sparse.coo_array([[0, 3, 2], [3, 0, 1], [2, 1, 0]])
-
-    side_effects = []
-
-    def from_scipy_sparse_array(self, *args, **kwargs):
-        side_effects.append(1)  # Just to prove this was called
-        return self.convert_from_nx(
-            self.__getattr__("from_scipy_sparse_array")(*args, **kwargs),
-            preserve_edge_attrs=True,
-            preserve_node_attrs=True,
-            preserve_graph_attrs=True,
-        )
-
-    @staticmethod
-    def convert_to_nx(obj, *, name=None):
-        if type(obj) is nx.Graph:
-            return obj
-        return nx.Graph(obj)
-
-    # *This mutates LoopbackBackendInterface!*
-    orig_convert_to_nx = LoopbackBackendInterface.convert_to_nx
-    LoopbackBackendInterface.convert_to_nx = convert_to_nx
-    LoopbackBackendInterface.from_scipy_sparse_array = from_scipy_sparse_array
-
-    try:
-        assert side_effects == []
-        assert type(nx.from_scipy_sparse_array(A)) is nx.Graph
-        assert side_effects == [1]
-        assert (
-            type(nx.from_scipy_sparse_array(A, backend="nx_loopback")) is LoopbackGraph
-        )
-        assert side_effects == [1, 1]
-        # backend="networkx" is default implementation
-        assert type(nx.from_scipy_sparse_array(A, backend="networkx")) is nx.Graph
-        assert side_effects == [1, 1]
-    finally:
-        LoopbackBackendInterface.convert_to_nx = staticmethod(orig_convert_to_nx)
-        del LoopbackBackendInterface.from_scipy_sparse_array
-    with pytest.raises(ImportError, match="backend is not installed"):
-        nx.from_scipy_sparse_array(A, backend="bad-backend-name")
-
-
-@pytest.mark.skipif(
-    "not nx.config.backend_priority.algos "
-    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
-)
-def test_networkx_backend():
-    """Test using `backend="networkx"` in a dispatchable function."""
-    # (Implementing this test is harder than it should be)
-    from networkx.classes.tests.dispatch_interface import (
-        LoopbackBackendInterface,
-        LoopbackGraph,
-    )
-
-    G = LoopbackGraph()
-    G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4)])
-
-    @staticmethod
-    def convert_to_nx(obj, *, name=None):
-        if isinstance(obj, LoopbackGraph):
-            new_graph = nx.Graph()
-            new_graph.__dict__.update(obj.__dict__)
-            return new_graph
-        return obj
-
-    # *This mutates LoopbackBackendInterface!*
-    # This uses the same trick as in the previous test.
-    orig_convert_to_nx = LoopbackBackendInterface.convert_to_nx
-    LoopbackBackendInterface.convert_to_nx = convert_to_nx
-    try:
-        G2 = nx.ego_graph(G, 0, backend="networkx")
-        assert type(G2) is nx.Graph
-    finally:
-        LoopbackBackendInterface.convert_to_nx = staticmethod(orig_convert_to_nx)
-
-
-def test_dispatchable_are_functions():
-    assert type(nx.pagerank) is type(nx.pagerank.orig_func)
-
-
-@pytest.mark.skipif("not nx.utils.backends.backends")
-def test_mixing_backend_graphs():
-    from networkx.classes.tests import dispatch_interface
-
-    G = nx.Graph()
-    G.add_edge(1, 2)
-    G.add_edge(2, 3)
-    H = nx.Graph()
-    H.add_edge(2, 3)
-    rv = nx.intersection(G, H)
-    assert set(nx.intersection(G, H)) == {2, 3}
-    G2 = dispatch_interface.convert(G)
-    H2 = dispatch_interface.convert(H)
-    if "nx_loopback" in nx.config.backend_priority:
-        # Auto-convert
-        assert set(nx.intersection(G2, H)) == {2, 3}
-        assert set(nx.intersection(G, H2)) == {2, 3}
-    elif not nx.config.backend_priority and "nx_loopback" not in nx.config.backends:
-        # G2 and H2 are backend objects for a backend that is not registered!
-        with pytest.raises(ImportError, match="backend is not installed"):
-            nx.intersection(G2, H)
-        with pytest.raises(ImportError, match="backend is not installed"):
-            nx.intersection(G, H2)
-    # It would be nice to test passing graphs from *different* backends,
-    # but we are not set up to do this yet.
-
-
-def test_bad_backend_name():
-    """Using `backend=` raises with unknown backend even if there are no backends."""
-    with pytest.raises(
-        ImportError, match="'this_backend_does_not_exist' backend is not installed"
-    ):
-        nx.null_graph(backend="this_backend_does_not_exist")
-
-
-def test_not_implemented_by_nx():
-    assert "networkx" in nx.pagerank.backends
-    assert "networkx" not in _stub_func.backends
-
-    if "nx_loopback" in nx.config.backends:
-        from networkx.classes.tests.dispatch_interface import LoopbackBackendInterface
-
-        def stub_func_implementation(G):
-            return True
-
-        LoopbackBackendInterface._stub_func = staticmethod(stub_func_implementation)
-        try:
-            assert _stub_func(nx.Graph()) is True
-        finally:
-            del LoopbackBackendInterface._stub_func
-
-    with pytest.raises(NotImplementedError):
-        _stub_func(nx.Graph())
-
-
-@pytest.mark.skipif(
-    "not nx.config.backend_priority.algos "
-    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
-)
-def test_dispatch_graph_new():
-    from networkx.classes.tests.dispatch_interface import LoopbackGraph
-
-    G = nx.Graph()
-    assert not isinstance(G, LoopbackGraph)
-
-    # `backend=` argument that gets passed to __init__ is ignored.
-    # Best practice is that it should not be in the `.graph` dict.
-    G = nx.Graph(backend="networkx")
-    assert type(G) is nx.Graph
-    assert "backend" not in G.graph
-
-    G = nx.Graph(backend="nx_loopback")
-    assert isinstance(G, LoopbackGraph)
-    assert "backend" not in G.graph
-
-    # Args are passed
-    G1 = nx.Graph([(0, 1), (1, 2)])
-    assert not isinstance(G1, LoopbackGraph)
-    G2 = nx.Graph([(0, 1), (1, 2)], backend="nx_loopback")
-    assert isinstance(G2, LoopbackGraph)
-    assert nx.utils.misc.graphs_equal(G1, G2)
-
-    # Test config for automatic usage
-    with nx.config.backend_priority(classes=["nx_loopback"]):
-        G = nx.Graph()
-        assert isinstance(G, LoopbackGraph)
-        # LoopbackDiGraph __new__ is not implemented
-        G = nx.DiGraph()
-        assert not isinstance(G, LoopbackGraph)
-    G = nx.Graph()
-    assert not isinstance(G, LoopbackGraph)