okstra 0.108.0 → 0.109.0

package/runtime/python/okstra_vendor/networkx/utils/random_sequence.py

@@ -0,0 +1,198 @@
+"""
+Utilities for generating random numbers, random sequences, and
+random selections.
+"""
+
+import networkx as nx
+from networkx.utils import py_random_state
+
+__all__ = [
+    "powerlaw_sequence",
+    "is_valid_tree_degree_sequence",
+    "zipf_rv",
+    "cumulative_distribution",
+    "discrete_sequence",
+    "random_weighted_sample",
+    "weighted_choice",
+]
+
+
+# The same helpers for choosing random sequences from distributions
+# uses Python's random module
+# https://docs.python.org/3/library/random.html
+
+
+@py_random_state(2)
+def powerlaw_sequence(n, exponent=2.0, seed=None):
+    """
+    Return sample sequence of length n from a power law distribution.
+    """
+    return [seed.paretovariate(exponent - 1) for i in range(n)]
+
+
+def is_valid_tree_degree_sequence(degree_sequence):
+    """Check if a degree sequence is valid for a tree.
+
+    Two conditions must be met for a degree sequence to be valid for a tree:
+
+    1. The number of nodes must be one more than the number of edges.
+    2. The degree sequence must be trivial or have only strictly positive
+       node degrees.
+
+    Parameters
+    ----------
+    degree_sequence : iterable
+        Iterable of node degrees.
+
+    Returns
+    -------
+    bool
+        Whether the degree sequence is valid for a tree.
+    str
+        Reason for invalidity, or dummy string if valid.
+    """
+    seq = list(degree_sequence)
+    number_of_nodes = len(seq)
+    twice_number_of_edges = sum(seq)
+
+    if 2 * number_of_nodes - twice_number_of_edges != 2:
+        return False, "tree must have one more node than number of edges"
+    elif seq != [0] and any(d <= 0 for d in seq):
+        return False, "nontrivial tree must have strictly positive node degrees"
+    return True, ""
+
+
+@py_random_state(2)
+def zipf_rv(alpha, xmin=1, seed=None):
+    r"""Returns a random value chosen from the Zipf distribution.
+
+    The return value is an integer drawn from the probability distribution
+
+    .. math::
+
+        p(x)=\frac{x^{-\alpha}}{\zeta(\alpha, x_{\min})},
+
+    where $\zeta(\alpha, x_{\min})$ is the Hurwitz zeta function.
+
+    Parameters
+    ----------
+    alpha : float
+      Exponent value of the distribution
+    xmin : int
+      Minimum value
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    Returns
+    -------
+    x : int
+      Random value from Zipf distribution
+
+    Raises
+    ------
+    ValueError:
+      If xmin < 1 or
+      If alpha <= 1
+
+    Notes
+    -----
+    The rejection algorithm generates random values for a the power-law
+    distribution in uniformly bounded expected time dependent on
+    parameters.  See [1]_ for details on its operation.
+
+    Examples
+    --------
+    >>> nx.utils.zipf_rv(alpha=2, xmin=3, seed=42)
+    8
+
+    References
+    ----------
+    .. [1] Luc Devroye, Non-Uniform Random Variate Generation,
+       Springer-Verlag, New York, 1986.
+    """
+    if xmin < 1:
+        raise ValueError("xmin < 1")
+    if alpha <= 1:
+        raise ValueError("a <= 1.0")
+    a1 = alpha - 1.0
+    b = 2**a1
+    while True:
+        u = 1.0 - seed.random()  # u in (0,1]
+        v = seed.random()  # v in [0,1)
+        x = int(xmin * u ** -(1.0 / a1))
+        t = (1.0 + (1.0 / x)) ** a1
+        if v * x * (t - 1.0) / (b - 1.0) <= t / b:
+            break
+    return x
+
+
+def cumulative_distribution(distribution):
+    """Returns normalized cumulative distribution from discrete distribution."""
+
+    cdf = [0.0]
+    cumulative = 0.0
+    for element in distribution:
+        cumulative += element
+        cdf.append(cumulative)
+    return [element / cumulative for element in cdf]
+
+
+@py_random_state(3)
+def discrete_sequence(n, distribution=None, cdistribution=None, seed=None):
+    """
+    Return sample sequence of length n from a given discrete distribution
+    or discrete cumulative distribution.
+
+    One of the following must be specified.
+
+    distribution = histogram of values, will be normalized
+
+    cdistribution = normalized discrete cumulative distribution
+
+    """
+    import bisect
+
+    if cdistribution is not None:
+        cdf = cdistribution
+    elif distribution is not None:
+        cdf = cumulative_distribution(distribution)
+    else:
+        raise nx.NetworkXError(
+            "discrete_sequence: distribution or cdistribution missing"
+        )
+
+    # get a uniform random number
+    inputseq = [seed.random() for i in range(n)]
+
+    # choose from CDF
+    seq = [bisect.bisect_left(cdf, s) - 1 for s in inputseq]
+    return seq
+
+
+@py_random_state(2)
+def random_weighted_sample(mapping, k, seed=None):
+    """Returns k items without replacement from a weighted sample.
+
+    The input is a dictionary of items with weights as values.
+    """
+    if k > len(mapping):
+        raise ValueError("sample larger than population")
+    sample = set()
+    while len(sample) < k:
+        sample.add(weighted_choice(mapping, seed))
+    return list(sample)
+
+
+@py_random_state(1)
+def weighted_choice(mapping, seed=None):
+    """Returns a single element from a weighted sample.
+
+    The input is a dictionary of items with weights as values.
+    """
+    # use roulette method
+    rnd = seed.random() * sum(mapping.values())
+    for k, w in mapping.items():
+        rnd -= w
+        if rnd < 0:
+            return k

