okstra 0.130.4 → 0.131.1

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

@@ -1,62 +0,0 @@
-"""
-NetworkX
-========
-
-NetworkX is a Python package for the creation, manipulation, and study of the
-structure, dynamics, and functions of complex networks.
-
-See https://networkx.org for complete documentation.
-"""
-
-__version__ = "3.6.1"
-
-
-# These are imported in order as listed
-from networkx.lazy_imports import _lazy_import
-
-from networkx.exception import *
-
-from networkx import utils
-from networkx.utils import _clear_cache, _dispatchable
-
-# load_and_call entry_points, set configs
-config = utils.backends._set_configs_from_environment()
-utils.config = utils.configs.config = config  # type: ignore[attr-defined]
-
-from networkx import classes
-from networkx.classes import filters
-from networkx.classes import *
-
-from networkx import convert
-from networkx.convert import *
-
-from networkx import convert_matrix
-from networkx.convert_matrix import *
-
-from networkx import relabel
-from networkx.relabel import *
-
-from networkx import generators
-from networkx.generators import *
-
-from networkx import readwrite
-from networkx.readwrite import *
-
-# Need to test with SciPy, when available
-from networkx import algorithms
-from networkx.algorithms import *
-
-from networkx import linalg
-from networkx.linalg import *
-
-from networkx import drawing
-from networkx.drawing import *
-
-
-def __getattr__(name):
-    if name == "random_tree":
-        raise AttributeError(
-            "nx.random_tree was removed in version 3.4. Use `nx.random_labeled_tree` instead.\n"
-            "See: https://networkx.org/documentation/latest/release/release_3.4.html"
-        )
-    raise AttributeError(f"module 'networkx' has no attribute '{name}'")

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

