okstra 0.130.4 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/assortativity/pairs.py

@@ -1,127 +0,0 @@
-"""Generators of x-y pairs of node data."""
-
-import networkx as nx
-
-__all__ = ["node_attribute_xy", "node_degree_xy"]
-
-
-@nx._dispatchable(node_attrs="attribute")
-def node_attribute_xy(G, attribute, nodes=None):
-    """Yields 2-tuples of node attribute values for all edges in `G`.
-
-    This generator yields, for each edge in `G` incident to a node in `nodes`,
-    a 2-tuple of form ``(attribute value,  attribute value)`` for the parameter
-    specified node-attribute.
-
-    Parameters
-    ----------
-    G: NetworkX graph
-
-    attribute: key
-        The node attribute key.
-
-    nodes: list or iterable (optional)
-        Use only edges that are incident to specified nodes.
-        The default is all nodes.
-
-    Yields
-    ------
-    (x, y): 2-tuple
-        Generates 2-tuple of (attribute, attribute) values.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph()
-    >>> G.add_node(1, color="red")
-    >>> G.add_node(2, color="blue")
-    >>> G.add_node(3, color="green")
-    >>> G.add_edge(1, 2)
-    >>> list(nx.node_attribute_xy(G, "color"))
-    [('red', 'blue')]
-
-    Notes
-    -----
-    For undirected graphs, each edge is produced twice, once for each edge
-    representation (u, v) and (v, u), with the exception of self-loop edges
-    which only appear once.
-    """
-    if nodes is None:
-        nodes = set(G)
-    else:
-        nodes = set(nodes)
-    Gnodes = G.nodes
-    for u, nbrsdict in G.adjacency():
-        if u not in nodes:
-            continue
-        uattr = Gnodes[u].get(attribute, None)
-        if G.is_multigraph():
-            for v, keys in nbrsdict.items():
-                vattr = Gnodes[v].get(attribute, None)
-                for _ in keys:
-                    yield (uattr, vattr)
-        else:
-            for v in nbrsdict:
-                vattr = Gnodes[v].get(attribute, None)
-                yield (uattr, vattr)
-
-
-@nx._dispatchable(edge_attrs="weight")
-def node_degree_xy(G, x="out", y="in", weight=None, nodes=None):
-    """Yields 2-tuples of ``(degree, degree)`` values for edges in `G`.
-
-    This generator yields, for each edge in `G` incident to a node in `nodes`,
-    a 2-tuple of form ``(degree, degree)``. The node degrees are weighted
-    when a `weight` attribute is specified.
-
-    Parameters
-    ----------
-    G: NetworkX graph
-
-    x: string ('in','out')
-       The degree type for source node (directed graphs only).
-
-    y: string ('in','out')
-       The degree type for target node (directed graphs only).
-
-    weight: string or None, optional (default=None)
-       The edge attribute that holds the numerical value used
-       as a weight.  If None, then each edge has weight 1.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    nodes: list or iterable (optional)
-        Use only edges that are adjacency to specified nodes.
-        The default is all nodes.
-
-    Yields
-    ------
-    (x, y): 2-tuple
-        Generates 2-tuple of (degree, degree) values.
-
-    Examples
-    --------
-    >>> G = nx.DiGraph()
-    >>> G.add_edge(1, 2)
-    >>> list(nx.node_degree_xy(G, x="out", y="in"))
-    [(1, 1)]
-    >>> list(nx.node_degree_xy(G, x="in", y="out"))
-    [(0, 0)]
-
-    Notes
-    -----
-    For undirected graphs, each edge is produced twice, once for each edge
-    representation (u, v) and (v, u), with the exception of self-loop edges
-    which only appear once.
-    """
-    nodes = set(G) if nodes is None else set(nodes)
-    if G.is_directed():
-        direction = {"out": G.out_degree, "in": G.in_degree}
-        xdeg = direction[x]
-        ydeg = direction[y]
-    else:
-        xdeg = ydeg = G.degree
-
-    for u, degu in xdeg(nodes, weight=weight):
-        # use G.edges to treat multigraphs correctly
-        neighbors = (nbr for _, nbr in G.edges(u) if nbr in nodes)
-        for _, degv in ydeg(neighbors, weight=weight):
-            yield degu, degv

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

