okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/tree/operations.py

@@ -1,106 +0,0 @@
-"""Operations on trees."""
-
-from functools import partial
-from itertools import accumulate, chain
-
-import networkx as nx
-
-__all__ = ["join_trees"]
-
-
-# Argument types don't match dispatching, but allow manual selection of backend
-@nx._dispatchable(graphs=None, returns_graph=True)
-def join_trees(rooted_trees, *, label_attribute=None, first_label=0):
-    """Returns a new rooted tree made by joining `rooted_trees`
-
-    Constructs a new tree by joining each tree in `rooted_trees`.
-    A new root node is added and connected to each of the roots
-    of the input trees. While copying the nodes from the trees,
-    relabeling to integers occurs. If the `label_attribute` is provided,
-    the old node labels will be stored in the new tree under this attribute.
-
-    Parameters
-    ----------
-    rooted_trees : list
-        A list of pairs in which each left element is a NetworkX graph
-        object representing a tree and each right element is the root
-        node of that tree. The nodes of these trees will be relabeled to
-        integers.
-
-    label_attribute : str
-        If provided, the old node labels will be stored in the new tree
-        under this node attribute. If not provided, the original labels
-        of the nodes in the input trees are not stored.
-
-    first_label : int, optional (default=0)
-        Specifies the label for the new root node. If provided, the root node of the joined tree
-        will have this label. If not provided, the root node will default to a label of 0.
-
-    Returns
-    -------
-    NetworkX graph
-        The rooted tree resulting from joining the provided `rooted_trees`. The new tree has a root node
-        labeled as specified by `first_label` (defaulting to 0 if not provided). Subtrees from the input
-        `rooted_trees` are attached to this new root node. Each non-root node, if the `label_attribute`
-        is provided, has an attribute that indicates the original label of the node in the input tree.
-
-    Notes
-    -----
-    Trees are stored in NetworkX as NetworkX Graphs. There is no specific
-    enforcement of the fact that these are trees. Testing for each tree
-    can be done using :func:`networkx.is_tree`.
-
-    Graph, edge, and node attributes are propagated from the given
-    rooted trees to the created tree. If there are any overlapping graph
-    attributes, those from later trees will overwrite those from earlier
-    trees in the tuple of positional arguments.
-
-    Examples
-    --------
-    Join two full balanced binary trees of height *h* to get a full
-    balanced binary tree of depth *h* + 1::
-
-        >>> h = 4
-        >>> left = nx.balanced_tree(2, h)
-        >>> right = nx.balanced_tree(2, h)
-        >>> joined_tree = nx.join_trees([(left, 0), (right, 0)])
-        >>> nx.is_isomorphic(joined_tree, nx.balanced_tree(2, h + 1))
-        True
-
-    """
-    if not rooted_trees:
-        return nx.empty_graph(1)
-
-    # Unzip the zipped list of (tree, root) pairs.
-    trees, roots = zip(*rooted_trees)
-
-    # The join of the trees has the same type as the type of the first tree.
-    R = type(trees[0])()
-
-    lengths = (len(tree) for tree in trees[:-1])
-    first_labels = list(accumulate(lengths, initial=first_label + 1))
-
-    new_roots = []
-    for tree, root, first_node in zip(trees, roots, first_labels):
-        new_root = first_node + list(tree.nodes()).index(root)
-        new_roots.append(new_root)
-
-    # Relabel the nodes so that their union is the integers starting at first_label.
-    relabel = partial(
-        nx.convert_node_labels_to_integers, label_attribute=label_attribute
-    )
-    new_trees = [
-        relabel(tree, first_label=first_label)
-        for tree, first_label in zip(trees, first_labels)
-    ]
-
-    # Add all sets of nodes and edges, attributes
-    for tree in new_trees:
-        R.update(tree)
-
-    # Finally, join the subtrees at the root. We know first_label is unused by
-    # the way we relabeled the subtrees.
-    R.add_node(first_label)
-    R.add_edges_from((first_label, root) for root in new_roots)
-
-    return R