@@ -1,134 +0,0 @@
-from networkx.algorithms.assortativity import *
-from networkx.algorithms.asteroidal import *
-from networkx.algorithms.boundary import *
-from networkx.algorithms.broadcasting import *
-from networkx.algorithms.bridges import *
-from networkx.algorithms.chains import *
-from networkx.algorithms.centrality import *
-from networkx.algorithms.chordal import *
-from networkx.algorithms.cluster import *
-from networkx.algorithms.clique import *
-from networkx.algorithms.communicability_alg import *
-from networkx.algorithms.components import *
-from networkx.algorithms.coloring import *
-from networkx.algorithms.core import *
-from networkx.algorithms.covering import *
-from networkx.algorithms.cycles import *
-from networkx.algorithms.cuts import *
-from networkx.algorithms.d_separation import *
-from networkx.algorithms.dag import *
-from networkx.algorithms.distance_measures import *
-from networkx.algorithms.distance_regular import *
-from networkx.algorithms.dominance import *
-from networkx.algorithms.dominating import *
-from networkx.algorithms.efficiency_measures import *
-from networkx.algorithms.euler import *
-from networkx.algorithms.graphical import *
-from networkx.algorithms.hierarchy import *
-from networkx.algorithms.hybrid import *
-from networkx.algorithms.link_analysis import *
-from networkx.algorithms.link_prediction import *
-from networkx.algorithms.lowest_common_ancestors import *
-from networkx.algorithms.isolate import *
-from networkx.algorithms.matching import *
-from networkx.algorithms.minors import *
-from networkx.algorithms.mis import *
-from networkx.algorithms.moral import *
-from networkx.algorithms.non_randomness import *
-from networkx.algorithms.operators import *
-from networkx.algorithms.planarity import *
-from networkx.algorithms.planar_drawing import *
-from networkx.algorithms.polynomials import *
-from networkx.algorithms.perfect_graph import *
-from networkx.algorithms.reciprocity import *
-from networkx.algorithms.regular import *
-from networkx.algorithms.richclub import *
-from networkx.algorithms.shortest_paths import *
-from networkx.algorithms.similarity import *
-from networkx.algorithms.graph_hashing import *
-from networkx.algorithms.simple_paths import *
-from networkx.algorithms.smallworld import *
-from networkx.algorithms.smetric import *
-from networkx.algorithms.structuralholes import *
-from networkx.algorithms.sparsifiers import *
-from networkx.algorithms.summarization import *
-from networkx.algorithms.swap import *
-from networkx.algorithms.time_dependent import *
-from networkx.algorithms.traversal import *
-from networkx.algorithms.triads import *
-from networkx.algorithms.vitality import *
-from networkx.algorithms.voronoi import *
-from networkx.algorithms.walks import *
-from networkx.algorithms.wiener import *
-
-# Make certain subpackages available to the user as direct imports from
-# the `networkx` namespace.
-from networkx.algorithms import approximation
-from networkx.algorithms import assortativity
-from networkx.algorithms import bipartite
-from networkx.algorithms import node_classification
-from networkx.algorithms import centrality
-from networkx.algorithms import chordal
-from networkx.algorithms import cluster
-from networkx.algorithms import clique
-from networkx.algorithms import components
-from networkx.algorithms import connectivity
-from networkx.algorithms import community
-from networkx.algorithms import coloring
-from networkx.algorithms import flow
-from networkx.algorithms import isomorphism
-from networkx.algorithms import link_analysis
-from networkx.algorithms import lowest_common_ancestors
-from networkx.algorithms import operators
-from networkx.algorithms import shortest_paths
-from networkx.algorithms import tournament
-from networkx.algorithms import traversal
-from networkx.algorithms import tree
-
-# Make certain functions from some of the previous subpackages available
-# to the user as direct imports from the `networkx` namespace.
-from networkx.algorithms.bipartite import complete_bipartite_graph
-from networkx.algorithms.bipartite import is_bipartite
-from networkx.algorithms.bipartite import projected_graph
-from networkx.algorithms.connectivity import all_pairs_node_connectivity
-from networkx.algorithms.connectivity import all_node_cuts
-from networkx.algorithms.connectivity import average_node_connectivity
-from networkx.algorithms.connectivity import edge_connectivity
-from networkx.algorithms.connectivity import edge_disjoint_paths
-from networkx.algorithms.connectivity import k_components
-from networkx.algorithms.connectivity import k_edge_components
-from networkx.algorithms.connectivity import k_edge_subgraphs
-from networkx.algorithms.connectivity import k_edge_augmentation
-from networkx.algorithms.connectivity import is_k_edge_connected
-from networkx.algorithms.connectivity import minimum_edge_cut
-from networkx.algorithms.connectivity import minimum_node_cut
-from networkx.algorithms.connectivity import node_connectivity
-from networkx.algorithms.connectivity import node_disjoint_paths
-from networkx.algorithms.connectivity import stoer_wagner
-from networkx.algorithms.flow import capacity_scaling
-from networkx.algorithms.flow import cost_of_flow
-from networkx.algorithms.flow import gomory_hu_tree
-from networkx.algorithms.flow import max_flow_min_cost
-from networkx.algorithms.flow import maximum_flow
-from networkx.algorithms.flow import maximum_flow_value
-from networkx.algorithms.flow import min_cost_flow
-from networkx.algorithms.flow import min_cost_flow_cost
-from networkx.algorithms.flow import minimum_cut
-from networkx.algorithms.flow import minimum_cut_value
-from networkx.algorithms.flow import network_simplex
-from networkx.algorithms.isomorphism import could_be_isomorphic
-from networkx.algorithms.isomorphism import fast_could_be_isomorphic
-from networkx.algorithms.isomorphism import faster_could_be_isomorphic
-from networkx.algorithms.isomorphism import is_isomorphic
-from networkx.algorithms.isomorphism.vf2pp import *
-from networkx.algorithms.tree.branchings import maximum_branching
-from networkx.algorithms.tree.branchings import maximum_spanning_arborescence
-from networkx.algorithms.tree.branchings import minimum_branching
-from networkx.algorithms.tree.branchings import minimum_spanning_arborescence
-from networkx.algorithms.tree.branchings import ArborescenceIterator
-from networkx.algorithms.tree.coding import *
-from networkx.algorithms.tree.decomposition import *
-from networkx.algorithms.tree.mst import *
-from networkx.algorithms.tree.operations import *
-from networkx.algorithms.tree.recognition import *
-from networkx.algorithms.tournament import is_tournament

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

@@ -1,26 +0,0 @@
-"""Approximations of graph properties and Heuristic methods for optimization.
-
-The functions in this class are not imported into the top-level ``networkx``
-namespace so the easiest way to use them is with::
-
-    >>> from networkx.algorithms import approximation
-
-Another option is to import the specific function with
-``from networkx.algorithms.approximation import function_name``.
-
-"""
-
-from networkx.algorithms.approximation.clustering_coefficient import *
-from networkx.algorithms.approximation.clique import *
-from networkx.algorithms.approximation.connectivity import *
-from networkx.algorithms.approximation.distance_measures import *
-from networkx.algorithms.approximation.dominating_set import *
-from networkx.algorithms.approximation.kcomponents import *
-from networkx.algorithms.approximation.matching import *
-from networkx.algorithms.approximation.ramsey import *
-from networkx.algorithms.approximation.steinertree import *
-from networkx.algorithms.approximation.traveling_salesman import *
-from networkx.algorithms.approximation.treewidth import *
-from networkx.algorithms.approximation.vertex_cover import *
-from networkx.algorithms.approximation.maxcut import *
-from networkx.algorithms.approximation.density import *

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/clique.py