@@ -1,164 +0,0 @@
-"""
-Algorithms for asteroidal triples and asteroidal numbers in graphs.
-
-An asteroidal triple in a graph G is a set of three non-adjacent vertices
-u, v and w such that there exist a path between any two of them that avoids
-closed neighborhood of the third. More formally, v_j, v_k belongs to the same
-connected component of G - N[v_i], where N[v_i] denotes the closed neighborhood
-of v_i. A graph which does not contain any asteroidal triples is called
-an AT-free graph. The class of AT-free graphs is a graph class for which
-many NP-complete problems are solvable in polynomial time. Amongst them,
-independent set and coloring.
-"""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["is_at_free", "find_asteroidal_triple"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def find_asteroidal_triple(G):
-    r"""Find an asteroidal triple in the given graph.
-
-    An asteroidal triple is a triple of non-adjacent vertices such that
-    there exists a path between any two of them which avoids the closed
-    neighborhood of the third. It checks all independent triples of vertices
-    and whether they are an asteroidal triple or not. This is done with the
-    help of a data structure called a component structure.
-    A component structure encodes information about which vertices belongs to
-    the same connected component when the closed neighborhood of a given vertex
-    is removed from the graph. The algorithm used to check is the trivial
-    one, outlined in [1]_, which has a runtime of
-    :math:`O(|V||\overline{E} + |V||E|)`, where the second term is the
-    creation of the component structure.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        The graph to check whether is AT-free or not
-
-    Returns
-    -------
-    list or None
-        An asteroidal triple is returned as a list of nodes. If no asteroidal
-        triple exists, i.e. the graph is AT-free, then None is returned.
-
-    Notes
-    -----
-    The component structure and the algorithm is described in [1]_. The current
-    implementation implements the trivial algorithm for simple graphs.
-
-    References
-    ----------
-    .. [1] Ekkehard Köhler,
-       "Recognizing Graphs without asteroidal triples",
-       Journal of Discrete Algorithms 2, pages 439-452, 2004.
-       https://www.sciencedirect.com/science/article/pii/S157086670400019X
-    """
-    V = set(G.nodes)
-
-    if len(V) < 6:
-        # An asteroidal triple cannot exist in a graph with 5 or less vertices.
-        return None
-
-    component_structure = create_component_structure(G)
-
-    for u, v in nx.non_edges(G):
-        u_neighborhood = set(G[u]).union([u])
-        v_neighborhood = set(G[v]).union([v])
-        union_of_neighborhoods = u_neighborhood.union(v_neighborhood)
-        for w in V - union_of_neighborhoods:
-            # Check for each pair of vertices whether they belong to the
-            # same connected component when the closed neighborhood of the
-            # third is removed.
-            if (
-                component_structure[u][v] == component_structure[u][w]
-                and component_structure[v][u] == component_structure[v][w]
-                and component_structure[w][u] == component_structure[w][v]
-            ):
-                return [u, v, w]
-    return None
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def is_at_free(G):
-    """Check if a graph is AT-free.
-
-    The method uses the `find_asteroidal_triple` method to recognize
-    an AT-free graph. If no asteroidal triple is found the graph is
-    AT-free and True is returned. If at least one asteroidal triple is
-    found the graph is not AT-free and False is returned.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        The graph to check whether is AT-free or not.
-
-    Returns
-    -------
-    bool
-        True if G is AT-free and False otherwise.
-
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
-    >>> nx.is_at_free(G)
-    True
-
-    >>> G = nx.cycle_graph(6)
-    >>> nx.is_at_free(G)
-    False
-    """
-    return find_asteroidal_triple(G) is None
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def create_component_structure(G):
-    r"""Create component structure for G.
-
-    A *component structure* is an `nxn` array, denoted `c`, where `n` is
-    the number of vertices,  where each row and column corresponds to a vertex.
-
-    .. math::
-        c_{uv} = \begin{cases} 0, if v \in N[u] \\
-            k, if v \in component k of G \setminus N[u] \end{cases}
-
-    Where `k` is an arbitrary label for each component. The structure is used
-    to simplify the detection of asteroidal triples.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        Undirected, simple graph.
-
-    Returns
-    -------
-    component_structure : dictionary
-        A dictionary of dictionaries, keyed by pairs of vertices.
-
-    """
-    V = set(G.nodes)
-    component_structure = {}
-    for v in V:
-        label = 0
-        closed_neighborhood = set(G[v]).union({v})
-        row_dict = {}
-        for u in closed_neighborhood:
-            row_dict[u] = 0
-
-        G_reduced = G.subgraph(set(G.nodes) - closed_neighborhood)
-        for cc in nx.connected_components(G_reduced):
-            label += 1
-            for u in cc:
-                row_dict[u] = label
-
-        component_structure[v] = row_dict
-
-    return component_structure

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

@@ -1,88 +0,0 @@
-r"""This module provides functions and operations for bipartite
-graphs.  Bipartite graphs `B = (U, V, E)` have two node sets `U,V` and edges in
-`E` that only connect nodes from opposite sets. It is common in the literature
-to use an spatial analogy referring to the two node sets as top and bottom nodes.
-
-The bipartite algorithms are not imported into the networkx namespace
-at the top level so the easiest way to use them is with:
-
->>> from networkx.algorithms import bipartite
-
-NetworkX does not have a custom bipartite graph class but the Graph()
-or DiGraph() classes can be used to represent bipartite graphs. However,
-you have to keep track of which set each node belongs to, and make
-sure that there is no edge between nodes of the same set. The convention used
-in NetworkX is to use a node attribute named `bipartite` with values 0 or 1 to
-identify the sets each node belongs to. This convention is not enforced in
-the source code of bipartite functions, it's only a recommendation.
-
-For example:
-
->>> B = nx.Graph()
->>> # Add nodes with the node attribute "bipartite"
->>> B.add_nodes_from([1, 2, 3, 4], bipartite=0)
->>> B.add_nodes_from(["a", "b", "c"], bipartite=1)
->>> # Add edges only between nodes of opposite node sets
->>> B.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
-
-Many algorithms of the bipartite module of NetworkX require, as an argument, a
-container with all the nodes that belong to one set, in addition to the bipartite
-graph `B`. The functions in the bipartite package do not check that the node set
-is actually correct nor that the input graph is actually bipartite.
-If `B` is connected, you can find the two node sets using a two-coloring
-algorithm:
-
->>> nx.is_connected(B)
-True
->>> bottom_nodes, top_nodes = bipartite.sets(B)
-
-However, if the input graph is not connected, there are more than one possible
-colorations. This is the reason why we require the user to pass a container
-with all nodes of one bipartite node set as an argument to most bipartite
-functions. In the face of ambiguity, we refuse the temptation to guess and
-raise an :exc:`AmbiguousSolution <networkx.AmbiguousSolution>`
-Exception if the input graph for
-:func:`bipartite.sets <networkx.algorithms.bipartite.basic.sets>`
-is disconnected.
-
-Using the `bipartite` node attribute, you can easily get the two node sets:
-
->>> top_nodes = {n for n, d in B.nodes(data=True) if d["bipartite"] == 0}
->>> bottom_nodes = set(B) - top_nodes
-
-So you can easily use the bipartite algorithms that require, as an argument, a
-container with all nodes that belong to one node set:
-
->>> print(round(bipartite.density(B, bottom_nodes), 2))
-0.5
->>> G = bipartite.projected_graph(B, top_nodes)
-
-All bipartite graph generators in NetworkX build bipartite graphs with the
-`bipartite` node attribute. Thus, you can use the same approach:
-
->>> RB = bipartite.random_graph(5, 7, 0.2)
->>> RB_top = {n for n, d in RB.nodes(data=True) if d["bipartite"] == 0}
->>> RB_bottom = set(RB) - RB_top
->>> list(RB_top)
-[0, 1, 2, 3, 4]
->>> list(RB_bottom)
-[5, 6, 7, 8, 9, 10, 11]
-
-For other bipartite graph generators see
-:mod:`Generators <networkx.algorithms.bipartite.generators>`.
-
-"""
-
-from networkx.algorithms.bipartite.basic import *
-from networkx.algorithms.bipartite.centrality import *
-from networkx.algorithms.bipartite.cluster import *
-from networkx.algorithms.bipartite.covering import *
-from networkx.algorithms.bipartite.edgelist import *
-from networkx.algorithms.bipartite.matching import *
-from networkx.algorithms.bipartite.matrix import *
-from networkx.algorithms.bipartite.projection import *
-from networkx.algorithms.bipartite.redundancy import *
-from networkx.algorithms.bipartite.spectral import *
-from networkx.algorithms.bipartite.generators import *
-from networkx.algorithms.bipartite.extendability import *
-from networkx.algorithms.bipartite.link_analysis import *

package/runtime/python/okstra_vendor/networkx/algorithms/bipartite/basic.py

@@ -1,322 +0,0 @@
-"""
-==========================
-Bipartite Graph Algorithms
-==========================
-"""
-
-import networkx as nx
-from networkx.algorithms.components import connected_components
-from networkx.exception import AmbiguousSolution
-
-__all__ = [
-    "is_bipartite",
-    "is_bipartite_node_set",
-    "color",
-    "sets",
-    "density",
-    "degrees",
-]
-
-
-@nx._dispatchable
-def color(G):
-    """Returns a two-coloring of the graph.
-
-    Raises an exception if the graph is not bipartite.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    color : dictionary
-        A dictionary keyed by node with a 1 or 0 as data for each node color.
-
-    Raises
-    ------
-    NetworkXError
-        If the graph is not two-colorable.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> c = bipartite.color(G)
-    >>> print(c)
-    {0: 1, 1: 0, 2: 1, 3: 0}
-
-    You can use this to set a node attribute indicating the bipartite set:
-
-    >>> nx.set_node_attributes(G, c, "bipartite")
-    >>> print(G.nodes[0]["bipartite"])
-    1
-    >>> print(G.nodes[1]["bipartite"])
-    0
-    """
-    if G.is_directed():
-        import itertools
-
-        def neighbors(v):
-            return itertools.chain.from_iterable([G.predecessors(v), G.successors(v)])
-
-    else:
-        neighbors = G.neighbors
-
-    color = {}
-    for n in G:  # handle disconnected graphs
-        if n in color or len(G[n]) == 0:  # skip isolates
-            continue
-        queue = [n]
-        color[n] = 1  # nodes seen with color (1 or 0)
-        while queue:
-            v = queue.pop()
-            c = 1 - color[v]  # opposite color of node v
-            for w in neighbors(v):
-                if w in color:
-                    if color[w] == color[v]:
-                        raise nx.NetworkXError("Graph is not bipartite.")
-                else:
-                    color[w] = c
-                    queue.append(w)
-    # color isolates with 0
-    color.update(dict.fromkeys(nx.isolates(G), 0))
-    return color
-
-
-@nx._dispatchable
-def is_bipartite(G):
-    """Returns True if graph G is bipartite, False if not.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> print(bipartite.is_bipartite(G))
-    True
-
-    See Also
-    --------
-    color, is_bipartite_node_set
-    """
-    try:
-        color(G)
-        return True
-    except nx.NetworkXError:
-        return False
-
-
-@nx._dispatchable
-def is_bipartite_node_set(G, nodes):
-    """Returns True if nodes and G/nodes are a bipartition of G.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    nodes: list or container
-      Check if nodes are a one of a bipartite set.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> X = set([1, 3])
-    >>> bipartite.is_bipartite_node_set(G, X)
-    True
-
-    Notes
-    -----
-    An exception is raised if the input nodes are not distinct, because in this
-    case some bipartite algorithms will yield incorrect results.
-    For connected graphs the bipartite sets are unique.  This function handles
-    disconnected graphs.
-    """
-    S = set(nodes)
-
-    if len(S) < len(nodes):
-        # this should maybe just return False?
-        raise AmbiguousSolution(
-            "The input node set contains duplicates.\n"
-            "This may lead to incorrect results when using it in bipartite algorithms.\n"
-            "Consider using set(nodes) as the input"
-        )
-
-    for CC in (G.subgraph(c).copy() for c in connected_components(G)):
-        X, Y = sets(CC)
-        if not (
-            (X.issubset(S) and Y.isdisjoint(S)) or (Y.issubset(S) and X.isdisjoint(S))
-        ):
-            return False
-    return True
-
-
-@nx._dispatchable
-def sets(G, top_nodes=None):
-    """Returns bipartite node sets of graph G.
-
-    Raises an exception if the graph is not bipartite or if the input
-    graph is disconnected and thus more than one valid solution exists.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    top_nodes : container, optional
-      Container with all nodes in one bipartite node set. If not supplied
-      it will be computed. But if more than one solution exists an exception
-      will be raised.
-
-    Returns
-    -------
-    X : set
-      Nodes from one side of the bipartite graph.
-    Y : set
-      Nodes from the other side.
-
-    Raises
-    ------
-    AmbiguousSolution
-      Raised if the input bipartite graph is disconnected and no container
-      with all nodes in one bipartite set is provided. When determining
-      the nodes in each bipartite set more than one valid solution is
-      possible if the input graph is disconnected.
-    NetworkXError
-      Raised if the input graph is not bipartite.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> X, Y = bipartite.sets(G)
-    >>> list(X)
-    [0, 2]
-    >>> list(Y)
-    [1, 3]
-
-    See Also
-    --------
-    color
-
-    """
-    if G.is_directed():
-        is_connected = nx.is_weakly_connected
-    else:
-        is_connected = nx.is_connected
-    if top_nodes is not None:
-        X = set(top_nodes)
-        Y = set(G) - X
-    else:
-        if not is_connected(G):
-            msg = "Disconnected graph: Ambiguous solution for bipartite sets."
-            raise nx.AmbiguousSolution(msg)
-        c = color(G)
-        X = {n for n, is_top in c.items() if is_top}
-        Y = {n for n, is_top in c.items() if not is_top}
-    return (X, Y)
-
-
-@nx._dispatchable(graphs="B")
-def density(B, nodes):
-    """Returns density of bipartite graph B.
-
-    Parameters
-    ----------
-    B : NetworkX graph
-
-    nodes: list or container
-      Nodes in one node set of the bipartite graph.
-
-    Returns
-    -------
-    d : float
-       The bipartite density
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.complete_bipartite_graph(3, 2)
-    >>> X = set([0, 1, 2])
-    >>> bipartite.density(G, X)
-    1.0
-    >>> Y = set([3, 4])
-    >>> bipartite.density(G, Y)
-    1.0
-
-    Notes
-    -----
-    The container of nodes passed as argument must contain all nodes
-    in one of the two bipartite node sets to avoid ambiguity in the
-    case of disconnected graphs.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-    See Also
-    --------
-    color
-    """
-    n = len(B)
-    m = nx.number_of_edges(B)
-    nb = len(nodes)
-    nt = n - nb
-    if m == 0:  # includes cases n==0 and n==1
-        d = 0.0
-    else:
-        if B.is_directed():
-            d = m / (2 * nb * nt)
-        else:
-            d = m / (nb * nt)
-    return d
-
-
-@nx._dispatchable(graphs="B", edge_attrs="weight")
-def degrees(B, nodes, weight=None):
-    """Returns the degrees of the two node sets in the bipartite graph B.
-
-    Parameters
-    ----------
-    B : NetworkX graph
-
-    nodes: list or container
-      Nodes in one node set of the bipartite graph.
-
-    weight : string or None, optional (default=None)
-       The edge attribute that holds the numerical value used as a weight.
-       If None, then each edge has weight 1.
-       The degree is the sum of the edge weights adjacent to the node.
-
-    Returns
-    -------
-    (degX,degY) : tuple of dictionaries
-       The degrees of the two bipartite sets as dictionaries keyed by node.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.complete_bipartite_graph(3, 2)
-    >>> Y = set([3, 4])
-    >>> degX, degY = bipartite.degrees(G, Y)
-    >>> dict(degX)
-    {0: 2, 1: 2, 2: 2}
-
-    Notes
-    -----
-    The container of nodes passed as argument must contain all nodes
-    in one of the two bipartite node sets to avoid ambiguity in the
-    case of disconnected graphs.
-    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
-    for further details on how bipartite graphs are handled in NetworkX.
-
-    See Also
-    --------
-    color, density
-    """
-    bottom = set(nodes)
-    top = set(B) - bottom
-    return (B.degree(top, weight), B.degree(bottom, weight))