okstra 0.130.3 → 0.131.0

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

@@ -1,171 +0,0 @@
-"""Functions for computing communities based on centrality notions."""
-
-import networkx as nx
-
-__all__ = ["girvan_newman"]
-
-
-@nx._dispatchable(preserve_edge_attrs="most_valuable_edge")
-def girvan_newman(G, most_valuable_edge=None):
-    """Finds communities in a graph using the Girvan–Newman method.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    most_valuable_edge : function
-        Function that takes a graph as input and outputs an edge. The
-        edge returned by this function will be recomputed and removed at
-        each iteration of the algorithm.
-
-        If not specified, the edge with the highest
-        :func:`networkx.edge_betweenness_centrality` will be used.
-
-    Returns
-    -------
-    iterator
-        Iterator over tuples of sets of nodes in `G`. Each set of node
-        is a community, each tuple is a sequence of communities at a
-        particular level of the algorithm.
-
-    Examples
-    --------
-    To get the first pair of communities::
-
-        >>> G = nx.path_graph(10)
-        >>> comp = nx.community.girvan_newman(G)
-        >>> tuple(sorted(c) for c in next(comp))
-        ([0, 1, 2, 3, 4], [5, 6, 7, 8, 9])
-
-    To get only the first *k* tuples of communities, use
-    :func:`itertools.islice`::
-
-        >>> import itertools
-        >>> G = nx.path_graph(8)
-        >>> k = 2
-        >>> comp = nx.community.girvan_newman(G)
-        >>> for communities in itertools.islice(comp, k):
-        ...     print(tuple(sorted(c) for c in communities))
-        ...
-        ([0, 1, 2, 3], [4, 5, 6, 7])
-        ([0, 1], [2, 3], [4, 5, 6, 7])
-
-    To stop getting tuples of communities once the number of communities
-    is greater than *k*, use :func:`itertools.takewhile`::
-
-        >>> import itertools
-        >>> G = nx.path_graph(8)
-        >>> k = 4
-        >>> comp = nx.community.girvan_newman(G)
-        >>> limited = itertools.takewhile(lambda c: len(c) <= k, comp)
-        >>> for communities in limited:
-        ...     print(tuple(sorted(c) for c in communities))
-        ...
-        ([0, 1, 2, 3], [4, 5, 6, 7])
-        ([0, 1], [2, 3], [4, 5, 6, 7])
-        ([0, 1], [2, 3], [4, 5], [6, 7])
-
-    To just choose an edge to remove based on the weight::
-
-        >>> from operator import itemgetter
-        >>> G = nx.path_graph(10)
-        >>> edges = G.edges()
-        >>> nx.set_edge_attributes(G, {(u, v): v for u, v in edges}, "weight")
-        >>> def heaviest(G):
-        ...     u, v, w = max(G.edges(data="weight"), key=itemgetter(2))
-        ...     return (u, v)
-        ...
-        >>> comp = nx.community.girvan_newman(G, most_valuable_edge=heaviest)
-        >>> tuple(sorted(c) for c in next(comp))
-        ([0, 1, 2, 3, 4, 5, 6, 7, 8], [9])
-
-    To utilize edge weights when choosing an edge with, for example, the
-    highest betweenness centrality::
-
-        >>> from networkx import edge_betweenness_centrality as betweenness
-        >>> def most_central_edge(G):
-        ...     centrality = betweenness(G, weight="weight")
-        ...     return max(centrality, key=centrality.get)
-        ...
-        >>> G = nx.path_graph(10)
-        >>> comp = nx.community.girvan_newman(G, most_valuable_edge=most_central_edge)
-        >>> tuple(sorted(c) for c in next(comp))
-        ([0, 1, 2, 3, 4], [5, 6, 7, 8, 9])
-
-    To specify a different ranking algorithm for edges, use the
-    `most_valuable_edge` keyword argument::
-
-        >>> from networkx import edge_betweenness_centrality
-        >>> from random import random
-        >>> def most_central_edge(G):
-        ...     centrality = edge_betweenness_centrality(G)
-        ...     max_cent = max(centrality.values())
-        ...     # Scale the centrality values so they are between 0 and 1,
-        ...     # and add some random noise.
-        ...     centrality = {e: c / max_cent for e, c in centrality.items()}
-        ...     # Add some random noise.
-        ...     centrality = {e: c + random() for e, c in centrality.items()}
-        ...     return max(centrality, key=centrality.get)
-        ...
-        >>> G = nx.path_graph(10)
-        >>> comp = nx.community.girvan_newman(G, most_valuable_edge=most_central_edge)
-
-    Notes
-    -----
-    The Girvan–Newman algorithm detects communities by progressively
-    removing edges from the original graph. The algorithm removes the
-    "most valuable" edge, traditionally the edge with the highest
-    betweenness centrality, at each step. As the graph breaks down into
-    pieces, the tightly knit community structure is exposed and the
-    result can be depicted as a dendrogram.
-
-    """
-    # If the graph is already empty, simply return its connected
-    # components.
-    if G.number_of_edges() == 0:
-        yield tuple(nx.connected_components(G))
-        return
-    # If no function is provided for computing the most valuable edge,
-    # use the edge betweenness centrality.
-    if most_valuable_edge is None:
-
-        def most_valuable_edge(G):
-            """Returns the edge with the highest betweenness centrality
-            in the graph `G`.
-
-            """
-            # We have guaranteed that the graph is non-empty, so this
-            # dictionary will never be empty.
-            betweenness = nx.edge_betweenness_centrality(G)
-            return max(betweenness, key=betweenness.get)
-
-    # The copy of G here must include the edge weight data.
-    g = G.copy().to_undirected()
-    # Self-loops must be removed because their removal has no effect on
-    # the connected components of the graph.
-    g.remove_edges_from(nx.selfloop_edges(g))
-    while g.number_of_edges() > 0:
-        yield _without_most_central_edges(g, most_valuable_edge)
-
-
-def _without_most_central_edges(G, most_valuable_edge):
-    """Returns the connected components of the graph that results from
-    repeatedly removing the most "valuable" edge in the graph.
-
-    `G` must be a non-empty graph. This function modifies the graph `G`
-    in-place; that is, it removes edges on the graph `G`.
-
-    `most_valuable_edge` is a function that takes the graph `G` as input
-    (or a subgraph with one or more edges of `G` removed) and returns an
-    edge. That edge will be removed and this process will be repeated
-    until the number of connected components in the graph increases.
-
-    """
-    original_num_components = nx.number_connected_components(G)
-    num_new_components = original_num_components
-    while num_new_components <= original_num_components:
-        edge = most_valuable_edge(G)
-        G.remove_edge(*edge)
-        new_components = tuple(nx.connected_components(G))
-        num_new_components = len(new_components)
-    return new_components