package/runtime/python/okstra_vendor/networkx/utils/rcm.py

@@ -0,0 +1,159 @@
+"""
+Cuthill-McKee ordering of graph nodes to produce sparse matrices
+"""
+
+from collections import deque
+from operator import itemgetter
+
+import networkx as nx
+
+from ..utils import arbitrary_element
+
+__all__ = ["cuthill_mckee_ordering", "reverse_cuthill_mckee_ordering"]
+
+
+def cuthill_mckee_ordering(G, heuristic=None):
+    """Generate an ordering (permutation) of the graph nodes to make
+    a sparse matrix.
+
+    Uses the Cuthill-McKee heuristic (based on breadth-first search) [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    heuristic : function, optional
+      Function to choose starting node for RCM algorithm.  If None
+      a node from a pseudo-peripheral pair is used.  A user-defined function
+      can be supplied that takes a graph object and returns a single node.
+
+    Returns
+    -------
+    nodes : generator
+       Generator of nodes in Cuthill-McKee ordering.
+
+    Examples
+    --------
+    >>> from networkx.utils import cuthill_mckee_ordering
+    >>> G = nx.path_graph(4)
+    >>> rcm = list(cuthill_mckee_ordering(G))
+    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
+
+    Smallest degree node as heuristic function:
+
+    >>> def smallest_degree(G):
+    ...     return min(G, key=G.degree)
+    >>> rcm = list(cuthill_mckee_ordering(G, heuristic=smallest_degree))
+
+
+    See Also
+    --------
+    reverse_cuthill_mckee_ordering
+
+    Notes
+    -----
+    The optimal solution the bandwidth reduction is NP-complete [2]_.
+
+
+    References
+    ----------
+    .. [1] E. Cuthill and J. McKee.
+       Reducing the bandwidth of sparse symmetric matrices,
+       In Proc. 24th Nat. Conf. ACM, pages 157-172, 1969.
+       http://doi.acm.org/10.1145/800195.805928
+    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
+       Springer-Verlag New York, Inc., New York, NY, USA.
+    """
+    for c in nx.connected_components(G):
+        yield from connected_cuthill_mckee_ordering(G.subgraph(c), heuristic)
+
+
+def reverse_cuthill_mckee_ordering(G, heuristic=None):
+    """Generate an ordering (permutation) of the graph nodes to make
+    a sparse matrix.
+
+    Uses the reverse Cuthill-McKee heuristic (based on breadth-first search)
+    [1]_.
+
+    Parameters
+    ----------
+    G : graph
+      A NetworkX graph
+
+    heuristic : function, optional
+      Function to choose starting node for RCM algorithm.  If None
+      a node from a pseudo-peripheral pair is used.  A user-defined function
+      can be supplied that takes a graph object and returns a single node.
+
+    Returns
+    -------
+    nodes : generator
+       Generator of nodes in reverse Cuthill-McKee ordering.
+
+    Examples
+    --------
+    >>> from networkx.utils import reverse_cuthill_mckee_ordering
+    >>> G = nx.path_graph(4)
+    >>> rcm = list(reverse_cuthill_mckee_ordering(G))
+    >>> A = nx.adjacency_matrix(G, nodelist=rcm)
+
+    Smallest degree node as heuristic function:
+
+    >>> def smallest_degree(G):
+    ...     return min(G, key=G.degree)
+    >>> rcm = list(reverse_cuthill_mckee_ordering(G, heuristic=smallest_degree))
+
+
+    See Also
+    --------
+    cuthill_mckee_ordering
+
+    Notes
+    -----
+    The optimal solution the bandwidth reduction is NP-complete [2]_.
+
+    References
+    ----------
+    .. [1] E. Cuthill and J. McKee.
+       Reducing the bandwidth of sparse symmetric matrices,
+       In Proc. 24th Nat. Conf. ACM, pages 157-72, 1969.
+       http://doi.acm.org/10.1145/800195.805928
+    .. [2]  Steven S. Skiena. 1997. The Algorithm Design Manual.
+       Springer-Verlag New York, Inc., New York, NY, USA.
+    """
+    return reversed(list(cuthill_mckee_ordering(G, heuristic=heuristic)))
+
+
+def connected_cuthill_mckee_ordering(G, heuristic=None):
+    # the cuthill mckee algorithm for connected graphs
+    if heuristic is None:
+        start = pseudo_peripheral_node(G)
+    else:
+        start = heuristic(G)
+    visited = {start}
+    queue = deque([start])
+    while queue:
+        parent = queue.popleft()
+        yield parent
+        nd = sorted(G.degree(set(G[parent]) - visited), key=itemgetter(1))
+        children = [n for n, d in nd]
+        visited.update(children)
+        queue.extend(children)
+
+
+def pseudo_peripheral_node(G):
+    # helper for cuthill-mckee to find a node in a "pseudo peripheral pair"
+    # to use as good starting node
+    u = arbitrary_element(G)
+    lp = 0
+    v = u
+    while True:
+        spl = nx.shortest_path_length(G, v)
+        l = max(spl.values())
+        if l <= lp:
+            break
+        lp = l
+        farthest = (n for n, dist in spl.items() if dist == l)
+        v, deg = min(G.degree(farthest), key=itemgetter(1))
+    return v

