okstra 0.114.0 → 0.116.0

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

@@ -1,229 +0,0 @@
-"""Unit tests for explicit image comparison with pytest-mpl."""
-
-import pytest
-
-import networkx as nx
-
-pytest.importorskip("pytest_mpl")
-
-mpl = pytest.importorskip("matplotlib")
-mpl.use("PS")
-plt = pytest.importorskip("matplotlib.pyplot")
-plt.rcParams["text.usetex"] = False
-np = pytest.importorskip("numpy")
-
-
-@pytest.mark.mpl_image_compare
-def test_display_house_with_colors():
-    """
-    Originally, I wanted to use the exact samge image as test_house_with_colors.
-    But I can't seem to find the correct value for the margins to get the figures
-    to line up perfectly. To the human eye, these visualizations are basically the
-    same.
-    """
-    G = nx.house_graph()
-    fig, ax = plt.subplots()
-    nx.set_node_attributes(
-        G, {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)}, "pos"
-    )
-    nx.set_node_attributes(
-        G,
-        {
-            n: {
-                "size": 3000 if n != 4 else 2000,
-                "color": "tab:blue" if n != 4 else "tab:orange",
-            }
-            for n in G.nodes()
-        },
-    )
-    nx.display(
-        G,
-        node_pos="pos",
-        edge_alpha=0.5,
-        edge_width=6,
-        node_label=None,
-        node_border_color="k",
-    )
-    ax.margins(0.17)
-    plt.tight_layout()
-    plt.axis("off")
-    return fig
-
-
-@pytest.mark.mpl_image_compare
-def test_display_labels_and_colors():
-    """See 'Labels and Colors' gallery example"""
-    fig, ax = plt.subplots()
-    G = nx.cubical_graph()
-    pos = nx.spring_layout(G, seed=3113794652)  # positions for all nodes
-    nx.set_node_attributes(G, pos, "pos")  # Will not be needed after PR 7571
-    labels = iter(
-        [
-            r"$a$",
-            r"$b$",
-            r"$c$",
-            r"$d$",
-            r"$\alpha$",
-            r"$\beta$",
-            r"$\gamma$",
-            r"$\delta$",
-        ]
-    )
-    nx.set_node_attributes(
-        G,
-        {
-            n: {
-                "size": 800,
-                "alpha": 0.9,
-                "color": "tab:red" if n < 4 else "tab:blue",
-                "label": {"label": next(labels), "size": 22, "color": "whitesmoke"},
-            }
-            for n in G.nodes()
-        },
-    )
-
-    nx.display(G, node_pos="pos", edge_color="tab:grey")
-
-    # The tricky bit is the highlighted colors for the edges
-    edgelist = [(0, 1), (1, 2), (2, 3), (0, 3)]
-    nx.set_edge_attributes(
-        G,
-        {
-            (u, v): {
-                "width": 8,
-                "alpha": 0.5,
-                "color": "tab:red",
-                "visible": (u, v) in edgelist,
-            }
-            for u, v in G.edges()
-        },
-    )
-    nx.display(G, node_pos="pos", node_visible=False)
-    edgelist = [(4, 5), (5, 6), (6, 7), (4, 7)]
-    nx.set_edge_attributes(
-        G,
-        {
-            (u, v): {
-                "color": "tab:blue",
-                "visible": (u, v) in edgelist,
-            }
-            for u, v in G.edges()
-        },
-    )
-    nx.display(G, node_pos="pos", node_visible=False)
-
-    plt.tight_layout()
-    plt.axis("off")
-    return fig
-
-
-@pytest.mark.mpl_image_compare
-def test_display_complex():
-    import itertools as it
-
-    fig, ax = plt.subplots()
-    G = nx.MultiDiGraph()
-    nodes = "ABC"
-    prod = list(it.product(nodes, repeat=2)) * 4
-    G = nx.MultiDiGraph()
-    for i, (u, v) in enumerate(prod):
-        G.add_edge(u, v, w=round(i / 3, 2))
-    nx.set_node_attributes(G, nx.spring_layout(G, seed=3113794652), "pos")
-    csi = it.cycle([f"arc3,rad={r}" for r in it.accumulate([0.15] * 4)])
-    nx.set_edge_attributes(G, {e: next(csi) for e in G.edges(keys=True)}, "curvature")
-    nx.set_edge_attributes(
-        G,
-        {
-            tuple(e): {"label": w, "bbox": {"alpha": 0}}
-            for *e, w in G.edges(keys=True, data="w")
-        },
-        "label",
-    )
-    nx.apply_matplotlib_colors(G, "w", "color", mpl.colormaps["inferno"], nodes=False)
-    nx.display(G, canvas=ax, node_pos="pos")
-
-    plt.tight_layout()
-    plt.axis("off")
-    return fig
-
-
-@pytest.mark.mpl_image_compare
-def test_display_shortest_path():
-    fig, ax = plt.subplots()
-    G = nx.Graph()
-    G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
-    G.add_edge("A", "B", weight=4)
-    G.add_edge("A", "H", weight=8)
-    G.add_edge("B", "C", weight=8)
-    G.add_edge("B", "H", weight=11)
-    G.add_edge("C", "D", weight=7)
-    G.add_edge("C", "F", weight=4)
-    G.add_edge("C", "I", weight=2)
-    G.add_edge("D", "E", weight=9)
-    G.add_edge("D", "F", weight=14)
-    G.add_edge("E", "F", weight=10)
-    G.add_edge("F", "G", weight=2)
-    G.add_edge("G", "H", weight=1)
-    G.add_edge("G", "I", weight=6)
-    G.add_edge("H", "I", weight=7)
-
-    # Find the shortest path from node A to node E
-    path = nx.shortest_path(G, "A", "E", weight="weight")
-
-    # Create a list of edges in the shortest path
-    path_edges = list(zip(path, path[1:]))
-    nx.set_node_attributes(G, nx.spring_layout(G, seed=37), "pos")
-    nx.set_edge_attributes(
-        G,
-        {
-            (u, v): {
-                "color": (
-                    "red"
-                    if (u, v) in path_edges or tuple(reversed((u, v))) in path_edges
-                    else "black"
-                ),
-                "label": {"label": d["weight"], "rotate": False},
-            }
-            for u, v, d in G.edges(data=True)
-        },
-    )
-    nx.display(G, canvas=ax)
-    plt.tight_layout()
-    plt.axis("off")
-    return fig
-
-
-@pytest.mark.mpl_image_compare
-def test_display_empty_graph():
-    G = nx.empty_graph()
-    fig, ax = plt.subplots()
-    nx.display(G, canvas=ax)
-    plt.tight_layout()
-    plt.axis("off")
-    return fig
-
-
-@pytest.mark.mpl_image_compare
-def test_house_with_colors():
-    G = nx.house_graph()
-    # explicitly set positions
-    fig, ax = plt.subplots()
-    pos = {0: (0, 0), 1: (1, 0), 2: (0, 1), 3: (1, 1), 4: (0.5, 2.0)}
-
-    # Plot nodes with different properties for the "wall" and "roof" nodes
-    nx.draw_networkx_nodes(
-        G,
-        pos,
-        node_size=3000,
-        nodelist=[0, 1, 2, 3],
-        node_color="tab:blue",
-    )
-    nx.draw_networkx_nodes(
-        G, pos, node_size=2000, nodelist=[4], node_color="tab:orange"
-    )
-    nx.draw_networkx_edges(G, pos, alpha=0.5, width=6)
-    # Customize axes
-    ax.margins(0.11)
-    plt.tight_layout()
-    plt.axis("off")
-    return fig

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

