okstra 0.130.4 → 0.131.0

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

@@ -1,77 +0,0 @@
-"""Function for computing walks in a graph."""
-
-import networkx as nx
-
-__all__ = ["number_of_walks"]
-
-
-@nx._dispatchable
-def number_of_walks(G, walk_length):
-    """Returns the number of walks connecting each pair of nodes in `G`
-
-    A *walk* is a sequence of nodes in which each adjacent pair of nodes
-    in the sequence is adjacent in the graph. A walk can repeat the same
-    edge and go in the opposite direction just as people can walk on a
-    set of paths, but standing still is not counted as part of the walk.
-
-    This function only counts the walks with `walk_length` edges. Note that
-    the number of nodes in the walk sequence is one more than `walk_length`.
-    The number of walks can grow very quickly on a larger graph
-    and with a larger walk length.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    walk_length : int
-        A nonnegative integer representing the length of a walk.
-
-    Returns
-    -------
-    dict
-        A dictionary of dictionaries in which outer keys are source
-        nodes, inner keys are target nodes, and inner values are the
-        number of walks of length `walk_length` connecting those nodes.
-
-    Raises
-    ------
-    ValueError
-        If `walk_length` is negative
-
-    Examples
-    --------
-
-    >>> G = nx.Graph([(0, 1), (1, 2)])
-    >>> walks = nx.number_of_walks(G, 2)
-    >>> walks
-    {0: {0: 1, 1: 0, 2: 1}, 1: {0: 0, 1: 2, 2: 0}, 2: {0: 1, 1: 0, 2: 1}}
-    >>> total_walks = sum(sum(tgts.values()) for _, tgts in walks.items())
-
-    You can also get the number of walks from a specific source node using the
-    returned dictionary. For example, number of walks of length 1 from node 0
-    can be found as follows:
-
-    >>> walks = nx.number_of_walks(G, 1)
-    >>> walks[0]
-    {0: 0, 1: 1, 2: 0}
-    >>> sum(walks[0].values())  # walks from 0 of length 1
-    1
-
-    Similarly, a target node can also be specified:
-
-    >>> walks[0][1]
-    1
-
-    """
-    import scipy as sp
-
-    if walk_length < 0:
-        raise ValueError(f"`walk_length` cannot be negative: {walk_length}")
-
-    A = nx.adjacency_matrix(G, weight=None)
-    power = sp.sparse.linalg.matrix_power(A, walk_length).tocsr()
-    result = {
-        u: {v: power[u_idx, v_idx].item() for v_idx, v in enumerate(G)}
-        for u_idx, u in enumerate(G)
-    }
-    return result

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