package/runtime/python/okstra_vendor/networkx/utils/tests/test__init.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+def test_utils_namespace():
+    """Ensure objects are not unintentionally exposed in utils namespace."""
+    with pytest.raises(ImportError):
+        from networkx.utils import nx
+    with pytest.raises(ImportError):
+        from networkx.utils import sys
+    with pytest.raises(ImportError):
+        from networkx.utils import defaultdict, deque

package/runtime/python/okstra_vendor/networkx/utils/tests/test_backends.py

@@ -0,0 +1,225 @@
+import pickle
+
+import pytest
+
+import networkx as nx
+
+sp = pytest.importorskip("scipy")
+pytest.importorskip("numpy")
+
+
+@nx._dispatchable(implemented_by_nx=False)
+def _stub_func(G):
+    raise NotImplementedError("_stub_func is a stub")
+
+
+def test_dispatch_kwds_vs_args():
+    G = nx.path_graph(4)
+    nx.pagerank(G)
+    nx.pagerank(G=G)
+    with pytest.raises(TypeError):
+        nx.pagerank()
+
+
+def test_pickle():
+    count = 0
+    for name, func in nx.utils.backends._registered_algorithms.items():
+        pickled = pickle.dumps(func.__wrapped__)
+        assert pickle.loads(pickled) is func.__wrapped__
+        try:
+            # Some functions can't be pickled, but it's not b/c of _dispatchable
+            pickled = pickle.dumps(func)
+        except pickle.PicklingError:
+            continue
+        assert pickle.loads(pickled) is func
+        count += 1
+    assert count > 0
+    assert pickle.loads(pickle.dumps(nx.inverse_line_graph)) is nx.inverse_line_graph
+
+
+@pytest.mark.skipif(
+    "not nx.config.backend_priority.algos "
+    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
+)
+def test_graph_converter_needs_backend():
+    # When testing, `nx.from_scipy_sparse_array` will *always* call the backend
+    # implementation if it's implemented. If `backend=` isn't given, then the result
+    # will be converted back to NetworkX via `convert_to_nx`.
+    # If not testing, then calling `nx.from_scipy_sparse_array` w/o `backend=` will
+    # always call the original version. `backend=` is *required* to call the backend.
+    from networkx.classes.tests.dispatch_interface import (
+        LoopbackBackendInterface,
+        LoopbackGraph,
+    )
+
+    A = sp.sparse.coo_array([[0, 3, 2], [3, 0, 1], [2, 1, 0]])
+
+    side_effects = []
+
+    def from_scipy_sparse_array(self, *args, **kwargs):
+        side_effects.append(1)  # Just to prove this was called
+        return self.convert_from_nx(
+            self.__getattr__("from_scipy_sparse_array")(*args, **kwargs),
+            preserve_edge_attrs=True,
+            preserve_node_attrs=True,
+            preserve_graph_attrs=True,
+        )
+
+    @staticmethod
+    def convert_to_nx(obj, *, name=None):
+        if type(obj) is nx.Graph:
+            return obj
+        return nx.Graph(obj)
+
+    # *This mutates LoopbackBackendInterface!*
+    orig_convert_to_nx = LoopbackBackendInterface.convert_to_nx
+    LoopbackBackendInterface.convert_to_nx = convert_to_nx
+    LoopbackBackendInterface.from_scipy_sparse_array = from_scipy_sparse_array
+
+    try:
+        assert side_effects == []
+        assert type(nx.from_scipy_sparse_array(A)) is nx.Graph
+        assert side_effects == [1]
+        assert (
+            type(nx.from_scipy_sparse_array(A, backend="nx_loopback")) is LoopbackGraph
+        )
+        assert side_effects == [1, 1]
+        # backend="networkx" is default implementation
+        assert type(nx.from_scipy_sparse_array(A, backend="networkx")) is nx.Graph
+        assert side_effects == [1, 1]
+    finally:
+        LoopbackBackendInterface.convert_to_nx = staticmethod(orig_convert_to_nx)
+        del LoopbackBackendInterface.from_scipy_sparse_array
+    with pytest.raises(ImportError, match="backend is not installed"):
+        nx.from_scipy_sparse_array(A, backend="bad-backend-name")
+
+
+@pytest.mark.skipif(
+    "not nx.config.backend_priority.algos "
+    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
+)
+def test_networkx_backend():
+    """Test using `backend="networkx"` in a dispatchable function."""
+    # (Implementing this test is harder than it should be)
+    from networkx.classes.tests.dispatch_interface import (
+        LoopbackBackendInterface,
+        LoopbackGraph,
+    )
+
+    G = LoopbackGraph()
+    G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4)])
+
+    @staticmethod
+    def convert_to_nx(obj, *, name=None):
+        if isinstance(obj, LoopbackGraph):
+            new_graph = nx.Graph()
+            new_graph.__dict__.update(obj.__dict__)
+            return new_graph
+        return obj
+
+    # *This mutates LoopbackBackendInterface!*
+    # This uses the same trick as in the previous test.
+    orig_convert_to_nx = LoopbackBackendInterface.convert_to_nx
+    LoopbackBackendInterface.convert_to_nx = convert_to_nx
+    try:
+        G2 = nx.ego_graph(G, 0, backend="networkx")
+        assert type(G2) is nx.Graph
+    finally:
+        LoopbackBackendInterface.convert_to_nx = staticmethod(orig_convert_to_nx)
+
+
+def test_dispatchable_are_functions():
+    assert type(nx.pagerank) is type(nx.pagerank.orig_func)
+
+
+@pytest.mark.skipif("not nx.utils.backends.backends")
+def test_mixing_backend_graphs():
+    from networkx.classes.tests import dispatch_interface
+
+    G = nx.Graph()
+    G.add_edge(1, 2)
+    G.add_edge(2, 3)
+    H = nx.Graph()
+    H.add_edge(2, 3)
+    rv = nx.intersection(G, H)
+    assert set(nx.intersection(G, H)) == {2, 3}
+    G2 = dispatch_interface.convert(G)
+    H2 = dispatch_interface.convert(H)
+    if "nx_loopback" in nx.config.backend_priority:
+        # Auto-convert
+        assert set(nx.intersection(G2, H)) == {2, 3}
+        assert set(nx.intersection(G, H2)) == {2, 3}
+    elif not nx.config.backend_priority and "nx_loopback" not in nx.config.backends:
+        # G2 and H2 are backend objects for a backend that is not registered!
+        with pytest.raises(ImportError, match="backend is not installed"):
+            nx.intersection(G2, H)
+        with pytest.raises(ImportError, match="backend is not installed"):
+            nx.intersection(G, H2)
+    # It would be nice to test passing graphs from *different* backends,
+    # but we are not set up to do this yet.
+
+
+def test_bad_backend_name():
+    """Using `backend=` raises with unknown backend even if there are no backends."""
+    with pytest.raises(
+        ImportError, match="'this_backend_does_not_exist' backend is not installed"
+    ):
+        nx.null_graph(backend="this_backend_does_not_exist")
+
+
+def test_not_implemented_by_nx():
+    assert "networkx" in nx.pagerank.backends
+    assert "networkx" not in _stub_func.backends
+
+    if "nx_loopback" in nx.config.backends:
+        from networkx.classes.tests.dispatch_interface import LoopbackBackendInterface
+
+        def stub_func_implementation(G):
+            return True
+
+        LoopbackBackendInterface._stub_func = staticmethod(stub_func_implementation)
+        try:
+            assert _stub_func(nx.Graph()) is True
+        finally:
+            del LoopbackBackendInterface._stub_func
+
+    with pytest.raises(NotImplementedError):
+        _stub_func(nx.Graph())
+
+
+@pytest.mark.skipif(
+    "not nx.config.backend_priority.algos "
+    "or nx.config.backend_priority.algos[0] != 'nx_loopback'"
+)
+def test_dispatch_graph_new():
+    from networkx.classes.tests.dispatch_interface import LoopbackGraph
+
+    G = nx.Graph()
+    assert not isinstance(G, LoopbackGraph)
+
+    # `backend=` argument that gets passed to __init__ is ignored.
+    # Best practice is that it should not be in the `.graph` dict.
+    G = nx.Graph(backend="networkx")
+    assert type(G) is nx.Graph
+    assert "backend" not in G.graph
+
+    G = nx.Graph(backend="nx_loopback")
+    assert isinstance(G, LoopbackGraph)
+    assert "backend" not in G.graph
+
+    # Args are passed
+    G1 = nx.Graph([(0, 1), (1, 2)])
+    assert not isinstance(G1, LoopbackGraph)
+    G2 = nx.Graph([(0, 1), (1, 2)], backend="nx_loopback")
+    assert isinstance(G2, LoopbackGraph)
+    assert nx.utils.misc.graphs_equal(G1, G2)
+
+    # Test config for automatic usage
+    with nx.config.backend_priority(classes=["nx_loopback"]):
+        G = nx.Graph()
+        assert isinstance(G, LoopbackGraph)
+        # LoopbackDiGraph __new__ is not implemented
+        G = nx.DiGraph()
+        assert not isinstance(G, LoopbackGraph)
+    G = nx.Graph()
+    assert not isinstance(G, LoopbackGraph)