okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/readwrite/tests/test_leda.py

@@ -1,30 +0,0 @@
-import io
-
-import networkx as nx
-
-
-class TestLEDA:
-    def test_parse_leda(self):
-        data = """#header section         \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
-        G = nx.parse_leda(data)
-        G = nx.parse_leda(data.split("\n"))
-        assert sorted(G.nodes()) == ["v1", "v2", "v3", "v4", "v5"]
-        assert sorted(G.edges(data=True)) == [
-            ("v1", "v2", {"label": "4"}),
-            ("v1", "v3", {"label": "3"}),
-            ("v2", "v3", {"label": "2"}),
-            ("v3", "v4", {"label": "3"}),
-            ("v3", "v5", {"label": "7"}),
-            ("v4", "v5", {"label": "6"}),
-            ("v5", "v1", {"label": "foo"}),
-        ]
-
-    def test_read_LEDA(self):
-        fh = io.BytesIO()
-        data = """#header section         \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
-        G = nx.parse_leda(data)
-        fh.write(data.encode("UTF-8"))
-        fh.seek(0)
-        Gin = nx.read_leda(fh)
-        assert sorted(G.nodes()) == sorted(Gin.nodes())
-        assert sorted(G.edges()) == sorted(Gin.edges())

package/runtime/python/okstra_vendor/networkx/readwrite/tests/test_p2g.py

@@ -1,63 +0,0 @@
-import io
-
-import networkx as nx
-from networkx.readwrite.p2g import read_p2g, write_p2g
-from networkx.utils import edges_equal
-
-
-class TestP2G:
-    @classmethod
-    def setup_class(cls):
-        cls.G = nx.Graph(name="test")
-        e = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("a", "f")]
-        cls.G.add_edges_from(e)
-        cls.G.add_node("g")
-        cls.DG = nx.DiGraph(cls.G)
-
-    def test_read_p2g(self):
-        s = b"""\
-name
-3 4
-a
-1 2
-b
-
-c
-0 2
-"""
-        bytesIO = io.BytesIO(s)
-        DG = read_p2g(bytesIO)
-        assert DG.name == "name"
-        assert sorted(DG) == ["a", "b", "c"]
-        assert edges_equal(
-            DG.edges(), [("a", "c"), ("a", "b"), ("c", "a"), ("c", "c")], directed=True
-        )
-
-    def test_write_p2g(self):
-        s = b"""foo
-3 2
-1
-1 
-2
-2 
-3
-
-"""
-        fh = io.BytesIO()
-        G = nx.DiGraph()
-        G.name = "foo"
-        G.add_edges_from([(1, 2), (2, 3)])
-        write_p2g(G, fh)
-        fh.seek(0)
-        r = fh.read()
-        assert r == s
-
-    def test_write_read_p2g(self):
-        fh = io.BytesIO()
-        G = nx.DiGraph()
-        G.name = "foo"
-        G.add_edges_from([("a", "b"), ("b", "c")])
-        write_p2g(G, fh)
-        fh.seek(0)
-        H = read_p2g(fh)
-        assert edges_equal(G.edges(), H.edges(), directed=True)

package/runtime/python/okstra_vendor/networkx/readwrite/tests/test_pajek.py

