okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/linalg/spectrum.py

@@ -1,186 +0,0 @@
-"""
-Eigenvalue spectrum of graphs.
-"""
-
-import networkx as nx
-
-__all__ = [
-    "laplacian_spectrum",
-    "adjacency_spectrum",
-    "modularity_spectrum",
-    "normalized_laplacian_spectrum",
-    "bethe_hessian_spectrum",
-]
-
-
-@nx._dispatchable(edge_attrs="weight")
-def laplacian_spectrum(G, weight="weight"):
-    """Returns eigenvalues of the Laplacian of G
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    weight : string or None, optional (default='weight')
-       The edge data key used to compute each value in the matrix.
-       If None, then each edge has weight 1.
-
-    Returns
-    -------
-    evals : NumPy array
-      Eigenvalues
-
-    Notes
-    -----
-    For MultiGraph/MultiDiGraph, the edges weights are summed.
-    See :func:`~networkx.convert_matrix.to_numpy_array` for other options.
-
-    See Also
-    --------
-    laplacian_matrix
-
-    Examples
-    --------
-    The multiplicity of 0 as an eigenvalue of the laplacian matrix is equal
-    to the number of connected components of G.
-
-    >>> G = nx.Graph()  # Create a graph with 5 nodes and 3 connected components
-    >>> G.add_nodes_from(range(5))
-    >>> G.add_edges_from([(0, 2), (3, 4)])
-    >>> nx.laplacian_spectrum(G)
-    array([0., 0., 0., 2., 2.])
-
-    """
-    import scipy as sp
-
-    return sp.linalg.eigvalsh(nx.laplacian_matrix(G, weight=weight).todense())
-
-
-@nx._dispatchable(edge_attrs="weight")
-def normalized_laplacian_spectrum(G, weight="weight"):
-    """Return eigenvalues of the normalized Laplacian of G
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    weight : string or None, optional (default='weight')
-       The edge data key used to compute each value in the matrix.
-       If None, then each edge has weight 1.
-
-    Returns
-    -------
-    evals : NumPy array
-      Eigenvalues
-
-    Notes
-    -----
-    For MultiGraph/MultiDiGraph, the edges weights are summed.
-    See to_numpy_array for other options.
-
-    See Also
-    --------
-    normalized_laplacian_matrix
-    """
-    import scipy as sp
-
-    return sp.linalg.eigvalsh(
-        nx.normalized_laplacian_matrix(G, weight=weight).todense()
-    )
-
-
-@nx._dispatchable(edge_attrs="weight")
-def adjacency_spectrum(G, weight="weight"):
-    """Returns eigenvalues of the adjacency matrix of G.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    weight : string or None, optional (default='weight')
-       The edge data key used to compute each value in the matrix.
-       If None, then each edge has weight 1.
-
-    Returns
-    -------
-    evals : NumPy array
-      Eigenvalues
-
-    Notes
-    -----
-    For MultiGraph/MultiDiGraph, the edges weights are summed.
-    See to_numpy_array for other options.
-
-    See Also
-    --------
-    adjacency_matrix
-    """
-    import scipy as sp
-
-    return sp.linalg.eigvals(nx.adjacency_matrix(G, weight=weight).todense())
-
-
-@nx._dispatchable
-def modularity_spectrum(G):
-    """Returns eigenvalues of the modularity matrix of G.
-
-    Parameters
-    ----------
-    G : Graph
-       A NetworkX Graph or DiGraph
-
-    Returns
-    -------
-    evals : NumPy array
-      Eigenvalues
-
-    See Also
-    --------
-    modularity_matrix
-
-    References
-    ----------
-    .. [1] M. E. J. Newman, "Modularity and community structure in networks",
-       Proc. Natl. Acad. Sci. USA, vol. 103, pp. 8577-8582, 2006.
-    """
-    import scipy as sp
-
-    if G.is_directed():
-        return sp.linalg.eigvals(nx.directed_modularity_matrix(G))
-    else:
-        return sp.linalg.eigvals(nx.modularity_matrix(G))
-
-
-@nx._dispatchable
-def bethe_hessian_spectrum(G, r=None):
-    """Returns eigenvalues of the Bethe Hessian matrix of G.
-
-    Parameters
-    ----------
-    G : Graph
-       A NetworkX Graph or DiGraph
-
-    r : float
-       Regularizer parameter
-
-    Returns
-    -------
-    evals : NumPy array
-      Eigenvalues
-
-    See Also
-    --------
-    bethe_hessian_matrix
-
-    References
-    ----------
-    .. [1] A. Saade, F. Krzakala and L. Zdeborová
-       "Spectral clustering of graphs with the bethe hessian",
-       Advances in Neural Information Processing Systems. 2014.
-    """
-    import scipy as sp
-
-    return sp.linalg.eigvalsh(nx.bethe_hessian_matrix(G, r).todense())

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