@@ -1,285 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-def test_tikz_attributes():
-    G = nx.path_graph(4, create_using=nx.DiGraph)
-    pos = {n: (n, n) for n in G}
-
-    G.add_edge(0, 0)
-    G.edges[(0, 0)]["label"] = "Loop"
-    G.edges[(0, 0)]["label_options"] = "midway"
-
-    G.nodes[0]["style"] = "blue"
-    G.nodes[1]["style"] = "line width=3,draw"
-    G.nodes[2]["style"] = "circle,draw,blue!50"
-    G.nodes[3]["label"] = "Stop"
-    G.edges[(0, 1)]["label"] = "1st Step"
-    G.edges[(0, 1)]["label_options"] = "near end"
-    G.edges[(2, 3)]["label"] = "3rd Step"
-    G.edges[(2, 3)]["label_options"] = "near start"
-    G.edges[(2, 3)]["style"] = "bend left,green"
-    G.edges[(1, 2)]["label"] = "2nd"
-    G.edges[(1, 2)]["label_options"] = "pos=0.5"
-    G.edges[(1, 2)]["style"] = ">->,bend right,line width=3,green!90"
-
-    output_tex = nx.to_latex(
-        G,
-        pos=pos,
-        as_document=False,
-        tikz_options="[scale=3]",
-        node_options="style",
-        edge_options="style",
-        node_label="label",
-        edge_label="label",
-        edge_label_options="label_options",
-    )
-    expected_tex = r"""\begin{figure}
-  \begin{tikzpicture}[scale=3]
-      \draw
-        (0, 0) node[blue] (0){0}
-        (1, 1) node[line width=3,draw] (1){1}
-        (2, 2) node[circle,draw,blue!50] (2){2}
-        (3, 3) node (3){Stop};
-      \begin{scope}[->]
-        \draw (0) to node[near end] {1st Step} (1);
-        \draw[loop,] (0) to node[midway] {Loop} (0);
-        \draw[>->,bend right,line width=3,green!90] (1) to node[pos=0.5] {2nd} (2);
-        \draw[bend left,green] (2) to node[near start] {3rd Step} (3);
-      \end{scope}
-    \end{tikzpicture}
-\end{figure}"""
-
-    # First, check for consistency line-by-line - if this fails, the mismatched
-    # line will be shown explicitly in the failure summary
-    for expected, actual in zip(expected_tex.split("\n"), output_tex.split("\n")):
-        assert expected == actual
-
-    assert output_tex == expected_tex
-
-
-def test_basic_multiple_graphs():
-    H1 = nx.path_graph(4)
-    H2 = nx.complete_graph(4)
-    H3 = nx.path_graph(8)
-    H4 = nx.complete_graph(8)
-    captions = [
-        "Path on 4 nodes",
-        "Complete graph on 4 nodes",
-        "Path on 8 nodes",
-        "Complete graph on 8 nodes",
-    ]
-    labels = ["fig2a", "fig2b", "fig2c", "fig2d"]
-    latex_code = nx.to_latex(
-        [H1, H2, H3, H4],
-        n_rows=2,
-        sub_captions=captions,
-        sub_labels=labels,
-    )
-    assert "begin{document}" in latex_code
-    assert "begin{figure}" in latex_code
-    assert latex_code.count("begin{subfigure}") == 4
-    assert latex_code.count("tikzpicture") == 8
-    assert latex_code.count("[-]") == 4
-
-
-def test_basic_tikz():
-    expected_tex = r"""\documentclass{report}
-\usepackage{tikz}
-\usepackage{subcaption}
-
-\begin{document}
-\begin{figure}
-  \begin{subfigure}{0.5\textwidth}
-  \begin{tikzpicture}[scale=2]
-      \draw[gray!90]
-        (0.749, 0.702) node[red!90] (0){0}
-        (1.0, -0.014) node[red!90] (1){1}
-        (-0.777, -0.705) node (2){2}
-        (-0.984, 0.042) node (3){3}
-        (-0.028, 0.375) node[cyan!90] (4){4}
-        (-0.412, 0.888) node (5){5}
-        (0.448, -0.856) node (6){6}
-        (0.003, -0.431) node[cyan!90] (7){7};
-      \begin{scope}[->,gray!90]
-        \draw (0) to (4);
-        \draw (0) to (5);
-        \draw (0) to (6);
-        \draw (0) to (7);
-        \draw (1) to (4);
-        \draw (1) to (5);
-        \draw (1) to (6);
-        \draw (1) to (7);
-        \draw (2) to (4);
-        \draw (2) to (5);
-        \draw (2) to (6);
-        \draw (2) to (7);
-        \draw (3) to (4);
-        \draw (3) to (5);
-        \draw (3) to (6);
-        \draw (3) to (7);
-      \end{scope}
-    \end{tikzpicture}
-    \caption{My tikz number 1 of 2}\label{tikz_1_2}
-  \end{subfigure}
-  \begin{subfigure}{0.5\textwidth}
-  \begin{tikzpicture}[scale=2]
-      \draw[gray!90]
-        (0.749, 0.702) node[green!90] (0){0}
-        (1.0, -0.014) node[green!90] (1){1}
-        (-0.777, -0.705) node (2){2}
-        (-0.984, 0.042) node (3){3}
-        (-0.028, 0.375) node[purple!90] (4){4}
-        (-0.412, 0.888) node (5){5}
-        (0.448, -0.856) node (6){6}
-        (0.003, -0.431) node[purple!90] (7){7};
-      \begin{scope}[->,gray!90]
-        \draw (0) to (4);
-        \draw (0) to (5);
-        \draw (0) to (6);
-        \draw (0) to (7);
-        \draw (1) to (4);
-        \draw (1) to (5);
-        \draw (1) to (6);
-        \draw (1) to (7);
-        \draw (2) to (4);
-        \draw (2) to (5);
-        \draw (2) to (6);
-        \draw (2) to (7);
-        \draw (3) to (4);
-        \draw (3) to (5);
-        \draw (3) to (6);
-        \draw (3) to (7);
-      \end{scope}
-    \end{tikzpicture}
-    \caption{My tikz number 2 of 2}\label{tikz_2_2}
-  \end{subfigure}
-  \caption{A graph generated with python and latex.}
-\end{figure}
-\end{document}"""
-
-    edges = [
-        (0, 4),
-        (0, 5),
-        (0, 6),
-        (0, 7),
-        (1, 4),
-        (1, 5),
-        (1, 6),
-        (1, 7),
-        (2, 4),
-        (2, 5),
-        (2, 6),
-        (2, 7),
-        (3, 4),
-        (3, 5),
-        (3, 6),
-        (3, 7),
-    ]
-    G = nx.DiGraph()
-    G.add_nodes_from(range(8))
-    G.add_edges_from(edges)
-    pos = {
-        0: (0.7490296171687696, 0.702353520257394),
-        1: (1.0, -0.014221357723796535),
-        2: (-0.7765783344161441, -0.7054170966808919),
-        3: (-0.9842690223417624, 0.04177547602465483),
-        4: (-0.02768523817180917, 0.3745724439551441),
-        5: (-0.41154855146767433, 0.8880106515525136),
-        6: (0.44780153389148264, -0.8561492709269164),
-        7: (0.0032499953371383505, -0.43092436645809945),
-    }
-
-    rc_node_color = {0: "red!90", 1: "red!90", 4: "cyan!90", 7: "cyan!90"}
-    gp_node_color = {0: "green!90", 1: "green!90", 4: "purple!90", 7: "purple!90"}
-
-    H = G.copy()
-    nx.set_node_attributes(G, rc_node_color, "color")
-    nx.set_node_attributes(H, gp_node_color, "color")
-
-    sub_captions = ["My tikz number 1 of 2", "My tikz number 2 of 2"]
-    sub_labels = ["tikz_1_2", "tikz_2_2"]
-
-    output_tex = nx.to_latex(
-        [G, H],
-        [pos, pos],
-        tikz_options="[scale=2]",
-        default_node_options="gray!90",
-        default_edge_options="gray!90",
-        node_options="color",
-        sub_captions=sub_captions,
-        sub_labels=sub_labels,
-        caption="A graph generated with python and latex.",
-        n_rows=2,
-        as_document=True,
-    )
-
-    # First, check for consistency line-by-line - if this fails, the mismatched
-    # line will be shown explicitly in the failure summary
-    for expected, actual in zip(expected_tex.split("\n"), output_tex.split("\n")):
-        assert expected == actual
-    # Double-check for document-level consistency
-    assert output_tex == expected_tex
-
-
-def test_exception_pos_single_graph(to_latex=nx.to_latex):
-    # smoke test that pos can be a string
-    G = nx.path_graph(4)
-    to_latex(G, pos="pos")
-
-    # must include all nodes
-    pos = {0: (1, 2), 1: (0, 1), 2: (2, 1)}
-    with pytest.raises(nx.NetworkXError):
-        to_latex(G, pos)
-
-    # must have 2 values
-    pos[3] = (1, 2, 3)
-    with pytest.raises(nx.NetworkXError):
-        to_latex(G, pos)
-    pos[3] = 2
-    with pytest.raises(nx.NetworkXError):
-        to_latex(G, pos)
-
-    # check that passes with 2 values
-    pos[3] = (3, 2)
-    to_latex(G, pos)
-
-
-def test_exception_multiple_graphs(to_latex=nx.to_latex):
-    G = nx.path_graph(3)
-    pos_bad = {0: (1, 2), 1: (0, 1)}
-    pos_OK = {0: (1, 2), 1: (0, 1), 2: (2, 1)}
-    fourG = [G, G, G, G]
-    fourpos = [pos_OK, pos_OK, pos_OK, pos_OK]
-
-    # input single dict to use for all graphs
-    to_latex(fourG, pos_OK)
-    with pytest.raises(nx.NetworkXError):
-        to_latex(fourG, pos_bad)
-
-    # input list of dicts to use for all graphs
-    to_latex(fourG, fourpos)
-    with pytest.raises(nx.NetworkXError):
-        to_latex(fourG, [pos_bad, pos_bad, pos_bad, pos_bad])
-
-    # every pos dict must include all nodes
-    with pytest.raises(nx.NetworkXError):
-        to_latex(fourG, [pos_OK, pos_OK, pos_bad, pos_OK])
-
-    # test sub_captions and sub_labels (len must match Gbunch)
-    with pytest.raises(nx.NetworkXError):
-        to_latex(fourG, fourpos, sub_captions=["hi", "hi"])
-
-    with pytest.raises(nx.NetworkXError):
-        to_latex(fourG, fourpos, sub_labels=["hi", "hi"])
-
-    # all pass
-    to_latex(fourG, fourpos, sub_captions=["hi"] * 4, sub_labels=["lbl"] * 4)
-
-
-def test_exception_multigraph():
-    G = nx.path_graph(4, create_using=nx.MultiGraph)
-    G.add_edge(1, 2)
-    with pytest.raises(nx.NetworkXNotImplemented):
-        nx.to_latex(G)