okstra 0.130.3 → 0.131.0

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

@@ -1,19 +0,0 @@
-"""
-*********
-JSON data
-*********
-Generate and parse JSON serializable data for NetworkX graphs.
-
-These formats are suitable for use with the d3.js examples https://d3js.org/
-
-The three formats that you can generate with NetworkX are:
-
- - node-link like in the d3.js example https://bl.ocks.org/mbostock/4062045
- - tree like in the d3.js example https://bl.ocks.org/mbostock/4063550
- - adjacency like in the d3.js example https://bost.ocks.org/mike/miserables/
-"""
-
-from networkx.readwrite.json_graph.node_link import *
-from networkx.readwrite.json_graph.adjacency import *
-from networkx.readwrite.json_graph.tree import *
-from networkx.readwrite.json_graph.cytoscape import *

package/runtime/python/okstra_vendor/networkx/readwrite/json_graph/adjacency.py

@@ -1,156 +0,0 @@
-import networkx as nx
-
-__all__ = ["adjacency_data", "adjacency_graph"]
-
-_attrs = {"id": "id", "key": "key"}
-
-
-def adjacency_data(G, attrs=_attrs):
-    """Returns data in adjacency format that is suitable for JSON serialization
-    and use in JavaScript documents.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    attrs : dict
-        A dictionary that contains two keys 'id' and 'key'. The corresponding
-        values provide the attribute names for storing NetworkX-internal graph
-        data. The values should be unique. Default value:
-        :samp:`dict(id='id', key='key')`.
-
-        If some user-defined graph data use these attribute names as data keys,
-        they may be silently dropped.
-
-    Returns
-    -------
-    data : dict
-       A dictionary with adjacency formatted data.
-
-    Raises
-    ------
-    NetworkXError
-        If values in attrs are not unique.
-
-    Examples
-    --------
-    >>> from networkx.readwrite import json_graph
-    >>> G = nx.Graph([(1, 2)])
-    >>> data = json_graph.adjacency_data(G)
-
-    To serialize with json
-
-    >>> import json
-    >>> s = json.dumps(data)
-
-    Notes
-    -----
-    Graph, node, and link attributes will be written when using this format
-    but attribute keys must be strings if you want to serialize the resulting
-    data with JSON.
-
-    The default value of attrs will be changed in a future release of NetworkX.
-
-    See Also
-    --------
-    adjacency_graph, node_link_data, tree_data
-    """
-    multigraph = G.is_multigraph()
-    id_ = attrs["id"]
-    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
-    key = None if not multigraph else attrs["key"]
-    if id_ == key:
-        raise nx.NetworkXError("Attribute names are not unique.")
-    data = {}
-    data["directed"] = G.is_directed()
-    data["multigraph"] = multigraph
-    data["graph"] = list(G.graph.items())
-    data["nodes"] = []
-    data["adjacency"] = []
-    for n, nbrdict in G.adjacency():
-        data["nodes"].append({**G.nodes[n], id_: n})
-        adj = []
-        if multigraph:
-            for nbr, keys in nbrdict.items():
-                for k, d in keys.items():
-                    adj.append({**d, id_: nbr, key: k})
-        else:
-            for nbr, d in nbrdict.items():
-                adj.append({**d, id_: nbr})
-        data["adjacency"].append(adj)
-    return data
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def adjacency_graph(data, directed=False, multigraph=True, attrs=_attrs):
-    """Returns graph from adjacency data format.
-
-    Parameters
-    ----------
-    data : dict
-        Adjacency list formatted graph data
-
-    directed : bool
-        If True, and direction not specified in data, return a directed graph.
-
-    multigraph : bool
-        If True, and multigraph not specified in data, return a multigraph.
-
-    attrs : dict
-        A dictionary that contains two keys 'id' and 'key'. The corresponding
-        values provide the attribute names for storing NetworkX-internal graph
-        data. The values should be unique. Default value:
-        :samp:`dict(id='id', key='key')`.
-
-    Returns
-    -------
-    G : NetworkX graph
-       A NetworkX graph object
-
-    Examples
-    --------
-    >>> from networkx.readwrite import json_graph
-    >>> G = nx.Graph([(1, 2)])
-    >>> data = json_graph.adjacency_data(G)
-    >>> H = json_graph.adjacency_graph(data)
-
-    Notes
-    -----
-    The default value of attrs will be changed in a future release of NetworkX.
-
-    See Also
-    --------
-    adjacency_graph, node_link_data, tree_data
-    """
-    multigraph = data.get("multigraph", multigraph)
-    directed = data.get("directed", directed)
-    if multigraph:
-        graph = nx.MultiGraph()
-    else:
-        graph = nx.Graph()
-    if directed:
-        graph = graph.to_directed()
-    id_ = attrs["id"]
-    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
-    key = None if not multigraph else attrs["key"]
-    graph.graph = dict(data.get("graph", []))
-    mapping = []
-    for d in data["nodes"]:
-        node_data = d.copy()
-        node = node_data.pop(id_)
-        mapping.append(node)
-        graph.add_node(node)
-        graph.nodes[node].update(node_data)
-    for i, d in enumerate(data["adjacency"]):
-        source = mapping[i]
-        for tdata in d:
-            target_data = tdata.copy()
-            target = target_data.pop(id_)
-            if not multigraph:
-                graph.add_edge(source, target)
-                graph[source][target].update(target_data)
-            else:
-                ky = target_data.pop(key, None)
-                graph.add_edge(source, target, key=ky)
-                graph[source][target][ky].update(target_data)
-    return graph