@@ -1,259 +0,0 @@
-"""Functions for computing large cliques and maximum independent sets."""
-
-import networkx as nx
-from networkx.algorithms.approximation import ramsey
-from networkx.utils import not_implemented_for
-
-__all__ = [
-    "clique_removal",
-    "max_clique",
-    "large_clique_size",
-    "maximum_independent_set",
-]
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def maximum_independent_set(G):
-    """Returns an approximate maximum independent set.
-
-    Independent set or stable set is a set of vertices in a graph, no two of
-    which are adjacent. That is, it is a set I of vertices such that for every
-    two vertices in I, there is no edge connecting the two. Equivalently, each
-    edge in the graph has at most one endpoint in I. The size of an independent
-    set is the number of vertices it contains [1]_.
-
-    A maximum independent set is a largest independent set for a given graph G
-    and its size is denoted $\\alpha(G)$. The problem of finding such a set is called
-    the maximum independent set problem and is an NP-hard optimization problem.
-    As such, it is unlikely that there exists an efficient algorithm for finding
-    a maximum independent set of a graph.
-
-    The Independent Set algorithm is based on [2]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    Returns
-    -------
-    iset : Set
-        The apx-maximum independent set
-
-    Examples
-    --------
-    >>> G = nx.path_graph(10)
-    >>> nx.approximation.maximum_independent_set(G)
-    {0, 2, 4, 6, 9}
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    Notes
-    -----
-    Finds the $O(|V|/(log|V|)^2)$ apx of independent set in the worst case.
-
-    References
-    ----------
-    .. [1] `Wikipedia: Independent set
-        <https://en.wikipedia.org/wiki/Independent_set_(graph_theory)>`_
-    .. [2] Boppana, R., & Halldórsson, M. M. (1992).
-       Approximating maximum independent sets by excluding subgraphs.
-       BIT Numerical Mathematics, 32(2), 180–196. Springer.
-    """
-    iset, _ = clique_removal(G)
-    return iset
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def max_clique(G):
-    r"""Find the Maximum Clique
-
-    Finds the $O(|V|/(log|V|)^2)$ apx of maximum clique/independent set
-    in the worst case.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    Returns
-    -------
-    clique : set
-        The apx-maximum clique of the graph
-
-    Examples
-    --------
-    >>> G = nx.path_graph(10)
-    >>> nx.approximation.max_clique(G)
-    {8, 9}
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    Notes
-    -----
-    A clique in an undirected graph G = (V, E) is a subset of the vertex set
-    `C \subseteq V` such that for every two vertices in C there exists an edge
-    connecting the two. This is equivalent to saying that the subgraph
-    induced by C is complete (in some cases, the term clique may also refer
-    to the subgraph).
-
-    A maximum clique is a clique of the largest possible size in a given graph.
-    The clique number `\omega(G)` of a graph G is the number of
-    vertices in a maximum clique in G. The intersection number of
-    G is the smallest number of cliques that together cover all edges of G.
-
-    https://en.wikipedia.org/wiki/Maximum_clique
-
-    References
-    ----------
-    .. [1] Boppana, R., & Halldórsson, M. M. (1992).
-        Approximating maximum independent sets by excluding subgraphs.
-        BIT Numerical Mathematics, 32(2), 180–196. Springer.
-        doi:10.1007/BF01994876
-    """
-    # finding the maximum clique in a graph is equivalent to finding
-    # the independent set in the complementary graph
-    cgraph = nx.complement(G)
-    iset, _ = clique_removal(cgraph)
-    return iset
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def clique_removal(G):
-    r"""Repeatedly remove cliques from the graph.
-
-    Results in a $O(|V|/(\log |V|)^2)$ approximation of maximum clique
-    and independent set. Returns the largest independent set found, along
-    with found maximal cliques.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-
-    Returns
-    -------
-    max_ind_cliques : (set, list) tuple
-        2-tuple of Maximal Independent Set and list of maximal cliques (sets).
-
-    Examples
-    --------
-    >>> G = nx.path_graph(10)
-    >>> nx.approximation.clique_removal(G)
-    ({0, 2, 4, 6, 9}, [{0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}])
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    References
-    ----------
-    .. [1] Boppana, R., & Halldórsson, M. M. (1992).
-        Approximating maximum independent sets by excluding subgraphs.
-        BIT Numerical Mathematics, 32(2), 180–196. Springer.
-    """
-    graph = G.copy()
-    c_i, i_i = ramsey.ramsey_R2(graph)
-    cliques = [c_i]
-    isets = [i_i]
-    while graph:
-        graph.remove_nodes_from(c_i)
-        c_i, i_i = ramsey.ramsey_R2(graph)
-        if c_i:
-            cliques.append(c_i)
-        if i_i:
-            isets.append(i_i)
-    # Determine the largest independent set as measured by cardinality.
-    maxiset = max(isets, key=len)
-    return maxiset, cliques
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-@nx._dispatchable
-def large_clique_size(G):
-    """Find the size of a large clique in a graph.
-
-    A *clique* is a subset of nodes in which each pair of nodes is
-    adjacent. This function is a heuristic for finding the size of a
-    large clique in the graph.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    Returns
-    -------
-    k: integer
-       The size of a large clique in the graph.
-
-    Examples
-    --------
-    >>> G = nx.path_graph(10)
-    >>> nx.approximation.large_clique_size(G)
-    2
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    Notes
-    -----
-    This implementation is from [1]_. Its worst case time complexity is
-    :math:`O(n d^2)`, where *n* is the number of nodes in the graph and
-    *d* is the maximum degree.
-
-    This function is a heuristic, which means it may work well in
-    practice, but there is no rigorous mathematical guarantee on the
-    ratio between the returned number and the actual largest clique size
-    in the graph.
-
-    References
-    ----------
-    .. [1] Pattabiraman, Bharath, et al.
-       "Fast Algorithms for the Maximum Clique Problem on Massive Graphs
-       with Applications to Overlapping Community Detection."
-       *Internet Mathematics* 11.4-5 (2015): 421--448.
-       <https://doi.org/10.1080/15427951.2014.986778>
-
-    See also
-    --------
-
-    :func:`networkx.algorithms.approximation.clique.max_clique`
-        A function that returns an approximate maximum clique with a
-        guarantee on the approximation ratio.
-
-    :mod:`networkx.algorithms.clique`
-        Functions for finding the exact maximum clique in a graph.
-
-    """
-    degrees = G.degree
-
-    def _clique_heuristic(G, U, size, best_size):
-        if not U:
-            return max(best_size, size)
-        u = max(U, key=degrees)
-        U.remove(u)
-        N_prime = {v for v in G[u] if degrees[v] >= best_size}
-        return _clique_heuristic(G, U & N_prime, size + 1, best_size)
-
-    best_size = 0
-    nodes = (u for u in G if degrees[u] >= best_size)
-    for u in nodes:
-        neighbors = {v for v in G[u] if degrees[v] >= best_size}
-        best_size = _clique_heuristic(G, neighbors, 1, best_size)
-    return best_size

