okstra 0.113.0 → 0.115.0

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

@@ -1,53 +0,0 @@
-from itertools import chain
-
-import networkx as nx
-from networkx.utils import edges_equal, nodes_equal
-
-
-def _check_custom_label_attribute(input_trees, res_tree, label_attribute):
-    res_attr_dict = nx.get_node_attributes(res_tree, label_attribute)
-    res_attr_set = set(res_attr_dict.values())
-    input_label = (tree for tree, root in input_trees)
-    input_label_set = set(chain.from_iterable(input_label))
-    return res_attr_set == input_label_set
-
-
-def test_empty_sequence():
-    """Joining the empty sequence results in the tree with one node."""
-    T = nx.join_trees([])
-    assert len(T) == 1
-    assert T.number_of_edges() == 0
-
-
-def test_single():
-    """Joining just one tree yields a tree with one more node."""
-    T = nx.empty_graph(1)
-    trees = [(T, 0)]
-    actual_with_label = nx.join_trees(trees, label_attribute="custom_label")
-    expected = nx.path_graph(2)
-    assert nodes_equal(list(expected), list(actual_with_label))
-    assert edges_equal(list(expected.edges()), list(actual_with_label.edges()))
-
-
-def test_basic():
-    """Joining multiple subtrees at a root node."""
-    trees = [(nx.full_rary_tree(2, 2**2 - 1), 0) for i in range(2)]
-    expected = nx.full_rary_tree(2, 2**3 - 1)
-    actual = nx.join_trees(trees, label_attribute="old_labels")
-    assert nx.is_isomorphic(actual, expected)
-    assert _check_custom_label_attribute(trees, actual, "old_labels")
-
-    actual_without_label = nx.join_trees(trees)
-    assert nx.is_isomorphic(actual_without_label, expected)
-    # check that no labels were stored
-    assert all(not data for _, data in actual_without_label.nodes(data=True))
-
-
-def test_first_label():
-    """Test the functionality of the first_label argument."""
-    T1 = nx.path_graph(3)
-    T2 = nx.path_graph(2)
-    actual = nx.join_trees([(T1, 0), (T2, 0)], first_label=10)
-    expected_nodes = set(range(10, 16))
-    assert set(actual.nodes()) == expected_nodes
-    assert set(actual.neighbors(10)) == {11, 14}

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