package/runtime/python/okstra_vendor/networkx/algorithms/community/community_utils.py

@@ -1,30 +0,0 @@
-"""Helper functions for community-finding algorithms."""
-
-import networkx as nx
-
-__all__ = ["is_partition"]
-
-
-@nx._dispatchable
-def is_partition(G, communities):
-    """Returns *True* if `communities` is a partition of the nodes of `G`.
-
-    A partition of a universe set is a family of pairwise disjoint sets
-    whose union is the entire universe set.
-
-    Parameters
-    ----------
-    G : NetworkX graph.
-
-    communities : list or iterable of sets of nodes
-        If not a list, the iterable is converted internally to a list.
-        If it is an iterator it is exhausted.
-
-    """
-    # Alternate implementation:
-    # return all(sum(1 if v in c else 0 for c in communities) == 1 for v in G)
-    if not isinstance(communities, list):
-        communities = list(communities)
-    nodes = {n for c in communities for n in c if n in G}
-
-    return len(G) == len(nodes) == sum(len(c) for c in communities)

package/runtime/python/okstra_vendor/networkx/algorithms/community/divisive.py

@@ -1,216 +0,0 @@
-import functools
-
-import networkx as nx
-
-__all__ = [
-    "edge_betweenness_partition",
-    "edge_current_flow_betweenness_partition",
-]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def edge_betweenness_partition(G, number_of_sets, *, weight=None):
-    """Partition created by iteratively removing the highest edge betweenness edge.
-
-    This algorithm works by calculating the edge betweenness for all
-    edges and removing the edge with the highest value. It is then
-    determined whether the graph has been broken into at least
-    `number_of_sets` connected components.
-    If not the process is repeated.
-
-    Parameters
-    ----------
-    G : NetworkX Graph, DiGraph or MultiGraph
-      Graph to be partitioned
-
-    number_of_sets : int
-      Number of sets in the desired partition of the graph
-
-    weight : key, optional, default=None
-      The key to use if using weights for edge betweenness calculation
-
-    Returns
-    -------
-    C : list of sets
-      Partition of the nodes of G
-
-    Raises
-    ------
-    NetworkXError
-      If number_of_sets is <= 0 or if number_of_sets > len(G)
-
-    Examples
-    --------
-    >>> G = nx.karate_club_graph()
-    >>> part = nx.community.edge_betweenness_partition(G, 2)
-    >>> {0, 1, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16, 17, 19, 21} in part
-    True
-    >>> {
-    ...     2,
-    ...     8,
-    ...     9,
-    ...     14,
-    ...     15,
-    ...     18,
-    ...     20,
-    ...     22,
-    ...     23,
-    ...     24,
-    ...     25,
-    ...     26,
-    ...     27,
-    ...     28,
-    ...     29,
-    ...     30,
-    ...     31,
-    ...     32,
-    ...     33,
-    ... } in part
-    True
-
-    See Also
-    --------
-    edge_current_flow_betweenness_partition
-
-    Notes
-    -----
-    This algorithm is fairly slow, as both the calculation of connected
-    components and edge betweenness relies on all pairs shortest
-    path algorithms. They could potentially be combined to cut down
-    on overall computation time.
-
-    References
-    ----------
-    .. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
-       Volume 486, Issue 3-5 p. 75-174
-       http://arxiv.org/abs/0906.0612
-    """
-    if number_of_sets <= 0:
-        raise nx.NetworkXError("number_of_sets must be >0")
-    if number_of_sets == 1:
-        return [set(G)]
-    if number_of_sets == len(G):
-        return [{n} for n in G]
-    if number_of_sets > len(G):
-        raise nx.NetworkXError("number_of_sets must be <= len(G)")
-
-    H = G.copy()
-    partition = list(nx.connected_components(H))
-    while len(partition) < number_of_sets:
-        ranking = nx.edge_betweenness_centrality(H, weight=weight)
-        edge = max(ranking, key=ranking.get)
-        H.remove_edge(*edge)
-        partition = list(nx.connected_components(H))
-    return partition
-
-
-@nx._dispatchable(edge_attrs="weight")
-def edge_current_flow_betweenness_partition(G, number_of_sets, *, weight=None):
-    """Partition created by removing the highest edge current flow betweenness edge.
-
-    This algorithm works by calculating the edge current flow
-    betweenness for all edges and removing the edge with the
-    highest value. It is then determined whether the graph has
-    been broken into at least `number_of_sets` connected
-    components. If not the process is repeated.
-
-    Parameters
-    ----------
-    G : NetworkX Graph, DiGraph or MultiGraph
-      Graph to be partitioned
-
-    number_of_sets : int
-      Number of sets in the desired partition of the graph
-
-    weight : key, optional (default=None)
-      The edge attribute key to use as weights for
-      edge current flow betweenness calculations
-
-    Returns
-    -------
-    C : list of sets
-      Partition of G
-
-    Raises
-    ------
-    NetworkXError
-      If number_of_sets is <= 0 or number_of_sets > len(G)
-
-    Examples
-    --------
-    >>> G = nx.karate_club_graph()
-    >>> part = nx.community.edge_current_flow_betweenness_partition(G, 2)
-    >>> {0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 16, 17, 19, 21} in part
-    True
-    >>> {8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33} in part
-    True
-
-
-    See Also
-    --------
-    edge_betweenness_partition
-
-    Notes
-    -----
-    This algorithm is extremely slow, as the recalculation of the edge
-    current flow betweenness is extremely slow.
-
-    References
-    ----------
-    .. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
-       Volume 486, Issue 3-5 p. 75-174
-       http://arxiv.org/abs/0906.0612
-    """
-    if number_of_sets <= 0:
-        raise nx.NetworkXError("number_of_sets must be >0")
-    elif number_of_sets == 1:
-        return [set(G)]
-    elif number_of_sets == len(G):
-        return [{n} for n in G]
-    elif number_of_sets > len(G):
-        raise nx.NetworkXError("number_of_sets must be <= len(G)")
-
-    rank = functools.partial(
-        nx.edge_current_flow_betweenness_centrality, normalized=False, weight=weight
-    )
-
-    # current flow requires a connected network so we track the components explicitly
-    H = G.copy()
-    partition = list(nx.connected_components(H))
-    if len(partition) > 1:
-        Hcc_subgraphs = [H.subgraph(cc).copy() for cc in partition]
-    else:
-        Hcc_subgraphs = [H]
-
-    ranking = {}
-    for Hcc in Hcc_subgraphs:
-        ranking.update(rank(Hcc))
-
-    while len(partition) < number_of_sets:
-        edge = max(ranking, key=ranking.get)
-        for cc, Hcc in zip(partition, Hcc_subgraphs):
-            if edge[0] in cc:
-                Hcc.remove_edge(*edge)
-                del ranking[edge]
-                splitcc_list = list(nx.connected_components(Hcc))
-                if len(splitcc_list) > 1:
-                    # there are 2 connected components. split off smaller one
-                    cc_new = min(splitcc_list, key=len)
-                    Hcc_new = Hcc.subgraph(cc_new).copy()
-                    # update edge rankings for Hcc_new
-                    newranks = rank(Hcc_new)
-                    for e, r in newranks.items():
-                        ranking[e if e in ranking else e[::-1]] = r
-                    # append new cc and Hcc to their lists.
-                    partition.append(cc_new)
-                    Hcc_subgraphs.append(Hcc_new)
-
-                    # leave existing cc and Hcc in their lists, but shrink them
-                    Hcc.remove_nodes_from(cc_new)
-                    cc.difference_update(cc_new)
-                # update edge rankings for Hcc whether it was split or not
-                newranks = rank(Hcc)
-                for e, r in newranks.items():
-                    ranking[e if e in ranking else e[::-1]] = r
-                break
-    return partition

