okstra 0.130.3 → 0.131.0

package/runtime/python/okstra_vendor/networkx/algorithms/isomorphism/vf2userfunc.py

@@ -1,192 +0,0 @@
-"""
-Module to simplify the specification of user-defined equality functions for
-node and edge attributes during isomorphism checks.
-
-During the construction of an isomorphism, the algorithm considers two
-candidate nodes n1 in G1 and n2 in G2.  The graphs G1 and G2 are then
-compared with respect to properties involving n1 and n2, and if the outcome
-is good, then the candidate nodes are considered isomorphic. NetworkX
-provides a simple mechanism for users to extend the comparisons to include
-node and edge attributes.
-
-Node attributes are handled by the node_match keyword. When considering
-n1 and n2, the algorithm passes their node attribute dictionaries to
-node_match, and if it returns False, then n1 and n2 cannot be
-considered to be isomorphic.
-
-Edge attributes are handled by the edge_match keyword. When considering
-n1 and n2, the algorithm must verify that outgoing edges from n1 are
-commensurate with the outgoing edges for n2. If the graph is directed,
-then a similar check is also performed for incoming edges.
-
-Focusing only on outgoing edges, we consider pairs of nodes (n1, v1) from
-G1 and (n2, v2) from G2. For graphs and digraphs, there is only one edge
-between (n1, v1) and only one edge between (n2, v2). Those edge attribute
-dictionaries are passed to edge_match, and if it returns False, then
-n1 and n2 cannot be considered isomorphic. For multigraphs and
-multidigraphs, there can be multiple edges between (n1, v1) and also
-multiple edges between (n2, v2).  Now, there must exist an isomorphism
-from "all the edges between (n1, v1)" to "all the edges between (n2, v2)".
-So, all of the edge attribute dictionaries are passed to edge_match, and
-it must determine if there is an isomorphism between the two sets of edges.
-"""
-
-from . import isomorphvf2 as vf2
-
-__all__ = ["GraphMatcher", "DiGraphMatcher", "MultiGraphMatcher", "MultiDiGraphMatcher"]
-
-
-def _semantic_feasibility(self, G1_node, G2_node):
-    """Returns True if mapping G1_node to G2_node is semantically feasible."""
-    # Make sure the nodes match
-    if self.node_match is not None:
-        nm = self.node_match(self.G1.nodes[G1_node], self.G2.nodes[G2_node])
-        if not nm:
-            return False
-
-    # Make sure the edges match
-    if self.edge_match is not None:
-        # Cached lookups
-        G1nbrs = self.G1_adj[G1_node]
-        G2nbrs = self.G2_adj[G2_node]
-        core_1 = self.core_1
-        edge_match = self.edge_match
-
-        for neighbor in G1nbrs:
-            # G1_node is not in core_1, so we must handle R_self separately
-            if neighbor == G1_node:
-                if G2_node in G2nbrs and not edge_match(
-                    G1nbrs[G1_node], G2nbrs[G2_node]
-                ):
-                    return False
-            elif neighbor in core_1:
-                G2_nbr = core_1[neighbor]
-                if G2_nbr in G2nbrs and not edge_match(
-                    G1nbrs[neighbor], G2nbrs[G2_nbr]
-                ):
-                    return False
-        # syntactic check has already verified that neighbors are symmetric
-
-    return True
-
-
-class GraphMatcher(vf2.GraphMatcher):
-    """VF2 isomorphism checker for undirected graphs."""
-
-    def __init__(self, G1, G2, node_match=None, edge_match=None):
-        """Initialize graph matcher.
-
-        Parameters
-        ----------
-        G1, G2: graph
-            The graphs to be tested.
-
-        node_match: callable
-            A function that returns True iff node n1 in G1 and n2 in G2
-            should be considered equal during the isomorphism test. The
-            function will be called like::
-
-               node_match(G1.nodes[n1], G2.nodes[n2])
-
-            That is, the function will receive the node attribute dictionaries
-            of the nodes under consideration. If None, then no attributes are
-            considered when testing for an isomorphism.
-
-        edge_match: callable
-            A function that returns True iff the edge attribute dictionary for
-            the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should be
-            considered equal during the isomorphism test. The function will be
-            called like::
-
-               edge_match(G1[u1][v1], G2[u2][v2])
-
-            That is, the function will receive the edge attribute dictionaries
-            of the edges under consideration. If None, then no attributes are
-            considered when testing for an isomorphism.
-
-        """
-        vf2.GraphMatcher.__init__(self, G1, G2)
-
-        self.node_match = node_match
-        self.edge_match = edge_match
-
-        # These will be modified during checks to minimize code repeat.
-        self.G1_adj = self.G1.adj
-        self.G2_adj = self.G2.adj
-
-    semantic_feasibility = _semantic_feasibility
-
-
-class DiGraphMatcher(vf2.DiGraphMatcher):
-    """VF2 isomorphism checker for directed graphs."""
-
-    def __init__(self, G1, G2, node_match=None, edge_match=None):
-        """Initialize graph matcher.
-
-        Parameters
-        ----------
-        G1, G2 : graph
-            The graphs to be tested.
-
-        node_match : callable
-            A function that returns True iff node n1 in G1 and n2 in G2
-            should be considered equal during the isomorphism test. The
-            function will be called like::
-
-               node_match(G1.nodes[n1], G2.nodes[n2])
-
-            That is, the function will receive the node attribute dictionaries
-            of the nodes under consideration. If None, then no attributes are
-            considered when testing for an isomorphism.
-
-        edge_match : callable
-            A function that returns True iff the edge attribute dictionary for
-            the pair of nodes (u1, v1) in G1 and (u2, v2) in G2 should be
-            considered equal during the isomorphism test. The function will be
-            called like::
-
-               edge_match(G1[u1][v1], G2[u2][v2])
-
-            That is, the function will receive the edge attribute dictionaries
-            of the edges under consideration. If None, then no attributes are
-            considered when testing for an isomorphism.
-
-        """
-        vf2.DiGraphMatcher.__init__(self, G1, G2)
-
-        self.node_match = node_match
-        self.edge_match = edge_match
-
-        # These will be modified during checks to minimize code repeat.
-        self.G1_adj = self.G1.adj
-        self.G2_adj = self.G2.adj
-
-    def semantic_feasibility(self, G1_node, G2_node):
-        """Returns True if mapping G1_node to G2_node is semantically feasible."""
-
-        # Test node_match and also test edge_match on successors
-        feasible = _semantic_feasibility(self, G1_node, G2_node)
-        if not feasible:
-            return False
-
-        # Test edge_match on predecessors
-        self.G1_adj = self.G1.pred
-        self.G2_adj = self.G2.pred
-        feasible = _semantic_feasibility(self, G1_node, G2_node)
-        self.G1_adj = self.G1.adj
-        self.G2_adj = self.G2.adj
-
-        return feasible
-
-
-# The "semantics" of edge_match are different for multi(di)graphs, but
-# the implementation is the same.  So, technically we do not need to
-# provide "multi" versions, but we do so to match NetworkX's base classes.
-
-
-class MultiGraphMatcher(GraphMatcher):
-    """VF2 isomorphism checker for undirected multigraphs."""
-
-
-class MultiDiGraphMatcher(DiGraphMatcher):
-    """VF2 isomorphism checker for directed multigraphs."""

