okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/algorithms/boundary.py

@@ -1,168 +0,0 @@
-"""Routines to find the boundary of a set of nodes.
-
-An edge boundary is a set of edges, each of which has exactly one
-endpoint in a given set of nodes (or, in the case of directed graphs,
-the set of edges whose source node is in the set).
-
-A node boundary of a set *S* of nodes is the set of (out-)neighbors of
-nodes in *S* that are outside *S*.
-
-"""
-
-from itertools import chain
-
-import networkx as nx
-
-__all__ = ["edge_boundary", "node_boundary"]
-
-
-@nx._dispatchable(edge_attrs={"data": "default"}, preserve_edge_attrs="data")
-def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None):
-    """Returns the edge boundary of `nbunch1`.
-
-    The *edge boundary* of a set *S* with respect to a set *T* is the
-    set of edges (*u*, *v*) such that *u* is in *S* and *v* is in *T*.
-    If *T* is not specified, it is assumed to be the set of all nodes
-    not in *S*.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    nbunch1 : iterable
-        Iterable of nodes in the graph representing the set of nodes
-        whose edge boundary will be returned. (This is the set *S* from
-        the definition above.)
-
-    nbunch2 : iterable
-        Iterable of nodes representing the target (or "exterior") set of
-        nodes. (This is the set *T* from the definition above.) If not
-        specified, this is assumed to be the set of all nodes in `G`
-        not in `nbunch1`.
-
-    keys : bool
-        This parameter has the same meaning as in
-        :meth:`MultiGraph.edges`.
-
-    data : bool or object
-        This parameter has the same meaning as in
-        :meth:`MultiGraph.edges`.
-
-    default : object
-        This parameter has the same meaning as in
-        :meth:`MultiGraph.edges`.
-
-    Returns
-    -------
-    iterator
-        An iterator over the edges in the boundary of `nbunch1` with
-        respect to `nbunch2`. If `keys`, `data`, or `default`
-        are specified and `G` is a multigraph, then edges are returned
-        with keys and/or data, as in :meth:`MultiGraph.edges`.
-
-    Examples
-    --------
-    >>> G = nx.wheel_graph(6)
-
-    When nbunch2=None:
-
-    >>> list(nx.edge_boundary(G, (1, 3)))
-    [(1, 0), (1, 2), (1, 5), (3, 0), (3, 2), (3, 4)]
-
-    When nbunch2 is given:
-
-    >>> list(nx.edge_boundary(G, (1, 3), (2, 0)))
-    [(1, 0), (1, 2), (3, 0), (3, 2)]
-
-    Notes
-    -----
-    Any element of `nbunch` that is not in the graph `G` will be
-    ignored.
-
-    `nbunch1` and `nbunch2` are usually meant to be disjoint, but in
-    the interest of speed and generality, that is not required here.
-
-    """
-    nset1 = {n for n in nbunch1 if n in G}
-    # Here we create an iterator over edges incident to nodes in the set
-    # `nset1`. The `Graph.edges()` method does not provide a guarantee
-    # on the orientation of the edges, so our algorithm below must
-    # handle the case in which exactly one orientation, either (u, v) or
-    # (v, u), appears in this iterable.
-    if G.is_multigraph():
-        edges = G.edges(nset1, data=data, keys=keys, default=default)
-    else:
-        edges = G.edges(nset1, data=data, default=default)
-    # If `nbunch2` is not provided, then it is assumed to be the set
-    # complement of `nbunch1`. For the sake of efficiency, this is
-    # implemented by using the `not in` operator, instead of by creating
-    # an additional set and using the `in` operator.
-    if nbunch2 is None:
-        return (e for e in edges if (e[0] in nset1) ^ (e[1] in nset1))
-    nset2 = set(nbunch2)
-    return (
-        e
-        for e in edges
-        if (e[0] in nset1 and e[1] in nset2) or (e[1] in nset1 and e[0] in nset2)
-    )
-
-
-@nx._dispatchable
-def node_boundary(G, nbunch1, nbunch2=None):
-    """Returns the node boundary of `nbunch1`.
-
-    The *node boundary* of a set *S* with respect to a set *T* is the
-    set of nodes *v* in *T* such that for some *u* in *S*, there is an
-    edge joining *u* to *v*. If *T* is not specified, it is assumed to
-    be the set of all nodes not in *S*.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    nbunch1 : iterable
-        Iterable of nodes in the graph representing the set of nodes
-        whose node boundary will be returned. (This is the set *S* from
-        the definition above.)
-
-    nbunch2 : iterable
-        Iterable of nodes representing the target (or "exterior") set of
-        nodes. (This is the set *T* from the definition above.) If not
-        specified, this is assumed to be the set of all nodes in `G`
-        not in `nbunch1`.
-
-    Returns
-    -------
-    set
-        The node boundary of `nbunch1` with respect to `nbunch2`.
-
-    Examples
-    --------
-    >>> G = nx.wheel_graph(6)
-
-    When nbunch2=None:
-
-    >>> list(nx.node_boundary(G, (3, 4)))
-    [0, 2, 5]
-
-    When nbunch2 is given:
-
-    >>> list(nx.node_boundary(G, (3, 4), (0, 1, 5)))
-    [0, 5]
-
-    Notes
-    -----
-    Any element of `nbunch` that is not in the graph `G` will be
-    ignored.
-
-    `nbunch1` and `nbunch2` are usually meant to be disjoint, but in
-    the interest of speed and generality, that is not required here.
-
-    """
-    nset1 = {n for n in nbunch1 if n in G}
-    bdy = set(chain.from_iterable(G[v] for v in nset1)) - nset1
-    # If `nbunch2` is not specified, it is assumed to be the set
-    # complement of `nbunch1`.
-    if nbunch2 is not None:
-        bdy &= set(nbunch2)
-    return bdy