package/runtime/python/okstra_vendor/networkx/readwrite/json_graph/cytoscape.py

@@ -1,190 +0,0 @@
-import networkx as nx
-
-__all__ = ["cytoscape_data", "cytoscape_graph"]
-
-
-def cytoscape_data(G, name="name", ident="id"):
-    """Returns data in Cytoscape JSON format (cyjs).
-
-    Parameters
-    ----------
-    G : NetworkX Graph
-        The graph to convert to cytoscape format
-    name : string
-        A string which is mapped to the 'name' node element in cyjs format.
-        Must not have the same value as `ident`.
-    ident : string
-        A string which is mapped to the 'id' node element in cyjs format.
-        Must not have the same value as `name`.
-
-    Returns
-    -------
-    data: dict
-        A dictionary with cyjs formatted data.
-
-    Raises
-    ------
-    NetworkXError
-        If the values for `name` and `ident` are identical.
-
-    See Also
-    --------
-    cytoscape_graph: convert a dictionary in cyjs format to a graph
-
-    References
-    ----------
-    .. [1] Cytoscape user's manual:
-       http://manual.cytoscape.org/en/stable/index.html
-
-    Examples
-    --------
-    >>> from pprint import pprint
-    >>> G = nx.path_graph(2)
-    >>> cyto_data = nx.cytoscape_data(G)
-    >>> pprint(cyto_data, sort_dicts=False)
-    {'data': [],
-     'directed': False,
-     'multigraph': False,
-     'elements': {'nodes': [{'data': {'id': '0', 'value': 0, 'name': '0'}},
-                            {'data': {'id': '1', 'value': 1, 'name': '1'}}],
-                  'edges': [{'data': {'source': 0, 'target': 1}}]}}
-
-    The :mod:`json` package can be used to serialize the resulting data
-
-    >>> import io, json
-    >>> with io.StringIO() as fh:  # replace io with `open(...)` to write to disk
-    ...     json.dump(cyto_data, fh)
-    ...     fh.seek(0)  # doctest: +SKIP
-    ...     print(fh.getvalue()[:64])  # View the first 64 characters
-    {"data": [], "directed": false, "multigraph": false, "elements":
-
-    """
-    if name == ident:
-        raise nx.NetworkXError("name and ident must be different.")
-
-    jsondata = {"data": list(G.graph.items())}
-    jsondata["directed"] = G.is_directed()
-    jsondata["multigraph"] = G.is_multigraph()
-    jsondata["elements"] = {"nodes": [], "edges": []}
-    nodes = jsondata["elements"]["nodes"]
-    edges = jsondata["elements"]["edges"]
-
-    for i, j in G.nodes.items():
-        n = {"data": j.copy()}
-        n["data"]["id"] = j.get(ident) or str(i)
-        n["data"]["value"] = i
-        n["data"]["name"] = j.get(name) or str(i)
-        nodes.append(n)
-
-    if G.is_multigraph():
-        for e in G.edges(keys=True):
-            n = {"data": G.adj[e[0]][e[1]][e[2]].copy()}
-            n["data"]["source"] = e[0]
-            n["data"]["target"] = e[1]
-            n["data"]["key"] = e[2]
-            edges.append(n)
-    else:
-        for e in G.edges():
-            n = {"data": G.adj[e[0]][e[1]].copy()}
-            n["data"]["source"] = e[0]
-            n["data"]["target"] = e[1]
-            edges.append(n)
-    return jsondata
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def cytoscape_graph(data, name="name", ident="id"):
-    """
-    Create a NetworkX graph from a dictionary in cytoscape JSON format.
-
-    Parameters
-    ----------
-    data : dict
-        A dictionary of data conforming to cytoscape JSON format.
-    name : string
-        A string which is mapped to the 'name' node element in cyjs format.
-        Must not have the same value as `ident`.
-    ident : string
-        A string which is mapped to the 'id' node element in cyjs format.
-        Must not have the same value as `name`.
-
-    Returns
-    -------
-    graph : a NetworkX graph instance
-        The `graph` can be an instance of `Graph`, `DiGraph`, `MultiGraph`, or
-        `MultiDiGraph` depending on the input data.
-
-    Raises
-    ------
-    NetworkXError
-        If the `name` and `ident` attributes are identical.
-
-    See Also
-    --------
-    cytoscape_data: convert a NetworkX graph to a dict in cyjs format
-
-    References
-    ----------
-    .. [1] Cytoscape user's manual:
-       http://manual.cytoscape.org/en/stable/index.html
-
-    Examples
-    --------
-    >>> data_dict = {
-    ...     "data": [],
-    ...     "directed": False,
-    ...     "multigraph": False,
-    ...     "elements": {
-    ...         "nodes": [
-    ...             {"data": {"id": "0", "value": 0, "name": "0"}},
-    ...             {"data": {"id": "1", "value": 1, "name": "1"}},
-    ...         ],
-    ...         "edges": [{"data": {"source": 0, "target": 1}}],
-    ...     },
-    ... }
-    >>> G = nx.cytoscape_graph(data_dict)
-    >>> G.name
-    ''
-    >>> G.nodes()
-    NodeView((0, 1))
-    >>> G.nodes(data=True)[0]
-    {'id': '0', 'value': 0, 'name': '0'}
-    >>> G.edges(data=True)
-    EdgeDataView([(0, 1, {'source': 0, 'target': 1})])
-    """
-    if name == ident:
-        raise nx.NetworkXError("name and ident must be different.")
-
-    multigraph = data.get("multigraph")
-    directed = data.get("directed")
-    if multigraph:
-        graph = nx.MultiGraph()
-    else:
-        graph = nx.Graph()
-    if directed:
-        graph = graph.to_directed()
-    graph.graph = dict(data.get("data"))
-    for d in data["elements"]["nodes"]:
-        node_data = d["data"].copy()
-        node = d["data"]["value"]
-
-        if d["data"].get(name):
-            node_data[name] = d["data"].get(name)
-        if d["data"].get(ident):
-            node_data[ident] = d["data"].get(ident)
-
-        graph.add_node(node)
-        graph.nodes[node].update(node_data)
-
-    for d in data["elements"]["edges"]:
-        edge_data = d["data"].copy()
-        sour = d["data"]["source"]
-        targ = d["data"]["target"]
-        if multigraph:
-            key = d["data"].get("key", 0)
-            graph.add_edge(sour, targ, key=key)
-            graph.edges[sour, targ, key].update(edge_data)
-        else:
-            graph.add_edge(sour, targ)
-            graph.edges[sour, targ].update(edge_data)
-    return graph

