Example #1
0
    def test_rst_to_dt(self):
        lw_trees = ["(R:rel (S x) (N y))",

                    """
                    (R:rel
                        (S x)
                        (N:rel (N h) (S t)))
                    """,

                    """
                    (R:r
                        (S x)
                        (N:r (N:r (S t1) (N h))
                             (S t2)))
                    """
                    ]

        for lstr in lw_trees:
            rst1 = parse_lightweight_tree(lstr)
            dep = relaxed_nuclearity_to_deptree(rst1)
            rst2 = relaxed_nuclearity_from_deptree(dep, [])
            self.assertEqual(rst1, rst2, "round-trip on " + lstr)

        for name, tree in self._test_trees().items():
            rst1 = SimpleRSTTree.from_rst_tree(tree)
            dep = relaxed_nuclearity_to_deptree(rst1)
            rst2 = relaxed_nuclearity_from_deptree(dep, [])
            self.assertEqual(treenode(rst1).span,
                             treenode(rst2).span,
                             "span equality on " + name)
            self.assertEqual(treenode(rst1).edu_span,
                             treenode(rst2).edu_span,
                             "edu span equality on " + name)
Example #2
0
    def test_rst_to_dt(self):
        lw_trees = [
            "(R:rel (S x) (N y))", """
                    (R:rel
                        (S x)
                        (N:rel (N h) (S t)))
                    """, """
                    (R:r
                        (S x)
                        (N:r (N:r (S t1) (N h))
                             (S t2)))
                    """
        ]

        for lstr in lw_trees:
            rst1 = parse_lightweight_tree(lstr)
            dep = RstDepTree.from_simple_rst_tree(rst1)
            rst2 = deptree_to_simple_rst_tree(dep)
            self.assertEqual(rst1, rst2, "round-trip on " + lstr)

        for name, tree in self._test_trees().items():
            rst1 = SimpleRSTTree.from_rst_tree(tree)
            dep = RstDepTree.from_simple_rst_tree(rst1)
            rst2 = deptree_to_simple_rst_tree(dep)
            self.assertEqual(
                treenode(rst1).span,
                treenode(rst2).span, "span equality on " + name)
            self.assertEqual(
                treenode(rst1).edu_span,
                treenode(rst2).edu_span, "edu span equality on " + name)
Example #3
0
    def test_rst_to_dt_nuclearity_loss(self):
        """
        Test that we still get sane tree structure with
        nuclearity loss
        """
        tricky = """
                 (R:r (S t) (N h))
                 """

        nuked = """
                (R:r (N t) (N h))
                """

#        tricky = """
#                 (R:r
#                     (S x)
#                     (N:r (N:r (S t1) (N h))
#                          (S t2)))
#                 """
#
#        nuked = """
#                 (R:r
#                     (N x)
#                     (N:r (N:r (N t1) (N h))
#                          (N t2)))
#                 """

        rst0 = parse_lightweight_tree(nuked)
        rst1 = parse_lightweight_tree(tricky)

        # a little sanity check first
        dep0 = relaxed_nuclearity_to_deptree(rst0)
        rev0 = relaxed_nuclearity_from_deptree(dep0, ['r'])
        self.assertEqual(rst0, rev0, "same structure " + nuked)  # sanity

        # now the real test
        dep1 = relaxed_nuclearity_to_deptree(rst1)
        rev1 = relaxed_nuclearity_from_deptree(dep1, ['r'])
Example #4
0
    def test_rst_to_dt_nuclearity_loss(self):
        """
        Test that we still get sane tree structure with
        nuclearity loss
        """
        tricky = """
                 (R:r (S t) (N h))
                 """

        nuked = """
                (R:r (N t) (N h))
                """

        #        tricky = """
        #                 (R:r
        #                     (S x)
        #                     (N:r (N:r (S t1) (N h))
        #                          (S t2)))
        #                 """
        #
        #        nuked = """
        #                 (R:r
        #                     (N x)
        #                     (N:r (N:r (N t1) (N h))
        #                          (N t2)))
        #                 """

        rst0 = parse_lightweight_tree(nuked)
        rst1 = parse_lightweight_tree(tricky)

        # a little sanity check first
        dep0 = RstDepTree.from_simple_rst_tree(rst0)
        rev0 = deptree_to_simple_rst_tree(dep0)  # was:, ['r'])
        self.assertEqual(rst0, rev0, "same structure " + nuked)  # sanity

        # now the real test
        dep1 = RstDepTree.from_simple_rst_tree(rst1)
        rev1 = deptree_to_simple_rst_tree(dep1)  # was:, ['r'])
Example #5
0
    def test_dt_to_rst_order(self):
        lw_trees = [
            "(R:r (N:r (N h) (S r1)) (S r2))",
            "(R:r (S:r (S l2) (N l1)) (N h))",
            "(R:r (N:r (S l1) (N h)) (S r1))",
            """
            (R:r
              (N:r
                (N:r (S l2)
                     (N:r (S l1)
                          (N h)))
                (S r1))
              (S r2))
            """,  # ((l2 <- l1 <- h) -> r1 -> r2)
            """
            (R:r
              (N:r
                (S l2)
                (N:r (N:r (S l1)
                          (N h))
                     (S r1)))
              (S r2))
            """,  # (l2 <- ((l1 <- h) -> r1)) -> r2
        ]

        for lstr in lw_trees:
            rst1 = parse_lightweight_tree(lstr)
            dep = RstDepTree.from_simple_rst_tree(rst1)

            dep_a = dep
            rst2a = deptree_to_simple_rst_tree(dep_a)
            self.assertEqual(rst1, rst2a, "round-trip on " + lstr)

            dep_b = copy.deepcopy(dep)
            dep_b.deps(0).reverse()
            rst2b = deptree_to_simple_rst_tree(dep_b)
            # TODO assertion on rst2b?

            dep_c = copy.deepcopy(dep)
            random.shuffle(dep_c.deps(0))
            rst2c = deptree_to_simple_rst_tree(dep_c)
Example #6
0
    def test_dt_to_rst_order(self):
        lw_trees = ["(R:r (N:r (N h) (S r1)) (S r2))",
                    "(R:r (S:r (S l2) (N l1)) (N h))",
                    "(R:r (N:r (S l1) (N h)) (S r1))",
                    """
                    (R:r
                      (N:r
                        (N:r (S l2)
                             (N:r (S l1)
                                  (N h)))
                        (S r1))
                      (S r2))
                    """,  # ((l2 <- l1 <- h) -> r1 -> r2)
                    """
                    (R:r
                      (N:r
                        (S l2)
                        (N:r (N:r (S l1)
                                  (N h))
                             (S r1)))
                      (S r2))
                    """,  # (l2 <- ((l1 <- h) -> r1)) -> r2
                    ]

        for lstr in lw_trees:
            rst1 = parse_lightweight_tree(lstr)
            dep = relaxed_nuclearity_to_deptree(rst1)
            dep_a = dep
            rst2a = relaxed_nuclearity_from_deptree(dep_a, [])
            self.assertEqual(rst1, rst2a, "round-trip on " + lstr)

            dep_b = Tree(treenode(dep), dep[::-1])
            rst2b = relaxed_nuclearity_from_deptree(dep_b, [])

            dep_c_kids = list(dep)
            random.shuffle(dep_c_kids)
            dep_c = Tree(treenode(dep), dep_c_kids)
            rst2c = relaxed_nuclearity_from_deptree(dep_c, [])