@@ -1,17 +0,0 @@
-"""
-A package for reading and writing graphs in various formats.
-
-"""
-
-from networkx.readwrite.adjlist import *
-from networkx.readwrite.multiline_adjlist import *
-from networkx.readwrite.edgelist import *
-from networkx.readwrite.pajek import *
-from networkx.readwrite.leda import *
-from networkx.readwrite.sparse6 import *
-from networkx.readwrite.graph6 import *
-from networkx.readwrite.gml import *
-from networkx.readwrite.graphml import *
-from networkx.readwrite.gexf import *
-from networkx.readwrite.json_graph import *
-from networkx.readwrite.text import *

package/runtime/python/okstra_vendor/networkx/readwrite/adjlist.py

@@ -1,330 +0,0 @@
-"""
-**************
-Adjacency List
-**************
-Read and write NetworkX graphs as adjacency lists.
-
-Adjacency list format is useful for graphs without data associated
-with nodes or edges and for nodes that can be meaningfully represented
-as strings.
-
-Format
-------
-The adjacency list format consists of lines with node labels.  The
-first label in a line is the source node.  Further labels in the line
-are considered target nodes and are added to the graph along with an edge
-between the source node and target node.
-
-The graph with edges a-b, a-c, d-e can be represented as the following
-adjacency list (anything following the # in a line is a comment)::
-
-     a b c # source target target
-     d e
-"""
-
-__all__ = ["generate_adjlist", "write_adjlist", "parse_adjlist", "read_adjlist"]
-
-import networkx as nx
-from networkx.utils import open_file
-
-
-def generate_adjlist(G, delimiter=" "):
-    """Generate lines representing a graph in adjacency list format.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    delimiter : str, default=" "
-        Separator for node labels.
-
-    Yields
-    ------
-    str
-        Adjacency list for a node in `G`. The first item is the node label,
-        followed by the labels of its neighbors.
-
-    Examples
-    --------
-    >>> G = nx.lollipop_graph(4, 3)
-    >>> for line in nx.generate_adjlist(G):
-    ...     print(line)
-    0 1 2 3
-    1 2 3
-    2 3
-    3 4
-    4 5
-    5 6
-    6
-
-    When `G` is undirected, each edge is only listed once. For directed graphs,
-    edges appear once for each direction.
-
-    >>> G = nx.complete_graph(3, create_using=nx.DiGraph)
-    >>> for line in nx.generate_adjlist(G):
-    ...     print(line)
-    0 1 2
-    1 0 2
-    2 0 1
-
-    Node labels are shown multiple times for multiedges, but edge data (including keys)
-    are not included in the output.
-
-    >>> G = nx.MultiGraph([(0, 1, {"weight": 1}), (0, 1, {"weight": 2})])
-    >>> for line in nx.generate_adjlist(G):
-    ...     print(line)
-    0 1 1
-    1
-
-    See Also
-    --------
-    write_adjlist, read_adjlist
-
-    Notes
-    -----
-    The default `delimiter=" "` will result in unexpected results if node names contain
-    whitespace characters. To avoid this problem, specify an alternate delimiter when spaces are
-    valid in node names.
-
-    NB: This option is not available for data that isn't user-generated.
-
-    """
-    seen = set()
-    directed = G.is_directed()
-    multigraph = G.is_multigraph()
-    for s, nbrs in G.adjacency():
-        nodes = [str(s)]
-        for t, data in nbrs.items():
-            if t in seen:
-                continue
-            if multigraph and len(data) > 1:
-                nodes.extend((str(t),) * len(data))
-            else:
-                nodes.append(str(t))
-        if not directed:
-            seen.add(s)
-        yield delimiter.join(nodes)
-
-
-@open_file(1, mode="wb")
-def write_adjlist(G, path, comments="#", delimiter=" ", encoding="utf-8"):
-    """Write graph G in single-line adjacency-list format to path.
-
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    path : string or file
-       Filename or file handle for data output.
-       Filenames ending in .gz or .bz2 will be compressed.
-
-    comments : string, optional
-       Marker for comment lines
-
-    delimiter : string, optional
-       Separator for node labels
-
-    encoding : string, optional
-       Text encoding.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> nx.write_adjlist(G, "path4.adjlist")
-
-    The path can be a filehandle or a string with the name of the file. If a
-    filehandle is provided, it has to be opened in 'wb' mode.
-
-    >>> fh = open("path4.adjlist2", "wb")
-    >>> nx.write_adjlist(G, fh)
-
-    Notes
-    -----
-    The default `delimiter=" "` will result in unexpected results if node names contain
-    whitespace characters. To avoid this problem, specify an alternate delimiter when spaces are
-    valid in node names.
-    NB: This option is not available for data that isn't user-generated.
-
-    This format does not store graph, node, or edge data.
-
-    See Also
-    --------
-    read_adjlist, generate_adjlist
-    """
-    import sys
-    import time
-
-    pargs = comments + " ".join(sys.argv) + "\n"
-    header = (
-        pargs
-        + comments
-        + f" GMT {time.asctime(time.gmtime())}\n"
-        + comments
-        + f" {G.name}\n"
-    )
-    path.write(header.encode(encoding))
-
-    for line in generate_adjlist(G, delimiter):
-        line += "\n"
-        path.write(line.encode(encoding))
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def parse_adjlist(
-    lines, comments="#", delimiter=None, create_using=None, nodetype=None
-):
-    """Parse lines of a graph adjacency list representation.
-
-    Parameters
-    ----------
-    lines : list or iterator of strings
-        Input data in adjlist format
-
-    create_using : NetworkX graph constructor, optional (default=nx.Graph)
-       Graph type to create. If graph instance, then cleared before populated.
-
-    nodetype : Python type, optional
-       Convert nodes to this type.
-
-    comments : string, optional
-       Marker for comment lines
-
-    delimiter : string, optional
-       Separator for node labels.  The default is whitespace.
-
-    Returns
-    -------
-    G: NetworkX graph
-        The graph corresponding to the lines in adjacency list format.
-
-    Examples
-    --------
-    >>> lines = ["1 2 5", "2 3 4", "3 5", "4", "5"]
-    >>> G = nx.parse_adjlist(lines, nodetype=int)
-    >>> nodes = [1, 2, 3, 4, 5]
-    >>> all(node in G for node in nodes)
-    True
-    >>> edges = [(1, 2), (1, 5), (2, 3), (2, 4), (3, 5)]
-    >>> all((u, v) in G.edges() or (v, u) in G.edges() for (u, v) in edges)
-    True
-
-    See Also
-    --------
-    read_adjlist
-
-    """
-    G = nx.empty_graph(0, create_using)
-    for line in lines:
-        p = line.find(comments)
-        if p >= 0:
-            line = line[:p]
-        if not len(line):
-            continue
-        vlist = line.rstrip("\n").split(delimiter)
-        u = vlist.pop(0)
-        # convert types
-        if nodetype is not None:
-            try:
-                u = nodetype(u)
-            except BaseException as err:
-                raise TypeError(
-                    f"Failed to convert node ({u}) to type {nodetype}"
-                ) from err
-        G.add_node(u)
-        if nodetype is not None:
-            try:
-                vlist = list(map(nodetype, vlist))
-            except BaseException as err:
-                raise TypeError(
-                    f"Failed to convert nodes ({','.join(vlist)}) to type {nodetype}"
-                ) from err
-        G.add_edges_from([(u, v) for v in vlist])
-    return G
-
-
-@open_file(0, mode="rb")
-@nx._dispatchable(graphs=None, returns_graph=True)
-def read_adjlist(
-    path,
-    comments="#",
-    delimiter=None,
-    create_using=None,
-    nodetype=None,
-    encoding="utf-8",
-):
-    """Read graph in adjacency list format from path.
-
-    Parameters
-    ----------
-    path : string or file
-       Filename or file handle to read.
-       Filenames ending in .gz or .bz2 will be decompressed.
-
-    create_using : NetworkX graph constructor, optional (default=nx.Graph)
-       Graph type to create. If graph instance, then cleared before populated.
-
-    nodetype : Python type, optional
-       Convert nodes to this type.
-
-    comments : string, optional
-       Marker for comment lines
-
-    delimiter : string, optional
-       Separator for node labels.  The default is whitespace.
-
-    Returns
-    -------
-    G: NetworkX graph
-        The graph corresponding to the lines in adjacency list format.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> nx.write_adjlist(G, "test.adjlist")
-    >>> G = nx.read_adjlist("test.adjlist")
-
-    The path can be a filehandle or a string with the name of the file. If a
-    filehandle is provided, it has to be opened in 'rb' mode.
-
-    >>> fh = open("test.adjlist", "rb")
-    >>> G = nx.read_adjlist(fh)
-
-    Filenames ending in .gz or .bz2 will be compressed.
-
-    >>> nx.write_adjlist(G, "test.adjlist.gz")
-    >>> G = nx.read_adjlist("test.adjlist.gz")
-
-    The optional nodetype is a function to convert node strings to nodetype.
-
-    For example
-
-    >>> G = nx.read_adjlist("test.adjlist", nodetype=int)
-
-    will attempt to convert all nodes to integer type.
-
-    Since nodes must be hashable, the function nodetype must return hashable
-    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
-
-    The optional create_using parameter indicates the type of NetworkX graph
-    created.  The default is `nx.Graph`, an undirected graph.
-    To read the data as a directed graph use
-
-    >>> G = nx.read_adjlist("test.adjlist", create_using=nx.DiGraph)
-
-    Notes
-    -----
-    This format does not store graph or node data.
-
-    See Also
-    --------
-    write_adjlist
-    """
-    lines = (line.decode(encoding) for line in path)
-    return parse_adjlist(
-        lines,
-        comments=comments,
-        delimiter=delimiter,
-        create_using=create_using,
-        nodetype=nodetype,
-    )