示例#1
0
 def test_negative_head(self):
     self.assertEqual(
         head_to_token([
             {
                 "data": "a",
                 "head": 0
             },
             {
                 "data": "dog",
                 "head": 1
             },
             {
                 "data": "wags",
                 "head": -1
             },
             {
                 "data": "tail",
                 "head": -2
             },
         ]), {
             0: [{
                 "data": "a",
                 "head": 0
             }, {
                 "data": "wags",
                 "head": -1
             }, {
                 "data": "tail",
                 "head": -2
             }],
             1: [{
                 "data": "dog",
                 "head": 1
             }],
         })
示例#2
0
    def to_tree(self):
        def _create_tree(head_to_token_mapping, id_=0):
            return [
                TokenTree(child, _create_tree(head_to_token_mapping, child["id"]))
                for child in head_to_token_mapping[id_]
            ]

        root = _create_tree(head_to_token(self))[0]
        root.set_metadata(self.metadata)
        return root
示例#3
0
 def test_simple(self):
     self.assertEqual(
         head_to_token([
             {"data": "a", "head": 0},
             {"data": "dog", "head": 1},
             {"data": "wags", "head": 2},
             {"data": "tail", "head": 1},
         ]),
         {
             0: [{"data": "a", "head": 0}],
             1: [{"data": "dog", "head": 1}, {"data": "tail", "head": 1}],
             2: [{"data": "wags", "head": 2}],
         }
     )
示例#4
0
 def test_range_ids_ignored(self):
     self.assertEqual(
         dict(head_to_token([
             {"data": "a", "head": 0},
             {"data": "dog", "head": 1},
             {"data": "a dog", "head": 0, "id": (1, "-", 2)},  # Range node
             {"data": "wags", "head": 2},
             {"data": "tail", "head": 1},
         ])),
         {
             0: [{"data": "a", "head": 0}],
             1: [{"data": "dog", "head": 1}, {"data": "tail", "head": 1}],
             2: [{"data": "wags", "head": 2}],
         }
     )
示例#5
0
 def test_decimal_ids_ignored(self):
     self.assertEqual(
         dict(
             head_to_token([
                 {
                     "data": "a",
                     "head": 0
                 },
                 {
                     "data": "dog",
                     "head": 1
                 },
                 {
                     "data": "that",
                     "head": 1,
                     "id": (1, ".", 1)
                 },
                 {
                     "data": "wags",
                     "head": 2
                 },
                 {
                     "data": "its",
                     "head": 2,
                     "id": (2, ".", 1)
                 },  # Empty node
                 {
                     "data": "tail",
                     "head": 1
                 },
             ])),
         {
             0: [{
                 "data": "a",
                 "head": 0
             }],
             1: [{
                 "data": "dog",
                 "head": 1
             }, {
                 "data": "tail",
                 "head": 1
             }],
             2: [{
                 "data": "wags",
                 "head": 2
             }],
         })
示例#6
0
def parse_tree(data):
    tokenlists = parse(data)

    def _create_tree(head_to_token_mapping, id_=0):
        return [
            TokenTree(child, _create_tree(head_to_token_mapping, child["id"]))
            for child in head_to_token_mapping[id_]
        ]

    sentences = []
    for tokenlist in tokenlists:
        root = _create_tree(head_to_token(tokenlist))[0]
        root.set_metadata(tokenlist.metadata)
        sentences.append(root)

    return sentences
示例#7
0
    def test_missing_head(self):
        with self.assertRaises(ParseException):
            head_to_token([])

        with self.assertRaises(ParseException):
            head_to_token([{"data": "a"}])