package/runtime/python/okstra_vendor/networkx/readwrite/json_graph/node_link.py

@@ -1,261 +0,0 @@
-import warnings
-from itertools import count
-
-import networkx as nx
-
-__all__ = ["node_link_data", "node_link_graph"]
-
-
-def _to_tuple(x):
-    """Converts lists to tuples, including nested lists.
-
-    All other non-list inputs are passed through unmodified. This function is
-    intended to be used to convert potentially nested lists from json files
-    into valid nodes.
-
-    Examples
-    --------
-    >>> _to_tuple([1, 2, [3, 4]])
-    (1, 2, (3, 4))
-    """
-    if not isinstance(x, tuple | list):
-        return x
-    return tuple(map(_to_tuple, x))
-
-
-def node_link_data(
-    G,
-    *,
-    source="source",
-    target="target",
-    name="id",
-    key="key",
-    edges="edges",
-    nodes="nodes",
-):
-    """Returns data in node-link format that is suitable for JSON serialization
-    and use in JavaScript documents.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-    source : string
-        A string that provides the 'source' attribute name for storing NetworkX-internal graph data.
-    target : string
-        A string that provides the 'target' attribute name for storing NetworkX-internal graph data.
-    name : string
-        A string that provides the 'name' attribute name for storing NetworkX-internal graph data.
-    key : string
-        A string that provides the 'key' attribute name for storing NetworkX-internal graph data.
-    edges : string
-        A string that provides the 'edges' attribute name for storing NetworkX-internal graph data.
-    nodes : string
-        A string that provides the 'nodes' attribute name for storing NetworkX-internal graph data.
-
-    Returns
-    -------
-    data : dict
-       A dictionary with node-link formatted data.
-
-    Raises
-    ------
-    NetworkXError
-        If the values of 'source', 'target' and 'key' are not unique.
-
-    Examples
-    --------
-    >>> from pprint import pprint
-    >>> G = nx.Graph([("A", "B")])
-    >>> data1 = nx.node_link_data(G)
-    >>> pprint(data1)
-    {'directed': False,
-     'edges': [{'source': 'A', 'target': 'B'}],
-     'graph': {},
-     'multigraph': False,
-     'nodes': [{'id': 'A'}, {'id': 'B'}]}
-
-    To serialize with JSON
-
-    >>> import json
-    >>> s1 = json.dumps(data1)
-    >>> pprint(s1)
-    ('{"directed": false, "multigraph": false, "graph": {}, "nodes": [{"id": "A"}, '
-     '{"id": "B"}], "edges": [{"source": "A", "target": "B"}]}')
-
-
-    A graph can also be serialized by passing `node_link_data` as an encoder function.
-
-    >>> s1 = json.dumps(G, default=nx.node_link_data)
-    >>> pprint(s1)
-    ('{"directed": false, "multigraph": false, "graph": {}, "nodes": [{"id": "A"}, '
-     '{"id": "B"}], "edges": [{"source": "A", "target": "B"}]}')
-
-    The attribute names for storing NetworkX-internal graph data can
-    be specified as keyword options.
-
-    >>> H = nx.gn_graph(2)
-    >>> data2 = nx.node_link_data(
-    ...     H, edges="links", source="from", target="to", nodes="vertices"
-    ... )
-    >>> pprint(data2)
-    {'directed': True,
-     'graph': {},
-     'links': [{'from': 1, 'to': 0}],
-     'multigraph': False,
-     'vertices': [{'id': 0}, {'id': 1}]}
-
-    Notes
-    -----
-    Graph, node, and edge attributes are stored in this format.  Note that
-    attribute keys will be converted to strings in order to comply with JSON.
-
-    Attribute 'key' is only used for multigraphs.
-
-    To use `node_link_data` in conjunction with `node_link_graph`,
-    the keyword names for the attributes must match.
-
-    See Also
-    --------
-    node_link_graph, adjacency_data, tree_data
-    """
-    multigraph = G.is_multigraph()
-
-    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
-    key = None if not multigraph else key
-    if len({source, target, key}) < 3:
-        raise nx.NetworkXError("Attribute names are not unique.")
-    data = {
-        "directed": G.is_directed(),
-        "multigraph": multigraph,
-        "graph": G.graph,
-        nodes: [{**G.nodes[n], name: n} for n in G],
-    }
-    if multigraph:
-        data[edges] = [
-            {**d, source: u, target: v, key: k}
-            for u, v, k, d in G.edges(keys=True, data=True)
-        ]
-    else:
-        data[edges] = [{**d, source: u, target: v} for u, v, d in G.edges(data=True)]
-    return data
-
-
-@nx._dispatchable(graphs=None, returns_graph=True)
-def node_link_graph(
-    data,
-    directed=False,
-    multigraph=True,
-    *,
-    source="source",
-    target="target",
-    name="id",
-    key="key",
-    edges="edges",
-    nodes="nodes",
-):
-    """Returns graph from node-link data format.
-
-    Useful for de-serialization from JSON.
-
-    Parameters
-    ----------
-    data : dict
-        node-link formatted graph data
-
-    directed : bool
-        If True, and direction not specified in data, return a directed graph.
-
-    multigraph : bool
-        If True, and multigraph not specified in data, return a multigraph.
-
-    source : string
-        A string that provides the 'source' attribute name for storing NetworkX-internal graph data.
-    target : string
-        A string that provides the 'target' attribute name for storing NetworkX-internal graph data.
-    name : string
-        A string that provides the 'name' attribute name for storing NetworkX-internal graph data.
-    key : string
-        A string that provides the 'key' attribute name for storing NetworkX-internal graph data.
-    edges : string
-        A string that provides the 'edges' attribute name for storing NetworkX-internal graph data.
-    nodes : string
-        A string that provides the 'nodes' attribute name for storing NetworkX-internal graph data.
-
-    Returns
-    -------
-    G : NetworkX graph
-        A NetworkX graph object
-
-    Examples
-    --------
-
-    Create data in node-link format by converting a graph.
-
-    >>> from pprint import pprint
-    >>> G = nx.Graph([("A", "B")])
-    >>> data = nx.node_link_data(G)
-    >>> pprint(data)
-    {'directed': False,
-     'edges': [{'source': 'A', 'target': 'B'}],
-     'graph': {},
-     'multigraph': False,
-     'nodes': [{'id': 'A'}, {'id': 'B'}]}
-
-    Revert data in node-link format to a graph.
-
-    >>> H = nx.node_link_graph(data)
-    >>> print(H.edges)
-    [('A', 'B')]
-
-    To serialize and deserialize a graph with JSON,
-
-    >>> import json
-    >>> d = json.dumps(nx.node_link_data(G))
-    >>> H = nx.node_link_graph(json.loads(d))
-    >>> print(G.edges, H.edges)
-    [('A', 'B')] [('A', 'B')]
-
-
-    Notes
-    -----
-    Attribute 'key' is only used for multigraphs.
-
-    To use `node_link_data` in conjunction with `node_link_graph`,
-    the keyword names for the attributes must match.
-
-    See Also
-    --------
-    node_link_data, adjacency_data, tree_data
-    """
-    multigraph = data.get("multigraph", multigraph)
-    directed = data.get("directed", directed)
-    if multigraph:
-        graph = nx.MultiGraph()
-    else:
-        graph = nx.Graph()
-    if directed:
-        graph = graph.to_directed()
-
-    # Allow 'key' to be omitted from attrs if the graph is not a multigraph.
-    key = None if not multigraph else key
-    graph.graph = data.get("graph", {})
-    c = count()
-    for d in data[nodes]:
-        node = _to_tuple(d.get(name, next(c)))
-        nodedata = {str(k): v for k, v in d.items() if k != name}
-        graph.add_node(node, **nodedata)
-    for d in data[edges]:
-        src = tuple(d[source]) if isinstance(d[source], list) else d[source]
-        tgt = tuple(d[target]) if isinstance(d[target], list) else d[target]
-        if not multigraph:
-            edgedata = {str(k): v for k, v in d.items() if k != source and k != target}
-            graph.add_edge(src, tgt, **edgedata)
-        else:
-            ky = d.get(key, None)
-            edgedata = {
-                str(k): v
-                for k, v in d.items()
-                if k != source and k != target and k != key
-            }
-            graph.add_edge(src, tgt, ky, **edgedata)
-    return graph