okstra 0.130.4 → 0.131.1

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

@@ -1,360 +0,0 @@
-"""
-********************
-Bipartite Edge Lists
-********************
-Read and write NetworkX graphs as bipartite edge lists.
-
-Format
-------
-You can read or write three formats of edge lists with these functions.
-
-Node pairs with no data::
-
- 1 2
-
-Python dictionary as data::
-
- 1 2 {'weight':7, 'color':'green'}
-
-Arbitrary data::
-
- 1 2 7 green
-
-For each edge (u, v) the node u is assigned to part 0 and the node v to part 1.
-"""
-
-__all__ = ["generate_edgelist", "write_edgelist", "parse_edgelist", "read_edgelist"]
-
-import networkx as nx
-from networkx.utils import not_implemented_for, open_file
-
-
-@open_file(1, mode="wb")
-def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="utf-8"):
-    """Write a bipartite graph as a list of edges.
-
-    Parameters
-    ----------
-    G : Graph
-       A NetworkX bipartite graph
-    path : file or string
-       File or filename to write. If a file is provided, it must be
-       opened in 'wb' mode. Filenames ending in .gz or .bz2 will be compressed.
-    comments : string, optional
-       The character used to indicate the start of a comment
-    delimiter : string, optional
-       The string used to separate values.  The default is whitespace.
-    data : bool or list, optional
-       If False write no edge data.
-       If True write a string representation of the edge data dictionary..
-       If a list (or other iterable) is provided, write the  keys specified
-       in the list.
-    encoding: string, optional
-       Specify which encoding to use when writing file.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> G.add_nodes_from([0, 2], bipartite=0)
-    >>> G.add_nodes_from([1, 3], bipartite=1)
-    >>> nx.write_edgelist(G, "test.edgelist")
-    >>> fh = open("test.edgelist_open", "wb")
-    >>> nx.write_edgelist(G, fh)
-    >>> nx.write_edgelist(G, "test.edgelist.gz")
-    >>> nx.write_edgelist(G, "test.edgelist_nodata.gz", data=False)
-
-    >>> G = nx.Graph()
-    >>> G.add_edge(1, 2, weight=7, color="red")
-    >>> nx.write_edgelist(G, "test.edgelist_bigger_nodata", data=False)
-    >>> nx.write_edgelist(G, "test.edgelist_color", data=["color"])
-    >>> nx.write_edgelist(G, "test.edgelist_color_weight", data=["color", "weight"])
-
-    See Also
-    --------
-    write_edgelist
-    generate_edgelist
-    """
-    for line in generate_edgelist(G, delimiter, data):
-        line += "\n"
-        path.write(line.encode(encoding))
-
-
-@not_implemented_for("directed")
-def generate_edgelist(G, delimiter=" ", data=True):
-    """Generate a single line of the bipartite graph G in edge list format.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-       The graph is assumed to have node attribute `part` set to 0,1 representing
-       the two graph parts
-
-    delimiter : string, optional
-       Separator for node labels
-
-    data : bool or list of keys
-       If False generate no edge data.  If True use a dictionary
-       representation of edge data.  If a list of keys use a list of data
-       values corresponding to the keys.
-
-    Returns
-    -------
-    lines : string
-        Lines of data in adjlist format.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> G.add_nodes_from([0, 2], bipartite=0)
-    >>> G.add_nodes_from([1, 3], bipartite=1)
-    >>> G[1][2]["weight"] = 3
-    >>> G[2][3]["capacity"] = 12
-    >>> for line in bipartite.generate_edgelist(G, data=False):
-    ...     print(line)
-    0 1
-    2 1
-    2 3
-
-    >>> for line in bipartite.generate_edgelist(G):
-    ...     print(line)
-    0 1 {}
-    2 1 {'weight': 3}
-    2 3 {'capacity': 12}
-
-    >>> for line in bipartite.generate_edgelist(G, data=["weight"]):
-    ...     print(line)
-    0 1
-    2 1 3
-    2 3
-    """
-    try:
-        part0 = [n for n, d in G.nodes.items() if d["bipartite"] == 0]
-    except BaseException as err:
-        raise AttributeError("Missing node attribute `bipartite`") from err
-    if data is True or data is False:
-        for n in part0:
-            for edge in G.edges(n, data=data):
-                yield delimiter.join(map(str, edge))
-    else:
-        for n in part0:
-            for u, v, d in G.edges(n, data=True):
-                edge = [u, v]
-                try:
-                    edge.extend(d[k] for k in data)
-                except KeyError:
-                    pass  # missing data for this edge, should warn?
-                yield delimiter.join(map(str, edge))
-
-
-@nx._dispatchable(name="bipartite_parse_edgelist", graphs=None, returns_graph=True)
-def parse_edgelist(
-    lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
-):
-    """Parse lines of an edge list representation of a bipartite graph.
-
-    Parameters
-    ----------
-    lines : list or iterator of strings
-        Input data in edgelist format
-    comments : string, optional
-       Marker for comment lines
-    delimiter : string, optional
-       Separator for node labels
-    create_using: NetworkX graph container, optional
-       Use given NetworkX graph for holding nodes or edges.
-    nodetype : Python type, optional
-       Convert nodes to this type.
-    data : bool or list of (label,type) tuples
-       If False generate no edge data or if True use a dictionary
-       representation of edge data or a list tuples specifying dictionary
-       key names and types for edge data.
-
-    Returns
-    -------
-    G: NetworkX Graph
-        The bipartite graph corresponding to lines
-
-    Examples
-    --------
-    Edgelist with no data:
-
-    >>> from networkx.algorithms import bipartite
-    >>> lines = ["1 2", "2 3", "3 4"]
-    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
-    >>> sorted(G.nodes())
-    [1, 2, 3, 4]
-    >>> sorted(G.nodes(data=True))
-    [(1, {'bipartite': 0}), (2, {'bipartite': 0}), (3, {'bipartite': 0}), (4, {'bipartite': 1})]
-    >>> sorted(G.edges())
-    [(1, 2), (2, 3), (3, 4)]
-
-    Edgelist with data in Python dictionary representation:
-
-    >>> lines = ["1 2 {'weight':3}", "2 3 {'weight':27}", "3 4 {'weight':3.0}"]
-    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
-    >>> sorted(G.nodes())
-    [1, 2, 3, 4]
-    >>> sorted(G.edges(data=True))
-    [(1, 2, {'weight': 3}), (2, 3, {'weight': 27}), (3, 4, {'weight': 3.0})]
-
-    Edgelist with data in a list:
-
-    >>> lines = ["1 2 3", "2 3 27", "3 4 3.0"]
-    >>> G = bipartite.parse_edgelist(lines, nodetype=int, data=(("weight", float),))
-    >>> sorted(G.nodes())
-    [1, 2, 3, 4]
-    >>> sorted(G.edges(data=True))
-    [(1, 2, {'weight': 3.0}), (2, 3, {'weight': 27.0}), (3, 4, {'weight': 3.0})]
-
-    See Also
-    --------
-    """
-    from ast import literal_eval
-
-    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
-        # split line, should have 2 or more
-        s = line.rstrip("\n").split(delimiter)
-        if len(s) < 2:
-            continue
-        u = s.pop(0)
-        v = s.pop(0)
-        d = s
-        if nodetype is not None:
-            try:
-                u = nodetype(u)
-                v = nodetype(v)
-            except BaseException as err:
-                raise TypeError(
-                    f"Failed to convert nodes {u},{v} to type {nodetype}."
-                ) from err
-
-        if len(d) == 0 or data is False:
-            # no data or data type specified
-            edgedata = {}
-        elif data is True:
-            # no edge types specified
-            try:  # try to evaluate as dictionary
-                edgedata = dict(literal_eval(" ".join(d)))
-            except BaseException as err:
-                raise TypeError(
-                    f"Failed to convert edge data ({d}) to dictionary."
-                ) from err
-        else:
-            # convert edge data to dictionary with specified keys and type
-            if len(d) != len(data):
-                raise IndexError(
-                    f"Edge data {d} and data_keys {data} are not the same length"
-                )
-            edgedata = {}
-            for (edge_key, edge_type), edge_value in zip(data, d):
-                try:
-                    edge_value = edge_type(edge_value)
-                except BaseException as err:
-                    raise TypeError(
-                        f"Failed to convert {edge_key} data "
-                        f"{edge_value} to type {edge_type}."
-                    ) from err
-                edgedata.update({edge_key: edge_value})
-        G.add_node(u, bipartite=0)
-        G.add_node(v, bipartite=1)
-        G.add_edge(u, v, **edgedata)
-    return G
-
-
-@open_file(0, mode="rb")
-@nx._dispatchable(name="bipartite_read_edgelist", graphs=None, returns_graph=True)
-def read_edgelist(
-    path,
-    comments="#",
-    delimiter=None,
-    create_using=None,
-    nodetype=None,
-    data=True,
-    edgetype=None,
-    encoding="utf-8",
-):
-    """Read a bipartite graph from a list of edges.
-
-    Parameters
-    ----------
-    path : file or string
-       File or filename to read. If a file is provided, it must be
-       opened in 'rb' mode.
-       Filenames ending in .gz or .bz2 will be decompressed.
-    comments : string, optional
-       The character used to indicate the start of a comment.
-    delimiter : string, optional
-       The string used to separate values.  The default is whitespace.
-    create_using : Graph container, optional,
-       Use specified container to build graph.  The default is networkx.Graph,
-       an undirected graph.
-    nodetype : int, float, str, Python type, optional
-       Convert node data from strings to specified type
-    data : bool or list of (label,type) tuples
-       Tuples specifying dictionary key names and types for edge data
-    edgetype : int, float, str, Python type, optional OBSOLETE
-       Convert edge data from strings to specified type and use as 'weight'
-    encoding: string, optional
-       Specify which encoding to use when reading file.
-
-    Returns
-    -------
-    G : graph
-       A networkx Graph or other type specified with create_using
-
-    Examples
-    --------
-    >>> from networkx.algorithms import bipartite
-    >>> G = nx.path_graph(4)
-    >>> G.add_nodes_from([0, 2], bipartite=0)
-    >>> G.add_nodes_from([1, 3], bipartite=1)
-    >>> bipartite.write_edgelist(G, "test.edgelist")
-    >>> G = bipartite.read_edgelist("test.edgelist")
-
-    >>> fh = open("test.edgelist", "rb")
-    >>> G = bipartite.read_edgelist(fh)
-    >>> fh.close()
-
-    >>> G = bipartite.read_edgelist("test.edgelist", nodetype=int)
-
-    Edgelist with data in a list:
-
-    >>> textline = "1 2 3"
-    >>> fh = open("test.edgelist", "w")
-    >>> d = fh.write(textline)
-    >>> fh.close()
-    >>> G = bipartite.read_edgelist(
-    ...     "test.edgelist", nodetype=int, data=(("weight", float),)
-    ... )
-    >>> list(G)
-    [1, 2]
-    >>> list(G.edges(data=True))
-    [(1, 2, {'weight': 3.0})]
-
-    See parse_edgelist() for more examples of formatting.
-
-    See Also
-    --------
-    parse_edgelist
-
-    Notes
-    -----
-    Since nodes must be hashable, the function nodetype must return hashable
-    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
-    """
-    lines = (line.decode(encoding) for line in path)
-    return parse_edgelist(
-        lines,
-        comments=comments,
-        delimiter=delimiter,
-        create_using=create_using,
-        nodetype=nodetype,
-        data=data,
-    )

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

