okstra 0.130.3 → 0.131.0

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

@@ -1,113 +0,0 @@
-"""
-This module provides the following: read and write of p2g format
-used in metabolic pathway studies.
-
-See:
-<https://web.archive.org/web/20080626113807/http://www.cs.purdue.edu/homes/koyuturk/pathway/>
-for a description.
-
-The summary is included here:
-
-A file that describes a uniquely labeled graph (with extension ".gr")
-format looks like the following:
-
-
-name
-3 4
-a
-1 2
-b
-
-c
-0 2
-
-"name" is simply a description of what the graph corresponds to. The
-second line displays the number of nodes and number of edges,
-respectively. This sample graph contains three nodes labeled "a", "b",
-and "c". The rest of the graph contains two lines for each node. The
-first line for a node contains the node label. After the declaration
-of the node label, the out-edges of that node in the graph are
-provided. For instance, "a" is linked to nodes 1 and 2, which are
-labeled "b" and "c", while the node labeled "b" has no outgoing
-edges. Observe that node labeled "c" has an outgoing edge to
-itself. Indeed, self-loops are allowed. Node index starts from 0.
-
-"""
-
-import networkx as nx
-from networkx.utils import open_file
-
-
-@open_file(1, mode="w")
-def write_p2g(G, path, encoding="utf-8"):
-    """Write NetworkX graph in p2g format.
-
-    Notes
-    -----
-    This format is meant to be used with directed graphs with
-    possible self loops.
-    """
-    path.write((f"{G.name}\n").encode(encoding))
-    path.write((f"{G.order()} {G.size()}\n").encode(encoding))
-    nodes = list(G)
-    # make dictionary mapping nodes to integers
-    nodenumber = dict(zip(nodes, range(len(nodes))))
-    for n in nodes:
-        path.write((f"{n}\n").encode(encoding))
-        for nbr in G.neighbors(n):
-            path.write((f"{nodenumber[nbr]} ").encode(encoding))
-        path.write("\n".encode(encoding))
-
-
-@open_file(0, mode="r")
-@nx._dispatchable(graphs=None, returns_graph=True)
-def read_p2g(path, encoding="utf-8"):
-    """Read graph in p2g format from path.
-
-    Parameters
-    ----------
-    path : string or file
-       Filename or file handle to read.
-       Filenames ending in .gz or .bz2 will be decompressed.
-
-    Returns
-    -------
-    MultiDiGraph
-
-    Notes
-    -----
-    If you want a DiGraph (with no self loops allowed and no edge data)
-    use D=nx.DiGraph(read_p2g(path))
-    """
-    lines = (line.decode(encoding) for line in path)
-    G = parse_p2g(lines)
-    return G
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def parse_p2g(lines):
-    """Parse p2g format graph from string or iterable.
-
-    Returns
-    -------
-    MultiDiGraph
-    """
-    description = next(lines).strip()
-    # are multiedges (parallel edges) allowed?
-    G = nx.MultiDiGraph(name=description, selfloops=True)
-    nnodes, nedges = map(int, next(lines).split())
-    nodelabel = {}
-    nbrs = {}
-    # loop over the nodes keeping track of node labels and out neighbors
-    # defer adding edges until all node labels are known
-    for i in range(nnodes):
-        n = next(lines).strip()
-        nodelabel[i] = n
-        G.add_node(n)
-        nbrs[n] = map(int, next(lines).split())
-    # now we know all of the node labels so we can add the edges
-    # with the correct labels
-    for n in G:
-        for nbr in nbrs[n]:
-            G.add_edge(n, nodelabel[nbr])
-    return G

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