package/runtime/python/okstra_vendor/networkx/algorithms/approximation/clustering_coefficient.py

@@ -1,71 +0,0 @@
-import networkx as nx
-from networkx.utils import not_implemented_for, py_random_state
-
-__all__ = ["average_clustering"]
-
-
-@not_implemented_for("directed")
-@py_random_state(2)
-@nx._dispatchable(name="approximate_average_clustering")
-def average_clustering(G, trials=1000, seed=None):
-    r"""Estimates the average clustering coefficient of G.
-
-    The local clustering of each node in `G` is the fraction of triangles
-    that actually exist over all possible triangles in its neighborhood.
-    The average clustering coefficient of a graph `G` is the mean of
-    local clusterings.
-
-    This function finds an approximate average clustering coefficient
-    for G by repeating `n` times (defined in `trials`) the following
-    experiment: choose a node at random, choose two of its neighbors
-    at random, and check if they are connected. The approximate
-    coefficient is the fraction of triangles found over the number
-    of trials [1]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-
-    trials : integer
-        Number of trials to perform (default 1000).
-
-    seed : integer, random_state, or None (default)
-        Indicator of random number generation state.
-        See :ref:`Randomness<randomness>`.
-
-    Returns
-    -------
-    c : float
-        Approximated average clustering coefficient.
-
-    Examples
-    --------
-    >>> from networkx.algorithms import approximation
-    >>> G = nx.erdos_renyi_graph(10, 0.2, seed=10)
-    >>> approximation.average_clustering(G, trials=1000, seed=10)
-    0.214
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If G is directed.
-
-    References
-    ----------
-    .. [1] Schank, Thomas, and Dorothea Wagner. Approximating clustering
-       coefficient and transitivity. Universität Karlsruhe, Fakultät für
-       Informatik, 2004.
-       https://doi.org/10.5445/IR/1000001239
-
-    """
-    n = len(G)
-    triangles = 0
-    nodes = list(G)
-    for i in [int(seed.random() * n) for i in range(trials)]:
-        nbrs = list(G[nodes[i]])
-        if len(nbrs) < 2:
-            continue
-        u, v = seed.sample(nbrs, 2)
-        if u in G[v]:
-            triangles += 1
-    return triangles / trials