@@ -1,105 +0,0 @@
-"""Provides a function for computing the extendability of a graph which is
-undirected, simple, connected and bipartite and contains at least one perfect matching."""
-
-import networkx as nx
-from networkx.utils import not_implemented_for
-
-__all__ = ["maximal_extendability"]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def maximal_extendability(G):
-    """Computes the extendability of a graph.
-
-    The extendability of a graph is defined as the maximum $k$ for which `G`
-    is $k$-extendable. Graph `G` is $k$-extendable if and only if `G` has a
-    perfect matching and every set of $k$ independent edges can be extended
-    to a perfect matching in `G`.
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        A fully-connected bipartite graph without self-loops
-
-    Returns
-    -------
-    extendability : int
-
-    Raises
-    ------
-    NetworkXError
-       If the graph `G` is disconnected.
-       If the graph `G` is not bipartite.
-       If the graph `G` does not contain a perfect matching.
-       If the residual graph of `G` is not strongly connected.
-
-    Notes
-    -----
-    Definition:
-    Let `G` be a simple, connected, undirected and bipartite graph with a perfect
-    matching M and bipartition (U,V). The residual graph of `G`, denoted by $G_M$,
-    is the graph obtained from G by directing the edges of M from V to U and the
-    edges that do not belong to M from U to V.
-
-    Lemma [1]_ :
-    Let M be a perfect matching of `G`. `G` is $k$-extendable if and only if its residual
-    graph $G_M$ is strongly connected and there are $k$ vertex-disjoint directed
-    paths between every vertex of U and every vertex of V.
-
-    Assuming that input graph `G` is undirected, simple, connected, bipartite and contains
-    a perfect matching M, this function constructs the residual graph $G_M$ of G and
-    returns the minimum value among the maximum vertex-disjoint directed paths between
-    every vertex of U and every vertex of V in $G_M$. By combining the definitions
-    and the lemma, this value represents the extendability of the graph `G`.
-
-    Time complexity O($n^3$ $m^2$)) where $n$ is the number of vertices
-    and $m$ is the number of edges.
-
-    References
-    ----------
-    .. [1] "A polynomial algorithm for the extendability problem in bipartite graphs",
-          J. Lakhal, L. Litzler, Information Processing Letters, 1998.
-    .. [2] "On n-extendible graphs", M. D. Plummer, Discrete Mathematics, 31:201–210, 1980
-          https://doi.org/10.1016/0012-365X(80)90037-0
-
-    """
-    if not nx.is_connected(G):
-        raise nx.NetworkXError("Graph G is not connected")
-
-    if not nx.bipartite.is_bipartite(G):
-        raise nx.NetworkXError("Graph G is not bipartite")
-
-    U, V = nx.bipartite.sets(G)
-
-    maximum_matching = nx.bipartite.hopcroft_karp_matching(G)
-
-    if not nx.is_perfect_matching(G, maximum_matching):
-        raise nx.NetworkXError("Graph G does not contain a perfect matching")
-
-    # list of edges in perfect matching, directed from V to U
-    pm = [(node, maximum_matching[node]) for node in V & maximum_matching.keys()]
-
-    # Direct all the edges of G, from V to U if in matching, else from U to V
-    directed_edges = [
-        (x, y) if (x in V and (x, y) in pm) or (x in U and (y, x) not in pm) else (y, x)
-        for x, y in G.edges
-    ]
-
-    # Construct the residual graph of G
-    residual_G = nx.DiGraph()
-    residual_G.add_nodes_from(G)
-    residual_G.add_edges_from(directed_edges)
-
-    if not nx.is_strongly_connected(residual_G):
-        raise nx.NetworkXError("The residual graph of G is not strongly connected")
-
-    # For node-pairs between V & U, keep min of max number of node-disjoint paths
-    # Variable $k$ stands for the extendability of graph G
-    k = float("inf")
-    for u in U:
-        for v in V:
-            num_paths = sum(1 for _ in nx.node_disjoint_paths(residual_G, u, v))
-            k = k if k < num_paths else num_paths
-    return k