@@ -1,174 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestTreeRecognition:
-    graph = nx.Graph
-    multigraph = nx.MultiGraph
-
-    @classmethod
-    def setup_class(cls):
-        cls.T1 = cls.graph()
-
-        cls.T2 = cls.graph()
-        cls.T2.add_node(1)
-
-        cls.T3 = cls.graph()
-        cls.T3.add_nodes_from(range(5))
-        edges = [(i, i + 1) for i in range(4)]
-        cls.T3.add_edges_from(edges)
-
-        cls.T5 = cls.multigraph()
-        cls.T5.add_nodes_from(range(5))
-        edges = [(i, i + 1) for i in range(4)]
-        cls.T5.add_edges_from(edges)
-
-        cls.T6 = cls.graph()
-        cls.T6.add_nodes_from([6, 7])
-        cls.T6.add_edge(6, 7)
-
-        cls.F1 = nx.compose(cls.T6, cls.T3)
-
-        cls.N4 = cls.graph()
-        cls.N4.add_node(1)
-        cls.N4.add_edge(1, 1)
-
-        cls.N5 = cls.graph()
-        cls.N5.add_nodes_from(range(5))
-
-        cls.N6 = cls.graph()
-        cls.N6.add_nodes_from(range(3))
-        cls.N6.add_edges_from([(0, 1), (1, 2), (2, 0)])
-
-        cls.NF1 = nx.compose(cls.T6, cls.N6)
-
-    def test_null_tree(self):
-        with pytest.raises(nx.NetworkXPointlessConcept):
-            nx.is_tree(self.graph())
-
-    def test_null_tree2(self):
-        with pytest.raises(nx.NetworkXPointlessConcept):
-            nx.is_tree(self.multigraph())
-
-    def test_null_forest(self):
-        with pytest.raises(nx.NetworkXPointlessConcept):
-            nx.is_forest(self.graph())
-
-    def test_null_forest2(self):
-        with pytest.raises(nx.NetworkXPointlessConcept):
-            nx.is_forest(self.multigraph())
-
-    def test_is_tree(self):
-        assert nx.is_tree(self.T2)
-        assert nx.is_tree(self.T3)
-        assert nx.is_tree(self.T5)
-
-    def test_is_not_tree(self):
-        assert not nx.is_tree(self.N4)
-        assert not nx.is_tree(self.N5)
-        assert not nx.is_tree(self.N6)
-
-    def test_is_forest(self):
-        assert nx.is_forest(self.T2)
-        assert nx.is_forest(self.T3)
-        assert nx.is_forest(self.T5)
-        assert nx.is_forest(self.F1)
-        assert nx.is_forest(self.N5)
-
-    def test_is_not_forest(self):
-        assert not nx.is_forest(self.N4)
-        assert not nx.is_forest(self.N6)
-        assert not nx.is_forest(self.NF1)
-
-
-class TestDirectedTreeRecognition(TestTreeRecognition):
-    graph = nx.DiGraph
-    multigraph = nx.MultiDiGraph
-
-
-def test_disconnected_graph():
-    # https://github.com/networkx/networkx/issues/1144
-    G = nx.Graph()
-    G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
-    assert not nx.is_tree(G)
-
-    G = nx.DiGraph()
-    G.add_edges_from([(0, 1), (1, 2), (2, 0), (3, 4)])
-    assert not nx.is_tree(G)
-
-
-def test_dag_nontree():
-    G = nx.DiGraph()
-    G.add_edges_from([(0, 1), (0, 2), (1, 2)])
-    assert not nx.is_tree(G)
-    assert nx.is_directed_acyclic_graph(G)
-
-
-def test_multicycle():
-    G = nx.MultiDiGraph()
-    G.add_edges_from([(0, 1), (0, 1)])
-    assert not nx.is_tree(G)
-    assert nx.is_directed_acyclic_graph(G)
-
-
-def test_emptybranch():
-    G = nx.DiGraph()
-    G.add_nodes_from(range(10))
-    assert nx.is_branching(G)
-    assert not nx.is_arborescence(G)
-
-
-def test_is_branching_empty_graph_raises():
-    G = nx.DiGraph()
-    with pytest.raises(nx.NetworkXPointlessConcept, match="G has no nodes."):
-        nx.is_branching(G)
-
-
-def test_path():
-    G = nx.DiGraph()
-    nx.add_path(G, range(5))
-    assert nx.is_branching(G)
-    assert nx.is_arborescence(G)
-
-
-def test_notbranching1():
-    # Acyclic violation.
-    G = nx.MultiDiGraph()
-    G.add_nodes_from(range(10))
-    G.add_edges_from([(0, 1), (1, 0)])
-    assert not nx.is_branching(G)
-    assert not nx.is_arborescence(G)
-
-
-def test_notbranching2():
-    # In-degree violation.
-    G = nx.MultiDiGraph()
-    G.add_nodes_from(range(10))
-    G.add_edges_from([(0, 1), (0, 2), (3, 2)])
-    assert not nx.is_branching(G)
-    assert not nx.is_arborescence(G)
-
-
-def test_notarborescence1():
-    # Not an arborescence due to not spanning.
-    G = nx.MultiDiGraph()
-    G.add_nodes_from(range(10))
-    G.add_edges_from([(0, 1), (0, 2), (1, 3), (5, 6)])
-    assert nx.is_branching(G)
-    assert not nx.is_arborescence(G)
-
-
-def test_notarborescence2():
-    # Not an arborescence due to in-degree violation.
-    G = nx.MultiDiGraph()
-    nx.add_path(G, range(5))
-    G.add_edge(6, 4)
-    assert not nx.is_branching(G)
-    assert not nx.is_arborescence(G)
-
-
-def test_is_arborescense_empty_graph_raises():
-    G = nx.DiGraph()
-    with pytest.raises(nx.NetworkXPointlessConcept, match="G has no nodes."):
-        nx.is_arborescence(G)

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