package/runtime/python/okstra_vendor/networkx/algorithms/tree/recognition.py

@@ -1,273 +0,0 @@
-"""
-Recognition Tests
-=================
-
-A *forest* is an acyclic, undirected graph, and a *tree* is a connected forest.
-Depending on the subfield, there are various conventions for generalizing these
-definitions to directed graphs.
-
-In one convention, directed variants of forest and tree are defined in an
-identical manner, except that the direction of the edges is ignored. In effect,
-each directed edge is treated as a single undirected edge. Then, additional
-restrictions are imposed to define *branchings* and *arborescences*.
-
-In another convention, directed variants of forest and tree correspond to
-the previous convention's branchings and arborescences, respectively. Then two
-new terms, *polyforest* and *polytree*, are defined to correspond to the other
-convention's forest and tree.
-
-Summarizing::
-
-   +-----------------------------+
-   | Convention A | Convention B |
-   +=============================+
-   | forest       | polyforest   |
-   | tree         | polytree     |
-   | branching    | forest       |
-   | arborescence | tree         |
-   +-----------------------------+
-
-Each convention has its reasons. The first convention emphasizes definitional
-similarity in that directed forests and trees are only concerned with
-acyclicity and do not have an in-degree constraint, just as their undirected
-counterparts do not. The second convention emphasizes functional similarity
-in the sense that the directed analog of a spanning tree is a spanning
-arborescence. That is, take any spanning tree and choose one node as the root.
-Then every edge is assigned a direction such there is a directed path from the
-root to every other node. The result is a spanning arborescence.
-
-NetworkX follows convention "A". Explicitly, these are:
-
-undirected forest
-   An undirected graph with no undirected cycles.
-
-undirected tree
-   A connected, undirected forest.
-
-directed forest
-   A directed graph with no undirected cycles. Equivalently, the underlying
-   graph structure (which ignores edge orientations) is an undirected forest.
-   In convention B, this is known as a polyforest.
-
-directed tree
-   A weakly connected, directed forest. Equivalently, the underlying graph
-   structure (which ignores edge orientations) is an undirected tree. In
-   convention B, this is known as a polytree.
-
-branching
-   A directed forest with each node having, at most, one parent. So the maximum
-   in-degree is equal to 1. In convention B, this is known as a forest.
-
-arborescence
-   A directed tree with each node having, at most, one parent. So the maximum
-   in-degree is equal to 1. In convention B, this is known as a tree.
-
-For trees and arborescences, the adjective "spanning" may be added to designate
-that the graph, when considered as a forest/branching, consists of a single
-tree/arborescence that includes all nodes in the graph. It is true, by
-definition, that every tree/arborescence is spanning with respect to the nodes
-that define the tree/arborescence and so, it might seem redundant to introduce
-the notion of "spanning". However, the nodes may represent a subset of
-nodes from a larger graph, and it is in this context that the term "spanning"
-becomes a useful notion.
-
-"""
-
-import networkx as nx
-
-__all__ = ["is_arborescence", "is_branching", "is_forest", "is_tree"]
-
-
-@nx.utils.not_implemented_for("undirected")
-@nx._dispatchable
-def is_arborescence(G):
-    """
-    Returns True if `G` is an arborescence.
-
-    An arborescence is a directed tree with maximum in-degree equal to 1.
-
-    Parameters
-    ----------
-    G : graph
-        The graph to test.
-
-    Returns
-    -------
-    b : bool
-        A boolean that is True if `G` is an arborescence.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (0, 2), (2, 3), (3, 4)])
-    >>> nx.is_arborescence(G)
-    True
-    >>> G.remove_edge(0, 1)
-    >>> G.add_edge(1, 2)  # maximum in-degree is 2
-    >>> nx.is_arborescence(G)
-    False
-
-    Notes
-    -----
-    In another convention, an arborescence is known as a *tree*.
-
-    See Also
-    --------
-    is_tree
-
-    """
-    return is_tree(G) and max(d for n, d in G.in_degree()) <= 1
-
-
-@nx.utils.not_implemented_for("undirected")
-@nx._dispatchable
-def is_branching(G):
-    """
-    Returns True if `G` is a branching.
-
-    A branching is a directed forest with maximum in-degree equal to 1.
-
-    Parameters
-    ----------
-    G : directed graph
-        The directed graph to test.
-
-    Returns
-    -------
-    b : bool
-        A boolean that is True if `G` is a branching.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4)])
-    >>> nx.is_branching(G)
-    True
-    >>> G.remove_edge(2, 3)
-    >>> G.add_edge(3, 1)  # maximum in-degree is 2
-    >>> nx.is_branching(G)
-    False
-
-    Notes
-    -----
-    In another convention, a branching is also known as a *forest*.
-
-    See Also
-    --------
-    is_forest
-
-    """
-    return is_forest(G) and max(d for n, d in G.in_degree()) <= 1
-
-
-@nx._dispatchable
-def is_forest(G):
-    """
-    Returns True if `G` is a forest.
-
-    A forest is a graph with no undirected cycles.
-
-    For directed graphs, `G` is a forest if the underlying graph is a forest.
-    The underlying graph is obtained by treating each directed edge as a single
-    undirected edge in a multigraph.
-
-    Parameters
-    ----------
-    G : graph
-        The graph to test.
-
-    Returns
-    -------
-    b : bool
-        A boolean that is True if `G` is a forest.
-
-    Raises
-    ------
-    NetworkXPointlessConcept
-        If `G` is empty.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5)])
-    >>> nx.is_forest(G)
-    True
-    >>> G.add_edge(4, 1)
-    >>> nx.is_forest(G)
-    False
-
-    Notes
-    -----
-    In another convention, a directed forest is known as a *polyforest* and
-    then *forest* corresponds to a *branching*.
-
-    See Also
-    --------
-    is_branching
-
-    """
-    if len(G) == 0:
-        raise nx.exception.NetworkXPointlessConcept("G has no nodes.")
-
-    if G.is_directed():
-        components = (G.subgraph(c) for c in nx.weakly_connected_components(G))
-    else:
-        components = (G.subgraph(c) for c in nx.connected_components(G))
-
-    return all(len(c) - 1 == c.number_of_edges() for c in components)
-
-
-@nx._dispatchable
-def is_tree(G):
-    """
-    Returns True if `G` is a tree.
-
-    A tree is a connected graph with no undirected cycles.
-
-    For directed graphs, `G` is a tree if the underlying graph is a tree. The
-    underlying graph is obtained by treating each directed edge as a single
-    undirected edge in a multigraph.
-
-    Parameters
-    ----------
-    G : graph
-        The graph to test.
-
-    Returns
-    -------
-    b : bool
-        A boolean that is True if `G` is a tree.
-
-    Raises
-    ------
-    NetworkXPointlessConcept
-        If `G` is empty.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5)])
-    >>> nx.is_tree(G)  # n-1 edges
-    True
-    >>> G.add_edge(3, 4)
-    >>> nx.is_tree(G)  # n edges
-    False
-
-    Notes
-    -----
-    In another convention, a directed tree is known as a *polytree* and then
-    *tree* corresponds to an *arborescence*.
-
-    See Also
-    --------
-    is_arborescence
-
-    """
-    if len(G) == 0:
-        raise nx.exception.NetworkXPointlessConcept("G has no nodes.")
-
-    if G.is_directed():
-        is_connected = nx.is_weakly_connected
-    else:
-        is_connected = nx.is_connected
-
-    # A connected graph with no cycles has n-1 edges.
-    return len(G) - 1 == G.number_of_edges() and is_connected(G)