package/runtime/python/okstra_vendor/networkx/algorithms/bridges.py

@@ -1,205 +0,0 @@
-"""Bridge-finding algorithms."""
-
-from itertools import chain
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["bridges", "has_bridges", "local_bridges"]
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def bridges(G, root=None):
-    """Generate all bridges in a graph.
-
-    A *bridge* in a graph is an edge whose removal causes the number of
-    connected components of the graph to increase.  Equivalently, a bridge is an
-    edge that does not belong to any cycle. Bridges are also known as cut-edges,
-    isthmuses, or cut arcs.
-
-    Parameters
-    ----------
-    G : undirected graph
-
-    root : node (optional)
-       A node in the graph `G`. If specified, only the bridges in the
-       connected component containing this node will be returned.
-
-    Yields
-    ------
-    e : edge
-       An edge in the graph whose removal disconnects the graph (or
-       causes the number of connected components to increase).
-
-    Raises
-    ------
-    NodeNotFound
-       If `root` is not in the graph `G`.
-
-    NetworkXNotImplemented
-        If `G` is a directed graph.
-
-    Examples
-    --------
-    The barbell graph with parameter zero has a single bridge:
-
-    >>> G = nx.barbell_graph(10, 0)
-    >>> list(nx.bridges(G))
-    [(9, 10)]
-
-    Notes
-    -----
-    This is an implementation of the algorithm described in [1]_.  An edge is a
-    bridge if and only if it is not contained in any chain. Chains are found
-    using the :func:`networkx.chain_decomposition` function.
-
-    The algorithm described in [1]_ requires a simple graph. If the provided
-    graph is a multigraph, we convert it to a simple graph and verify that any
-    bridges discovered by the chain decomposition algorithm are not multi-edges.
-
-    Ignoring polylogarithmic factors, the worst-case time complexity is the
-    same as the :func:`networkx.chain_decomposition` function,
-    $O(m + n)$, where $n$ is the number of nodes in the graph and $m$ is
-    the number of edges.
-
-    References
-    ----------
-    .. [1] https://en.wikipedia.org/wiki/Bridge_%28graph_theory%29#Bridge-Finding_with_Chain_Decompositions
-    """
-    multigraph = G.is_multigraph()
-    H = nx.Graph(G) if multigraph else G
-    chains = nx.chain_decomposition(H, root=root)
-    chain_edges = set(chain.from_iterable(chains))
-    if root is not None:
-        H = H.subgraph(nx.node_connected_component(H, root)).copy()
-    for u, v in H.edges():
-        if (u, v) not in chain_edges and (v, u) not in chain_edges:
-            if multigraph and len(G[u][v]) > 1:
-                continue
-            yield u, v
-
-
-@not_implemented_for("directed")
-@nx._dispatchable
-def has_bridges(G, root=None):
-    """Decide whether a graph has any bridges.
-
-    A *bridge* in a graph is an edge whose removal causes the number of
-    connected components of the graph to increase.
-
-    Parameters
-    ----------
-    G : undirected graph
-
-    root : node (optional)
-       A node in the graph `G`. If specified, only the bridges in the
-       connected component containing this node will be considered.
-
-    Returns
-    -------
-    bool
-       Whether the graph (or the connected component containing `root`)
-       has any bridges.
-
-    Raises
-    ------
-    NodeNotFound
-       If `root` is not in the graph `G`.
-
-    NetworkXNotImplemented
-        If `G` is a directed graph.
-
-    Examples
-    --------
-    The barbell graph with parameter zero has a single bridge::
-
-        >>> G = nx.barbell_graph(10, 0)
-        >>> nx.has_bridges(G)
-        True
-
-    On the other hand, the cycle graph has no bridges::
-
-        >>> G = nx.cycle_graph(5)
-        >>> nx.has_bridges(G)
-        False
-
-    Notes
-    -----
-    This implementation uses the :func:`networkx.bridges` function, so
-    it shares its worst-case time complexity, $O(m + n)$, ignoring
-    polylogarithmic factors, where $n$ is the number of nodes in the
-    graph and $m$ is the number of edges.
-
-    """
-    try:
-        next(bridges(G, root=root))
-    except StopIteration:
-        return False
-    else:
-        return True
-
-
-@not_implemented_for("multigraph")
-@not_implemented_for("directed")
-@nx._dispatchable(edge_attrs="weight")
-def local_bridges(G, with_span=True, weight=None):
-    """Iterate over local bridges of `G` optionally computing the span
-
-    A *local bridge* is an edge whose endpoints have no common neighbors.
-    That is, the edge is not part of a triangle in the graph.
-
-    The *span* of a *local bridge* is the shortest path length between
-    the endpoints if the local bridge is removed.
-
-    Parameters
-    ----------
-    G : undirected graph
-
-    with_span : bool
-        If True, yield a 3-tuple `(u, v, span)`
-
-    weight : function, string or None (default: None)
-        If function, used to compute edge weights for the span.
-        If string, the edge data attribute used in calculating span.
-        If None, all edges have weight 1.
-
-    Yields
-    ------
-    e : edge
-        The local bridges as an edge 2-tuple of nodes `(u, v)` or
-        as a 3-tuple `(u, v, span)` when `with_span is True`.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is a directed graph or multigraph.
-
-    Examples
-    --------
-    A cycle graph has every edge a local bridge with span N-1.
-
-       >>> G = nx.cycle_graph(9)
-       >>> (0, 8, 8) in set(nx.local_bridges(G))
-       True
-    """
-    if with_span is not True:
-        for u, v in G.edges:
-            if not (set(G[u]) & set(G[v])):
-                yield u, v
-    else:
-        wt = nx.weighted._weight_function(G, weight)
-        for u, v in G.edges:
-            if not (set(G[u]) & set(G[v])):
-                enodes = {u, v}
-
-                def hide_edge(n, nbr, d):
-                    if n not in enodes or nbr not in enodes:
-                        return wt(n, nbr, d)
-                    return None
-
-                try:
-                    span = nx.shortest_path_length(G, u, v, weight=hide_edge)
-                    yield u, v, span
-                except nx.NetworkXNoPath:
-                    yield u, v, float("inf")