@@ -1,286 +0,0 @@
-"""
-*****
-Pajek
-*****
-Read graphs in Pajek format.
-
-This implementation handles directed and undirected graphs including
-those with self loops and parallel edges.
-
-Format
-------
-See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
-for format information.
-
-"""
-
-import warnings
-
-import networkx as nx
-from networkx.utils import open_file
-
-__all__ = ["read_pajek", "parse_pajek", "generate_pajek", "write_pajek"]
-
-
-def generate_pajek(G):
-    """Generate lines in Pajek graph format.
-
-    Parameters
-    ----------
-    G : graph
-       A Networkx graph
-
-    References
-    ----------
-    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
-    for format information.
-    """
-    if G.name == "":
-        name = "NetworkX"
-    else:
-        name = G.name
-    # Apparently many Pajek format readers can't process this line
-    # So we'll leave it out for now.
-    # yield '*network %s'%name
-
-    # write nodes with attributes
-    yield f"*vertices {G.order()}"
-    nodes = list(G)
-    # make dictionary mapping nodes to integers
-    nodenumber = dict(zip(nodes, range(1, len(nodes) + 1)))
-    for n in nodes:
-        # copy node attributes and pop mandatory attributes
-        # to avoid duplication.
-        na = G.nodes.get(n, {}).copy()
-        x = na.pop("x", 0.0)
-        y = na.pop("y", 0.0)
-        try:
-            id = int(na.pop("id", nodenumber[n]))
-        except ValueError as err:
-            err.args += (
-                (
-                    "Pajek format requires 'id' to be an int()."
-                    " Refer to the 'Relabeling nodes' section."
-                ),
-            )
-            raise
-        nodenumber[n] = id
-        shape = na.pop("shape", "ellipse")
-        s = " ".join(map(make_qstr, (id, n, x, y, shape)))
-        # only optional attributes are left in na.
-        for k, v in na.items():
-            if isinstance(v, str) and v.strip() != "":
-                s += f" {make_qstr(k)} {make_qstr(v)}"
-            else:
-                warnings.warn(
-                    f"Node attribute {k} is not processed. {('Empty attribute' if isinstance(v, str) else 'Non-string attribute')}."
-                )
-        yield s
-
-    # write edges with attributes
-    if G.is_directed():
-        yield "*arcs"
-    else:
-        yield "*edges"
-    for u, v, edgedata in G.edges(data=True):
-        d = edgedata.copy()
-        value = d.pop("weight", 1.0)  # use 1 as default edge value
-        s = " ".join(map(make_qstr, (nodenumber[u], nodenumber[v], value)))
-        for k, v in d.items():
-            if isinstance(v, str) and v.strip() != "":
-                s += f" {make_qstr(k)} {make_qstr(v)}"
-            else:
-                warnings.warn(
-                    f"Edge attribute {k} is not processed. {('Empty attribute' if isinstance(v, str) else 'Non-string attribute')}."
-                )
-        yield s
-
-
-@open_file(1, mode="wb")
-def write_pajek(G, path, encoding="UTF-8"):
-    """Write graph in Pajek format to path.
-
-    Parameters
-    ----------
-    G : graph
-       A Networkx graph
-    path : file or string
-       File or filename to write.
-       Filenames ending in .gz or .bz2 will be compressed.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> nx.write_pajek(G, "test.netP4")
-
-    Warnings
-    --------
-    Optional node attributes and edge attributes must be non-empty strings.
-    Otherwise it will not be written into the file. You will need to
-    convert those attributes to strings if you want to keep them.
-
-    References
-    ----------
-    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
-    for format information.
-    """
-    for line in generate_pajek(G):
-        line += "\n"
-        path.write(line.encode(encoding))
-
-
-@open_file(0, mode="rb")
-@nx._dispatchable(graphs=None, returns_graph=True)
-def read_pajek(path, encoding="UTF-8"):
-    """Read graph in Pajek format from path.
-
-    Parameters
-    ----------
-    path : file or string
-       Filename or file handle to read.
-       Filenames ending in .gz or .bz2 will be decompressed.
-
-    Returns
-    -------
-    G : NetworkX MultiGraph or MultiDiGraph.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> nx.write_pajek(G, "test.net")
-    >>> G = nx.read_pajek("test.net")
-
-    To create a Graph instead of a MultiGraph use
-
-    >>> G1 = nx.Graph(G)
-
-    References
-    ----------
-    See http://vlado.fmf.uni-lj.si/pub/networks/pajek/doc/draweps.htm
-    for format information.
-    """
-    lines = (line.decode(encoding) for line in path)
-    return parse_pajek(lines)
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def parse_pajek(lines):
-    """Parse Pajek format graph from string or iterable.
-
-    Parameters
-    ----------
-    lines : string or iterable
-       Data in Pajek format.
-
-    Returns
-    -------
-    G : NetworkX graph
-
-    See Also
-    --------
-    read_pajek
-
-    """
-    import shlex
-
-    # multigraph=False
-    if isinstance(lines, str):
-        lines = iter(lines.split("\n"))
-    lines = iter([line.rstrip("\n") for line in lines])
-    G = nx.MultiDiGraph()  # are multiedges allowed in Pajek? assume yes
-    labels = []  # in the order of the file, needed for matrix
-    while lines:
-        try:
-            l = next(lines)
-        except:  # EOF
-            break
-        if l.lower().startswith("*network"):
-            try:
-                label, name = l.split(None, 1)
-            except ValueError:
-                # Line was not of the form:  *network NAME
-                pass
-            else:
-                G.graph["name"] = name
-        elif l.lower().startswith("*vertices"):
-            nodelabels = {}
-            l, nnodes = l.split()
-            for i in range(int(nnodes)):
-                l = next(lines)
-                try:
-                    splitline = [
-                        x.decode("utf-8") for x in shlex.split(str(l).encode("utf-8"))
-                    ]
-                except AttributeError:
-                    splitline = shlex.split(str(l))
-                id, label = splitline[0:2]
-                labels.append(label)
-                G.add_node(label)
-                nodelabels[id] = label
-                G.nodes[label]["id"] = id
-                try:
-                    x, y, shape = splitline[2:5]
-                    G.nodes[label].update(
-                        {"x": float(x), "y": float(y), "shape": shape}
-                    )
-                except:
-                    pass
-                extra_attr = zip(splitline[5::2], splitline[6::2])
-                G.nodes[label].update(extra_attr)
-        elif l.lower().startswith("*edges") or l.lower().startswith("*arcs"):
-            if l.lower().startswith("*edge"):
-                # switch from multidigraph to multigraph
-                G = nx.MultiGraph(G)
-            if l.lower().startswith("*arcs"):
-                # switch to directed with multiple arcs for each existing edge
-                G = G.to_directed()
-            for l in lines:
-                try:
-                    splitline = [
-                        x.decode("utf-8") for x in shlex.split(str(l).encode("utf-8"))
-                    ]
-                except AttributeError:
-                    splitline = shlex.split(str(l))
-
-                if len(splitline) < 2:
-                    continue
-                ui, vi = splitline[0:2]
-                u = nodelabels.get(ui, ui)
-                v = nodelabels.get(vi, vi)
-                # parse the data attached to this edge and put in a dictionary
-                edge_data = {}
-                try:
-                    # there should always be a single value on the edge?
-                    w = splitline[2:3]
-                    edge_data.update({"weight": float(w[0])})
-                except:
-                    pass
-                    # if there isn't, just assign a 1
-                #                    edge_data.update({'value':1})
-                extra_attr = zip(splitline[3::2], splitline[4::2])
-                edge_data.update(extra_attr)
-                # if G.has_edge(u,v):
-                #     multigraph=True
-                G.add_edge(u, v, **edge_data)
-        elif l.lower().startswith("*matrix"):
-            G = nx.DiGraph(G)
-            adj_list = (
-                (labels[row], labels[col], {"weight": int(data)})
-                for (row, line) in enumerate(lines)
-                for (col, data) in enumerate(line.split())
-                if int(data) != 0
-            )
-            G.add_edges_from(adj_list)
-
-    return G
-
-
-def make_qstr(t):
-    """Returns the string representation of t.
-    Add outer double-quotes if the string has a space.
-    """
-    if not isinstance(t, str):
-        t = str(t)
-    if " " in t:
-        t = f'"{t}"'
-    return t