@@ -1,192 +0,0 @@
-# This file contains utilities for testing the dispatching feature
-
-# A full test of all dispatchable algorithms is performed by
-# modifying the pytest invocation and setting an environment variable
-# NETWORKX_TEST_BACKEND=nx_loopback pytest
-# This is comprehensive, but only tests the `test_override_dispatch`
-# function in networkx.classes.backends.
-
-# To test the `_dispatchable` function directly, several tests scattered throughout
-# NetworkX have been augmented to test normal and dispatch mode.
-# Searching for `dispatch_interface` should locate the specific tests.
-
-import networkx as nx
-from networkx import DiGraph, Graph, MultiDiGraph, MultiGraph, PlanarEmbedding
-from networkx.classes.reportviews import NodeView
-
-
-class LoopbackGraph(Graph):
-    __networkx_backend__ = "nx_loopback"
-
-
-class LoopbackDiGraph(DiGraph):
-    __networkx_backend__ = "nx_loopback"
-
-
-class LoopbackMultiGraph(MultiGraph):
-    __networkx_backend__ = "nx_loopback"
-
-
-class LoopbackMultiDiGraph(MultiDiGraph):
-    __networkx_backend__ = "nx_loopback"
-
-
-class LoopbackPlanarEmbedding(PlanarEmbedding):
-    __networkx_backend__ = "nx_loopback"
-
-
-def convert(graph):
-    if isinstance(graph, PlanarEmbedding):
-        return LoopbackPlanarEmbedding(graph)
-    if isinstance(graph, MultiDiGraph):
-        return LoopbackMultiDiGraph(graph)
-    if isinstance(graph, MultiGraph):
-        return LoopbackMultiGraph(graph)
-    if isinstance(graph, DiGraph):
-        return LoopbackDiGraph(graph)
-    if isinstance(graph, Graph):
-        return LoopbackGraph(graph)
-    raise TypeError(f"Unsupported type of graph: {type(graph)}")
-
-
-class LoopbackBackendInterface:
-    def __getattr__(self, item):
-        try:
-            return nx.utils.backends._registered_algorithms[item].orig_func
-        except KeyError:
-            raise AttributeError(item) from None
-
-    @staticmethod
-    def graph__new__(cls, incoming_graph_data=None, **attr):
-        # LoopbackGraph.__init__ will be called next since the returned
-        # object is an instance of an nx.Graph. For more details, see:
-        # https://docs.python.org/3/reference/datamodel.html#object.__new__
-        return object.__new__(LoopbackGraph)
-
-    @staticmethod
-    def convert_from_nx(
-        graph,
-        *,
-        edge_attrs=None,
-        node_attrs=None,
-        preserve_edge_attrs=None,
-        preserve_node_attrs=None,
-        preserve_graph_attrs=None,
-        name=None,
-        graph_name=None,
-    ):
-        if name in {
-            # Raise if input graph changes. See test_dag.py::test_topological_sort6
-            "lexicographical_topological_sort",
-            "topological_generations",
-            "topological_sort",
-            # Would be nice to some day avoid these cutoffs of full testing
-        }:
-            return graph
-        if isinstance(graph, NodeView):
-            # Convert to a Graph with only nodes (no edges)
-            new_graph = Graph()
-            new_graph.add_nodes_from(graph.items())
-            graph = new_graph
-            G = LoopbackGraph()
-        elif not isinstance(graph, Graph):
-            raise TypeError(
-                f"Bad type for graph argument {graph_name} in {name}: {type(graph)}"
-            )
-        elif graph.__class__ in {Graph, LoopbackGraph}:
-            G = LoopbackGraph()
-        elif graph.__class__ in {DiGraph, LoopbackDiGraph}:
-            G = LoopbackDiGraph()
-        elif graph.__class__ in {MultiGraph, LoopbackMultiGraph}:
-            G = LoopbackMultiGraph()
-        elif graph.__class__ in {MultiDiGraph, LoopbackMultiDiGraph}:
-            G = LoopbackMultiDiGraph()
-        elif graph.__class__ in {PlanarEmbedding, LoopbackPlanarEmbedding}:
-            G = LoopbackDiGraph()  # or LoopbackPlanarEmbedding
-        else:
-            # Would be nice to handle these better some day
-            # nx.algorithms.approximation.kcomponents._AntiGraph
-            # nx.classes.tests.test_multidigraph.MultiDiGraphSubClass
-            # nx.classes.tests.test_multigraph.MultiGraphSubClass
-            G = graph.__class__()
-
-        if preserve_graph_attrs:
-            G.graph.update(graph.graph)
-
-        # add nodes
-        G.add_nodes_from(graph)
-        if preserve_node_attrs:
-            for n, dd in G._node.items():
-                dd.update(graph.nodes[n])
-        elif node_attrs:
-            for n, dd in G._node.items():
-                dd.update(
-                    (attr, graph._node[n].get(attr, default))
-                    for attr, default in node_attrs.items()
-                    if default is not None or attr in graph._node[n]
-                )
-
-        # tools to build datadict and keydict
-        if preserve_edge_attrs:
-
-            def G_new_datadict(old_dd):
-                return G.edge_attr_dict_factory(old_dd)
-        elif edge_attrs:
-
-            def G_new_datadict(old_dd):
-                return G.edge_attr_dict_factory(
-                    (attr, old_dd.get(attr, default))
-                    for attr, default in edge_attrs.items()
-                    if default is not None or attr in old_dd
-                )
-        else:
-
-            def G_new_datadict(old_dd):
-                return G.edge_attr_dict_factory()
-
-        if G.is_multigraph():
-
-            def G_new_inner(keydict):
-                kd = G.adjlist_inner_dict_factory(
-                    (k, G_new_datadict(dd)) for k, dd in keydict.items()
-                )
-                return kd
-        else:
-            G_new_inner = G_new_datadict
-
-        # add edges keeping the same order in _adj and _pred
-        G_adj = G._adj
-        if G.is_directed():
-            for n, nbrs in graph._adj.items():
-                G_adj[n].update((nbr, G_new_inner(dd)) for nbr, dd in nbrs.items())
-            # ensure same datadict for pred and adj; and pred order of graph._pred
-            G_pred = G._pred
-            for n, nbrs in graph._pred.items():
-                G_pred[n].update((nbr, G_adj[nbr][n]) for nbr in nbrs)
-        else:  # undirected
-            for n, nbrs in graph._adj.items():
-                # ensure same datadict for both ways; and adj order of graph._adj
-                G_adj[n].update(
-                    (nbr, G_adj[nbr][n] if n in G_adj[nbr] else G_new_inner(dd))
-                    for nbr, dd in nbrs.items()
-                )
-
-        return G
-
-    @staticmethod
-    def convert_to_nx(obj, *, name=None):
-        return obj
-
-    @staticmethod
-    def on_start_tests(items):
-        # Verify that items can be xfailed
-        for item in items:
-            assert hasattr(item, "add_marker")
-
-    def can_run(self, name, args, kwargs):
-        # It is unnecessary to define this function if algorithms are fully supported.
-        # We include it for illustration purposes.
-        return hasattr(self, name)
-
-
-backend_interface = LoopbackBackendInterface()