okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/components/semiconnected.py

@@ -1,71 +0,0 @@
-"""Semiconnectedness."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for, pairwise
-
-__all__ = ["is_semiconnected"]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def is_semiconnected(G):
-    r"""Returns True if the graph is semiconnected, False otherwise.
-
-    A graph is semiconnected if and only if for any pair of nodes, either one
-    is reachable from the other, or they are mutually reachable.
-
-    This function uses a theorem that states that a DAG is semiconnected
-    if for any topological sort, for node $v_n$ in that sort, there is an
-    edge $(v_i, v_{i+1})$. That allows us to check if a non-DAG `G` is
-    semiconnected by condensing the graph: i.e. constructing a new graph `H`
-    with nodes being the strongly connected components of `G`, and edges
-    (scc_1, scc_2) if there is a edge $(v_1, v_2)$ in `G` for some
-    $v_1 \in scc_1$ and $v_2 \in scc_2$. That results in a DAG, so we compute
-    the topological sort of `H` and check if for every $n$ there is an edge
-    $(scc_n, scc_{n+1})$.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph.
-
-    Returns
-    -------
-    semiconnected : bool
-        True if the graph is semiconnected, False otherwise.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the input graph is undirected.
-
-    NetworkXPointlessConcept
-        If the graph is empty.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4, create_using=nx.DiGraph())
-    >>> print(nx.is_semiconnected(G))
-    True
-    >>> G = nx.DiGraph([(1, 2), (3, 2)])
-    >>> print(nx.is_semiconnected(G))
-    False
-
-    See Also
-    --------
-    is_strongly_connected
-    is_weakly_connected
-    is_connected
-    is_biconnected
-    """
-    if len(G) == 0:
-        raise nx.NetworkXPointlessConcept(
-            "Connectivity is undefined for the null graph."
-        )
-
-    if not nx.is_weakly_connected(G):
-        return False
-
-    H = nx.condensation(G)
-
-    return all(H.has_edge(u, v) for u, v in pairwise(nx.topological_sort(H)))

package/runtime/python/okstra_vendor/networkx/algorithms/components/strongly_connected.py

@@ -1,359 +0,0 @@
-"""Strongly connected components."""
-
-import networkx as nx
-from networkx.utils.decorators import not_implemented_for
-
-__all__ = [
-    "number_strongly_connected_components",
-    "strongly_connected_components",
-    "is_strongly_connected",
-    "kosaraju_strongly_connected_components",
-    "condensation",
-]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def strongly_connected_components(G):
-    """Generate nodes in strongly connected components of graph.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        A directed graph.
-
-    Returns
-    -------
-    comp : generator of sets
-        A generator of sets of nodes, one for each strongly connected
-        component of G.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    Generate a sorted list of strongly connected components, largest first.
-
-    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
-    >>> nx.add_cycle(G, [10, 11, 12])
-    >>> [
-    ...     len(c)
-    ...     for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)
-    ... ]
-    [4, 3]
-
-    If you only want the largest component, it's more efficient to
-    use max instead of sort.
-
-    >>> largest = max(nx.strongly_connected_components(G), key=len)
-
-    See Also
-    --------
-    connected_components
-    weakly_connected_components
-    kosaraju_strongly_connected_components
-
-    Notes
-    -----
-    Uses Tarjan's algorithm[1]_ with Nuutila's modifications[2]_.
-    Nonrecursive version of algorithm.
-
-    References
-    ----------
-    .. [1] Depth-first search and linear graph algorithms, R. Tarjan
-       SIAM Journal of Computing 1(2):146-160, (1972).
-
-    .. [2] On finding the strongly connected components in a directed graph.
-       E. Nuutila and E. Soisalon-Soinen
-       Information Processing Letters 49(1): 9-14, (1994)..
-
-    """
-    preorder = {}
-    lowlink = {}
-    scc_found = set()
-    scc_queue = []
-    i = 0  # Preorder counter
-    neighbors = {v: iter(G._adj[v]) for v in G}
-    for source in G:
-        if source not in scc_found:
-            queue = [source]
-            while queue:
-                v = queue[-1]
-                if v not in preorder:
-                    i = i + 1
-                    preorder[v] = i
-                done = True
-                for w in neighbors[v]:
-                    if w not in preorder:
-                        queue.append(w)
-                        done = False
-                        break
-                if done:
-                    lowlink[v] = preorder[v]
-                    for w in G._adj[v]:
-                        if w not in scc_found:
-                            if preorder[w] > preorder[v]:
-                                lowlink[v] = min([lowlink[v], lowlink[w]])
-                            else:
-                                lowlink[v] = min([lowlink[v], preorder[w]])
-                    queue.pop()
-                    if lowlink[v] == preorder[v]:
-                        scc = {v}
-                        while scc_queue and preorder[scc_queue[-1]] > preorder[v]:
-                            k = scc_queue.pop()
-                            scc.add(k)
-                        scc_found.update(scc)
-                        yield scc
-                    else:
-                        scc_queue.append(v)
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def kosaraju_strongly_connected_components(G, source=None):
-    """Generate nodes in strongly connected components of graph.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        A directed graph.
-
-    source : node, optional (default=None)
-        Specify a node from which to start the depth-first search.
-        If not provided, the algorithm will start from an arbitrary node.
-
-    Yields
-    ------
-    set
-        A set of all nodes in a strongly connected component of `G`.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is undirected.
-
-    NetworkXError
-        If `source` is not a node in `G`.
-
-    Examples
-    --------
-    Generate a list of strongly connected components of a graph:
-
-    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
-    >>> nx.add_cycle(G, [10, 11, 12])
-    >>> sorted(nx.kosaraju_strongly_connected_components(G), key=len, reverse=True)
-    [{0, 1, 2, 3}, {10, 11, 12}]
-
-    If you only want the largest component, it's more efficient to
-    use `max()` instead of `sorted()`.
-
-    >>> max(nx.kosaraju_strongly_connected_components(G), key=len)
-    {0, 1, 2, 3}
-
-    See Also
-    --------
-    strongly_connected_components
-
-    Notes
-    -----
-    Uses Kosaraju's algorithm.
-    """
-    post = list(nx.dfs_postorder_nodes(G.reverse(copy=False), source=source))
-    n = len(post)
-    seen = set()
-    while post and len(seen) < n:
-        r = post.pop()
-        if r in seen:
-            continue
-        new = {r}
-        seen.add(r)
-        stack = [r]
-        while stack and len(seen) < n:
-            v = stack.pop()
-            for w in G._adj[v]:
-                if w not in seen:
-                    new.add(w)
-                    seen.add(w)
-                    stack.append(w)
-        yield new
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def number_strongly_connected_components(G):
-    """Returns number of strongly connected components in graph.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-       A directed graph.
-
-    Returns
-    -------
-    n : integer
-       Number of strongly connected components
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph(
-    ...     [(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)]
-    ... )
-    >>> nx.number_strongly_connected_components(G)
-    3
-
-    See Also
-    --------
-    strongly_connected_components
-    number_connected_components
-    number_weakly_connected_components
-
-    Notes
-    -----
-    For directed graphs only.
-    """
-    return sum(1 for scc in strongly_connected_components(G))
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def is_strongly_connected(G):
-    """Test directed graph for strong connectivity.
-
-    A directed graph is strongly connected if and only if every vertex in
-    the graph is reachable from every other vertex.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-       A directed graph.
-
-    Returns
-    -------
-    connected : bool
-      True if the graph is strongly connected, False otherwise.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (4, 2)])
-    >>> nx.is_strongly_connected(G)
-    True
-    >>> G.remove_edge(2, 3)
-    >>> nx.is_strongly_connected(G)
-    False
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    See Also
-    --------
-    is_weakly_connected
-    is_semiconnected
-    is_connected
-    is_biconnected
-    strongly_connected_components
-
-    Notes
-    -----
-    For directed graphs only.
-    """
-    if len(G) == 0:
-        raise nx.NetworkXPointlessConcept(
-            """Connectivity is undefined for the null graph."""
-        )
-
-    return len(next(strongly_connected_components(G))) == len(G)
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(returns_graph=True)
-def condensation(G, scc=None):
-    """Returns the condensation of G.
-
-    The condensation of G is the graph with each of the strongly connected
-    components contracted into a single node.
-
-    Parameters
-    ----------
-    G : NetworkX DiGraph
-       A directed graph.
-
-    scc:  list or generator (optional, default=None)
-       Strongly connected components. If provided, the elements in
-       `scc` must partition the nodes in `G`. If not provided, it will be
-       calculated as scc=nx.strongly_connected_components(G).
-
-    Returns
-    -------
-    C : NetworkX DiGraph
-       The condensation graph C of G.  The node labels are integers
-       corresponding to the index of the component in the list of
-       strongly connected components of G.  C has a graph attribute named
-       'mapping' with a dictionary mapping the original nodes to the
-       nodes in C to which they belong.  Each node in C also has a node
-       attribute 'members' with the set of original nodes in G that
-       form the SCC that the node in C represents.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    Contracting two sets of strongly connected nodes into two distinct SCC
-    using the barbell graph.
-
-    >>> G = nx.barbell_graph(4, 0)
-    >>> G.remove_edge(3, 4)
-    >>> G = nx.DiGraph(G)
-    >>> H = nx.condensation(G)
-    >>> H.nodes.data()
-    NodeDataView({0: {'members': {0, 1, 2, 3}}, 1: {'members': {4, 5, 6, 7}}})
-    >>> H.graph["mapping"]
-    {0: 0, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1}
-
-    Contracting a complete graph into one single SCC.
-
-    >>> G = nx.complete_graph(7, create_using=nx.DiGraph)
-    >>> H = nx.condensation(G)
-    >>> H.nodes
-    NodeView((0,))
-    >>> H.nodes.data()
-    NodeDataView({0: {'members': {0, 1, 2, 3, 4, 5, 6}}})
-
-    Notes
-    -----
-    After contracting all strongly connected components to a single node,
-    the resulting graph is a directed acyclic graph.
-
-    """
-    if scc is None:
-        scc = nx.strongly_connected_components(G)
-    mapping = {}
-    members = {}
-    C = nx.DiGraph()
-    # Add mapping dict as graph attribute
-    C.graph["mapping"] = mapping
-    if len(G) == 0:
-        return C
-    for i, component in enumerate(scc):
-        members[i] = component
-        mapping.update((n, i) for n in component)
-    number_of_components = i + 1
-    C.add_nodes_from(range(number_of_components))
-    C.add_edges_from(
-        (mapping[u], mapping[v]) for u, v in G.edges() if mapping[u] != mapping[v]
-    )
-    # Add a list of members (ie original nodes) to each node (ie scc) in C.
-    nx.set_node_attributes(C, members, "members")
-    return C

package/runtime/python/okstra_vendor/networkx/algorithms/components/weakly_connected.py

@@ -1,196 +0,0 @@
-"""Weakly connected components."""
-
-import networkx as nx
-from networkx.utils.decorators import not_implemented_for
-
-__all__ = [
-    "number_weakly_connected_components",
-    "weakly_connected_components",
-    "is_weakly_connected",
-]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def weakly_connected_components(G):
-    """Generate weakly connected components of G.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph
-
-    Returns
-    -------
-    comp : generator of sets
-        A generator of sets of nodes, one for each weakly connected
-        component of G.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    Generate a sorted list of weakly connected components, largest first.
-
-    >>> G = nx.path_graph(4, create_using=nx.DiGraph())
-    >>> nx.add_path(G, [10, 11, 12])
-    >>> [
-    ...     len(c)
-    ...     for c in sorted(nx.weakly_connected_components(G), key=len, reverse=True)
-    ... ]
-    [4, 3]
-
-    If you only want the largest component, it's more efficient to
-    use max instead of sort:
-
-    >>> largest_cc = max(nx.weakly_connected_components(G), key=len)
-
-    See Also
-    --------
-    connected_components
-    strongly_connected_components
-
-    Notes
-    -----
-    For directed graphs only.
-
-    """
-    seen = set()
-    n = len(G)  # must be outside the loop to avoid performance hit with graph views
-    for v in G:
-        if v not in seen:
-            c = _plain_bfs(G, n - len(seen), v)
-            seen.update(c)
-            yield c
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def number_weakly_connected_components(G):
-    """Returns the number of weakly connected components in G.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph.
-
-    Returns
-    -------
-    n : integer
-        Number of weakly connected components
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (2, 1), (3, 4)])
-    >>> nx.number_weakly_connected_components(G)
-    2
-
-    See Also
-    --------
-    weakly_connected_components
-    number_connected_components
-    number_strongly_connected_components
-
-    Notes
-    -----
-    For directed graphs only.
-
-    """
-    return sum(1 for _ in weakly_connected_components(G))
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable
-def is_weakly_connected(G):
-    """Test directed graph for weak connectivity.
-
-    A directed graph is weakly connected if and only if the graph
-    is connected when the direction of the edge between nodes is ignored.
-
-    Note that if a graph is strongly connected (i.e. the graph is connected
-    even when we account for directionality), it is by definition weakly
-    connected as well.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        A directed graph.
-
-    Returns
-    -------
-    connected : bool
-        True if the graph is weakly connected, False otherwise.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is undirected.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (2, 1)])
-    >>> G.add_node(3)
-    >>> nx.is_weakly_connected(G)  # node 3 is not connected to the graph
-    False
-    >>> G.add_edge(2, 3)
-    >>> nx.is_weakly_connected(G)
-    True
-
-    See Also
-    --------
-    is_strongly_connected
-    is_semiconnected
-    is_connected
-    is_biconnected
-    weakly_connected_components
-
-    Notes
-    -----
-    For directed graphs only.
-
-    """
-    n = len(G)
-    if n == 0:
-        raise nx.NetworkXPointlessConcept(
-            """Connectivity is undefined for the null graph."""
-        )
-
-    return len(next(weakly_connected_components(G))) == n
-
-
-def _plain_bfs(G, n, source):
-    """A fast BFS node generator
-
-    The direction of the edge between nodes is ignored.
-
-    For directed graphs only.
-
-    """
-    Gsucc = G._succ
-    Gpred = G._pred
-    seen = {source}
-    nextlevel = [source]
-
-    while nextlevel:
-        thislevel = nextlevel
-        nextlevel = []
-        for v in thislevel:
-            for w in Gsucc[v]:
-                if w not in seen:
-                    seen.add(w)
-                    nextlevel.append(w)
-            for w in Gpred[v]:
-                if w not in seen:
-                    seen.add(w)
-                    nextlevel.append(w)
-            if len(seen) == n:
-                return seen
-    return seen

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/__init__.py

@@ -1,11 +0,0 @@
-"""Connectivity and cut algorithms"""
-
-from .connectivity import *
-from .cuts import *
-from .edge_augmentation import *
-from .edge_kcomponents import *
-from .disjoint_paths import *
-from .kcomponents import *
-from .kcutsets import *
-from .stoerwagner import *
-from .utils import *