package/runtime/python/okstra_vendor/networkx/algorithms/link_analysis/__init__.py

@@ -1,2 +0,0 @@
-from networkx.algorithms.link_analysis.hits_alg import *
-from networkx.algorithms.link_analysis.pagerank_alg import *

package/runtime/python/okstra_vendor/networkx/algorithms/link_analysis/hits_alg.py

@@ -1,337 +0,0 @@
-"""Hubs and authorities analysis of graph structure."""
-
-import networkx as nx
-
-__all__ = ["hits"]
-
-
-@nx._dispatchable(preserve_edge_attrs={"G": {"weight": 1}})
-def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
-    """Returns HITS hubs and authorities values for nodes.
-
-    The HITS algorithm computes two numbers for a node.
-    Authorities estimates the node value based on the incoming links.
-    Hubs estimates the node value based on outgoing links.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    max_iter : integer, optional
-      Maximum number of iterations in power method.
-
-    tol : float, optional
-      Error tolerance used to check convergence in power method iteration.
-
-    nstart : dictionary, optional
-      Starting value of each node for power method iteration.
-
-    normalized : bool (default=True)
-       Normalize results by the sum of all of the values.
-
-    Returns
-    -------
-    (hubs,authorities) : two-tuple of dictionaries
-       Two dictionaries keyed by node containing the hub and authority
-       values.
-
-    Raises
-    ------
-    PowerIterationFailedConvergence
-        If the algorithm fails to converge to the specified tolerance
-        within the specified number of iterations of the power iteration
-        method.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-    >>> h, a = nx.hits(G)
-
-    Notes
-    -----
-    The eigenvector calculation is done by the power iteration method
-    and has no guarantee of convergence.  The iteration will stop
-    after max_iter iterations or an error tolerance of
-    number_of_nodes(G)*tol has been reached.
-
-    The HITS algorithm was designed for directed graphs but this
-    algorithm does not check if the input graph is directed and will
-    execute on undirected graphs.
-
-    References
-    ----------
-    .. [1] A. Langville and C. Meyer,
-       "A survey of eigenvector methods of web information retrieval."
-       https://epubs.siam.org/doi/epdf/10.1137/S0036144503424786
-    .. [2] Jon Kleinberg,
-       Authoritative sources in a hyperlinked environment
-       Journal of the ACM 46 (5): 604-32, 1999.
-       https://www.cs.cornell.edu/home/kleinber/auth.pdf
-       doi:10.1145/324133.324140.
-    """
-    import numpy as np
-    import scipy as sp
-
-    if len(G) == 0:
-        return {}, {}
-    A = nx.adjacency_matrix(G, nodelist=list(G), dtype=float)
-
-    if nstart is not None:
-        nstart = np.array(list(nstart.values()))
-    if max_iter <= 0:
-        raise nx.PowerIterationFailedConvergence(max_iter)
-    try:
-        _, _, vt = sp.sparse.linalg.svds(A, k=1, v0=nstart, maxiter=max_iter, tol=tol)
-    except sp.sparse.linalg.ArpackNoConvergence as exc:
-        raise nx.PowerIterationFailedConvergence(max_iter) from exc
-
-    a = vt.flatten().real
-    h = A @ a
-    if normalized:
-        h /= h.sum()
-        a /= a.sum()
-    hubs = dict(zip(G, map(float, h)))
-    authorities = dict(zip(G, map(float, a)))
-    return hubs, authorities
-
-
-def _hits_python(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
-    if isinstance(G, nx.MultiGraph | nx.MultiDiGraph):
-        raise Exception("hits() not defined for graphs with multiedges.")
-    if len(G) == 0:
-        return {}, {}
-    # choose fixed starting vector if not given
-    if nstart is None:
-        h = dict.fromkeys(G, 1.0 / G.number_of_nodes())
-    else:
-        h = nstart
-        # normalize starting vector
-        s = 1.0 / sum(h.values())
-        for k in h:
-            h[k] *= s
-    for _ in range(max_iter):  # power iteration: make up to max_iter iterations
-        hlast = h
-        h = dict.fromkeys(hlast.keys(), 0)
-        a = dict.fromkeys(hlast.keys(), 0)
-        # this "matrix multiply" looks odd because it is
-        # doing a left multiply a^T=hlast^T*G
-        for n in h:
-            for nbr in G[n]:
-                a[nbr] += hlast[n] * G[n][nbr].get("weight", 1)
-        # now multiply h=Ga
-        for n in h:
-            for nbr in G[n]:
-                h[n] += a[nbr] * G[n][nbr].get("weight", 1)
-        # normalize vector
-        s = 1.0 / max(h.values())
-        for n in h:
-            h[n] *= s
-        # normalize vector
-        s = 1.0 / max(a.values())
-        for n in a:
-            a[n] *= s
-        # check convergence, l1 norm
-        err = sum(abs(h[n] - hlast[n]) for n in h)
-        if err < tol:
-            break
-    else:
-        raise nx.PowerIterationFailedConvergence(max_iter)
-    if normalized:
-        s = 1.0 / sum(a.values())
-        for n in a:
-            a[n] *= s
-        s = 1.0 / sum(h.values())
-        for n in h:
-            h[n] *= s
-    return h, a
-
-
-def _hits_numpy(G, normalized=True):
-    """Returns HITS hubs and authorities values for nodes.
-
-    The HITS algorithm computes two numbers for a node.
-    Authorities estimates the node value based on the incoming links.
-    Hubs estimates the node value based on outgoing links.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    normalized : bool (default=True)
-       Normalize results by the sum of all of the values.
-
-    Returns
-    -------
-    (hubs,authorities) : two-tuple of dictionaries
-       Two dictionaries keyed by node containing the hub and authority
-       values.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(4)
-
-    The `hubs` and `authorities` are given by the eigenvectors corresponding to the
-    maximum eigenvalues of the hubs_matrix and the authority_matrix, respectively.
-
-    The ``hubs`` and ``authority`` matrices are computed from the adjacency
-    matrix:
-
-    >>> adj_ary = nx.to_numpy_array(G)
-    >>> hubs_matrix = adj_ary @ adj_ary.T
-    >>> authority_matrix = adj_ary.T @ adj_ary
-
-    `_hits_numpy` maps the eigenvector corresponding to the maximum eigenvalue
-    of the respective matrices to the nodes in `G`:
-
-    >>> from networkx.algorithms.link_analysis.hits_alg import _hits_numpy
-    >>> hubs, authority = _hits_numpy(G)
-
-    Notes
-    -----
-    The eigenvector calculation uses NumPy's interface to LAPACK.
-
-    The HITS algorithm was designed for directed graphs but this
-    algorithm does not check if the input graph is directed and will
-    execute on undirected graphs.
-
-    References
-    ----------
-    .. [1] A. Langville and C. Meyer,
-       "A survey of eigenvector methods of web information retrieval."
-       http://citeseer.ist.psu.edu/713792.html
-    .. [2] Jon Kleinberg,
-       Authoritative sources in a hyperlinked environment
-       Journal of the ACM 46 (5): 604-32, 1999.
-       doi:10.1145/324133.324140.
-       http://www.cs.cornell.edu/home/kleinber/auth.pdf.
-    """
-    import numpy as np
-
-    if len(G) == 0:
-        return {}, {}
-    adj_ary = nx.to_numpy_array(G)
-    # Hub matrix
-    H = adj_ary @ adj_ary.T
-    e, ev = np.linalg.eig(H)
-    h = ev[:, np.argmax(e)]  # eigenvector corresponding to the maximum eigenvalue
-    # Authority matrix
-    A = adj_ary.T @ adj_ary
-    e, ev = np.linalg.eig(A)
-    a = ev[:, np.argmax(e)]  # eigenvector corresponding to the maximum eigenvalue
-    if normalized:
-        h /= h.sum()
-        a /= a.sum()
-    else:
-        h /= h.max()
-        a /= a.max()
-    hubs = dict(zip(G, map(float, h)))
-    authorities = dict(zip(G, map(float, a)))
-    return hubs, authorities
-
-
-def _hits_scipy(G, max_iter=100, tol=1.0e-6, nstart=None, normalized=True):
-    """Returns HITS hubs and authorities values for nodes.
-
-
-    The HITS algorithm computes two numbers for a node.
-    Authorities estimates the node value based on the incoming links.
-    Hubs estimates the node value based on outgoing links.
-
-    Parameters
-    ----------
-    G : graph
-      A NetworkX graph
-
-    max_iter : integer, optional
-      Maximum number of iterations in power method.
-
-    tol : float, optional
-      Error tolerance used to check convergence in power method iteration.
-
-    nstart : dictionary, optional
-      Starting value of each node for power method iteration.
-
-    normalized : bool (default=True)
-       Normalize results by the sum of all of the values.
-
-    Returns
-    -------
-    (hubs,authorities) : two-tuple of dictionaries
-       Two dictionaries keyed by node containing the hub and authority
-       values.
-
-    Examples
-    --------
-    >>> from networkx.algorithms.link_analysis.hits_alg import _hits_scipy
-    >>> G = nx.path_graph(4)
-    >>> h, a = _hits_scipy(G)
-
-    Notes
-    -----
-    This implementation uses SciPy sparse matrices.
-
-    The eigenvector calculation is done by the power iteration method
-    and has no guarantee of convergence.  The iteration will stop
-    after max_iter iterations or an error tolerance of
-    number_of_nodes(G)*tol has been reached.
-
-    The HITS algorithm was designed for directed graphs but this
-    algorithm does not check if the input graph is directed and will
-    execute on undirected graphs.
-
-    Raises
-    ------
-    PowerIterationFailedConvergence
-        If the algorithm fails to converge to the specified tolerance
-        within the specified number of iterations of the power iteration
-        method.
-
-    References
-    ----------
-    .. [1] A. Langville and C. Meyer,
-       "A survey of eigenvector methods of web information retrieval."
-       http://citeseer.ist.psu.edu/713792.html
-    .. [2] Jon Kleinberg,
-       Authoritative sources in a hyperlinked environment
-       Journal of the ACM 46 (5): 604-632, 1999.
-       doi:10.1145/324133.324140.
-       http://www.cs.cornell.edu/home/kleinber/auth.pdf.
-    """
-    import numpy as np
-
-    if len(G) == 0:
-        return {}, {}
-    A = nx.to_scipy_sparse_array(G, nodelist=list(G))
-    (n, _) = A.shape  # should be square
-    ATA = A.T @ A  # authority matrix
-    # choose fixed starting vector if not given
-    if nstart is None:
-        x = np.ones((n, 1)) / n
-    else:
-        x = np.array([nstart.get(n, 0) for n in list(G)], dtype=float)
-        x /= x.sum()
-
-    # power iteration on authority matrix
-    i = 0
-    while True:
-        xlast = x
-        x = ATA @ x
-        x /= x.max()
-        # check convergence, l1 norm
-        err = np.absolute(x - xlast).sum()
-        if err < tol:
-            break
-        if i > max_iter:
-            raise nx.PowerIterationFailedConvergence(max_iter)
-        i += 1
-
-    a = x.flatten()
-    h = A @ a
-    if normalized:
-        h /= h.sum()
-        a /= a.sum()
-    hubs = dict(zip(G, map(float, h)))
-    authorities = dict(zip(G, map(float, a)))
-    return hubs, authorities