@@ -1,278 +0,0 @@
-"""Functions related to the Wiener Index of a graph.
-
-The Wiener Index is a topological measure of a graph
-related to the distance between nodes and their degree.
-The Schultz Index and Gutman Index are similar measures.
-They are used categorize molecules via the network of
-atoms connected by chemical bonds. The indices are
-correlated with functional aspects of the molecules.
-
-References
-----------
-.. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_
-.. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
-       Croatica Chemica Acta, 71 (1998), 21-51.
-       https://hrcak.srce.hr/132323
-"""
-
-import itertools as it
-
-import networkx as nx
-
-__all__ = ["wiener_index", "schultz_index", "gutman_index", "hyper_wiener_index"]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def wiener_index(G, weight=None):
-    """Returns the Wiener index of the given graph.
-
-    The *Wiener index* of a graph is the sum of the shortest-path
-    (weighted) distances between each pair of reachable nodes.
-    For pairs of nodes in undirected graphs, only one orientation
-    of the pair is counted.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    weight : string or None, optional (default: None)
-        If None, every edge has weight 1.
-        If a string, use this edge attribute as the edge weight.
-        Any edge attribute not present defaults to 1.
-        The edge weights are used to computing shortest-path distances.
-
-    Returns
-    -------
-    number
-        The Wiener index of the graph `G`.
-
-    Raises
-    ------
-    NetworkXError
-        If the graph `G` is not connected.
-
-    Notes
-    -----
-    If a pair of nodes is not reachable, the distance is assumed to be
-    infinity. This means that for graphs that are not
-    strongly-connected, this function returns ``inf``.
-
-    The Wiener index is not usually defined for directed graphs, however
-    this function uses the natural generalization of the Wiener index to
-    directed graphs.
-
-    Examples
-    --------
-    The Wiener index of the (unweighted) complete graph on *n* nodes
-    equals the number of pairs of the *n* nodes, since each pair of
-    nodes is at distance one::
-
-        >>> n = 10
-        >>> G = nx.complete_graph(n)
-        >>> nx.wiener_index(G) == n * (n - 1) / 2
-        True
-
-    Graphs that are not strongly-connected have infinite Wiener index::
-
-        >>> G = nx.empty_graph(2)
-        >>> nx.wiener_index(G)
-        inf
-
-    References
-    ----------
-    .. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_
-    """
-    connected = nx.is_strongly_connected(G) if G.is_directed() else nx.is_connected(G)
-    if not connected:
-        return float("inf")
-
-    spl = nx.shortest_path_length(G, weight=weight)
-    total = sum(it.chain.from_iterable(nbrs.values() for node, nbrs in spl))
-    # Need to account for double counting pairs of nodes in undirected graphs.
-    return total if G.is_directed() else total / 2
-
-
-@nx.utils.not_implemented_for("directed")
-@nx.utils.not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def schultz_index(G, weight=None):
-    r"""Returns the Schultz Index (of the first kind) of `G`
-
-    The *Schultz Index* [3]_ of a graph is the sum over all node pairs of
-    distances times the sum of degrees. Consider an undirected graph `G`.
-    For each node pair ``(u, v)`` compute ``dist(u, v) * (deg(u) + deg(v)``
-    where ``dist`` is the shortest path length between two nodes and ``deg``
-    is the degree of a node.
-
-    The Schultz Index is the sum of these quantities over all (unordered)
-    pairs of nodes.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The undirected graph of interest.
-    weight : string or None, optional (default: None)
-        If None, every edge has weight 1.
-        If a string, use this edge attribute as the edge weight.
-        Any edge attribute not present defaults to 1.
-        The edge weights are used to computing shortest-path distances.
-
-    Returns
-    -------
-    number
-        The first kind of Schultz Index of the graph `G`.
-
-    Examples
-    --------
-    The Schultz Index of the (unweighted) complete graph on *n* nodes
-    equals the number of pairs of the *n* nodes times ``2 * (n - 1)``,
-    since each pair of nodes is at distance one and the sum of degree
-    of two nodes is ``2 * (n - 1)``.
-
-    >>> n = 10
-    >>> G = nx.complete_graph(n)
-    >>> nx.schultz_index(G) == (n * (n - 1) / 2) * (2 * (n - 1))
-    True
-
-    Graph that is disconnected
-
-    >>> nx.schultz_index(nx.empty_graph(2))
-    inf
-
-    References
-    ----------
-    .. [1] I. Gutman, Selected properties of the Schultz molecular topological index,
-           J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089.
-           https://doi.org/10.1021/ci00021a009
-    .. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
-           Croatica Chemica Acta, 71 (1998), 21-51.
-           https://hrcak.srce.hr/132323
-    .. [3] H. P. Schultz, Topological organic chemistry. 1.
-           Graph theory and topological indices of alkanes,i
-           J. Chem. Inf. Comput. Sci. 29 (1989), 239–257.
-
-    """
-    if not nx.is_connected(G):
-        return float("inf")
-
-    spl = nx.shortest_path_length(G, weight=weight)
-    d = dict(G.degree, weight=weight)
-    return sum(dist * (d[u] + d[v]) for u, info in spl for v, dist in info.items()) / 2
-
-
-@nx.utils.not_implemented_for("directed")
-@nx.utils.not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def gutman_index(G, weight=None):
-    r"""Returns the Gutman Index for the graph `G`.
-
-    The *Gutman Index* measures the topology of networks, especially for molecule
-    networks of atoms connected by bonds [1]_. It is also called the Schultz Index
-    of the second kind [2]_.
-
-    Consider an undirected graph `G` with node set ``V``.
-    The Gutman Index of a graph is the sum over all (unordered) pairs of nodes
-    of nodes ``(u, v)``, with distance ``dist(u, v)`` and degrees ``deg(u)``
-    and ``deg(v)``, of ``dist(u, v) * deg(u) * deg(v)``
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    weight : string or None, optional (default: None)
-        If None, every edge has weight 1.
-        If a string, use this edge attribute as the edge weight.
-        Any edge attribute not present defaults to 1.
-        The edge weights are used to computing shortest-path distances.
-
-    Returns
-    -------
-    number
-        The Gutman Index of the graph `G`.
-
-    Examples
-    --------
-    The Gutman Index of the (unweighted) complete graph on *n* nodes
-    equals the number of pairs of the *n* nodes times ``(n - 1) * (n - 1)``,
-    since each pair of nodes is at distance one and the product of degree of two
-    vertices is ``(n - 1) * (n - 1)``.
-
-    >>> n = 10
-    >>> G = nx.complete_graph(n)
-    >>> nx.gutman_index(G) == (n * (n - 1) / 2) * ((n - 1) * (n - 1))
-    True
-
-    Graphs that are disconnected
-
-    >>> G = nx.empty_graph(2)
-    >>> nx.gutman_index(G)
-    inf
-
-    References
-    ----------
-    .. [1] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
-           Croatica Chemica Acta, 71 (1998), 21-51.
-           https://hrcak.srce.hr/132323
-    .. [2] I. Gutman, Selected properties of the Schultz molecular topological index,
-           J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089.
-           https://doi.org/10.1021/ci00021a009
-
-    """
-    if not nx.is_connected(G):
-        return float("inf")
-
-    spl = nx.shortest_path_length(G, weight=weight)
-    d = dict(G.degree, weight=weight)
-    return sum(dist * d[u] * d[v] for u, vinfo in spl for v, dist in vinfo.items()) / 2
-
-
-@nx.utils.not_implemented_for("directed")
-@nx.utils.not_implemented_for("multigraph")
-@nx._dispatchable(edge_attrs="weight")
-def hyper_wiener_index(G, weight=None):
-    r"""Returns the Hyper-Wiener index of the graph `G`.
-
-    The Hyper-Wiener index of a connected graph `G` is defined as
-
-    .. math::
-        WW(G) = \frac{1}{2} \sum_{u,v \in V(G)} (d(u,v) + d(u,v)^2)
-
-    where ``d(u, v)`` is the shortest-path distance between nodes ``u`` and ``v``.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        An undirected, connected graph.
-
-    weight : string or None, optional (default: None)
-        The edge attribute to use for calculating shortest-path distances.
-        If None, all edges are considered to have a weight of 1.
-
-    Returns
-    -------
-    float
-        The Hyper-Wiener index of the graph G.
-        Returns float("inf") if the graph is not connected.
-
-    References
-    ----------
-    .. [1] M. Randić, "Novel molecular descriptor for structure-property studies,"
-           Chemical Physics Letters, vol. 211, pp. 478-483, 1993.
-    .. [2] `Wikipedia: Hyper-Wiener Index <https://en.wikipedia.org/wiki/Hyper-Wiener_index>`_
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> nx.hyper_wiener_index(G)
-    30.0
-
-    >>> G = nx.cycle_graph(4)
-    >>> nx.hyper_wiener_index(G)
-    20.0
-    """
-    if not nx.is_connected(G):
-        return float("inf")
-
-    spl = nx.shortest_path_length(G, weight=weight)
-    total = sum(dist + dist**2 for _, lengths in spl for dist in lengths.values())
-    return total / 2

package/runtime/python/okstra_vendor/networkx/classes/__init__.py

@@ -1,13 +0,0 @@
-from .graph import Graph
-from .digraph import DiGraph
-from .multigraph import MultiGraph
-from .multidigraph import MultiDiGraph
-
-from .function import *
-from .graphviews import subgraph_view, reverse_view
-
-from networkx.classes import filters
-
-from networkx.classes import coreviews
-from networkx.classes import graphviews
-from networkx.classes import reportviews