okstra 0.114.0 → 0.116.0

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

@@ -1,261 +0,0 @@
-"""
-Testing
-=======
-
-General guidelines for writing good tests:
-
-- doctests always assume ``import networkx as nx`` so don't add that
-- prefer pytest fixtures over classes with setup methods.
-- use the ``@pytest.mark.parametrize``  decorator
-- use ``pytest.importorskip`` for numpy, scipy, pandas, and matplotlib b/c of PyPy.
-  and add the module to the relevant entries below.
-
-"""
-
-import os
-import warnings
-from importlib.metadata import entry_points
-
-import pytest
-
-import networkx as nx
-
-
-def pytest_addoption(parser):
-    parser.addoption(
-        "--runslow", action="store_true", default=False, help="run slow tests"
-    )
-    parser.addoption(
-        "--backend",
-        action="store",
-        default=None,
-        help="Run tests with a backend by auto-converting nx graphs to backend graphs",
-    )
-    parser.addoption(
-        "--fallback-to-nx",
-        action="store_true",
-        default=False,
-        help="Run nx function if a backend doesn't implement a dispatchable function"
-        " (use with --backend)",
-    )
-
-
-def pytest_configure(config):
-    config.addinivalue_line("markers", "slow: mark test as slow to run")
-    backend = config.getoption("--backend")
-    if backend is None:
-        backend = os.environ.get("NETWORKX_TEST_BACKEND")
-    # nx_loopback backend is only available when testing with a backend
-    loopback_ep = entry_points(name="nx_loopback", group="networkx.backends")
-    if not loopback_ep:
-        warnings.warn(
-            "\n\n             WARNING: Mixed NetworkX configuration! \n\n"
-            "        This environment has mixed configuration for networkx.\n"
-            "        The test object nx_loopback is not configured correctly.\n"
-            "        You should not be seeing this message.\n"
-            "        Try `pip install -e .`, or change your PYTHONPATH\n"
-            "        Make sure python finds the networkx repo you are testing\n\n"
-        )
-    config.backend = backend
-    if backend:
-        # We will update `networkx.config.backend_priority` below in `*_modify_items`
-        # to allow tests to get set up with normal networkx graphs.
-        nx.utils.backends.backends["nx_loopback"] = loopback_ep["nx_loopback"]
-        nx.utils.backends.backend_info["nx_loopback"] = {}
-        nx.config.backends = nx.utils.Config(
-            nx_loopback=nx.utils.Config(),
-            **nx.config.backends,
-        )
-        fallback_to_nx = config.getoption("--fallback-to-nx")
-        if not fallback_to_nx:
-            fallback_to_nx = os.environ.get("NETWORKX_FALLBACK_TO_NX")
-        nx.config.fallback_to_nx = bool(fallback_to_nx)
-        nx.utils.backends._dispatchable.__call__ = (
-            nx.utils.backends._dispatchable._call_if_any_backends_installed
-        )
-
-
-def pytest_collection_modifyitems(config, items):
-    # Setting this to True here allows tests to be set up before dispatching
-    # any function call to a backend.
-    if config.backend:
-        # Allow pluggable backends to add markers to tests (such as skip or xfail)
-        # when running in auto-conversion test mode
-        backend_name = config.backend
-        if backend_name != "networkx":
-            nx.utils.backends._dispatchable._is_testing = True
-            nx.config.backend_priority.algos = [backend_name]
-            nx.config.backend_priority.generators = [backend_name]
-            backend = nx.utils.backends.backends[backend_name].load()
-            if hasattr(backend, "on_start_tests"):
-                getattr(backend, "on_start_tests")(items)
-
-    if config.getoption("--runslow"):
-        # --runslow given in cli: do not skip slow tests
-        return
-    skip_slow = pytest.mark.skip(reason="need --runslow option to run")
-    for item in items:
-        if "slow" in item.keywords:
-            item.add_marker(skip_slow)
-
-
-# TODO: The warnings below need to be dealt with, but for now we silence them.
-@pytest.fixture(autouse=True)
-def set_warnings():
-    warnings.filterwarnings(
-        "ignore",
-        category=UserWarning,
-        message=r"Exited (at iteration \d+|postprocessing) with accuracies.*",
-    )
-    warnings.filterwarnings(
-        "ignore",
-        category=UserWarning,
-        message=r"The hashes produced for ",
-    )
-    warnings.filterwarnings(
-        "ignore", category=DeprecationWarning, message="\n\nThe `normalized`"
-    )
-    warnings.filterwarnings(
-        "ignore", category=DeprecationWarning, message="maybe_regular_expander"
-    )
-    warnings.filterwarnings(
-        "ignore", category=DeprecationWarning, message="metric_closure is deprecated"
-    )
-
-
-@pytest.fixture(autouse=True)
-def add_nx(doctest_namespace):
-    doctest_namespace["nx"] = nx
-
-
-# What dependencies are installed?
-
-try:
-    import numpy as np
-
-    has_numpy = True
-except ImportError:
-    has_numpy = False
-
-try:
-    import scipy as sp
-
-    has_scipy = True
-except ImportError:
-    has_scipy = False
-
-try:
-    import matplotlib as mpl
-
-    has_matplotlib = True
-except ImportError:
-    has_matplotlib = False
-
-try:
-    import pandas as pd
-
-    has_pandas = True
-except ImportError:
-    has_pandas = False
-
-try:
-    import pygraphviz
-
-    has_pygraphviz = True
-except ImportError:
-    has_pygraphviz = False
-
-try:
-    import pydot
-
-    has_pydot = True
-except ImportError:
-    has_pydot = False
-
-try:
-    import sympy
-
-    has_sympy = True
-except ImportError:
-    has_sympy = False
-
-
-# List of files that pytest should ignore
-
-collect_ignore = []
-
-needs_numpy = [
-    "algorithms/approximation/traveling_salesman.py",
-    "algorithms/centrality/current_flow_closeness.py",
-    "algorithms/centrality/laplacian.py",
-    "algorithms/node_classification.py",
-    "algorithms/non_randomness.py",
-    "algorithms/polynomials.py",
-    "algorithms/shortest_paths/dense.py",
-    "algorithms/tree/mst.py",
-    "drawing/nx_latex.py",
-    "generators/expanders.py",
-    "linalg/bethehessianmatrix.py",
-    "linalg/laplacianmatrix.py",
-    "utils/misc.py",
-]
-needs_scipy = [
-    "algorithms/approximation/traveling_salesman.py",
-    "algorithms/assortativity/correlation.py",
-    "algorithms/assortativity/mixing.py",
-    "algorithms/assortativity/pairs.py",
-    "algorithms/bipartite/matrix.py",
-    "algorithms/bipartite/spectral.py",
-    "algorithms/bipartite/link_analysis.py",
-    "algorithms/centrality/current_flow_betweenness.py",
-    "algorithms/centrality/current_flow_betweenness_subset.py",
-    "algorithms/centrality/eigenvector.py",
-    "algorithms/centrality/katz.py",
-    "algorithms/centrality/laplacian.py",
-    "algorithms/centrality/second_order.py",
-    "algorithms/centrality/subgraph_alg.py",
-    "algorithms/communicability_alg.py",
-    "algorithms/community/divisive.py",
-    "algorithms/community/bipartitions.py",
-    "algorithms/distance_measures.py",
-    "algorithms/link_analysis/hits_alg.py",
-    "algorithms/link_analysis/pagerank_alg.py",
-    "algorithms/node_classification.py",
-    "algorithms/similarity.py",
-    "algorithms/tree/mst.py",
-    "algorithms/walks.py",
-    "convert_matrix.py",
-    "drawing/layout.py",
-    "drawing/nx_pylab.py",
-    "generators/spectral_graph_forge.py",
-    "generators/geometric.py",
-    "generators/expanders.py",
-    "linalg/algebraicconnectivity.py",
-    "linalg/attrmatrix.py",
-    "linalg/bethehessianmatrix.py",
-    "linalg/graphmatrix.py",
-    "linalg/laplacianmatrix.py",
-    "linalg/modularitymatrix.py",
-    "linalg/spectrum.py",
-    "utils/rcm.py",
-]
-needs_matplotlib = ["drawing/nx_pylab.py", "generators/classic.py"]
-needs_pandas = ["convert_matrix.py"]
-needs_pygraphviz = ["drawing/nx_agraph.py"]
-needs_pydot = ["drawing/nx_pydot.py"]
-needs_sympy = ["algorithms/polynomials.py"]
-
-if not has_numpy:
-    collect_ignore += needs_numpy
-if not has_scipy:
-    collect_ignore += needs_scipy
-if not has_matplotlib:
-    collect_ignore += needs_matplotlib
-if not has_pandas:
-    collect_ignore += needs_pandas
-if not has_pygraphviz:
-    collect_ignore += needs_pygraphviz
-if not has_pydot:
-    collect_ignore += needs_pydot
-if not has_sympy:
-    collect_ignore += needs_sympy

