okstra 0.130.3 → 0.131.0

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

@@ -1,196 +0,0 @@
-"""
-Provides functions for finding and testing for locally `(k, l)`-connected
-graphs.
-
-"""
-
-import copy
-
-import networkx as nx
-
-__all__ = ["kl_connected_subgraph", "is_kl_connected"]
-
-
-@nx._dispatchable(returns_graph=True)
-def kl_connected_subgraph(G, k, l, low_memory=False, same_as_graph=False):
-    """Returns the maximum locally `(k, l)`-connected subgraph of `G`.
-
-    A graph is locally `(k, l)`-connected if for each edge `(u, v)` in the
-    graph there are at least `l` edge-disjoint paths of length at most `k`
-    joining `u` to `v`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The graph in which to find a maximum locally `(k, l)`-connected
-        subgraph.
-
-    k : integer
-        The maximum length of paths to consider. A higher number means a looser
-        connectivity requirement.
-
-    l : integer
-        The number of edge-disjoint paths. A higher number means a stricter
-        connectivity requirement.
-
-    low_memory : bool
-        If this is True, this function uses an algorithm that uses slightly
-        more time but less memory.
-
-    same_as_graph : bool
-        If True then return a tuple of the form `(H, is_same)`,
-        where `H` is the maximum locally `(k, l)`-connected subgraph and
-        `is_same` is a Boolean representing whether `G` is locally `(k,
-        l)`-connected (and hence, whether `H` is simply a copy of the input
-        graph `G`).
-
-    Returns
-    -------
-    NetworkX graph or two-tuple
-        If `same_as_graph` is True, then this function returns a
-        two-tuple as described above. Otherwise, it returns only the maximum
-        locally `(k, l)`-connected subgraph.
-
-    See also
-    --------
-    is_kl_connected
-
-    References
-    ----------
-    .. [1] Chung, Fan and Linyuan Lu. "The Small World Phenomenon in Hybrid
-           Power Law Graphs." *Complex Networks*. Springer Berlin Heidelberg,
-           2004. 89--104.
-
-    """
-    H = copy.deepcopy(G)  # subgraph we construct by removing from G
-
-    graphOK = True
-    deleted_some = True  # hack to start off the while loop
-    while deleted_some:
-        deleted_some = False
-        # We use `for edge in list(H.edges()):` instead of
-        # `for edge in H.edges():` because we edit the graph `H` in
-        # the loop. Hence using an iterator will result in
-        # `RuntimeError: dictionary changed size during iteration`
-        for edge in list(H.edges()):
-            (u, v) = edge
-            # Get copy of graph needed for this search
-            if low_memory:
-                verts = {u, v}
-                for i in range(k):
-                    for w in verts.copy():
-                        verts.update(G[w])
-                G2 = G.subgraph(verts).copy()
-            else:
-                G2 = copy.deepcopy(G)
-            ###
-            path = [u, v]
-            cnt = 0
-            accept = 0
-            while path:
-                cnt += 1  # Found a path
-                if cnt >= l:
-                    accept = 1
-                    break
-                # record edges along this graph
-                prev = u
-                for w in path:
-                    if prev != w:
-                        G2.remove_edge(prev, w)
-                        prev = w
-                #                path = shortest_path(G2, u, v, k) # ??? should "Cutoff" be k+1?
-                try:
-                    path = nx.shortest_path(G2, u, v)  # ??? should "Cutoff" be k+1?
-                except nx.NetworkXNoPath:
-                    path = False
-            # No Other Paths
-            if accept == 0:
-                H.remove_edge(u, v)
-                deleted_some = True
-                if graphOK:
-                    graphOK = False
-    # We looked through all edges and removed none of them.
-    # So, H is the maximal (k,l)-connected subgraph of G
-    if same_as_graph:
-        return (H, graphOK)
-    return H
-
-
-@nx._dispatchable
-def is_kl_connected(G, k, l, low_memory=False):
-    """Returns True if and only if `G` is locally `(k, l)`-connected.
-
-    A graph is locally `(k, l)`-connected if for each edge `(u, v)` in the
-    graph there are at least `l` edge-disjoint paths of length at most `k`
-    joining `u` to `v`.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        The graph to test for local `(k, l)`-connectedness.
-
-    k : integer
-        The maximum length of paths to consider. A higher number means a looser
-        connectivity requirement.
-
-    l : integer
-        The number of edge-disjoint paths. A higher number means a stricter
-        connectivity requirement.
-
-    low_memory : bool
-        If this is True, this function uses an algorithm that uses slightly
-        more time but less memory.
-
-    Returns
-    -------
-    bool
-        Whether the graph is locally `(k, l)`-connected subgraph.
-
-    See also
-    --------
-    kl_connected_subgraph
-
-    References
-    ----------
-    .. [1] Chung, Fan and Linyuan Lu. "The Small World Phenomenon in Hybrid
-           Power Law Graphs." *Complex Networks*. Springer Berlin Heidelberg,
-           2004. 89--104.
-
-    """
-    graphOK = True
-    for edge in G.edges():
-        (u, v) = edge
-        # Get copy of graph needed for this search
-        if low_memory:
-            verts = {u, v}
-            for i in range(k):
-                [verts.update(G.neighbors(w)) for w in verts.copy()]
-            G2 = G.subgraph(verts)
-        else:
-            G2 = copy.deepcopy(G)
-        ###
-        path = [u, v]
-        cnt = 0
-        accept = 0
-        while path:
-            cnt += 1  # Found a path
-            if cnt >= l:
-                accept = 1
-                break
-            # record edges along this graph
-            prev = u
-            for w in path:
-                if w != prev:
-                    G2.remove_edge(prev, w)
-                    prev = w
-            #            path = shortest_path(G2, u, v, k) # ??? should "Cutoff" be k+1?
-            try:
-                path = nx.shortest_path(G2, u, v)  # ??? should "Cutoff" be k+1?
-            except nx.NetworkXNoPath:
-                path = False
-        # No Other Paths
-        if accept == 0:
-            graphOK = False
-            break
-    # return status
-    return graphOK

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

