okstra 0.130.4 → 0.131.1

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

@@ -1,78 +0,0 @@
-"""
-Algorithm to find a maximal (not maximum) independent set.
-
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for, py_random_state
-
-__all__ = ["maximal_independent_set"]
-
-
-@not_implemented_for("directed")
-@py_random_state(2)
-@nx._dispatchable
-def maximal_independent_set(G, nodes=None, seed=None):
-    """Returns a random maximal independent set guaranteed to contain
-    a given set of nodes.
-
-    An independent set is a set of nodes such that the subgraph
-    of G induced by these nodes contains no edges. A maximal
-    independent set is an independent set such that it is not possible
-    to add a new node and still get an independent set.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    nodes : list or iterable
-       Nodes that must be part of the independent set. This set of nodes
-       must be independent.
-
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    indep_nodes : list
-       List of nodes that are part of a maximal independent set.
-
-    Raises
-    ------
-    NetworkXUnfeasible
-       If the nodes in the provided list are not part of the graph or
-       do not form an independent set, an exception is raised.
-
-    NetworkXNotImplemented
-        If `G` is directed.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(5)
-    >>> nx.maximal_independent_set(G)  # doctest: +SKIP
-    [4, 0, 2]
-    >>> nx.maximal_independent_set(G, [1])  # doctest: +SKIP
-    [1, 3]
-
-    Notes
-    -----
-    This algorithm does not solve the maximum independent set problem.
-
-    """
-    if not nodes:
-        nodes = {seed.choice(list(G))}
-    else:
-        nodes = set(nodes)
-    if not nodes.issubset(G):
-        raise nx.NetworkXUnfeasible(f"{nodes} is not a subset of the nodes of G")
-    neighbors = set.union(*[set(G.adj[v]) for v in nodes])
-    if set.intersection(neighbors, nodes):
-        raise nx.NetworkXUnfeasible(f"{nodes} is not an independent set of G")
-    indep_nodes = list(nodes)
-    available_nodes = set(G.nodes()).difference(neighbors.union(nodes))
-    while available_nodes:
-        node = seed.choice(list(available_nodes))
-        indep_nodes.append(node)
-        available_nodes.difference_update(list(G.adj[node]) + [node])
-    return indep_nodes

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

@@ -1,59 +0,0 @@
-r"""Function for computing the moral graph of a directed graph."""
-
-import itertools
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["moral_graph"]
-
-
-@not_implemented_for("undirected")
-@nx._dispatchable(returns_graph=True)
-def moral_graph(G):
-    r"""Return the Moral Graph
-
-    Returns the moralized graph of a given directed graph.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Directed graph
-
-    Returns
-    -------
-    H : NetworkX graph
-        The undirected moralized graph of G
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If `G` is undirected.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 2), (2, 3), (2, 5), (3, 4), (4, 3)])
-    >>> G_moral = nx.moral_graph(G)
-    >>> G_moral.edges()
-    EdgeView([(1, 2), (2, 3), (2, 5), (2, 4), (3, 4)])
-
-    Notes
-    -----
-    A moral graph is an undirected graph H = (V, E) generated from a
-    directed Graph, where if a node has more than one parent node, edges
-    between these parent nodes are inserted and all directed edges become
-    undirected.
-
-    https://en.wikipedia.org/wiki/Moral_graph
-
-    References
-    ----------
-    .. [1] Wray L. Buntine. 1995. Chain graphs for learning.
-           In Proceedings of the Eleventh conference on Uncertainty
-           in artificial intelligence (UAI'95)
-    """
-    H = G.to_undirected()
-    for preds in G.pred.values():
-        predecessors_combinations = itertools.combinations(preds, r=2)
-        H.add_edges_from(predecessors_combinations)
-    return H

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

@@ -1,219 +0,0 @@
-"""This module provides the functions for node classification problem.
-
-The functions in this module are not imported
-into the top level `networkx` namespace.
-You can access these functions by importing
-the `networkx.algorithms.node_classification` modules,
-then accessing the functions as attributes of `node_classification`.
-For example:
-
-  >>> from networkx.algorithms import node_classification
-  >>> G = nx.path_graph(4)
-  >>> G.edges()
-  EdgeView([(0, 1), (1, 2), (2, 3)])
-  >>> G.nodes[0]["label"] = "A"
-  >>> G.nodes[3]["label"] = "B"
-  >>> node_classification.harmonic_function(G)
-  ['A', 'A', 'B', 'B']
-
-References
-----------
-Zhu, X., Ghahramani, Z., & Lafferty, J. (2003, August).
-Semi-supervised learning using gaussian fields and harmonic functions.
-In ICML (Vol. 3, pp. 912-919).
-"""
-
-import networkx as nx
-
-__all__ = ["harmonic_function", "local_and_global_consistency"]
-
-
-@nx.utils.not_implemented_for("directed")
-@nx._dispatchable(node_attrs="label_name")
-def harmonic_function(G, max_iter=30, label_name="label"):
-    """Node classification by Harmonic function
-
-    Function for computing Harmonic function algorithm by Zhu et al.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-    max_iter : int
-        maximum number of iterations allowed
-    label_name : string
-        name of target labels to predict
-
-    Returns
-    -------
-    predicted : list
-        List of length ``len(G)`` with the predicted labels for each node.
-
-    Raises
-    ------
-    NetworkXError
-        If no nodes in `G` have attribute `label_name`.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import node_classification
-    >>> G = nx.path_graph(4)
-    >>> G.nodes[0]["label"] = "A"
-    >>> G.nodes[3]["label"] = "B"
-    >>> G.nodes(data=True)
-    NodeDataView({0: {'label': 'A'}, 1: {}, 2: {}, 3: {'label': 'B'}})
-    >>> G.edges()
-    EdgeView([(0, 1), (1, 2), (2, 3)])
-    >>> predicted = node_classification.harmonic_function(G)
-    >>> predicted
-    ['A', 'A', 'B', 'B']
-
-    References
-    ----------
-    Zhu, X., Ghahramani, Z., & Lafferty, J. (2003, August).
-    Semi-supervised learning using gaussian fields and harmonic functions.
-    In ICML (Vol. 3, pp. 912-919).
-    """
-    import numpy as np
-    import scipy as sp
-
-    X = nx.to_scipy_sparse_array(G)  # adjacency matrix
-    labels, label_dict = _get_label_info(G, label_name)
-
-    if labels.shape[0] == 0:
-        raise nx.NetworkXError(
-            f"No node on the input graph is labeled by '{label_name}'."
-        )
-
-    n_samples = X.shape[0]
-    n_classes = label_dict.shape[0]
-    F = np.zeros((n_samples, n_classes))
-
-    # Build propagation matrix
-    degrees = X.sum(axis=0)
-    degrees[degrees == 0] = 1  # Avoid division by 0
-    D = sp.sparse.dia_array((1.0 / degrees, 0), shape=(n_samples, n_samples)).tocsr()
-    P = (D @ X).tolil()
-    P[labels[:, 0]] = 0  # labels[:, 0] indicates IDs of labeled nodes
-    # Build base matrix
-    B = np.zeros((n_samples, n_classes))
-    B[labels[:, 0], labels[:, 1]] = 1
-
-    for _ in range(max_iter):
-        F = (P @ F) + B
-
-    return label_dict[np.argmax(F, axis=1)].tolist()
-
-
-@nx.utils.not_implemented_for("directed")
-@nx._dispatchable(node_attrs="label_name")
-def local_and_global_consistency(G, alpha=0.99, max_iter=30, label_name="label"):
-    """Node classification by Local and Global Consistency
-
-    Function for computing Local and global consistency algorithm by Zhou et al.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-    alpha : float
-        Clamping factor
-    max_iter : int
-        Maximum number of iterations allowed
-    label_name : string
-        Name of target labels to predict
-
-    Returns
-    -------
-    predicted : list
-        List of length ``len(G)`` with the predicted labels for each node.
-
-    Raises
-    ------
-    NetworkXError
-        If no nodes in `G` have attribute `label_name`.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import node_classification
-    >>> G = nx.path_graph(4)
-    >>> G.nodes[0]["label"] = "A"
-    >>> G.nodes[3]["label"] = "B"
-    >>> G.nodes(data=True)
-    NodeDataView({0: {'label': 'A'}, 1: {}, 2: {}, 3: {'label': 'B'}})
-    >>> G.edges()
-    EdgeView([(0, 1), (1, 2), (2, 3)])
-    >>> predicted = node_classification.local_and_global_consistency(G)
-    >>> predicted
-    ['A', 'A', 'B', 'B']
-
-    References
-    ----------
-    Zhou, D., Bousquet, O., Lal, T. N., Weston, J., & Schölkopf, B. (2004).
-    Learning with local and global consistency.
-    Advances in neural information processing systems, 16(16), 321-328.
-    """
-    import numpy as np
-    import scipy as sp
-
-    X = nx.to_scipy_sparse_array(G)  # adjacency matrix
-    labels, label_dict = _get_label_info(G, label_name)
-
-    if labels.shape[0] == 0:
-        raise nx.NetworkXError(
-            f"No node on the input graph is labeled by '{label_name}'."
-        )
-
-    n_samples = X.shape[0]
-    n_classes = label_dict.shape[0]
-    F = np.zeros((n_samples, n_classes))
-
-    # Build propagation matrix
-    degrees = X.sum(axis=0)
-    degrees[degrees == 0] = 1  # Avoid division by 0
-    D2 = sp.sparse.dia_array(
-        (1.0 / np.sqrt(degrees), 0), shape=(n_samples, n_samples)
-    ).tocsr()
-    P = alpha * ((D2 @ X) @ D2)
-    # Build base matrix
-    B = np.zeros((n_samples, n_classes))
-    B[labels[:, 0], labels[:, 1]] = 1 - alpha
-
-    for _ in range(max_iter):
-        F = (P @ F) + B
-
-    return label_dict[np.argmax(F, axis=1)].tolist()
-
-
-def _get_label_info(G, label_name):
-    """Get and return information of labels from the input graph
-
-    Parameters
-    ----------
-    G : Network X graph
-    label_name : string
-        Name of the target label
-
-    Returns
-    -------
-    labels : numpy array, shape = [n_labeled_samples, 2]
-        Array of pairs of labeled node ID and label ID
-    label_dict : numpy array, shape = [n_classes]
-        Array of labels
-        i-th element contains the label corresponding label ID `i`
-    """
-    import numpy as np
-
-    labels = []
-    label_to_id = {}
-    lid = 0
-    for i, n in enumerate(G.nodes(data=True)):
-        if label_name in n[1]:
-            label = n[1][label_name]
-            if label not in label_to_id:
-                label_to_id[label] = lid
-                lid += 1
-            labels.append([i, label_to_id[label]])
-    labels = np.array(labels)
-    label_dict = np.array(
-        [label for label, _ in sorted(label_to_id.items(), key=lambda x: x[1])]
-    )
-    return (labels, label_dict)

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

@@ -1,155 +0,0 @@
-r"""Computation of graph non-randomness."""
-
-import math
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["non_randomness"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def non_randomness(G, k=None, weight="weight"):
-    """Compute the non-randomness of a graph.
-
-    The first value $R_G$ is the sum of non-randomness values of all
-    edges within the graph (where the non-randomness of an edge tends to be
-    small when the two nodes linked by that edge are from two different
-    communities).
-
-    The second value $R_G^*$ is a relative measure that indicates
-    to what extent `G` is different from a random graph in terms
-    of probability. The closer it is to 0, the higher the likelihood
-    the graph was generated by an Erdős--Rényi model.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Graph must be undirected, connected, and without self-loops.
-
-    k : int or None, optional (default=None)
-        The number of communities in `G`.
-        If `k` is not set, the function uses a default community detection
-        algorithm (:func:`~networkx.algorithms.community.label_propagation_communities`)
-        to set it.
-
-    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, i.e., the graph is
-        binary.
-
-    Returns
-    -------
-    (float, float) tuple
-        The first value is $R_G$, the non-randomness of the graph,
-        the second is $R_G^*$, the relative non-randomness
-        w.r.t. the Erdős--Rényi model.
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the input graph is directed or a multigraph.
-
-    NetworkXException
-        If the input graph is not connected.
-
-    NetworkXError
-        If the input graph contains self-loops or has no edges.
-
-    ValueError
-        If `k` is not in $\\{1, \\dots, n-1\\}$, where $n$ is the number of nodes,
-        or if `k` is such that the computed edge probability
-        $p = \\frac{2km}{n(n-k)}$ does not satisfy $0 < p < 1$.
-
-    Examples
-    --------
-    >>> G = nx.karate_club_graph()
-    >>> nr, nr_rd = nx.non_randomness(G, 2)
-    >>> nr, nr_rd = nx.non_randomness(G, 2, "weight")
-
-    When the number of communities `k` is not specified,
-    :func:`~networkx.algorithms.community.label_propagation_communities`
-    is used to compute it.
-    This algorithm can give different results depending on
-    the order of nodes and edges in the graph.
-    For example, while the following graphs are identical,
-    computing the non-randomness of each of them yields different results:
-
-    >>> G1, G2 = nx.Graph(), nx.Graph()
-    >>> G1.add_edges_from([(0, 1), (1, 2), (1, 3), (3, 4)])
-    >>> G2.add_edges_from([(0, 1), (1, 3), (1, 2), (3, 4)])
-    >>> [round(r, 6) for r in nx.non_randomness(G1)]
-    [-1.847759, -5.842437]
-    >>> [round(r, 6) for r in nx.non_randomness(G2)]
-    Traceback (most recent call last):
-     ...
-    ValueError: invalid number of communities for graph with 5 nodes and 4 edges: 2
-
-    This is because the community detection algorithm finds
-    1 community in `G1` and 2 communities in `G2`.
-    This can be resolved by specifying the number of communities `k`:
-
-    >>> [round(r, 6) for r in nx.non_randomness(G2, k=1)]
-    [-1.847759, -5.842437]
-
-    Notes
-    -----
-    If a `weight` argument is passed, this algorithm will use the eigenvalues
-    of the weighted adjacency matrix instead.
-
-    The output of this function corresponds to (4.4) and (4.5) in [1]_.
-    A lower value of $R^*_G$ indicates a more random graph;
-    one can think of $1 - \\Phi(R_G^*)$ as the similarity
-    between the graph and a random graph,
-    where $\\Phi(x)$ is the cumulative distribution function
-    of the standard normal distribution.
-
-    Theorem 2 in [2]_ states that for any graph $G$
-    with $n$ nodes, $m$ edges, and $k$ communities,
-    its non-randomness is bounded below by the non-randomness of an
-    $r$-regular graph (a graph where each node has degree $r$),
-    and bounded above by the non-randomness of an $l$-complete graph
-    (a graph where each community is a clique of $l$ nodes).
-
-    References
-    ----------
-    .. [1] Xiaowei Ying and Xintao Wu,
-           On Randomness Measures for Social Networks,
-           SIAM International Conference on Data Mining. 2009
-           https://doi.org/10.1137/1.9781611972795.61
-    .. [2] Ying, Xiaowei & Wu, Leting & Wu, Xintao. (2012).
-           A Spectrum-Based Framework for Quantifying Randomness of Social Networks.
-           IEEE Transactions on Knowledge and Data Engineering 23(12):1842--1856.
-           https://dl.acm.org/doi/abs/10.1109/TKDE.2010.218
-    """
-    import numpy as np
-
-    # corner case: graph has no edges
-    if nx.is_empty(G):
-        raise nx.NetworkXError("non_randomness not applicable to empty graphs")
-    if not nx.is_connected(G):
-        raise nx.NetworkXException("Non connected graph.")
-    if len(list(nx.selfloop_edges(G))) > 0:
-        raise nx.NetworkXError("Graph must not contain self-loops")
-
-    n = G.number_of_nodes()
-    m = G.number_of_edges()
-
-    if k is None:
-        k = len(tuple(nx.community.label_propagation_communities(G)))
-    if not 1 <= k < n or not 0 < (p := (2 * k * m) / (n * (n - k))) < 1:
-        err = (
-            f"invalid number of communities for graph with {n} nodes and {m} edges: {k}"
-        )
-        raise ValueError(err)
-
-    # eq. 4.4
-    eigenvalues = np.linalg.eigvals(nx.to_numpy_array(G, weight=weight))
-    nr = float(np.real(np.sum(eigenvalues[:k])))
-
-    # eq. 4.5
-    nr_rd = (nr - ((n - 2 * k) * p + k)) / math.sqrt(2 * k * p * (1 - p))
-
-    return nr, nr_rd

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

@@ -1,4 +0,0 @@
-from networkx.algorithms.operators.all import *
-from networkx.algorithms.operators.binary import *
-from networkx.algorithms.operators.product import *
-from networkx.algorithms.operators.unary import *