@@ -1,128 +0,0 @@
-"""
-Pajek tests
-"""
-
-import networkx as nx
-from networkx.utils import edges_equal, nodes_equal
-
-
-class TestPajek:
-    @classmethod
-    def setup_class(cls):
-        cls.data = """*network Tralala\n*vertices 4\n   1 "A1"         0.0938 0.0896   ellipse x_fact 1 y_fact 1\n   2 "Bb"         0.8188 0.2458   ellipse x_fact 1 y_fact 1\n   3 "C"          0.3688 0.7792   ellipse x_fact 1\n   4 "D2"         0.9583 0.8563   ellipse x_fact 1\n*arcs\n1 1 1  h2 0 w 3 c Blue s 3 a1 -130 k1 0.6 a2 -130 k2 0.6 ap 0.5 l "Bezier loop" lc BlueViolet fos 20 lr 58 lp 0.3 la 360\n2 1 1  h2 0 a1 120 k1 1.3 a2 -120 k2 0.3 ap 25 l "Bezier arc" lphi 270 la 180 lr 19 lp 0.5\n1 2 1  h2 0 a1 40 k1 2.8 a2 30 k2 0.8 ap 25 l "Bezier arc" lphi 90 la 0 lp 0.65\n4 2 -1  h2 0 w 1 k1 -2 k2 250 ap 25 l "Circular arc" c Red lc OrangeRed\n3 4 1  p Dashed h2 0 w 2 c OliveGreen ap 25 l "Straight arc" lc PineGreen\n1 3 1  p Dashed h2 0 w 5 k1 -1 k2 -20 ap 25 l "Oval arc" c Brown lc Black\n3 3 -1  h1 6 w 1 h2 12 k1 -2 k2 -15 ap 0.5 l "Circular loop" c Red lc OrangeRed lphi 270 la 180"""
-        cls.G = nx.MultiDiGraph()
-        cls.G.add_nodes_from(["A1", "Bb", "C", "D2"])
-        cls.G.add_edges_from(
-            [
-                ("A1", "A1"),
-                ("A1", "Bb"),
-                ("A1", "C"),
-                ("Bb", "A1"),
-                ("C", "C"),
-                ("C", "D2"),
-                ("D2", "Bb"),
-            ]
-        )
-
-        cls.G.graph["name"] = "Tralala"
-
-    def test_parse_pajek_simple(self):
-        # Example without node positions or shape
-        data = """*Vertices 2\n1 "1"\n2 "2"\n*Edges\n1 2\n2 1"""
-        G = nx.parse_pajek(data)
-        assert sorted(G.nodes()) == ["1", "2"]
-        assert edges_equal(G.edges(), [("1", "2"), ("1", "2")])
-
-    def test_parse_pajek(self):
-        G = nx.parse_pajek(self.data)
-        assert sorted(G.nodes()) == ["A1", "Bb", "C", "D2"]
-        assert edges_equal(
-            G.edges(),
-            [
-                ("A1", "A1"),
-                ("A1", "Bb"),
-                ("A1", "C"),
-                ("Bb", "A1"),
-                ("C", "C"),
-                ("C", "D2"),
-                ("D2", "Bb"),
-            ],
-            directed=True,
-        )
-
-    def test_parse_pajek_mat(self):
-        data = """*Vertices 3\n1 "one"\n2 "two"\n3 "three"\n*Matrix\n1 1 0\n0 1 0\n0 1 0\n"""
-        G = nx.parse_pajek(data)
-        assert set(G.nodes()) == {"one", "two", "three"}
-        assert G.nodes["two"] == {"id": "2"}
-        assert edges_equal(
-            G.edges(),
-            [("one", "one"), ("one", "two"), ("two", "two"), ("three", "two")],
-            directed=True,
-        )
-
-    def test_read_pajek(self, tmp_path):
-        G = nx.parse_pajek(self.data)
-        # Read data from file
-        fname = tmp_path / "test.pjk"
-        with open(fname, "wb") as fh:
-            fh.write(self.data.encode("UTF-8"))
-
-        Gin = nx.read_pajek(fname)
-        assert sorted(G.nodes()) == sorted(Gin.nodes())
-        assert edges_equal(G.edges(), Gin.edges(), directed=True)
-        assert self.G.graph == Gin.graph
-        for n in G:
-            assert G.nodes[n] == Gin.nodes[n]
-
-    def test_write_pajek(self):
-        import io
-
-        G = nx.parse_pajek(self.data)
-        fh = io.BytesIO()
-        nx.write_pajek(G, fh)
-        fh.seek(0)
-        H = nx.read_pajek(fh)
-        assert nodes_equal(list(G), list(H))
-        assert edges_equal(G.edges(), H.edges(), directed=True)
-        # Graph name is left out for now, therefore it is not tested.
-        # assert_equal(G.graph, H.graph)
-
-    def test_ignored_attribute(self):
-        import io
-
-        G = nx.Graph()
-        fh = io.BytesIO()
-        G.add_node(1, int_attr=1)
-        G.add_node(2, empty_attr="  ")
-        G.add_edge(1, 2, int_attr=2)
-        G.add_edge(2, 3, empty_attr="  ")
-
-        import warnings
-
-        with warnings.catch_warnings(record=True) as w:
-            nx.write_pajek(G, fh)
-            assert len(w) == 4
-
-    def test_noname(self):
-        # Make sure we can parse a line such as:  *network
-        # Issue #952
-        line = "*network\n"
-        other_lines = self.data.split("\n")[1:]
-        data = line + "\n".join(other_lines)
-        G = nx.parse_pajek(data)
-
-    def test_unicode(self):
-        import io
-
-        G = nx.Graph()
-        name1 = chr(2344) + chr(123) + chr(6543)
-        name2 = chr(5543) + chr(1543) + chr(324)
-        G.add_edge(name1, "Radiohead", foo=name2)
-        fh = io.BytesIO()
-        nx.write_pajek(G, fh)
-        fh.seek(0)
-        H = nx.read_pajek(fh)
-        assert nodes_equal(list(G), list(H))
-        assert edges_equal(list(G.edges()), list(H.edges()))
-        assert G.graph == H.graph

package/runtime/python/okstra_vendor/networkx/readwrite/tests/test_sparse6.py