@@ -1,107 +0,0 @@
-"""
-Functions for identifying isolate (degree zero) nodes.
-"""
-
-import networkx as nx
-
-__all__ = ["is_isolate", "isolates", "number_of_isolates"]
-
-
-@nx._dispatchable
-def is_isolate(G, n):
-    """Determines whether a node is an isolate.
-
-    An *isolate* is a node with no neighbors (that is, with degree
-    zero). For directed graphs, this means no in-neighbors and no
-    out-neighbors.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    n : node
-        A node in `G`.
-
-    Returns
-    -------
-    is_isolate : bool
-       True if and only if `n` has no neighbors.
-
-    Examples
-    --------
-    >>> G = nx.Graph()
-    >>> G.add_edge(1, 2)
-    >>> G.add_node(3)
-    >>> nx.is_isolate(G, 2)
-    False
-    >>> nx.is_isolate(G, 3)
-    True
-    """
-    return G.degree(n) == 0
-
-
-@nx._dispatchable
-def isolates(G):
-    """Iterator over isolates in the graph.
-
-    An *isolate* is a node with no neighbors (that is, with degree
-    zero). For directed graphs, this means no in-neighbors and no
-    out-neighbors.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    iterator
-        An iterator over the isolates of `G`.
-
-    Examples
-    --------
-    To get a list of all isolates of a graph, use the :class:`list`
-    constructor:
-
-    >>> G = nx.Graph()
-    >>> G.add_edge(1, 2)
-    >>> G.add_node(3)
-    >>> list(nx.isolates(G))
-    [3]
-
-    To remove all isolates in the graph, first create a list of the
-    isolates, then use :meth:`Graph.remove_nodes_from`:
-
-    >>> G.remove_nodes_from(list(nx.isolates(G)))
-    >>> list(G)
-    [1, 2]
-
-    For digraphs, isolates have zero in-degree and zero out_degree:
-
-    >>> G = nx.DiGraph([(0, 1), (1, 2)])
-    >>> G.add_node(3)
-    >>> list(nx.isolates(G))
-    [3]
-
-    """
-    return (n for n, d in G.degree() if d == 0)
-
-
-@nx._dispatchable
-def number_of_isolates(G):
-    """Returns the number of isolates in the graph.
-
-    An *isolate* is a node with no neighbors (that is, with degree
-    zero). For directed graphs, this means no in-neighbors and no
-    out-neighbors.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    int
-        The number of degree zero nodes in the graph `G`.
-
-    """
-    return sum(1 for v in isolates(G))

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

@@ -1,7 +0,0 @@
-from networkx.algorithms.isomorphism.isomorph import *
-from networkx.algorithms.isomorphism.vf2userfunc import *
-from networkx.algorithms.isomorphism.matchhelpers import *
-from networkx.algorithms.isomorphism.temporalisomorphvf2 import *
-from networkx.algorithms.isomorphism.ismags import *
-from networkx.algorithms.isomorphism.tree_isomorphism import *
-from networkx.algorithms.isomorphism.vf2pp import *