package/runtime/python/okstra_vendor/networkx/drawing/tests/test_agraph.py

@@ -1,237 +0,0 @@
-"""Unit tests for PyGraphviz interface."""
-
-import warnings
-
-import pytest
-
-import networkx as nx
-from networkx.utils import edges_equal, graphs_equal, nodes_equal
-
-pygraphviz = pytest.importorskip("pygraphviz")
-
-
-class TestAGraph:
-    def build_graph(self, G):
-        edges = [("A", "B"), ("A", "C"), ("A", "C"), ("B", "C"), ("A", "D")]
-        G.add_edges_from(edges)
-        G.add_node("E")
-        G.graph["metal"] = "bronze"
-        return G
-
-    def assert_equal(self, G1, G2):
-        assert nodes_equal(G1.nodes(), G2.nodes())
-        assert edges_equal(G1.edges(), G2.edges(), directed=G1.is_directed())
-        assert G1.graph["metal"] == G2.graph["metal"]
-
-    @pytest.mark.parametrize(
-        "G", (nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph())
-    )
-    def test_agraph_roundtripping(self, G, tmp_path):
-        G = self.build_graph(G)
-        A = nx.nx_agraph.to_agraph(G)
-        H = nx.nx_agraph.from_agraph(A)
-        self.assert_equal(G, H)
-
-        fname = tmp_path / "test.dot"
-        nx.drawing.nx_agraph.write_dot(H, fname)
-        Hin = nx.nx_agraph.read_dot(fname)
-        self.assert_equal(H, Hin)
-
-        fname = tmp_path / "fh_test.dot"
-        with open(fname, "w") as fh:
-            nx.drawing.nx_agraph.write_dot(H, fh)
-
-        with open(fname) as fh:
-            Hin = nx.nx_agraph.read_dot(fh)
-        self.assert_equal(H, Hin)
-
-    def test_from_agraph_name(self):
-        G = nx.Graph(name="test")
-        A = nx.nx_agraph.to_agraph(G)
-        H = nx.nx_agraph.from_agraph(A)
-        assert G.name == "test"
-
-    @pytest.mark.parametrize(
-        "graph_class", (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
-    )
-    def test_from_agraph_create_using(self, graph_class):
-        G = nx.path_graph(3)
-        A = nx.nx_agraph.to_agraph(G)
-        H = nx.nx_agraph.from_agraph(A, create_using=graph_class)
-        assert isinstance(H, graph_class)
-
-    def test_from_agraph_named_edges(self):
-        # Create an AGraph from an existing (non-multi) Graph
-        G = nx.Graph()
-        G.add_nodes_from([0, 1])
-        A = nx.nx_agraph.to_agraph(G)
-        # Add edge (+ name, given by key) to the AGraph
-        A.add_edge(0, 1, key="foo")
-        # Verify a.name roundtrips out to 'key' in from_agraph
-        H = nx.nx_agraph.from_agraph(A)
-        assert isinstance(H, nx.Graph)
-        assert ("0", "1", {"key": "foo"}) in H.edges(data=True)
-
-    def test_to_agraph_with_nodedata(self):
-        G = nx.Graph()
-        G.add_node(1, color="red")
-        A = nx.nx_agraph.to_agraph(G)
-        assert dict(A.nodes()[0].attr) == {"color": "red"}
-
-    @pytest.mark.parametrize("graph_class", (nx.Graph, nx.MultiGraph))
-    def test_to_agraph_with_edgedata(self, graph_class):
-        G = graph_class()
-        G.add_nodes_from([0, 1])
-        G.add_edge(0, 1, color="yellow")
-        A = nx.nx_agraph.to_agraph(G)
-        assert dict(A.edges()[0].attr) == {"color": "yellow"}
-
-    def test_view_pygraphviz_path(self, tmp_path):
-        G = nx.complete_graph(3)
-        input_path = str(tmp_path / "graph.png")
-        out_path, A = nx.nx_agraph.view_pygraphviz(G, path=input_path, show=False)
-        assert out_path == input_path
-        # Ensure file is not empty
-        with open(input_path, "rb") as fh:
-            data = fh.read()
-        assert len(data) > 0
-
-    def test_view_pygraphviz_file_suffix(self, tmp_path):
-        G = nx.complete_graph(3)
-        path, A = nx.nx_agraph.view_pygraphviz(G, suffix=1, show=False)
-        assert path[-6:] == "_1.png"
-
-    def test_view_pygraphviz(self):
-        G = nx.Graph()  # "An empty graph cannot be drawn."
-        pytest.raises(nx.NetworkXException, nx.nx_agraph.view_pygraphviz, G)
-        G = nx.barbell_graph(4, 6)
-        nx.nx_agraph.view_pygraphviz(G, show=False)
-
-    def test_view_pygraphviz_edgelabel(self):
-        G = nx.Graph()
-        G.add_edge(1, 2, weight=7)
-        G.add_edge(2, 3, weight=8)
-        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel="weight", show=False)
-        for edge in A.edges():
-            assert edge.attr["weight"] in ("7", "8")
-
-    def test_view_pygraphviz_callable_edgelabel(self):
-        G = nx.complete_graph(3)
-
-        def foo_label(data):
-            return "foo"
-
-        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel=foo_label, show=False)
-        for edge in A.edges():
-            assert edge.attr["label"] == "foo"
-
-    def test_view_pygraphviz_multigraph_edgelabels(self):
-        G = nx.MultiGraph()
-        G.add_edge(0, 1, key=0, name="left_fork")
-        G.add_edge(0, 1, key=1, name="right_fork")
-        path, A = nx.nx_agraph.view_pygraphviz(G, edgelabel="name", show=False)
-        edges = A.edges()
-        assert len(edges) == 2
-        for edge in edges:
-            assert edge.attr["label"].strip() in ("left_fork", "right_fork")
-
-    def test_graph_with_reserved_keywords(self):
-        # test attribute/keyword clash case for #1582
-        # node: n
-        # edges: u,v
-        G = nx.Graph()
-        G = self.build_graph(G)
-        G.nodes["E"]["n"] = "keyword"
-        G.edges[("A", "B")]["u"] = "keyword"
-        G.edges[("A", "B")]["v"] = "keyword"
-        A = nx.nx_agraph.to_agraph(G)
-
-    def test_view_pygraphviz_no_added_attrs_to_input(self):
-        G = nx.complete_graph(2)
-        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
-        assert G.graph == {}
-
-    @pytest.mark.xfail(reason="known bug in clean_attrs")
-    def test_view_pygraphviz_leaves_input_graph_unmodified(self):
-        G = nx.complete_graph(2)
-        # Add entries to graph dict that to_agraph handles specially
-        G.graph["node"] = {"width": "0.80"}
-        G.graph["edge"] = {"fontsize": "14"}
-        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
-        assert G.graph == {"node": {"width": "0.80"}, "edge": {"fontsize": "14"}}
-
-    def test_graph_with_AGraph_attrs(self):
-        G = nx.complete_graph(2)
-        # Add entries to graph dict that to_agraph handles specially
-        G.graph["node"] = {"width": "0.80"}
-        G.graph["edge"] = {"fontsize": "14"}
-        path, A = nx.nx_agraph.view_pygraphviz(G, show=False)
-        # Ensure user-specified values are not lost
-        assert dict(A.node_attr)["width"] == "0.80"
-        assert dict(A.edge_attr)["fontsize"] == "14"
-
-    def test_round_trip_empty_graph(self):
-        G = nx.Graph()
-        A = nx.nx_agraph.to_agraph(G)
-        H = nx.nx_agraph.from_agraph(A)
-        assert graphs_equal(G, H)
-        AA = nx.nx_agraph.to_agraph(H)
-        HH = nx.nx_agraph.from_agraph(AA)
-        assert graphs_equal(H, HH)
-        assert graphs_equal(G, HH)
-
-    @pytest.mark.xfail(reason="integer->string node conversion in round trip")
-    def test_round_trip_integer_nodes(self):
-        G = nx.complete_graph(3)
-        A = nx.nx_agraph.to_agraph(G)
-        H = nx.nx_agraph.from_agraph(A)
-        assert graphs_equal(G, H)
-
-    def test_graphviz_alias(self):
-        G = self.build_graph(nx.Graph())
-        pos_graphviz = nx.nx_agraph.graphviz_layout(G)
-        pos_pygraphviz = nx.nx_agraph.pygraphviz_layout(G)
-        assert pos_graphviz == pos_pygraphviz
-
-    @pytest.mark.parametrize("root", range(5))
-    def test_pygraphviz_layout_root(self, root):
-        # NOTE: test depends on layout prog being deterministic
-        G = nx.complete_graph(5)
-        A = nx.nx_agraph.to_agraph(G)
-        # Get layout with root arg is not None
-        pygv_layout = nx.nx_agraph.pygraphviz_layout(G, prog="circo", root=root)
-        # Equivalent layout directly on AGraph
-        A.layout(args=f"-Groot={root}", prog="circo")
-        # Parse AGraph layout
-        a1_pos = tuple(float(v) for v in dict(A.get_node("1").attr)["pos"].split(","))
-        assert pygv_layout[1] == a1_pos
-
-    def test_2d_layout(self):
-        G = nx.Graph()
-        G = self.build_graph(G)
-        G.graph["dimen"] = 2
-        pos = nx.nx_agraph.pygraphviz_layout(G, prog="neato")
-        pos = list(pos.values())
-        assert len(pos) == 5
-        assert len(pos[0]) == 2
-
-    def test_3d_layout(self):
-        G = nx.Graph()
-        G = self.build_graph(G)
-        G.graph["dimen"] = 3
-        pos = nx.nx_agraph.pygraphviz_layout(G, prog="neato")
-        pos = list(pos.values())
-        assert len(pos) == 5
-        assert len(pos[0]) == 3
-
-    def test_no_warnings_raised(self):
-        # Test that no warnings are raised when Networkx graph
-        # is converted to Pygraphviz graph and 'pos'
-        # attribute is given
-        G = nx.Graph()
-        G.add_node(0, pos=(0, 0))
-        G.add_node(1, pos=(1, 1))
-        A = nx.nx_agraph.to_agraph(G)
-        with warnings.catch_warnings(record=True) as record:
-            A.layout()
-        assert len(record) == 0