okstra 0.130.4 → 0.131.1

package/runtime/python/okstra_vendor/networkx/relabel.py

@@ -1,285 +0,0 @@
-import networkx as nx
-
-__all__ = ["convert_node_labels_to_integers", "relabel_nodes"]
-
-
-@nx._dispatchable(
-    preserve_all_attrs=True, mutates_input={"not copy": 2}, returns_graph=True
-)
-def relabel_nodes(G, mapping, copy=True):
-    """Relabel the nodes of the graph G according to a given mapping.
-
-    The original node ordering may not be preserved if `copy` is `False` and the
-    mapping includes overlap between old and new labels.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    mapping : dictionary
-       A dictionary with the old labels as keys and new labels as values.
-       A partial mapping is allowed. Mapping 2 nodes to a single node is allowed.
-       Any non-node keys in the mapping are ignored.
-
-    copy : bool (optional, default=True)
-       If True return a copy, or if False relabel the nodes in place.
-
-    Examples
-    --------
-    To create a new graph with nodes relabeled according to a given
-    dictionary:
-
-    >>> G = nx.path_graph(3)
-    >>> sorted(G)
-    [0, 1, 2]
-    >>> mapping = {0: "a", 1: "b", 2: "c"}
-    >>> H = nx.relabel_nodes(G, mapping)
-    >>> sorted(H)
-    ['a', 'b', 'c']
-
-    Nodes can be relabeled with any hashable object, including numbers
-    and strings:
-
-    >>> import string
-    >>> G = nx.path_graph(26)  # nodes are integers 0 through 25
-    >>> sorted(G)[:3]
-    [0, 1, 2]
-    >>> mapping = dict(zip(G, string.ascii_lowercase))
-    >>> G = nx.relabel_nodes(G, mapping)  # nodes are characters a through z
-    >>> sorted(G)[:3]
-    ['a', 'b', 'c']
-    >>> mapping = dict(zip(G, range(1, 27)))
-    >>> G = nx.relabel_nodes(G, mapping)  # nodes are integers 1 through 26
-    >>> sorted(G)[:3]
-    [1, 2, 3]
-
-    To perform a partial in-place relabeling, provide a dictionary
-    mapping only a subset of the nodes, and set the `copy` keyword
-    argument to False:
-
-    >>> G = nx.path_graph(3)  # nodes 0-1-2
-    >>> mapping = {0: "a", 1: "b"}  # 0->'a' and 1->'b'
-    >>> G = nx.relabel_nodes(G, mapping, copy=False)
-    >>> sorted(G, key=str)
-    [2, 'a', 'b']
-
-    A mapping can also be given as a function:
-
-    >>> G = nx.path_graph(3)
-    >>> H = nx.relabel_nodes(G, lambda x: x**2)
-    >>> list(H)
-    [0, 1, 4]
-
-    In a multigraph, relabeling two or more nodes to the same new node
-    will retain all edges, but may change the edge keys in the process:
-
-    >>> G = nx.MultiGraph()
-    >>> G.add_edge(0, 1, value="a")  # returns the key for this edge
-    0
-    >>> G.add_edge(0, 2, value="b")
-    0
-    >>> G.add_edge(0, 3, value="c")
-    0
-    >>> mapping = {1: 4, 2: 4, 3: 4}
-    >>> H = nx.relabel_nodes(G, mapping, copy=True)
-    >>> print(H[0])
-    {4: {0: {'value': 'a'}, 1: {'value': 'b'}, 2: {'value': 'c'}}}
-
-    This works for in-place relabeling too:
-
-    >>> G = nx.relabel_nodes(G, mapping, copy=False)
-    >>> print(G[0])
-    {4: {0: {'value': 'a'}, 1: {'value': 'b'}, 2: {'value': 'c'}}}
-
-    Notes
-    -----
-    Only the nodes specified in the mapping will be relabeled.
-    Any non-node keys in the mapping are ignored.
-
-    The keyword setting copy=False modifies the graph in place.
-    Relabel_nodes avoids naming collisions by building a
-    directed graph from ``mapping`` which specifies the order of
-    relabelings. Naming collisions, such as a->b, b->c, are ordered
-    such that "b" gets renamed to "c" before "a" gets renamed "b".
-    In cases of circular mappings (e.g. a->b, b->a), modifying the
-    graph is not possible in-place and an exception is raised.
-    In that case, use copy=True.
-
-    If a relabel operation on a multigraph would cause two or more
-    edges to have the same source, target and key, the second edge must
-    be assigned a new key to retain all edges. The new key is set
-    to the lowest non-negative integer not already used as a key
-    for edges between these two nodes. Note that this means non-numeric
-    keys may be replaced by numeric keys.
-
-    See Also
-    --------
-    convert_node_labels_to_integers
-    """
-    # you can pass any callable e.g. f(old_label) -> new_label or
-    # e.g. str(old_label) -> new_label, but we'll just make a dictionary here regardless
-    m = {n: mapping(n) for n in G} if callable(mapping) else mapping
-
-    if copy:
-        return _relabel_copy(G, m)
-    else:
-        return _relabel_inplace(G, m)
-
-
-def _relabel_inplace(G, mapping):
-    if len(mapping.keys() & mapping.values()) > 0:
-        # labels sets overlap
-        # can we topological sort and still do the relabeling?
-        D = nx.DiGraph(list(mapping.items()))
-        D.remove_edges_from(nx.selfloop_edges(D))
-        try:
-            nodes = reversed(list(nx.topological_sort(D)))
-        except nx.NetworkXUnfeasible as err:
-            raise nx.NetworkXUnfeasible(
-                "The node label sets are overlapping and no ordering can "
-                "resolve the mapping. Use copy=True."
-            ) from err
-    else:
-        # non-overlapping label sets, sort them in the order of G nodes
-        nodes = [n for n in G if n in mapping]
-
-    multigraph = G.is_multigraph()
-    directed = G.is_directed()
-
-    for old in nodes:
-        # Test that old is in both mapping and G, otherwise ignore.
-        try:
-            new = mapping[old]
-            G.add_node(new, **G.nodes[old])
-        except KeyError:
-            continue
-        if new == old:
-            continue
-        if multigraph:
-            new_edges = [
-                (new, new if old == target else target, key, data)
-                for (_, target, key, data) in G.edges(old, data=True, keys=True)
-            ]
-            if directed:
-                new_edges += [
-                    (new if old == source else source, new, key, data)
-                    for (source, _, key, data) in G.in_edges(old, data=True, keys=True)
-                ]
-            # Ensure new edges won't overwrite existing ones
-            seen = set()
-            for i, (source, target, key, data) in enumerate(new_edges):
-                if target in G[source] and key in G[source][target]:
-                    new_key = 0 if not isinstance(key, int | float) else key
-                    while new_key in G[source][target] or (target, new_key) in seen:
-                        new_key += 1
-                    new_edges[i] = (source, target, new_key, data)
-                    seen.add((target, new_key))
-        else:
-            new_edges = [
-                (new, new if old == target else target, data)
-                for (_, target, data) in G.edges(old, data=True)
-            ]
-            if directed:
-                new_edges += [
-                    (new if old == source else source, new, data)
-                    for (source, _, data) in G.in_edges(old, data=True)
-                ]
-        G.remove_node(old)
-        G.add_edges_from(new_edges)
-    return G
-
-
-def _relabel_copy(G, mapping):
-    H = G.__class__()
-    H.add_nodes_from(mapping.get(n, n) for n in G)
-    H._node.update((mapping.get(n, n), d.copy()) for n, d in G.nodes.items())
-    if G.is_multigraph():
-        new_edges = [
-            (mapping.get(n1, n1), mapping.get(n2, n2), k, d.copy())
-            for (n1, n2, k, d) in G.edges(keys=True, data=True)
-        ]
-
-        # check for conflicting edge-keys
-        undirected = not G.is_directed()
-        seen_edges = set()
-        for i, (source, target, key, data) in enumerate(new_edges):
-            while (source, target, key) in seen_edges:
-                if not isinstance(key, int | float):
-                    key = 0
-                key += 1
-            seen_edges.add((source, target, key))
-            if undirected:
-                seen_edges.add((target, source, key))
-            new_edges[i] = (source, target, key, data)
-
-        H.add_edges_from(new_edges)
-    else:
-        H.add_edges_from(
-            (mapping.get(n1, n1), mapping.get(n2, n2), d.copy())
-            for (n1, n2, d) in G.edges(data=True)
-        )
-    H.graph.update(G.graph)
-    return H
-
-
-@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
-def convert_node_labels_to_integers(
-    G, first_label=0, ordering="default", label_attribute=None
-):
-    """Returns a copy of the graph G with the nodes relabeled using
-    consecutive integers.
-
-    Parameters
-    ----------
-    G : graph
-       A NetworkX graph
-
-    first_label : int, optional (default=0)
-       An integer specifying the starting offset in numbering nodes.
-       The new integer labels are numbered first_label, ..., n-1+first_label.
-
-    ordering : string
-       "default" : inherit node ordering from G.nodes()
-       "sorted"  : inherit node ordering from sorted(G.nodes())
-       "increasing degree" : nodes are sorted by increasing degree
-       "decreasing degree" : nodes are sorted by decreasing degree
-
-    label_attribute : string, optional (default=None)
-       Name of node attribute to store old label.  If None no attribute
-       is created.
-
-    Notes
-    -----
-    Node and edge attribute data are copied to the new (relabeled) graph.
-
-    There is no guarantee that the relabeling of nodes to integers will
-    give the same two integers for two (even identical graphs).
-    Use the `ordering` argument to try to preserve the order.
-
-    See Also
-    --------
-    relabel_nodes
-    """
-    N = G.number_of_nodes() + first_label
-    if ordering == "default":
-        mapping = dict(zip(G.nodes(), range(first_label, N)))
-    elif ordering == "sorted":
-        nlist = sorted(G.nodes())
-        mapping = dict(zip(nlist, range(first_label, N)))
-    elif ordering == "increasing degree":
-        dv_pairs = [(d, n) for (n, d) in G.degree()]
-        dv_pairs.sort()  # in-place sort from lowest to highest degree
-        mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N)))
-    elif ordering == "decreasing degree":
-        dv_pairs = [(d, n) for (n, d) in G.degree()]
-        dv_pairs.sort()  # in-place sort from lowest to highest degree
-        dv_pairs.reverse()
-        mapping = dict(zip([n for d, n in dv_pairs], range(first_label, N)))
-    else:
-        raise nx.NetworkXError(f"Unknown node ordering: {ordering}")
-    H = relabel_nodes(G, mapping)
-    # create node attribute with the old label
-    if label_attribute is not None:
-        nx.set_node_attributes(H, {v: k for k, v in mapping.items()}, label_attribute)
-    return H

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

@@ -1,8 +0,0 @@
-from networkx.utils.misc import *
-from networkx.utils.decorators import *
-from networkx.utils.random_sequence import *
-from networkx.utils.union_find import *
-from networkx.utils.rcm import *
-from networkx.utils.heaps import *
-from networkx.utils.configs import *
-from networkx.utils.backends import *