package/runtime/python/okstra_vendor/networkx/algorithms/broadcasting.py

@@ -1,164 +0,0 @@
-"""Routines to calculate the broadcast time of certain graphs.
-
-Broadcasting is an information dissemination problem in which a node in a graph,
-called the originator, must distribute a message to all other nodes by placing
-a series of calls along the edges of the graph. Once informed, other nodes aid
-the originator in distributing the message.
-
-The broadcasting must be completed as quickly as possible subject to the
-following constraints:
-- Each call requires one unit of time.
-- A node can only participate in one call per unit of time.
-- Each call only involves two adjacent nodes: a sender and a receiver.
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = [
-    "tree_broadcast_center",
-    "tree_broadcast_time",
-]
-
-
-def _get_max_broadcast_value(G, U, v, values):
-    adj = sorted(set(G.neighbors(v)) & U, key=values.get, reverse=True)
-    return max(values[u] + i for i, u in enumerate(adj, start=1))
-
-
-def _get_broadcast_centers(G, v, values, target):
-    adj = sorted(G.neighbors(v), key=values.get, reverse=True)
-    j = next(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
-    return set([v] + adj[:j])
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def tree_broadcast_center(G):
-    """Return the broadcast center of a tree.
-
-    The broadcast center of a graph `G` denotes the set of nodes having
-    minimum broadcast time [1]_. This function implements a linear algorithm
-    for determining the broadcast center of a tree with ``n`` nodes. As a
-    by-product, it also determines the broadcast time from the broadcast center.
-
-    Parameters
-    ----------
-    G : Graph
-        The graph should be an undirected tree.
-
-    Returns
-    -------
-    b_T, b_C : (int, set) tuple
-        Minimum broadcast time of the broadcast center in `G`, set of nodes
-        in the broadcast center.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is directed or is a multigraph.
-
-    NotATree
-        If `G` is not a tree.
-
-    References
-    ----------
-    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
-       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
-    """
-    # Assert that the graph G is a tree
-    if not nx.is_tree(G):
-        raise nx.NotATree("G is not a tree")
-    # step 0
-    if (n := len(G)) < 3:
-        return n - 1, set(G)
-
-    # step 1
-    U = {node for node, deg in G.degree if deg == 1}
-    values = {n: 0 for n in U}
-    T = G.copy()
-    T.remove_nodes_from(U)
-
-    # step 2
-    W = {node for node, deg in T.degree if deg == 1}
-    values.update((w, G.degree[w] - 1) for w in W)
-
-    # step 3
-    while len(T) >= 2:
-        # step 4
-        w = min(W, key=values.get)
-        v = next(T.neighbors(w))
-
-        # step 5
-        U.add(w)
-        W.remove(w)
-        T.remove_node(w)
-
-        # step 6
-        if T.degree(v) == 1:
-            # update t(v)
-            values.update({v: _get_max_broadcast_value(G, U, v, values)})
-            W.add(v)
-
-    # step 7
-    v = nx.utils.arbitrary_element(T)
-    b_T = _get_max_broadcast_value(G, U, v, values)
-    return b_T, _get_broadcast_centers(G, v, values, b_T)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def tree_broadcast_time(G, node=None):
-    """Return the minimum broadcast time of a (node in a) tree.
-
-    The minimum broadcast time of a node is defined as the minimum amount
-    of time required to complete broadcasting starting from that node.
-    The broadcast time of a graph is the maximum over
-    all nodes of the minimum broadcast time from that node [1]_.
-    This function returns the minimum broadcast time of `node`.
-    If `node` is `None`, the broadcast time for the graph is returned.
-
-    Parameters
-    ----------
-    G : Graph
-        The graph should be an undirected tree.
-
-    node : node, optional (default=None)
-        Starting node for the broadcasting. If `None`, the algorithm
-        returns the broadcast time of the graph instead.
-
-    Returns
-    -------
-    int
-        Minimum broadcast time of `node` in `G`, or broadcast time of `G`
-        if no node is provided.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is directed or is a multigraph.
-
-    NodeNotFound
-        If `node` is not a node in `G`.
-
-    NotATree
-        If `G` is not a tree.
-
-    References
-    ----------
-    .. [1] Harutyunyan, H. A. and Li, Z.
-        "A Simple Construction of Broadcast Graphs."
-        In Computing and Combinatorics. COCOON 2019
-        (Ed. D. Z. Du and C. Tian.) Springer, pp. 240-253, 2019.
-    """
-    if node is not None and node not in G:
-        err = f"node {node} not in G"
-        raise nx.NodeNotFound(err)
-    b_T, b_C = tree_broadcast_center(G)
-    if node is None:
-        return b_T + sum(1 for _ in nx.bfs_layers(G, b_C)) - 1
-    return b_T + next(
-        d for d, layer in enumerate(nx.bfs_layers(G, b_C)) if node in layer
-    )

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

@@ -1,20 +0,0 @@
-from .betweenness import *
-from .betweenness_subset import *
-from .closeness import *
-from .current_flow_betweenness import *
-from .current_flow_betweenness_subset import *
-from .current_flow_closeness import *
-from .degree_alg import *
-from .dispersion import *
-from .eigenvector import *
-from .group import *
-from .harmonic import *
-from .katz import *
-from .load import *
-from .percolation import *
-from .reaching import *
-from .second_order import *
-from .subgraph_alg import *
-from .trophic import *
-from .voterank_alg import *
-from .laplacian import *