Python pos.POSTag类代码示例

    def _get_pos_tags(self, tokens):
        """Iterate through list of tokens and use POS tagger to build
        a corresponding list of tags.

        :param tokens: List of tokens to be POS-tagged
        :return: List with POS-tag for each token
        """
        # Import (and define tagger) with other imports?    
        from cltk.tag.pos import POSTag
        tagger = POSTag('latin')
        tokens = " ".join(tokens)
        tags = tagger.tag_ngram_123_backoff(tokens)
        tags = [tag[1][0].lower() if tag[1] else tag[1] for tag in tags]
        return tags

    def post(self):
        self.reqparse = reqparse.RequestParser()
        self.reqparse.add_argument('string', required=True)
        self.reqparse.add_argument('lang', required=True, choices=POS_METHODS.keys())
        self.reqparse.add_argument('method', required=False,
                                   default=DEFAULT_POS_METHOD)

        args = self.reqparse.parse_args()
        string = args['string']
        lang = args['lang']
        method = args['method']

        if method not in POS_METHODS[lang]:
            return {'message': {'method': method + ' is not a valid choice'}}

        tagger = POSTag(lang)
        tagged = []
        if method == 'unigram':
            tagged = tagger.tag_unigram(string)
        elif method == 'bigram':
            tagged = tagger.tag_bigram(string)
        elif method == 'trigram':
            tagged = tagger.tag_trigram(string)
        elif method == 'ngram123':
            tagged = tagger.tag_ngram_123_backoff(string)
        elif method == 'tnt':
            tagged = tagger.tag_tnt(string)

        return {'tags': [{'word': word, 'tag': tag}
                         if tag is not None else {'word': word, 'tag': 'None'}
                         for word, tag in tagged]}

 def test_pos_perceptron_tagger_old_english(self):
     """Test tagging Old English POS with Perceptron tagger."""
     tagger = POSTag('old_english')
     tagged = tagger.tag_perceptron('Hwæt! We Gardena in geardagum, þeodcyninga, þrym gefrunon, hu ða æþelingas ellen fremedon.')
     self.assertTrue(tagged)

 def test_pos_ngram123_tagger_old_english(self):
     """Test tagging Old English POS with a 1-, 2-, and 3-gram backoff tagger."""
     tagger = POSTag('old_english')
     tagged = tagger.tag_ngram_123_backoff('Hwæt! We Gardena in geardagum, þeodcyninga, þrym gefrunon, hu ða æþelingas ellen fremedon.')  # pylint: disable=line-too-long
     self.assertTrue(tagged)

 def test_pos_trigram_old_english(self):
     """Test tagging old_english POS with trigram tagger."""
     tagger = POSTag('old_english')
     tagged = tagger.tag_trigram('Hwæt! We Gardena in geardagum, þeodcyninga, þrym gefrunon, hu ða æþelingas ellen fremedon.')
     self.assertTrue(tagged)

 def test_pos_unigram_latin(self):
     """Test tagging Latin POS with unigram tagger."""
     tagger = POSTag('latin')
     tagged = tagger.tag_unigram('Gallia est omnis divisa in partes tres')
     self.assertTrue(tagged)

 def test_pos_tnt_tagger_greek(self):
     """Test tagging Greek POS with TnT tagger."""
     tagger = POSTag('greek')
     tagged = tagger.tag_tnt('θεοὺς μὲν αἰτῶ τῶνδ᾽ ἀπαλλαγὴν πόνων φρουρᾶς ἐτείας μῆκος')  # pylint: disable=line-too-long
     self.assertTrue(tagged)

 def test_pos_ngram123_tagger_greek(self):
     """Test tagging Greek POS with a 1-, 2-, and 3-gram backoff tagger."""
     tagger = POSTag('greek')
     tagged = tagger.tag_ngram_123_backoff('θεοὺς μὲν αἰτῶ τῶνδ᾽ ἀπαλλαγὴν πόνων φρουρᾶς ἐτείας μῆκος')  # pylint: disable=line-too-long
     self.assertTrue(tagged)

 def test_pos_ngram12_tagger_middle_low_german(self):
     """ Test MOG POS 12-backoff tagger"""
     tagger = POSTag('middle_low_german')
     tagged = tagger.tag_ngram_12_backoff('Jck Johannes preister verwarer vnde voirs tender des Juncfrouwen kloisters to Mariendale')
     self.assertTrue(tagged)

 def test_pos_tnt_tagger_old_norse(self):
     """Test tagging Old Norse POS with TnT tagger."""
     tagger = POSTag('old_norse')
     tagged = tagger.tag_tnt('Hlióðs bið ek allar.')
     print(tagged)
     self.assertTrue(tagged)

 def test_pos_crf_tagger_latin(self):
     """Test tagging Latin POS with CRF tagger."""
     tagger = POSTag('latin')
     tagged = tagger.tag_crf('Gallia est omnis divisa in partes tres')
     self.assertTrue(tagged)

 def test_pos_ngram123_tagger_latin(self):
     """Test tagging Latin POS with a 1-, 2-, and 3-gram backoff tagger."""
     tagger = POSTag('latin')
     tagged = tagger.tag_ngram_123_backoff('Gallia est omnis divisa in partes tres')  # pylint: disable=line-too-long
     self.assertTrue(tagged)

# Import modules

# For XML
from xml.dom.minidom import parse, parseString
import codecs
# For CLTK
from cltk.stem.latin.j_v import JVReplacer
from cltk.stem.lemma import LemmaReplacer
from cltk.tag.pos import POSTag

# Initialize CLTK
lemmatizer = LemmaReplacer('latin')
tagger = POSTag('latin')
j = JVReplacer()

# Parse XML

xmldoc = parse('/home/ilbuonme/siti/paolo.monella/ursus/casanatensis.xml')
#xmldoc = parse('/home/ilbuonme/siti/paolo.monella/ursus/shorter_casanatensis.xml')
wordElementList = xmldoc.getElementsByTagName('w')

for w in wordElementList:
        form = w.attributes['ana'].value
        print(form)
        # Parse the inflected word
        try:
            lemmaList = lemmatizer.lemmatize(form.lower())
            lemma = lemmaList[0].replace('v', 'u')

 def getPos(self):
   tagger = POSTag('latin')
   return tagger.tag_unigram(self.text)