Python ParentedTree.fromstring方法代码示例

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_comments(self):
        '''
        Test that comments are correctly filtered out of tgrep search
        strings.
        '''
        tree = ParentedTree.fromstring('(S (NN x) (NP x) (NN x))')
        search1 = '''
        @ NP /^NP/;
        @ NN /^NN/;
        @NN
        '''
        self.assertEqual(list(tgrep.tgrep_positions(search1, [tree])),
                         [[(0,), (2,)]])
        search2 = '''
        # macros
        @ NP /^NP/;
        @ NN /^NN/;

        # search string
        @NN
        '''
        self.assertEqual(list(tgrep.tgrep_positions(search2, [tree])),
                         [[(0,), (2,)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def tests_rel_indexed_children(self):
        '''
        Test matching nodes based on their index in their parent node.
        '''
        tree = ParentedTree.fromstring('(S (A x) (B x) (C x))')
        self.assertEqual(list(tgrep.tgrep_positions('* >, S', [tree])),   [[(0,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >1 S', [tree])),   [[(0,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >2 S', [tree])),   [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >3 S', [tree])),   [[(2,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >\' S', [tree])),  [[(2,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >-1 S', [tree])),  [[(2,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >-2 S', [tree])),  [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* >-3 S', [tree])),  [[(0,)]])
        tree = ParentedTree.fromstring(
            '(S (D (A x) (B x) (C x)) (E (B x) (C x) (A x)) '
            '(F (C x) (A x) (B x)))')
        self.assertEqual(list(tgrep.tgrep_positions('* <, A', [tree])),   [[(0,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <1 A', [tree])),   [[(0,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <2 A', [tree])),   [[(2,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <3 A', [tree])),   [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <\' A', [tree])),  [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <-1 A', [tree])),  [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <-2 A', [tree])),  [[(2,)]])
        self.assertEqual(list(tgrep.tgrep_positions('* <-3 A', [tree])),  [[(0,)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_rel_precedence(self):
        '''
        Test matching nodes based on precedence relations.
        '''
        tree = ParentedTree.fromstring('(S (NP (NP (PP x)) (NP (AP x)))'
                                       ' (VP (AP (X (PP x)) (Y (AP x))))'
                                       ' (NP (RC (NP (AP x)))))')
        self.assertEqual(list(tgrep.tgrep_positions('* . X', [tree])),
                         [[(0,), (0, 1), (0, 1, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* . Y', [tree])),
                         [[(1, 0, 0), (1, 0, 0, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* .. X', [tree])),
                         [[(0,), (0, 0), (0, 0, 0), (0, 1), (0, 1, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* .. Y', [tree])),
                         [[(0,), (0, 0), (0, 0, 0), (0, 1), (0, 1, 0),
                          (1, 0, 0), (1, 0, 0, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* , X', [tree])),
                         [[(1, 0, 1), (1, 0, 1, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* , Y', [tree])),
                         [[(2,), (2, 0), (2, 0, 0), (2, 0, 0, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* ,, X', [tree])),
                         [[(1, 0, 1), (1, 0, 1, 0), (2,), (2, 0), (2, 0, 0),
                          (2, 0, 0, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('* ,, Y', [tree])),
                         [[(2,), (2, 0), (2, 0, 0), (2, 0, 0, 0)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_use_macros(self):
        '''
        Test defining and using tgrep2 macros.
        '''
        tree = ParentedTree.fromstring(
            '(VP (VB sold) (NP (DET the) '
            '(NN heiress)) (NP (NN deed) (PREP to) '
            '(NP (DET the) (NN school) (NN house))))')
        self.assertEqual(list(tgrep.tgrep_positions(
            '@ NP /^NP/;\[email protected] NN /^NN/;\[email protected] !< @NP !$.. @NN',
            [tree])),
                         [[(1,), (2, 2)]])
        # use undefined macro @CNP
        self.assertRaises(
            tgrep.TgrepException,
            list,
            tgrep.tgrep_positions(
                '@ NP /^NP/;\[email protected] NN /^NN/;\[email protected] !< @NP !$.. @NN', [tree])) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def findSentencePTreeToken(sentence, keyword):
	import nltk
	from nltk.tree import ParentedTree
	stemmed = _lemma_(keyword)

	tmp = proc.parse_doc(sentence)
	i = 0
	numSentences = len(tmp['sentences'])
	rs = []
	for i in range(0, numSentences):
		p = tmp['sentences'][i]['parse']
		ptree = ParentedTree.fromstring(p)

		# rs = []
		for i in range(0, len(ptree.leaves())):
			tree_position = ptree.leaf_treeposition(i)

			node = ptree[tree_position]

			if _stem_(node)==stemmed:
				tree_position = tree_position[0:len(tree_position)-1]
				rs.append(ptree[tree_position])
		# if len(rs)>0:
		# 	return rs
	return rs 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def get_all_parts_of_ctree(self, cparse, clabeldict, learn_features):
        self.cparse = ParentedTree.fromstring(str(cparse))
        if len(cparse.leaves()) != len(self.tokens):
            raise Exception("sentences do not line up!")

        # replacing leaves with node-ids
        idx = 0
        for pos in self.cparse.treepositions('leaves'):
            self.cparse[pos] = idx
            idx += 1
        # replacing internal nodes with node-ids
        for st in self.cparse.subtrees():
            # if x[0] in parentedp.leaves(): continue
            self.idxlabelmap[idx] = clabeldict.addstr(st.label())
            st.set_label(idx)
            idx += 1
        self.get_all_constit_spans()

        if not learn_features:
            return
        # get stuff for constit features
        self.leafnodes = [k for k in self.cparse.subtrees(lambda t: t.height() == 2)]
        for a in xrange(len(self.leafnodes)):
            if self.leafnodes[a][0] != a:
                raise Exception("order mixup!")
        self.get_cpath_to_root()

        # get all lowest common ancestors
        for j in xrange(len(self.leafnodes)):
            for k in xrange(j, len(self.leafnodes)):
                lca, lcaid = self.get_lca(self.leafnodes[j], self.leafnodes[k])
                self.lca[(j, k)] = (lca, lcaid) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_simple(self):
        '''
        Test a simple use of tgrep for finding nodes matching a given
        pattern.
        '''
        tree = ParentedTree.fromstring(
            '(S (NP (DT the) (JJ big) (NN dog)) '
            '(VP bit) (NP (DT a) (NN cat)))')
        self.assertEqual(list(tgrep.tgrep_positions('NN', [tree])),
                         [[(0,2), (2,1)]])
        self.assertEqual(list(tgrep.tgrep_nodes('NN', [tree])),
                         [[tree[0,2], tree[2,1]]])
        self.assertEqual(list(tgrep.tgrep_positions('NN|JJ', [tree])),
                         [[(0, 1), (0, 2), (2, 1)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_printing(self):
        '''Test that the tgrep print operator ' is properly ignored.'''
        tree = ParentedTree.fromstring('(S (n x) (N x))')
        self.assertEqual(list(tgrep.tgrep_positions('N', [tree])),
                         list(tgrep.tgrep_positions('\'N', [tree])))
        self.assertEqual(list(tgrep.tgrep_positions('/[Nn]/', [tree])),
                         list(tgrep.tgrep_positions('\'/[Nn]/', [tree]))) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_encoding(self):
        '''
        Test that tgrep search strings handles bytes and strs the same
        way.
        '''
        tree = ParentedTree.fromstring(
            '(S (NP (DT the) (JJ big) (NN dog)) '
            '(VP bit) (NP (DT a) (NN cat)))')
        self.assertEqual(list(tgrep.tgrep_positions(b('NN'), [tree])),
                         list(tgrep.tgrep_positions('NN', [tree])))
        self.assertEqual(list(tgrep.tgrep_nodes(b('NN'), [tree])),
                         list(tgrep.tgrep_nodes('NN', [tree])))
        self.assertEqual(list(tgrep.tgrep_positions(b('NN|JJ'), [tree])),
                         list(tgrep.tgrep_positions('NN|JJ', [tree]))) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_nocase(self):
        '''
        Test selecting nodes using case insensitive node names.
        '''
        tree = ParentedTree.fromstring('(S (n x) (N x))')
        self.assertEqual(list(tgrep.tgrep_positions('"N"', [tree])), [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('[email protected]"N"', [tree])), [[(0,), (1,)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_quoted(self):
        '''
        Test selecting nodes using quoted node names.
        '''
        tree = ParentedTree.fromstring('(N ("N" x) (N" x) ("\\" x))')
        self.assertEqual(list(tgrep.tgrep_positions('"N"', [tree])), [[()]])
        self.assertEqual(list(tgrep.tgrep_positions('"\\"N\\""', [tree])), [[(0,)]])
        self.assertEqual(list(tgrep.tgrep_positions('"N\\""', [tree])), [[(1,)]])
        self.assertEqual(list(tgrep.tgrep_positions('"\\"\\\\\\""', [tree])), [[(2,)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_regex_2(self):
        '''
        Test regex matching on nodes.
        '''
        tree = ParentedTree.fromstring('(S (SBJ x) (SBJ1 x) (NP-SBJ x))')
        self.assertEqual(list(tgrep.tgrep_positions('/^SBJ/', [tree])),
                         [[(0,), (1,)]])
        # This is a regular expression that matches any node whose
        # name includes SBJ, including NP-SBJ:
        self.assertEqual(list(tgrep.tgrep_positions('/SBJ/', [tree])),
                         [[(0,), (1,), (2,)]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_tree_position(self):
        '''
        Test matching on nodes based on NLTK tree position.
        '''
        tree = ParentedTree.fromstring('(S (NP-SBJ x) (NP x) (NNP x) (VP x))')
        # test all tree positions that are not leaves
        leaf_positions = set([tree.leaf_treeposition(x)
                              for x in range(len(tree.leaves()))])
        tree_positions = [x for x in tree.treepositions()
                          if x not in leaf_positions]
        for position in tree_positions:
            node_id = 'N{0}'.format(position)
            tgrep_positions = list(tgrep.tgrep_positions(node_id, [tree]))
            self.assertEqual(len(tgrep_positions[0]), 1)
            self.assertEqual(tgrep_positions[0][0], position) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_node_noleaves(self):
        '''
        Test node name matching with the search_leaves flag set to False.
        '''
        tree = ParentedTree.fromstring('(S (A (T x)) (B (N x)))')
        self.assertEqual(list(tgrep.tgrep_positions('x', [tree])),
                         [[(0, 0, 0), (1, 0, 0)]])
        self.assertEqual(list(tgrep.tgrep_positions('x', [tree], False)),
                         [[]]) 

# 需要导入模块: from nltk.tree import ParentedTree [as 别名]
# 或者: from nltk.tree.ParentedTree import fromstring [as 别名]
def test_bad_operator(self):
        '''
        Test error handling of undefined tgrep operators.
        '''
        tree = ParentedTree.fromstring('(S (A (T x)) (B (N x)))')
        self.assertRaises(
            tgrep.TgrepException,
            list,
            tgrep.tgrep_positions('* >>> S', [tree]))