okstra 0.130.4 → 0.131.0

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

@@ -1,200 +0,0 @@
-"""Load centrality."""
-
-from operator import itemgetter
-
-import networkx as nx
-
-__all__ = ["load_centrality", "edge_load_centrality"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def newman_betweenness_centrality(G, v=None, cutoff=None, normalized=True, weight=None):
-    """Compute load centrality for nodes.
-
-    The load centrality of a node is the fraction of all shortest
-    paths that pass through that node.
-
-    Parameters
-    ----------
-    G : graph
-      A networkx graph.
-
-    normalized : bool, optional (default=True)
-      If True the betweenness values are normalized by b=b/(n-1)(n-2) where
-      n is the number of nodes in G.
-
-    weight : None or string, optional (default=None)
-      If None, edge weights are ignored.
-      Otherwise holds the name of the edge attribute used as weight.
-      The weight of an edge is treated as the length or distance between the two sides.
-
-    cutoff : bool, optional (default=None)
-      If specified, only consider paths of length <= cutoff.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with centrality as the value.
-
-    See Also
-    --------
-    betweenness_centrality
-
-    Notes
-    -----
-    Load centrality is slightly different than betweenness. It was originally
-    introduced by [2]_. For this load algorithm see [1]_.
-
-    References
-    ----------
-    .. [1] Mark E. J. Newman:
-       Scientific collaboration networks. II.
-       Shortest paths, weighted networks, and centrality.
-       Physical Review E 64, 016132, 2001.
-       http://journals.aps.org/pre/abstract/10.1103/PhysRevE.64.016132
-    .. [2] Kwang-Il Goh, Byungnam Kahng and Doochul Kim
-       Universal behavior of Load Distribution in Scale-Free Networks.
-       Physical Review Letters 87(27):1–4, 2001.
-       https://doi.org/10.1103/PhysRevLett.87.278701
-    """
-    if v is not None:  # only one node
-        betweenness = 0.0
-        for source in G:
-            ubetween = _node_betweenness(G, source, cutoff, False, weight)
-            betweenness += ubetween[v] if v in ubetween else 0
-        if normalized:
-            order = G.order()
-            if order <= 2:
-                return betweenness  # no normalization b=0 for all nodes
-            betweenness *= 1.0 / ((order - 1) * (order - 2))
-    else:
-        betweenness = {}.fromkeys(G, 0.0)
-        for source in betweenness:
-            ubetween = _node_betweenness(G, source, cutoff, False, weight)
-            for vk in ubetween:
-                betweenness[vk] += ubetween[vk]
-        if normalized:
-            order = G.order()
-            if order <= 2:
-                return betweenness  # no normalization b=0 for all nodes
-            scale = 1.0 / ((order - 1) * (order - 2))
-            for v in betweenness:
-                betweenness[v] *= scale
-    return betweenness  # all nodes
-
-
-def _node_betweenness(G, source, cutoff=False, normalized=True, weight=None):
-    """Node betweenness_centrality helper:
-
-    See betweenness_centrality for what you probably want.
-    This actually computes "load" and not betweenness.
-    See https://networkx.lanl.gov/ticket/103
-
-    This calculates the load of each node for paths from a single source.
-    (The fraction of number of shortests paths from source that go
-    through each node.)
-
-    To get the load for a node you need to do all-pairs shortest paths.
-
-    If weight is not None then use Dijkstra for finding shortest paths.
-    """
-    # get the predecessor and path length data
-    if weight is None:
-        (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True)
-    else:
-        (pred, length) = nx.dijkstra_predecessor_and_distance(G, source, cutoff, weight)
-
-    # order the nodes by path length
-    onodes = [(l, vert) for (vert, l) in length.items()]
-    onodes.sort()
-    onodes[:] = [vert for (l, vert) in onodes if l > 0]
-
-    # initialize betweenness
-    between = {}.fromkeys(length, 1.0)
-
-    while onodes:
-        v = onodes.pop()
-        if v in pred:
-            num_paths = len(pred[v])  # Discount betweenness if more than
-            for x in pred[v]:  # one shortest path.
-                if x == source:  # stop if hit source because all remaining v
-                    break  # also have pred[v]==[source]
-                between[x] += between[v] / num_paths
-    #  remove source
-    for v in between:
-        between[v] -= 1
-    # rescale to be between 0 and 1
-    if normalized:
-        l = len(between)
-        if l > 2:
-            # scale by 1/the number of possible paths
-            scale = 1 / ((l - 1) * (l - 2))
-            for v in between:
-                between[v] *= scale
-    return between
-
-
-load_centrality = newman_betweenness_centrality
-
-
-@nx._dispatchable
-def edge_load_centrality(G, cutoff=False):
-    """Compute edge load.
-
-    WARNING: This concept of edge load has not been analysed
-    or discussed outside of NetworkX that we know of.
-    It is based loosely on load_centrality in the sense that
-    it counts the number of shortest paths which cross each edge.
-    This function is for demonstration and testing purposes.
-
-    Parameters
-    ----------
-    G : graph
-        A networkx graph
-
-    cutoff : bool, optional (default=False)
-        If specified, only consider paths of length <= cutoff.
-
-    Returns
-    -------
-    A dict keyed by edge 2-tuple to the number of shortest paths
-    which use that edge. Where more than one path is shortest
-    the count is divided equally among paths.
-    """
-    betweenness = {}
-    for u, v in G.edges():
-        betweenness[(u, v)] = 0.0
-        betweenness[(v, u)] = 0.0
-
-    for source in G:
-        ubetween = _edge_betweenness(G, source, cutoff=cutoff)
-        for e, ubetweenv in ubetween.items():
-            betweenness[e] += ubetweenv  # cumulative total
-    return betweenness
-
-
-def _edge_betweenness(G, source, nodes=None, cutoff=False):
-    """Edge betweenness helper."""
-    # get the predecessor data
-    (pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True)
-    # order the nodes by path length
-    onodes = [n for n, d in sorted(length.items(), key=itemgetter(1))]
-    # initialize betweenness, doesn't account for any edge weights
-    between = {}
-    for u, v in G.edges(nodes):
-        between[(u, v)] = 1.0
-        between[(v, u)] = 1.0
-
-    while onodes:  # work through all paths
-        v = onodes.pop()
-        if v in pred:
-            # Discount betweenness if more than one shortest path.
-            num_paths = len(pred[v])
-            for w in pred[v]:
-                if w in pred:
-                    # Discount betweenness, mult path
-                    num_paths = len(pred[w])
-                    for x in pred[w]:
-                        between[(w, x)] += between[(v, w)] / num_paths
-                        between[(x, w)] += between[(w, v)] / num_paths
-    return between

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

@@ -1,128 +0,0 @@
-"""Percolation centrality measures."""
-
-import networkx as nx
-from networkx.algorithms.centrality.betweenness import (
-    _single_source_dijkstra_path_basic as dijkstra,
-)
-from networkx.algorithms.centrality.betweenness import (
-    _single_source_shortest_path_basic as shortest_path,
-)
-
-__all__ = ["percolation_centrality"]
-
-
-@nx._dispatchable(node_attrs="attribute", edge_attrs="weight")
-def percolation_centrality(G, attribute="percolation", states=None, weight=None):
-    r"""Compute the percolation centrality for nodes.
-
-    Percolation centrality of a node $v$, at a given time, is defined
-    as the proportion of ‘percolated paths’ that go through that node.
-
-    This measure quantifies relative impact of nodes based on their
-    topological connectivity, as well as their percolation states.
-
-    Percolation states of nodes are used to depict network percolation
-    scenarios (such as during infection transmission in a social network
-    of individuals, spreading of computer viruses on computer networks, or
-    transmission of disease over a network of towns) over time. In this
-    measure usually the percolation state is expressed as a decimal
-    between 0.0 and 1.0.
-
-    When all nodes are in the same percolated state this measure is
-    equivalent to betweenness centrality.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph.
-
-    attribute : None or string, optional (default='percolation')
-      Name of the node attribute to use for percolation state, used
-      if `states` is None. If a node does not set the attribute the
-      state of that node will be set to the default value of 1.
-      If all nodes do not have the attribute all nodes will be set to
-      1 and the centrality measure will be equivalent to betweenness centrality.
-
-    states : None or dict, optional (default=None)
-      Specify percolation states for the nodes, nodes as keys states
-      as values.
-
-    weight : None or string, optional (default=None)
-      If None, all edge weights are considered equal.
-      Otherwise holds the name of the edge attribute used as weight.
-      The weight of an edge is treated as the length or distance between the two sides.
-
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary of nodes with percolation centrality as the value.
-
-    See Also
-    --------
-    betweenness_centrality
-
-    Notes
-    -----
-    The algorithm is from Mahendra Piraveenan, Mikhail Prokopenko, and
-    Liaquat Hossain [1]_
-    Pair dependencies are calculated and accumulated using [2]_
-
-    For weighted graphs the edge weights must be greater than zero.
-    Zero edge weights can produce an infinite number of equal length
-    paths between pairs of nodes.
-
-    References
-    ----------
-    .. [1] Mahendra Piraveenan, Mikhail Prokopenko, Liaquat Hossain
-       Percolation Centrality: Quantifying Graph-Theoretic Impact of Nodes
-       during Percolation in Networks
-       http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0053095
-    .. [2] Ulrik Brandes:
-       A Faster Algorithm for Betweenness Centrality.
-       Journal of Mathematical Sociology 25(2):163-177, 2001.
-       https://doi.org/10.1080/0022250X.2001.9990249
-    """
-    percolation = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
-
-    nodes = G
-
-    if states is None:
-        states = nx.get_node_attributes(nodes, attribute, default=1)
-
-    # sum of all percolation states
-    p_sigma_x_t = 0.0
-    for v in states.values():
-        p_sigma_x_t += v
-
-    for s in nodes:
-        # single source shortest paths
-        if weight is None:  # use BFS
-            S, P, sigma, _ = shortest_path(G, s)
-        else:  # use Dijkstra's algorithm
-            S, P, sigma, _ = dijkstra(G, s, weight)
-        # accumulation
-        percolation = _accumulate_percolation(
-            percolation, S, P, sigma, s, states, p_sigma_x_t
-        )
-
-    n = len(G)
-
-    for v in percolation:
-        percolation[v] *= 1 / (n - 2)
-
-    return percolation
-
-
-def _accumulate_percolation(percolation, S, P, sigma, s, states, p_sigma_x_t):
-    delta = dict.fromkeys(S, 0)
-    while S:
-        w = S.pop()
-        coeff = (1 + delta[w]) / sigma[w]
-        for v in P[w]:
-            delta[v] += sigma[v] * coeff
-        if w != s:
-            # percolation weight
-            pw_s_w = states[s] / (p_sigma_x_t - states[w])
-            percolation[w] += delta[w] * pw_s_w
-    return percolation

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

@@ -1,209 +0,0 @@
-"""Functions for computing reaching centrality of a node or a graph."""
-
-import networkx as nx
-from networkx.utils import pairwise
-
-__all__ = ["global_reaching_centrality", "local_reaching_centrality"]
-
-
-def _average_weight(G, path, weight=None):
-    """Returns the average weight of an edge in a weighted path.
-
-    Parameters
-    ----------
-    G : graph
-      A networkx graph.
-
-    path: list
-      A list of vertices that define the path.
-
-    weight : None or string, optional (default=None)
-      If None, edge weights are ignored.  Then the average weight of an edge
-      is assumed to be the multiplicative inverse of the length of the path.
-      Otherwise holds the name of the edge attribute used as weight.
-    """
-    path_length = len(path) - 1
-    if path_length <= 0:
-        return 0
-    if weight is None:
-        return 1 / path_length
-    total_weight = sum(G.edges[i, j][weight] for i, j in pairwise(path))
-    return total_weight / path_length
-
-
-@nx._dispatchable(edge_attrs="weight")
-def global_reaching_centrality(G, weight=None, normalized=True):
-    """Returns the global reaching centrality of a directed graph.
-
-    The *global reaching centrality* of a weighted directed graph is the
-    average over all nodes of the difference between the local reaching
-    centrality of the node and the greatest local reaching centrality of
-    any node in the graph [1]_. For more information on the local
-    reaching centrality, see :func:`local_reaching_centrality`.
-    Informally, the local reaching centrality is the proportion of the
-    graph that is reachable from the neighbors of the node.
-
-    Parameters
-    ----------
-    G : DiGraph
-        A networkx DiGraph.
-
-    weight : None or string, optional (default=None)
-        Attribute to use for edge weights. If ``None``, each edge weight
-        is assumed to be one. A higher weight implies a stronger
-        connection between nodes and a *shorter* path length.
-
-    normalized : bool, optional (default=True)
-        Whether to normalize the edge weights by the total sum of edge
-        weights.
-
-    Returns
-    -------
-    h : float
-        The global reaching centrality of the graph.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph()
-    >>> G.add_edge(1, 2)
-    >>> G.add_edge(1, 3)
-    >>> nx.global_reaching_centrality(G)
-    1.0
-    >>> G.add_edge(3, 2)
-    >>> nx.global_reaching_centrality(G)
-    0.75
-
-    See also
-    --------
-    local_reaching_centrality
-
-    References
-    ----------
-    .. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
-           "Hierarchy Measure for Complex Networks."
-           *PLoS ONE* 7.3 (2012): e33799.
-           https://doi.org/10.1371/journal.pone.0033799
-    """
-    if nx.is_negatively_weighted(G, weight=weight):
-        raise nx.NetworkXError("edge weights must be positive")
-    total_weight = G.size(weight=weight)
-    if total_weight <= 0:
-        raise nx.NetworkXError("Size of G must be positive")
-    # If provided, weights must be interpreted as connection strength
-    # (so higher weights are more likely to be chosen). However, the
-    # shortest path algorithms in NetworkX assume the provided "weight"
-    # is actually a distance (so edges with higher weight are less
-    # likely to be chosen). Therefore we need to invert the weights when
-    # computing shortest paths.
-    #
-    # If weight is None, we leave it as-is so that the shortest path
-    # algorithm can use a faster, unweighted algorithm.
-    if weight is not None:
-
-        def as_distance(u, v, d):
-            return total_weight / d.get(weight, 1)
-
-        shortest_paths = dict(nx.shortest_path(G, weight=as_distance))
-    else:
-        shortest_paths = dict(nx.shortest_path(G))
-
-    centrality = local_reaching_centrality
-    # TODO This can be trivially parallelized.
-    lrc = [
-        centrality(G, node, paths=paths, weight=weight, normalized=normalized)
-        for node, paths in shortest_paths.items()
-    ]
-
-    max_lrc = max(lrc)
-    return sum(max_lrc - c for c in lrc) / (len(G) - 1)
-
-
-@nx._dispatchable(edge_attrs="weight")
-def local_reaching_centrality(G, v, paths=None, weight=None, normalized=True):
-    """Returns the local reaching centrality of a node in a directed
-    graph.
-
-    The *local reaching centrality* of a node in a directed graph is the
-    proportion of other nodes reachable from that node [1]_.
-
-    Parameters
-    ----------
-    G : DiGraph
-        A NetworkX DiGraph.
-
-    v : node
-        A node in the directed graph `G`.
-
-    paths : dictionary (default=None)
-        If this is not `None` it must be a dictionary representation
-        of single-source shortest paths, as computed by, for example,
-        :func:`networkx.shortest_path` with source node `v`. Use this
-        keyword argument if you intend to invoke this function many
-        times but don't want the paths to be recomputed each time.
-
-    weight : None or string, optional (default=None)
-        Attribute to use for edge weights.  If `None`, each edge weight
-        is assumed to be one. A higher weight implies a stronger
-        connection between nodes and a *shorter* path length.
-
-    normalized : bool, optional (default=True)
-        Whether to normalize the edge weights by the total sum of edge
-        weights.
-
-    Returns
-    -------
-    h : float
-        The local reaching centrality of the node ``v`` in the graph
-        ``G``.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph()
-    >>> G.add_edges_from([(1, 2), (1, 3)])
-    >>> nx.local_reaching_centrality(G, 3)
-    0.0
-    >>> G.add_edge(3, 2)
-    >>> nx.local_reaching_centrality(G, 3)
-    0.5
-
-    See also
-    --------
-    global_reaching_centrality
-
-    References
-    ----------
-    .. [1] Mones, Enys, Lilla Vicsek, and Tamás Vicsek.
-           "Hierarchy Measure for Complex Networks."
-           *PLoS ONE* 7.3 (2012): e33799.
-           https://doi.org/10.1371/journal.pone.0033799
-    """
-    # Corner case: graph with single node containing a self-loop
-    if (total_weight := G.size(weight=weight)) > 0 and len(G) == 1:
-        raise nx.NetworkXError(
-            "local_reaching_centrality of a single node with self-loop not well-defined"
-        )
-    if paths is None:
-        if nx.is_negatively_weighted(G, weight=weight):
-            raise nx.NetworkXError("edge weights must be positive")
-        if total_weight <= 0:
-            raise nx.NetworkXError("Size of G must be positive")
-        if weight is not None:
-            # Interpret weights as lengths.
-            def as_distance(u, v, d):
-                return total_weight / d.get(weight, 1)
-
-            paths = nx.shortest_path(G, source=v, weight=as_distance)
-        else:
-            paths = nx.shortest_path(G, source=v)
-    # If the graph is unweighted, simply return the proportion of nodes
-    # reachable from the source node ``v``.
-    if weight is None and G.is_directed():
-        return (len(paths) - 1) / (len(G) - 1)
-    if normalized and weight is not None:
-        norm = G.size(weight=weight) / G.size()
-    else:
-        norm = 1
-    # TODO This can be trivially parallelized.
-    avgw = (_average_weight(G, path, weight=weight) for path in paths.values())
-    sum_avg_weight = sum(avgw) / norm
-    return sum_avg_weight / (len(G) - 1)

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

@@ -1,141 +0,0 @@
-"""Copyright (c) 2015 – Thomson Licensing, SAS
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted (subject to the limitations in the
-disclaimer below) provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
-
-* Neither the name of Thomson Licensing, or Technicolor, nor the names
-of its contributors may be used to endorse or promote products derived
-from this software without specific prior written permission.
-
-NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
-GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
-HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-# Authors: Erwan Le Merrer (erwan.lemerrer@technicolor.com)
-
-__all__ = ["second_order_centrality"]
-
-
-@not_implemented_for("directed")
-@nx._dispatchable(edge_attrs="weight")
-def second_order_centrality(G, weight="weight"):
-    """Compute the second order centrality for nodes of G.
-
-    The second order centrality of a given node is the standard deviation of
-    the return times to that node of a perpetual random walk on G:
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX connected and undirected graph.
-
-    weight : string or None, optional (default="weight")
-        The name of an edge attribute that holds the numerical value
-        used as a weight. If None then each edge has weight 1.
-
-    Returns
-    -------
-    nodes : dictionary
-       Dictionary keyed by node with second order centrality as the value.
-
-    Examples
-    --------
-    >>> G = nx.star_graph(10)
-    >>> soc = nx.second_order_centrality(G)
-    >>> print(sorted(soc.items(), key=lambda x: x[1])[0][0])  # pick first id
-    0
-
-    Raises
-    ------
-    NetworkXException
-        If the graph G is empty, non connected or has negative weights.
-
-    See Also
-    --------
-    betweenness_centrality
-
-    Notes
-    -----
-    Lower values of second order centrality indicate higher centrality.
-
-    The algorithm is from Kermarrec, Le Merrer, Sericola and Trédan [1]_.
-
-    This code implements the analytical version of the algorithm, i.e.,
-    there is no simulation of a random walk process involved. The random walk
-    is here unbiased (corresponding to eq 6 of the paper [1]_), thus the
-    centrality values are the standard deviations for random walk return times
-    on the transformed input graph G (equal in-degree at each nodes by adding
-    self-loops).
-
-    Complexity of this implementation, made to run locally on a single machine,
-    is O(n^3), with n the size of G, which makes it viable only for small
-    graphs.
-
-    References
-    ----------
-    .. [1] Anne-Marie Kermarrec, Erwan Le Merrer, Bruno Sericola, Gilles Trédan
-       "Second order centrality: Distributed assessment of nodes criticity in
-       complex networks", Elsevier Computer Communications 34(5):619-628, 2011.
-    """
-    import numpy as np
-
-    n = len(G)
-
-    if n == 0:
-        raise nx.NetworkXException("Empty graph.")
-    if not nx.is_connected(G):
-        raise nx.NetworkXException("Non connected graph.")
-    if any(d.get(weight, 0) < 0 for u, v, d in G.edges(data=True)):
-        raise nx.NetworkXException("Graph has negative edge weights.")
-
-    # balancing G for Metropolis-Hastings random walks
-    G = nx.DiGraph(G)
-    in_deg = dict(G.in_degree(weight=weight))
-    d_max = max(in_deg.values())
-    for i, deg in in_deg.items():
-        if deg < d_max:
-            G.add_edge(i, i, weight=d_max - deg)
-
-    P = nx.to_numpy_array(G)
-    P /= P.sum(axis=1)[:, np.newaxis]  # to transition probability matrix
-
-    def _Qj(P, j):
-        P = P.copy()
-        P[:, j] = 0
-        return P
-
-    M = np.empty([n, n])
-
-    for i in range(n):
-        M[:, i] = np.linalg.solve(
-            np.identity(n) - _Qj(P, i), np.ones([n, 1])[:, 0]
-        )  # eq 3
-
-    return dict(
-        zip(
-            G.nodes,
-            (float(np.sqrt(2 * np.sum(M[:, i]) - n * (n + 1))) for i in range(n)),
-        )
-    )  # eq 6