okstra 0.130.4 → 0.131.1

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

@@ -1,142 +0,0 @@
-"""Time dependent algorithms."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["cd_index"]
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable(node_attrs={"time": None, "weight": 1})
-def cd_index(G, node, time_delta, *, time="time", weight=None):
-    r"""Compute the CD index for `node` within the graph `G`.
-
-    Calculates the CD index for the given node of the graph,
-    considering only its predecessors who have the `time` attribute
-    smaller than or equal to the `time` attribute of the `node`
-    plus `time_delta`.
-
-    Parameters
-    ----------
-    G : graph
-       A directed networkx graph whose nodes have `time` attributes and optionally
-       `weight` attributes (if a weight is not given, it is considered 1).
-    node : node
-       The node for which the CD index is calculated.
-    time_delta : numeric or timedelta
-       Amount of time after the `time` attribute of the `node`. The value of
-       `time_delta` must support comparison with the `time` node attribute. For
-       example, if the `time` attribute of the nodes are `datetime.datetime`
-       objects, then `time_delta` should be a `datetime.timedelta` object.
-    time : string (Optional, default is "time")
-        The name of the node attribute that will be used for the calculations.
-    weight : string (Optional, default is None)
-        The name of the node attribute used as weight.
-
-    Returns
-    -------
-    float
-       The CD index calculated for the node `node` within the graph `G`.
-
-    Raises
-    ------
-    NetworkXError
-       If not all nodes have a `time` attribute or
-       `time_delta` and `time` attribute types are not compatible or
-       `n` equals 0.
-
-    NetworkXNotImplemented
-        If `G` is a non-directed graph or a multigraph.
-
-    Examples
-    --------
-    >>> from datetime import datetime, timedelta
-    >>> G = nx.DiGraph()
-    >>> nodes = {
-    ...     1: {"time": datetime(2015, 1, 1)},
-    ...     2: {"time": datetime(2012, 1, 1), "weight": 4},
-    ...     3: {"time": datetime(2010, 1, 1)},
-    ...     4: {"time": datetime(2008, 1, 1)},
-    ...     5: {"time": datetime(2014, 1, 1)},
-    ... }
-    >>> G.add_nodes_from([(n, nodes[n]) for n in nodes])
-    >>> edges = [(1, 3), (1, 4), (2, 3), (3, 4), (3, 5)]
-    >>> G.add_edges_from(edges)
-    >>> delta = timedelta(days=5 * 365)
-    >>> nx.cd_index(G, 3, time_delta=delta, time="time")
-    0.5
-    >>> nx.cd_index(G, 3, time_delta=delta, time="time", weight="weight")
-    0.12
-
-    Integers can also be used for the time values:
-    >>> node_times = {1: 2015, 2: 2012, 3: 2010, 4: 2008, 5: 2014}
-    >>> nx.set_node_attributes(G, node_times, "new_time")
-    >>> nx.cd_index(G, 3, time_delta=4, time="new_time")
-    0.5
-    >>> nx.cd_index(G, 3, time_delta=4, time="new_time", weight="weight")
-    0.12
-
-    Notes
-    -----
-    This method implements the algorithm for calculating the CD index,
-    as described in the paper by Funk and Owen-Smith [1]_. The CD index
-    is used in order to check how consolidating or destabilizing a patent
-    is, hence the nodes of the graph represent patents and the edges show
-    the citations between these patents. The mathematical model is given
-    below:
-
-    .. math::
-        CD_{t}=\frac{1}{n_{t}}\sum_{i=1}^{n}\frac{-2f_{it}b_{it}+f_{it}}{w_{it}},
-
-    where `f_{it}` equals 1 if `i` cites the focal patent else 0, `b_{it}` equals
-    1 if `i` cites any of the focal patents successors else 0, `n_{t}` is the number
-    of forward citations in `i` and `w_{it}` is a matrix of weight for patent `i`
-    at time `t`.
-
-    The `datetime.timedelta` package can lead to off-by-one issues when converting
-    from years to days. In the example above `timedelta(days=5 * 365)` looks like
-    5 years, but it isn't because of leap year days. So it gives the same result
-    as `timedelta(days=4 * 365)`. But using `timedelta(days=5 * 365 + 1)` gives
-    a 5 year delta **for this choice of years** but may not if the 5 year gap has
-    more than 1 leap year. To avoid these issues, use integers to represent years,
-    or be very careful when you convert units of time.
-
-    References
-    ----------
-    .. [1] Funk, Russell J., and Jason Owen-Smith.
-           "A dynamic network measure of technological change."
-           Management science 63, no. 3 (2017): 791-817.
-           http://russellfunk.org/cdindex/static/papers/funk_ms_2017.pdf
-
-    """
-    if not all(time in G.nodes[n] for n in G):
-        raise nx.NetworkXError("Not all nodes have a 'time' attribute.")
-
-    try:
-        # get target_date
-        target_date = G.nodes[node][time] + time_delta
-        # keep the predecessors that existed before the target date
-        pred = {i for i in G.pred[node] if G.nodes[i][time] <= target_date}
-    except:
-        raise nx.NetworkXError(
-            "Addition and comparison are not supported between 'time_delta' "
-            "and 'time' types."
-        )
-
-    # -1 if any edge between node's predecessors and node's successors, else 1
-    b = [-1 if any(j in G[i] for j in G[node]) else 1 for i in pred]
-
-    # n is size of the union of the focal node's predecessors and its successors' predecessors
-    n = len(pred.union(*(G.pred[s].keys() - {node} for s in G[node])))
-    if n == 0:
-        raise nx.NetworkXError("The cd index cannot be defined.")
-
-    # calculate cd index
-    if weight is None:
-        return round(sum(bi for bi in b) / n, 2)
-    else:
-        # If a node has the specified weight attribute, its weight is used in the calculation
-        # otherwise, a weight of 1 is assumed for that node
-        weights = [G.nodes[i].get(weight, 1) for i in pred]
-        return round(sum(bi / wt for bi, wt in zip(b, weights)) / n, 2)

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

@@ -1,406 +0,0 @@
-"""Functions concerning tournament graphs.
-
-A `tournament graph`_ is a complete oriented graph. In other words, it
-is a directed graph in which there is exactly one directed edge joining
-each pair of distinct nodes. For each function in this module that
-accepts a graph as input, you must provide a tournament graph. The
-responsibility is on the caller to ensure that the graph is a tournament
-graph:
-
-    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
-    >>> nx.is_tournament(G)
-    True
-
-To access the functions in this module, you must access them through the
-:mod:`networkx.tournament` module::
-
-    >>> nx.tournament.is_reachable(G, 0, 1)
-    True
-
-.. _tournament graph: https://en.wikipedia.org/wiki/Tournament_%28graph_theory%29
-
-"""
-
-from itertools import combinations
-
-import networkx as nx
-from networkx.utils import arbitrary_element, not_implemented_for, py_random_state
-
-__all__ = [
-    "hamiltonian_path",
-    "is_reachable",
-    "is_strongly_connected",
-    "is_tournament",
-    "random_tournament",
-    "score_sequence",
-    "tournament_matrix",
-]
-
-
-def index_satisfying(iterable, condition):
-    """Returns the index of the first element in `iterable` that
-    satisfies the given condition.
-
-    If no such element is found (that is, when the iterable is
-    exhausted), this returns the length of the iterable (that is, one
-    greater than the last index of the iterable).
-
-    `iterable` must not be empty. If `iterable` is empty, this
-    function raises :exc:`ValueError`.
-
-    """
-    # Pre-condition: iterable must not be empty.
-    for i, x in enumerate(iterable):
-        if condition(x):
-            return i
-    # If we reach the end of the iterable without finding an element
-    # that satisfies the condition, return the length of the iterable,
-    # which is one greater than the index of its last element. If the
-    # iterable was empty, `i` will not be defined, so we raise an
-    # exception.
-    try:
-        return i + 1
-    except NameError as err:
-        raise ValueError("iterable must be non-empty") from err
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def is_tournament(G):
-    """Returns True if and only if `G` is a tournament.
-
-    A tournament is a directed graph, with neither self-loops nor
-    multi-edges, in which there is exactly one directed edge joining
-    each pair of distinct nodes.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    Returns
-    -------
-    bool
-        Whether the given graph is a tournament graph.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
-    >>> nx.is_tournament(G)
-    True
-
-    Notes
-    -----
-    Some definitions require a self-loop on each node, but that is not
-    the convention used here.
-
-    """
-    # In a tournament, there is exactly one directed edge joining each pair.
-    return (
-        all((v in G[u]) ^ (u in G[v]) for u, v in combinations(G, 2))
-        and nx.number_of_selfloops(G) == 0
-    )
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def hamiltonian_path(G):
-    """Returns a Hamiltonian path in the given tournament graph.
-
-    Each tournament has a Hamiltonian path. If furthermore, the
-    tournament is strongly connected, then the returned Hamiltonian path
-    is a Hamiltonian cycle (by joining the endpoints of the path).
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    Returns
-    -------
-    path : list
-        A list of nodes which form a Hamiltonian path in `G`.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)])
-    >>> nx.is_tournament(G)
-    True
-    >>> nx.tournament.hamiltonian_path(G)
-    [0, 1, 2, 3]
-
-    Notes
-    -----
-    This is a recursive implementation with an asymptotic running time
-    of $O(n^2)$, ignoring multiplicative polylogarithmic factors, where
-    $n$ is the number of nodes in the graph.
-
-    """
-    if len(G) == 0:
-        return []
-    if len(G) == 1:
-        return [arbitrary_element(G)]
-    v = arbitrary_element(G)
-    hampath = hamiltonian_path(G.subgraph(set(G) - {v}))
-    # Get the index of the first node in the path that does *not* have
-    # an edge to `v`, then insert `v` before that node.
-    index = index_satisfying(hampath, lambda u: v not in G[u])
-    hampath.insert(index, v)
-    return hampath
-
-
-@py_random_state(1)
-@nx._dispatchable(graphs=None, returns_graph=True)
-def random_tournament(n, seed=None):
-    r"""Returns a random tournament graph on `n` nodes.
-
-    Parameters
-    ----------
-    n : int
-        The number of nodes in the returned graph.
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    G : DiGraph
-        A tournament on `n` nodes, with exactly one directed edge joining
-        each pair of distinct nodes.
-
-    Notes
-    -----
-    This algorithm adds, for each pair of distinct nodes, an edge with
-    uniformly random orientation. In other words, `\binom{n}{2}` flips
-    of an unbiased coin decide the orientations of the edges in the
-    graph.
-
-    """
-    # Flip an unbiased coin for each pair of distinct nodes.
-    coins = (seed.random() for i in range((n * (n - 1)) // 2))
-    pairs = combinations(range(n), 2)
-    edges = ((u, v) if r < 0.5 else (v, u) for (u, v), r in zip(pairs, coins))
-    return nx.DiGraph(edges)
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def score_sequence(G):
-    """Returns the score sequence for the given tournament graph.
-
-    The score sequence is the sorted list of the out-degrees of the
-    nodes of the graph.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    Returns
-    -------
-    list
-        A sorted list of the out-degrees of the nodes of `G`.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 0), (1, 3), (0, 2), (0, 3), (2, 1), (3, 2)])
-    >>> nx.is_tournament(G)
-    True
-    >>> nx.tournament.score_sequence(G)
-    [1, 1, 2, 2]
-
-    """
-    return sorted(d for v, d in G.out_degree())
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable(preserve_edge_attrs={"G": {"weight": 1}})
-def tournament_matrix(G):
-    r"""Returns the tournament matrix for the given tournament graph.
-
-    This function requires SciPy.
-
-    The *tournament matrix* of a tournament graph with edge set *E* is
-    the matrix *T* defined by
-
-    .. math::
-
-       T_{i j} =
-       \begin{cases}
-       +1 & \text{if } (i, j) \in E \\
-       -1 & \text{if } (j, i) \in E \\
-       0 & \text{if } i == j.
-       \end{cases}
-
-    An equivalent definition is `T = A - A^T`, where *A* is the
-    adjacency matrix of the graph `G`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    Returns
-    -------
-    SciPy sparse array
-        The tournament matrix of the tournament graph `G`.
-
-    Raises
-    ------
-    ImportError
-        If SciPy is not available.
-
-    """
-    A = nx.adjacency_matrix(G)
-    return A - A.T
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def is_reachable(G, s, t):
-    """Decides whether there is a path from `s` to `t` in the
-    tournament.
-
-    This function is more theoretically efficient than the reachability
-    checks than the shortest path algorithms in
-    :mod:`networkx.algorithms.shortest_paths`.
-
-    The given graph **must** be a tournament, otherwise this function's
-    behavior is undefined.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    s : node
-        A node in the graph.
-
-    t : node
-        A node in the graph.
-
-    Returns
-    -------
-    bool
-        Whether there is a path from `s` to `t` in `G`.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(1, 0), (1, 3), (1, 2), (2, 3), (2, 0), (3, 0)])
-    >>> nx.is_tournament(G)
-    True
-    >>> nx.tournament.is_reachable(G, 1, 3)
-    True
-    >>> nx.tournament.is_reachable(G, 3, 2)
-    False
-
-    Notes
-    -----
-    Although this function is more theoretically efficient than the
-    generic shortest path functions, a speedup requires the use of
-    parallelism. Though it may in the future, the current implementation
-    does not use parallelism, thus you may not see much of a speedup.
-
-    This algorithm comes from [1].
-
-    References
-    ----------
-    .. [1] Tantau, Till.
-           "A note on the complexity of the reachability problem for
-           tournaments."
-           *Electronic Colloquium on Computational Complexity*. 2001.
-           <http://eccc.hpi-web.de/report/2001/092/>
-    """
-
-    def two_neighborhood(G, v):
-        """Returns the set of nodes at distance at most two from `v`.
-
-        `G` must be a graph and `v` a node in that graph.
-
-        The returned set includes the nodes at distance zero (that is,
-        the node `v` itself), the nodes at distance one (that is, the
-        out-neighbors of `v`), and the nodes at distance two.
-
-        """
-        v_adj = G._adj[v]
-        return {
-            x
-            for x, x_pred in G._pred.items()
-            if x == v or x in v_adj or any(z in v_adj for z in x_pred)
-        }
-
-    def is_closed(G, S):
-        """Decides whether the given set of nodes is closed.
-
-        A set *S* of nodes is *closed* if for each node *u* in the graph
-        not in *S* and for each node *v* in *S*, there is an edge from
-        *u* to *v*.
-
-        """
-        return all(u in S or all(v in unbrs for v in S) for u, unbrs in G._adj.items())
-
-    neighborhoods = (two_neighborhood(G, v) for v in G)
-    return not any(s in S and t not in S and is_closed(G, S) for S in neighborhoods)
-
-
-@not_implemented_for("undirected")
-@not_implemented_for("multigraph")
-@nx._dispatchable(name="tournament_is_strongly_connected")
-def is_strongly_connected(G):
-    """Decides whether the given tournament is strongly connected.
-
-    This function is more theoretically efficient than the
-    :func:`~networkx.algorithms.components.is_strongly_connected`
-    function.
-
-    The given graph **must** be a tournament, otherwise this function's
-    behavior is undefined.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        A directed graph representing a tournament.
-
-    Returns
-    -------
-    bool
-        Whether the tournament is strongly connected.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph([(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 0)])
-    >>> nx.is_tournament(G)
-    True
-    >>> nx.tournament.is_strongly_connected(G)
-    True
-    >>> G.remove_edge(3, 0)
-    >>> G.add_edge(0, 3)
-    >>> nx.is_tournament(G)
-    True
-    >>> nx.tournament.is_strongly_connected(G)
-    False
-
-    Notes
-    -----
-    Although this function is more theoretically efficient than the
-    generic strong connectivity function, a speedup requires the use of
-    parallelism. Though it may in the future, the current implementation
-    does not use parallelism, thus you may not see much of a speedup.
-
-    This algorithm comes from [1].
-
-    References
-    ----------
-    .. [1] Tantau, Till.
-           "A note on the complexity of the reachability problem for
-           tournaments."
-           *Electronic Colloquium on Computational Complexity*. 2001.
-           <http://eccc.hpi-web.de/report/2001/092/>
-
-    """
-    return all(is_reachable(G, u, v) for u in G for v in G)

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

@@ -1,5 +0,0 @@
-from .beamsearch import *
-from .breadth_first_search import *
-from .depth_first_search import *
-from .edgedfs import *
-from .edgebfs import *

package/runtime/python/okstra_vendor/networkx/algorithms/traversal/beamsearch.py

@@ -1,90 +0,0 @@
-"""Basic algorithms for breadth-first searching the nodes of a graph."""
-
-import networkx as nx
-
-__all__ = ["bfs_beam_edges"]
-
-
-@nx._dispatchable
-def bfs_beam_edges(G, source, value, width=None):
-    """Iterates over edges in a beam search.
-
-    The beam search is a generalized breadth-first search in which only
-    the "best" *w* neighbors of the current node are enqueued, where *w*
-    is the beam width and "best" is an application-specific
-    heuristic. In general, a beam search with a small beam width might
-    not visit each node in the graph.
-
-    .. note::
-
-       With the default value of ``width=None`` or `width` greater than the
-       maximum degree of the graph, this function equates to a slower
-       version of `~networkx.algorithms.traversal.breadth_first_search.bfs_edges`.
-       All nodes will be visited, though the order of the reported edges may
-       vary. In such cases, `value` has no effect - consider using `bfs_edges`
-       directly instead.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    source : node
-        Starting node for the breadth-first search; this function
-        iterates over only those edges in the component reachable from
-        this node.
-
-    value : function
-        A function that takes a node of the graph as input and returns a
-        real number indicating how "good" it is. A higher value means it
-        is more likely to be visited sooner during the search. When
-        visiting a new node, only the `width` neighbors with the highest
-        `value` are enqueued (in decreasing order of `value`).
-
-    width : int (default = None)
-        The beam width for the search. This is the number of neighbors
-        (ordered by `value`) to enqueue when visiting each new node.
-
-    Yields
-    ------
-    edge
-        Edges in the beam search starting from `source`, given as a pair
-        of nodes.
-
-    Examples
-    --------
-    To give nodes with, for example, a higher centrality precedence
-    during the search, set the `value` function to return the centrality
-    value of the node:
-
-    >>> G = nx.karate_club_graph()
-    >>> centrality = nx.eigenvector_centrality(G)
-    >>> list(nx.bfs_beam_edges(G, source=0, value=centrality.get, width=3))
-    [(0, 2), (0, 1), (0, 8), (2, 32), (1, 13), (8, 33)]
-    """
-
-    if width is None:
-        width = len(G)
-
-    def successors(v):
-        """Returns a list of the best neighbors of a node.
-
-        `v` is a node in the graph `G`.
-
-        The "best" neighbors are chosen according to the `value`
-        function (higher is better). Only the `width` best neighbors of
-        `v` are returned.
-        """
-        # TODO The Python documentation states that for small values, it
-        # is better to use `heapq.nlargest`. We should determine the
-        # threshold at which its better to use `heapq.nlargest()`
-        # instead of `sorted()[:]` and apply that optimization here.
-        #
-        # If `width` is greater than the number of neighbors of `v`, all
-        # neighbors are returned by the semantics of slicing in
-        # Python. This occurs in the special case that the user did not
-        # specify a `width`: in this case all neighbors are always
-        # returned, so this is just a (slower) implementation of
-        # `bfs_edges(G, source)` but with a sorted enqueue step.
-        return iter(sorted(G.neighbors(v), key=value, reverse=True)[:width])
-
-    yield from nx.generic_bfs_edges(G, source, successors)