package/runtime/python/okstra_vendor/networkx/algorithms/community/kclique.py

@@ -1,79 +0,0 @@
-from collections import defaultdict
-
-import networkx as nx
-
-__all__ = ["k_clique_communities"]
-
-
-@nx._dispatchable
-def k_clique_communities(G, k, cliques=None):
-    """Find k-clique communities in graph using the percolation method.
-
-    A k-clique community is the union of all cliques of size k that
-    can be reached through adjacent (sharing k-1 nodes) k-cliques.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    k : int
-       Size of smallest clique
-
-    cliques: list or generator
-       Precomputed cliques (use networkx.find_cliques(G))
-
-    Returns
-    -------
-    Yields sets of nodes, one for each k-clique community.
-
-    Examples
-    --------
-    >>> G = nx.complete_graph(5)
-    >>> K5 = nx.convert_node_labels_to_integers(G, first_label=2)
-    >>> G.add_edges_from(K5.edges())
-    >>> c = list(nx.community.k_clique_communities(G, 4))
-    >>> sorted(list(c[0]))
-    [0, 1, 2, 3, 4, 5, 6]
-    >>> list(nx.community.k_clique_communities(G, 6))
-    []
-
-    References
-    ----------
-    .. [1] Gergely Palla, Imre Derényi, Illés Farkas1, and Tamás Vicsek,
-       Uncovering the overlapping community structure of complex networks
-       in nature and society Nature 435, 814-818, 2005,
-       doi:10.1038/nature03607
-    """
-    if k < 2:
-        raise nx.NetworkXError(f"k={k}, k must be greater than 1.")
-    if cliques is None:
-        cliques = nx.find_cliques(G)
-    cliques = [frozenset(c) for c in cliques if len(c) >= k]
-
-    # First index which nodes are in which cliques
-    membership_dict = defaultdict(list)
-    for clique in cliques:
-        for node in clique:
-            membership_dict[node].append(clique)
-
-    # For each clique, see which adjacent cliques percolate
-    perc_graph = nx.Graph()
-    perc_graph.add_nodes_from(cliques)
-    for clique in cliques:
-        for adj_clique in _get_adjacent_cliques(clique, membership_dict):
-            if len(clique.intersection(adj_clique)) >= (k - 1):
-                perc_graph.add_edge(clique, adj_clique)
-
-    # Connected components of clique graph with perc edges
-    # are the percolated cliques
-    for component in nx.connected_components(perc_graph):
-        yield (frozenset.union(*component))
-
-
-def _get_adjacent_cliques(clique, membership_dict):
-    adjacent_cliques = set()
-    for n in clique:
-        for adj_clique in membership_dict[n]:
-            if clique != adj_clique:
-                adjacent_cliques.add(adj_clique)
-    return adjacent_cliques