@@ -1,166 +0,0 @@
-from io import BytesIO
-
-import pytest
-
-import networkx as nx
-from networkx.utils import edges_equal, nodes_equal
-
-
-class TestSparseGraph6:
-    def test_from_sparse6_bytes(self):
-        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM"
-        G = nx.from_sparse6_bytes(data)
-        assert nodes_equal(
-            sorted(G.nodes()),
-            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
-        )
-        assert edges_equal(
-            G.edges(),
-            [
-                (0, 1),
-                (0, 2),
-                (0, 3),
-                (1, 12),
-                (1, 14),
-                (2, 13),
-                (2, 15),
-                (3, 16),
-                (3, 17),
-                (4, 7),
-                (4, 9),
-                (4, 11),
-                (5, 6),
-                (5, 8),
-                (5, 9),
-                (6, 10),
-                (6, 11),
-                (7, 8),
-                (7, 10),
-                (8, 12),
-                (9, 15),
-                (10, 14),
-                (11, 13),
-                (12, 16),
-                (13, 17),
-                (14, 17),
-                (15, 16),
-            ],
-        )
-
-    def test_from_bytes_multigraph_graph(self):
-        graph_data = b":An"
-        G = nx.from_sparse6_bytes(graph_data)
-        assert isinstance(G, nx.Graph)
-        multigraph_data = b":Ab"
-        M = nx.from_sparse6_bytes(multigraph_data)
-        assert isinstance(M, nx.MultiGraph)
-
-    def test_read_sparse6(self):
-        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM"
-        G = nx.from_sparse6_bytes(data)
-        fh = BytesIO(data)
-        Gin = nx.read_sparse6(fh)
-        assert nodes_equal(G.nodes(), Gin.nodes())
-        assert edges_equal(G.edges(), Gin.edges())
-
-    def test_read_many_graph6(self):
-        # Read many graphs into list
-        data = b":Q___eDcdFcDeFcE`GaJ`IaHbKNbLM\n:Q___dCfDEdcEgcbEGbFIaJ`JaHN`IM"
-        fh = BytesIO(data)
-        glist = nx.read_sparse6(fh)
-        assert len(glist) == 2
-        for G in glist:
-            assert nodes_equal(
-                G.nodes(),
-                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
-            )
-
-
-class TestWriteSparse6:
-    """Unit tests for writing graphs in the sparse6 format.
-
-    Most of the test cases were checked against the sparse6 encoder in Sage.
-
-    """
-
-    def test_null_graph(self):
-        G = nx.null_graph()
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:?\n"
-
-    def test_trivial_graph(self):
-        G = nx.trivial_graph()
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:@\n"
-
-    def test_empty_graph(self):
-        G = nx.empty_graph(5)
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:D\n"
-
-    def test_large_empty_graph(self):
-        G = nx.empty_graph(68)
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:~?@C\n"
-
-    def test_very_large_empty_graph(self):
-        G = nx.empty_graph(258049)
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:~~???~?@\n"
-
-    def test_complete_graph(self):
-        G = nx.complete_graph(4)
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        assert result.getvalue() == b">>sparse6<<:CcKI\n"
-
-    def test_no_header(self):
-        G = nx.complete_graph(4)
-        result = BytesIO()
-        nx.write_sparse6(G, result, header=False)
-        assert result.getvalue() == b":CcKI\n"
-
-    def test_padding(self):
-        codes = (b":Cdv", b":DaYn", b":EaYnN", b":FaYnL", b":GaYnLz")
-        for n, code in enumerate(codes, start=4):
-            G = nx.path_graph(n)
-            result = BytesIO()
-            nx.write_sparse6(G, result, header=False)
-            assert result.getvalue() == code + b"\n"
-
-    def test_complete_bipartite(self):
-        G = nx.complete_bipartite_graph(6, 9)
-        result = BytesIO()
-        nx.write_sparse6(G, result)
-        # Compared with sage
-        expected = b">>sparse6<<:Nk" + b"?G`cJ" * 9 + b"\n"
-        assert result.getvalue() == expected
-
-    def test_read_write_inverse(self):
-        for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
-            m = min(2 * i, i * i // 2)
-            g = nx.random_graphs.gnm_random_graph(i, m, seed=i)
-            gstr = BytesIO()
-            nx.write_sparse6(g, gstr, header=False)
-            # Strip the trailing newline.
-            gstr = gstr.getvalue().rstrip()
-            g2 = nx.from_sparse6_bytes(gstr)
-            assert g2.order() == g.order()
-            assert edges_equal(g2.edges(), g.edges())
-
-    def test_no_directed_graphs(self):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.write_sparse6(nx.DiGraph(), BytesIO())
-
-    def test_write_path(self, tmp_path):
-        # Get a valid temporary file name
-        fullfilename = str(tmp_path / "test.s6")
-        # file should be closed now, so write_sparse6 can open it
-        nx.write_sparse6(nx.null_graph(), fullfilename)
-        with open(fullfilename, mode="rb") as fh:
-            assert fh.read() == b">>sparse6<<:?\n"