Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_aline.py

@@ -0,0 +1,48 @@
+"""
+Test Aline algorithm for aligning phonetic sequences
+"""
+from nltk.metrics import aline
+
+
+def test_aline():
+    result = aline.align("θin", "tenwis")
+    expected = [[("θ", "t"), ("i", "e"), ("n", "n")]]
+
+    assert result == expected
+
+    result = aline.align("jo", "ʒə")
+    expected = [[("j", "ʒ"), ("o", "ə")]]
+
+    assert result == expected
+
+    result = aline.align("pematesiweni", "pematesewen")
+    expected = [
+        [
+            ("p", "p"),
+            ("e", "e"),
+            ("m", "m"),
+            ("a", "a"),
+            ("t", "t"),
+            ("e", "e"),
+            ("s", "s"),
+            ("i", "e"),
+            ("w", "w"),
+            ("e", "e"),
+            ("n", "n"),
+        ]
+    ]
+
+    assert result == expected
+
+    result = aline.align("tuwθ", "dentis")
+    expected = [[("t", "t"), ("u", "i"), ("w", "-"), ("θ", "s")]]
+
+    assert result == expected
+
+
+def test_aline_delta():
+    """
+    Test aline for computing the difference between two segments
+    """
+    assert aline.delta("p", "q") == 20.0
+    assert aline.delta("a", "A") == 0.0

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_brill.py

@@ -0,0 +1,34 @@
+"""
+Tests for Brill tagger.
+"""
+
+import unittest
+
+from nltk.corpus import treebank
+from nltk.tag import UnigramTagger, brill, brill_trainer
+from nltk.tbl import demo
+
+
+class TestBrill(unittest.TestCase):
+    def test_pos_template(self):
+        train_sents = treebank.tagged_sents()[:1000]
+        tagger = UnigramTagger(train_sents)
+        trainer = brill_trainer.BrillTaggerTrainer(
+            tagger, [brill.Template(brill.Pos([-1]))]
+        )
+        brill_tagger = trainer.train(train_sents)
+        # Example from https://github.com/nltk/nltk/issues/769
+        result = brill_tagger.tag("This is a foo bar sentence".split())
+        expected = [
+            ("This", "DT"),
+            ("is", "VBZ"),
+            ("a", "DT"),
+            ("foo", None),
+            ("bar", "NN"),
+            ("sentence", None),
+        ]
+        self.assertEqual(result, expected)
+
+    @unittest.skip("Should be tested in __main__ of nltk.tbl.demo")
+    def test_brill_demo(self):
+        demo()

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_cfd_mutation.py

@@ -0,0 +1,39 @@
+import unittest
+
+import pytest
+
+from nltk import ConditionalFreqDist, tokenize
+
+
+class TestEmptyCondFreq(unittest.TestCase):
+    def test_tabulate(self):
+        empty = ConditionalFreqDist()
+        self.assertEqual(empty.conditions(), [])
+        with pytest.raises(ValueError):
+            empty.tabulate(conditions="BUG")  # nonexistent keys shouldn't be added
+        self.assertEqual(empty.conditions(), [])
+
+    def test_plot(self):
+        empty = ConditionalFreqDist()
+        self.assertEqual(empty.conditions(), [])
+        empty.plot(conditions=["BUG"])  # nonexistent keys shouldn't be added
+        self.assertEqual(empty.conditions(), [])
+
+    def test_increment(self):
+        # make sure that we can still mutate cfd normally
+        text = "cow cat mouse cat tiger"
+        cfd = ConditionalFreqDist()
+
+        # create cfd with word length as condition
+        for word in tokenize.word_tokenize(text):
+            condition = len(word)
+            cfd[condition][word] += 1
+
+        self.assertEqual(cfd.conditions(), [3, 5])
+
+        # incrementing previously unseen key is still possible
+        cfd[2]["hi"] += 1
+        self.assertCountEqual(cfd.conditions(), [3, 5, 2])  # new condition added
+        self.assertEqual(
+            cfd[2]["hi"], 1
+        )  # key's frequency incremented from 0 (unseen) to 1

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_cfg2chomsky.py

@@ -0,0 +1,49 @@
+import unittest
+
+import nltk
+from nltk.grammar import CFG
+
+
+class ChomskyNormalFormForCFGTest(unittest.TestCase):
+    def test_simple(self):
+        grammar = CFG.fromstring(
+            """
+          S -> NP VP
+          PP -> P NP
+          NP -> Det N | NP PP P
+          VP -> V NP | VP PP
+          VP -> Det
+          Det -> 'a' | 'the'
+          N -> 'dog' | 'cat'
+          V -> 'chased' | 'sat'
+          P -> 'on' | 'in'
+        """
+        )
+        self.assertFalse(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+        grammar = grammar.chomsky_normal_form(flexible=True)
+        self.assertTrue(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+
+        grammar2 = CFG.fromstring(
+            """
+          S -> NP VP
+          NP -> VP N P
+          VP -> P
+          N -> 'dog' | 'cat'
+          P -> 'on' | 'in'
+        """
+        )
+        self.assertFalse(grammar2.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar2.is_chomsky_normal_form())
+        grammar2 = grammar2.chomsky_normal_form()
+        self.assertTrue(grammar2.is_flexible_chomsky_normal_form())
+        self.assertTrue(grammar2.is_chomsky_normal_form())
+
+    def test_complex(self):
+        grammar = nltk.data.load("grammars/large_grammars/atis.cfg")
+        self.assertFalse(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+        grammar = grammar.chomsky_normal_form(flexible=True)
+        self.assertTrue(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_chunk.py

@@ -0,0 +1,85 @@
+import unittest
+
+from nltk import RegexpParser
+
+
+class TestChunkRule(unittest.TestCase):
+    def test_tag_pattern2re_pattern_quantifier(self):
+        """Test for bug https://github.com/nltk/nltk/issues/1597
+
+        Ensures that curly bracket quantifiers can be used inside a chunk rule.
+        This type of quantifier has been used for the supplementary example
+        in https://www.nltk.org/book/ch07.html#exploring-text-corpora.
+        """
+        sent = [
+            ("The", "AT"),
+            ("September-October", "NP"),
+            ("term", "NN"),
+            ("jury", "NN"),
+            ("had", "HVD"),
+            ("been", "BEN"),
+            ("charged", "VBN"),
+            ("by", "IN"),
+            ("Fulton", "NP-TL"),
+            ("Superior", "JJ-TL"),
+            ("Court", "NN-TL"),
+            ("Judge", "NN-TL"),
+            ("Durwood", "NP"),
+            ("Pye", "NP"),
+            ("to", "TO"),
+            ("investigate", "VB"),
+            ("reports", "NNS"),
+            ("of", "IN"),
+            ("possible", "JJ"),
+            ("``", "``"),
+            ("irregularities", "NNS"),
+            ("''", "''"),
+            ("in", "IN"),
+            ("the", "AT"),
+            ("hard-fought", "JJ"),
+            ("primary", "NN"),
+            ("which", "WDT"),
+            ("was", "BEDZ"),
+            ("won", "VBN"),
+            ("by", "IN"),
+            ("Mayor-nominate", "NN-TL"),
+            ("Ivan", "NP"),
+            ("Allen", "NP"),
+            ("Jr.", "NP"),
+            (".", "."),
+        ]  # source: brown corpus
+        cp = RegexpParser("CHUNK: {<N.*>{4,}}")
+        tree = cp.parse(sent)
+        assert (
+            tree.pformat()
+            == """(S
+  The/AT
+  September-October/NP
+  term/NN
+  jury/NN
+  had/HVD
+  been/BEN
+  charged/VBN
+  by/IN
+  Fulton/NP-TL
+  Superior/JJ-TL
+  (CHUNK Court/NN-TL Judge/NN-TL Durwood/NP Pye/NP)
+  to/TO
+  investigate/VB
+  reports/NNS
+  of/IN
+  possible/JJ
+  ``/``
+  irregularities/NNS
+  ''/''
+  in/IN
+  the/AT
+  hard-fought/JJ
+  primary/NN
+  which/WDT
+  was/BEDZ
+  won/VBN
+  by/IN
+  (CHUNK Mayor-nominate/NN-TL Ivan/NP Allen/NP Jr./NP)
+  ./.)"""
+        )

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_classify.py

@@ -0,0 +1,49 @@
+"""
+Unit tests for nltk.classify. See also: nltk/test/classify.doctest
+"""
+import pytest
+
+from nltk import classify
+
+TRAIN = [
+    (dict(a=1, b=1, c=1), "y"),
+    (dict(a=1, b=1, c=1), "x"),
+    (dict(a=1, b=1, c=0), "y"),
+    (dict(a=0, b=1, c=1), "x"),
+    (dict(a=0, b=1, c=1), "y"),
+    (dict(a=0, b=0, c=1), "y"),
+    (dict(a=0, b=1, c=0), "x"),
+    (dict(a=0, b=0, c=0), "x"),
+    (dict(a=0, b=1, c=1), "y"),
+]
+
+TEST = [
+    (dict(a=1, b=0, c=1)),  # unseen
+    (dict(a=1, b=0, c=0)),  # unseen
+    (dict(a=0, b=1, c=1)),  # seen 3 times, labels=y,y,x
+    (dict(a=0, b=1, c=0)),  # seen 1 time, label=x
+]
+
+RESULTS = [(0.16, 0.84), (0.46, 0.54), (0.41, 0.59), (0.76, 0.24)]
+
+
+def assert_classifier_correct(algorithm):
+    try:
+        classifier = classify.MaxentClassifier.train(
+            TRAIN, algorithm, trace=0, max_iter=1000
+        )
+    except (LookupError, AttributeError) as e:
+        pytest.skip(str(e))
+
+    for (px, py), featureset in zip(RESULTS, TEST):
+        pdist = classifier.prob_classify(featureset)
+        assert abs(pdist.prob("x") - px) < 1e-2, (pdist.prob("x"), px)
+        assert abs(pdist.prob("y") - py) < 1e-2, (pdist.prob("y"), py)
+
+
+def test_megam():
+    assert_classifier_correct("MEGAM")
+
+
+def test_tadm():
+    assert_classifier_correct("TADM")

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_concordance.py

@@ -0,0 +1,98 @@
+import contextlib
+import sys
+import unittest
+from io import StringIO
+
+from nltk.corpus import gutenberg
+from nltk.text import Text
+
+
+@contextlib.contextmanager
+def stdout_redirect(where):
+    sys.stdout = where
+    try:
+        yield where
+    finally:
+        sys.stdout = sys.__stdout__
+
+
+class TestConcordance(unittest.TestCase):
+    """Text constructed using: https://www.nltk.org/book/ch01.html"""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.corpus = gutenberg.words("melville-moby_dick.txt")
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        self.text = Text(TestConcordance.corpus)
+        self.query = "monstrous"
+        self.maxDiff = None
+        self.list_out = [
+            "ong the former , one was of a most monstrous size . ... This came towards us , ",
+            'ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r',
+            "ll over with a heathenish array of monstrous clubs and spears . Some were thick",
+            "d as you gazed , and wondered what monstrous cannibal and savage could ever hav",
+            "that has survived the flood ; most monstrous and most mountainous ! That Himmal",
+            "they might scout at Moby Dick as a monstrous fable , or still worse and more de",
+            "th of Radney .'\" CHAPTER 55 Of the Monstrous Pictures of Whales . I shall ere l",
+            "ing Scenes . In connexion with the monstrous pictures of whales , I am strongly",
+            "ere to enter upon those still more monstrous stories of them which are to be fo",
+            "ght have been rummaged out of this monstrous cabinet there is no telling . But ",
+            "of Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u",
+        ]
+
+    def tearDown(self):
+        pass
+
+    def test_concordance_list(self):
+        concordance_out = self.text.concordance_list(self.query)
+        self.assertEqual(self.list_out, [c.line for c in concordance_out])
+
+    def test_concordance_width(self):
+        list_out = [
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "Monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+        ]
+
+        concordance_out = self.text.concordance_list(self.query, width=0)
+        self.assertEqual(list_out, [c.query for c in concordance_out])
+
+    def test_concordance_lines(self):
+        concordance_out = self.text.concordance_list(self.query, lines=3)
+        self.assertEqual(self.list_out[:3], [c.line for c in concordance_out])
+
+    def test_concordance_print(self):
+        print_out = """Displaying 11 of 11 matches:
+        ong the former , one was of a most monstrous size . ... This came towards us ,
+        ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r
+        ll over with a heathenish array of monstrous clubs and spears . Some were thick
+        d as you gazed , and wondered what monstrous cannibal and savage could ever hav
+        that has survived the flood ; most monstrous and most mountainous ! That Himmal
+        they might scout at Moby Dick as a monstrous fable , or still worse and more de
+        th of Radney .'" CHAPTER 55 Of the Monstrous Pictures of Whales . I shall ere l
+        ing Scenes . In connexion with the monstrous pictures of whales , I am strongly
+        ere to enter upon those still more monstrous stories of them which are to be fo
+        ght have been rummaged out of this monstrous cabinet there is no telling . But
+        of Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u
+        """
+
+        with stdout_redirect(StringIO()) as stdout:
+            self.text.concordance(self.query)
+
+        def strip_space(raw_str):
+            return raw_str.replace(" ", "")
+
+        self.assertEqual(strip_space(print_out), strip_space(stdout.getvalue()))

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_corenlp.py

@@ -0,0 +1,1436 @@
+"""
+Mock test for Stanford CoreNLP wrappers.
+"""
+
+from unittest import TestCase
+from unittest.mock import MagicMock
+
+import pytest
+
+from nltk.parse import corenlp
+from nltk.tree import Tree
+
+
+def setup_module(module):
+    global server
+
+    try:
+        server = corenlp.CoreNLPServer(port=9000)
+    except LookupError:
+        pytest.skip("Could not instantiate CoreNLPServer.")
+
+    try:
+        server.start()
+    except corenlp.CoreNLPServerError as e:
+        pytest.skip(
+            "Skipping CoreNLP tests because the server could not be started. "
+            "Make sure that the 9000 port is free. "
+            "{}".format(e.strerror)
+        )
+
+
+def teardown_module(module):
+    server.stop()
+
+
+class TestTokenizerAPI(TestCase):
+    def test_tokenize(self):
+        corenlp_tokenizer = corenlp.CoreNLPParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "originalText": "Good",
+                            "word": "Good",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 12,
+                            "index": 2,
+                            "originalText": "muffins",
+                            "word": "muffins",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 13,
+                            "characterOffsetEnd": 17,
+                            "index": 3,
+                            "originalText": "cost",
+                            "word": "cost",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 18,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "originalText": "$",
+                            "word": "$",
+                        },
+                        {
+                            "after": "\n",
+                            "before": "",
+                            "characterOffsetBegin": 19,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "originalText": "3.88",
+                            "word": "3.88",
+                        },
+                        {
+                            "after": " ",
+                            "before": "\n",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 26,
+                            "index": 6,
+                            "originalText": "in",
+                            "word": "in",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 27,
+                            "characterOffsetEnd": 30,
+                            "index": 7,
+                            "originalText": "New",
+                            "word": "New",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 35,
+                            "index": 8,
+                            "originalText": "York",
+                            "word": "York",
+                        },
+                        {
+                            "after": "  ",
+                            "before": "",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 36,
+                            "index": 9,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+                {
+                    "index": 1,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "  ",
+                            "characterOffsetBegin": 38,
+                            "characterOffsetEnd": 44,
+                            "index": 1,
+                            "originalText": "Please",
+                            "word": "Please",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 45,
+                            "characterOffsetEnd": 48,
+                            "index": 2,
+                            "originalText": "buy",
+                            "word": "buy",
+                        },
+                        {
+                            "after": "\n",
+                            "before": " ",
+                            "characterOffsetBegin": 49,
+                            "characterOffsetEnd": 51,
+                            "index": 3,
+                            "originalText": "me",
+                            "word": "me",
+                        },
+                        {
+                            "after": " ",
+                            "before": "\n",
+                            "characterOffsetBegin": 52,
+                            "characterOffsetEnd": 55,
+                            "index": 4,
+                            "originalText": "two",
+                            "word": "two",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 56,
+                            "characterOffsetEnd": 58,
+                            "index": 5,
+                            "originalText": "of",
+                            "word": "of",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 59,
+                            "characterOffsetEnd": 63,
+                            "index": 6,
+                            "originalText": "them",
+                            "word": "them",
+                        },
+                        {
+                            "after": "\n",
+                            "before": "",
+                            "characterOffsetBegin": 63,
+                            "characterOffsetEnd": 64,
+                            "index": 7,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+                {
+                    "index": 2,
+                    "tokens": [
+                        {
+                            "after": "",
+                            "before": "\n",
+                            "characterOffsetBegin": 65,
+                            "characterOffsetEnd": 71,
+                            "index": 1,
+                            "originalText": "Thanks",
+                            "word": "Thanks",
+                        },
+                        {
+                            "after": "",
+                            "before": "",
+                            "characterOffsetBegin": 71,
+                            "characterOffsetEnd": 72,
+                            "index": 2,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+            ]
+        }
+        corenlp_tokenizer.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "Good muffins cost $3.88\nin New York.  Please buy me\ntwo of them.\nThanks."
+
+        expected_output = [
+            "Good",
+            "muffins",
+            "cost",
+            "$",
+            "3.88",
+            "in",
+            "New",
+            "York",
+            ".",
+            "Please",
+            "buy",
+            "me",
+            "two",
+            "of",
+            "them",
+            ".",
+            "Thanks",
+            ".",
+        ]
+
+        tokenized_output = list(corenlp_tokenizer.tokenize(input_string))
+
+        corenlp_tokenizer.api_call.assert_called_once_with(
+            "Good muffins cost $3.88\nin New York.  Please buy me\ntwo of them.\nThanks.",
+            properties={"annotators": "tokenize,ssplit"},
+        )
+        self.assertEqual(expected_output, tokenized_output)
+
+
+class TestTaggerAPI(TestCase):
+    def test_pos_tagger(self):
+        corenlp_tagger = corenlp.CoreNLPParser(tagtype="pos")
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod:of",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod:of",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "index": 0,
+                    "parse": "(ROOT\n  (SBARQ\n    (WHNP (WP What))\n    (SQ (VBZ is)\n      (NP\n        (NP (DT the) (NN airspeed))\n        (PP (IN of)\n          (NP (DT an) (NN unladen) (NN swallow)))))\n    (. ?)))",
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "lemma": "what",
+                            "originalText": "What",
+                            "pos": "WP",
+                            "word": "What",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 7,
+                            "index": 2,
+                            "lemma": "be",
+                            "originalText": "is",
+                            "pos": "VBZ",
+                            "word": "is",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 8,
+                            "characterOffsetEnd": 11,
+                            "index": 3,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 12,
+                            "characterOffsetEnd": 20,
+                            "index": 4,
+                            "lemma": "airspeed",
+                            "originalText": "airspeed",
+                            "pos": "NN",
+                            "word": "airspeed",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 21,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "lemma": "of",
+                            "originalText": "of",
+                            "pos": "IN",
+                            "word": "of",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 26,
+                            "index": 6,
+                            "lemma": "a",
+                            "originalText": "an",
+                            "pos": "DT",
+                            "word": "an",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 27,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "unladen",
+                            "originalText": "unladen",
+                            "pos": "JJ",
+                            "word": "unladen",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 42,
+                            "index": 8,
+                            "lemma": "swallow",
+                            "originalText": "swallow",
+                            "pos": "VB",
+                            "word": "swallow",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 43,
+                            "characterOffsetEnd": 44,
+                            "index": 9,
+                            "lemma": "?",
+                            "originalText": "?",
+                            "pos": ".",
+                            "word": "?",
+                        },
+                    ],
+                }
+            ]
+        }
+        corenlp_tagger.api_call = MagicMock(return_value=api_return_value)
+
+        input_tokens = "What is the airspeed of an unladen swallow ?".split()
+        expected_output = [
+            ("What", "WP"),
+            ("is", "VBZ"),
+            ("the", "DT"),
+            ("airspeed", "NN"),
+            ("of", "IN"),
+            ("an", "DT"),
+            ("unladen", "JJ"),
+            ("swallow", "VB"),
+            ("?", "."),
+        ]
+        tagged_output = corenlp_tagger.tag(input_tokens)
+
+        corenlp_tagger.api_call.assert_called_once_with(
+            "What is the airspeed of an unladen swallow ?",
+            properties={
+                "ssplit.isOneSentence": "true",
+                "annotators": "tokenize,ssplit,pos",
+            },
+        )
+        self.assertEqual(expected_output, tagged_output)
+
+    def test_ner_tagger(self):
+        corenlp_tagger = corenlp.CoreNLPParser(tagtype="ner")
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "lemma": "Rami",
+                            "ner": "PERSON",
+                            "originalText": "Rami",
+                            "pos": "NNP",
+                            "word": "Rami",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 8,
+                            "index": 2,
+                            "lemma": "Eid",
+                            "ner": "PERSON",
+                            "originalText": "Eid",
+                            "pos": "NNP",
+                            "word": "Eid",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 9,
+                            "characterOffsetEnd": 11,
+                            "index": 3,
+                            "lemma": "be",
+                            "ner": "O",
+                            "originalText": "is",
+                            "pos": "VBZ",
+                            "word": "is",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 12,
+                            "characterOffsetEnd": 20,
+                            "index": 4,
+                            "lemma": "study",
+                            "ner": "O",
+                            "originalText": "studying",
+                            "pos": "VBG",
+                            "word": "studying",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 21,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "lemma": "at",
+                            "ner": "O",
+                            "originalText": "at",
+                            "pos": "IN",
+                            "word": "at",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 29,
+                            "index": 6,
+                            "lemma": "Stony",
+                            "ner": "ORGANIZATION",
+                            "originalText": "Stony",
+                            "pos": "NNP",
+                            "word": "Stony",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 30,
+                            "characterOffsetEnd": 35,
+                            "index": 7,
+                            "lemma": "Brook",
+                            "ner": "ORGANIZATION",
+                            "originalText": "Brook",
+                            "pos": "NNP",
+                            "word": "Brook",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 36,
+                            "characterOffsetEnd": 46,
+                            "index": 8,
+                            "lemma": "University",
+                            "ner": "ORGANIZATION",
+                            "originalText": "University",
+                            "pos": "NNP",
+                            "word": "University",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 47,
+                            "characterOffsetEnd": 49,
+                            "index": 9,
+                            "lemma": "in",
+                            "ner": "O",
+                            "originalText": "in",
+                            "pos": "IN",
+                            "word": "in",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 50,
+                            "characterOffsetEnd": 52,
+                            "index": 10,
+                            "lemma": "NY",
+                            "ner": "O",
+                            "originalText": "NY",
+                            "pos": "NNP",
+                            "word": "NY",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_tagger.api_call = MagicMock(return_value=api_return_value)
+
+        input_tokens = "Rami Eid is studying at Stony Brook University in NY".split()
+        expected_output = [
+            ("Rami", "PERSON"),
+            ("Eid", "PERSON"),
+            ("is", "O"),
+            ("studying", "O"),
+            ("at", "O"),
+            ("Stony", "ORGANIZATION"),
+            ("Brook", "ORGANIZATION"),
+            ("University", "ORGANIZATION"),
+            ("in", "O"),
+            ("NY", "O"),
+        ]
+        tagged_output = corenlp_tagger.tag(input_tokens)
+
+        corenlp_tagger.api_call.assert_called_once_with(
+            "Rami Eid is studying at Stony Brook University in NY",
+            properties={
+                "ssplit.isOneSentence": "true",
+                "annotators": "tokenize,ssplit,ner",
+            },
+        )
+        self.assertEqual(expected_output, tagged_output)
+
+    def test_unexpected_tagtype(self):
+        with self.assertRaises(ValueError):
+            corenlp_tagger = corenlp.CoreNLPParser(tagtype="test")
+
+
+class TestParserAPI(TestCase):
+    def test_parse(self):
+        corenlp_parser = corenlp.CoreNLPParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "index": 0,
+                    "parse": "(ROOT\n  (NP\n    (NP (DT The) (JJ quick) (JJ brown) (NN fox))\n    (NP\n      (NP (NNS jumps))\n      (PP (IN over)\n        (NP (DT the) (JJ lazy) (NN dog))))))",
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 3,
+                            "index": 1,
+                            "lemma": "the",
+                            "originalText": "The",
+                            "pos": "DT",
+                            "word": "The",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 4,
+                            "characterOffsetEnd": 9,
+                            "index": 2,
+                            "lemma": "quick",
+                            "originalText": "quick",
+                            "pos": "JJ",
+                            "word": "quick",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 10,
+                            "characterOffsetEnd": 15,
+                            "index": 3,
+                            "lemma": "brown",
+                            "originalText": "brown",
+                            "pos": "JJ",
+                            "word": "brown",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 16,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "lemma": "fox",
+                            "originalText": "fox",
+                            "pos": "NN",
+                            "word": "fox",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 20,
+                            "characterOffsetEnd": 25,
+                            "index": 5,
+                            "lemma": "jump",
+                            "originalText": "jumps",
+                            "pos": "VBZ",
+                            "word": "jumps",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 26,
+                            "characterOffsetEnd": 30,
+                            "index": 6,
+                            "lemma": "over",
+                            "originalText": "over",
+                            "pos": "IN",
+                            "word": "over",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 39,
+                            "index": 8,
+                            "lemma": "lazy",
+                            "originalText": "lazy",
+                            "pos": "JJ",
+                            "word": "lazy",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 40,
+                            "characterOffsetEnd": 43,
+                            "index": 9,
+                            "lemma": "dog",
+                            "originalText": "dog",
+                            "pos": "NN",
+                            "word": "dog",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_parser.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "The quick brown fox jumps over the lazy dog".split()
+        expected_output = Tree(
+            "ROOT",
+            [
+                Tree(
+                    "NP",
+                    [
+                        Tree(
+                            "NP",
+                            [
+                                Tree("DT", ["The"]),
+                                Tree("JJ", ["quick"]),
+                                Tree("JJ", ["brown"]),
+                                Tree("NN", ["fox"]),
+                            ],
+                        ),
+                        Tree(
+                            "NP",
+                            [
+                                Tree("NP", [Tree("NNS", ["jumps"])]),
+                                Tree(
+                                    "PP",
+                                    [
+                                        Tree("IN", ["over"]),
+                                        Tree(
+                                            "NP",
+                                            [
+                                                Tree("DT", ["the"]),
+                                                Tree("JJ", ["lazy"]),
+                                                Tree("NN", ["dog"]),
+                                            ],
+                                        ),
+                                    ],
+                                ),
+                            ],
+                        ),
+                    ],
+                )
+            ],
+        )
+
+        parsed_data = next(corenlp_parser.parse(input_string))
+
+        corenlp_parser.api_call.assert_called_once_with(
+            "The quick brown fox jumps over the lazy dog",
+            properties={"ssplit.eolonly": "true"},
+        )
+        self.assertEqual(expected_output, parsed_data)
+
+    def test_dependency_parser(self):
+        corenlp_parser = corenlp.CoreNLPDependencyParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 3,
+                            "index": 1,
+                            "lemma": "the",
+                            "originalText": "The",
+                            "pos": "DT",
+                            "word": "The",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 4,
+                            "characterOffsetEnd": 9,
+                            "index": 2,
+                            "lemma": "quick",
+                            "originalText": "quick",
+                            "pos": "JJ",
+                            "word": "quick",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 10,
+                            "characterOffsetEnd": 15,
+                            "index": 3,
+                            "lemma": "brown",
+                            "originalText": "brown",
+                            "pos": "JJ",
+                            "word": "brown",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 16,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "lemma": "fox",
+                            "originalText": "fox",
+                            "pos": "NN",
+                            "word": "fox",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 20,
+                            "characterOffsetEnd": 25,
+                            "index": 5,
+                            "lemma": "jump",
+                            "originalText": "jumps",
+                            "pos": "VBZ",
+                            "word": "jumps",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 26,
+                            "characterOffsetEnd": 30,
+                            "index": 6,
+                            "lemma": "over",
+                            "originalText": "over",
+                            "pos": "IN",
+                            "word": "over",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 39,
+                            "index": 8,
+                            "lemma": "lazy",
+                            "originalText": "lazy",
+                            "pos": "JJ",
+                            "word": "lazy",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 40,
+                            "characterOffsetEnd": 43,
+                            "index": 9,
+                            "lemma": "dog",
+                            "originalText": "dog",
+                            "pos": "NN",
+                            "word": "dog",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_parser.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "The quick brown fox jumps over the lazy dog".split()
+        expected_output = Tree(
+            "jumps",
+            [
+                Tree("fox", ["The", "quick", "brown"]),
+                Tree("dog", ["over", "the", "lazy"]),
+            ],
+        )
+
+        parsed_data = next(corenlp_parser.parse(input_string))
+
+        corenlp_parser.api_call.assert_called_once_with(
+            "The quick brown fox jumps over the lazy dog",
+            properties={"ssplit.eolonly": "true"},
+        )
+        self.assertEqual(expected_output, parsed_data.tree())

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_corpora.py

@@ -0,0 +1,274 @@
+import unittest
+
+import pytest
+
+from nltk.corpus import (  # mwa_ppdb
+    cess_cat,
+    cess_esp,
+    conll2007,
+    floresta,
+    indian,
+    ptb,
+    sinica_treebank,
+    udhr,
+)
+from nltk.tree import Tree
+
+
+class TestUdhr(unittest.TestCase):
+    def test_words(self):
+        for name in udhr.fileids():
+            words = list(udhr.words(name))
+            self.assertTrue(words)
+
+    def test_raw_unicode(self):
+        for name in udhr.fileids():
+            txt = udhr.raw(name)
+            assert not isinstance(txt, bytes), name
+
+    def test_polish_encoding(self):
+        text_pl = udhr.raw("Polish-Latin2")[:164]
+        text_ppl = udhr.raw("Polish_Polski-Latin2")[:164]
+        expected = """POWSZECHNA DEKLARACJA PRAW CZŁOWIEKA
+[Preamble]
+Trzecia Sesja Ogólnego Zgromadzenia ONZ, obradująca w Paryżu, \
+uchwaliła 10 grudnia 1948 roku jednomyślnie Powszechną"""
+        assert text_pl == expected, "Polish-Latin2"
+        assert text_ppl == expected, "Polish_Polski-Latin2"
+
+
+class TestIndian(unittest.TestCase):
+    def test_words(self):
+        words = indian.words()[:3]
+        self.assertEqual(words, ["মহিষের", "সন্তান", ":"])
+
+    def test_tagged_words(self):
+        tagged_words = indian.tagged_words()[:3]
+        self.assertEqual(
+            tagged_words, [("মহিষের", "NN"), ("সন্তান", "NN"), (":", "SYM")]
+        )
+
+
+class TestCess(unittest.TestCase):
+    def test_catalan(self):
+        words = cess_cat.words()[:15]
+        txt = "El Tribunal_Suprem -Fpa- TS -Fpt- ha confirmat la condemna a quatre anys d' inhabilitació especial"
+        self.assertEqual(words, txt.split())
+        self.assertEqual(cess_cat.tagged_sents()[0][34][0], "càrrecs")
+
+    def test_esp(self):
+        words = cess_esp.words()[:15]
+        txt = "El grupo estatal Electricité_de_France -Fpa- EDF -Fpt- anunció hoy , jueves , la compra del"
+        self.assertEqual(words, txt.split())
+        self.assertEqual(cess_esp.words()[115], "años")
+
+
+class TestFloresta(unittest.TestCase):
+    def test_words(self):
+        words = floresta.words()[:10]
+        txt = "Um revivalismo refrescante O 7_e_Meio é um ex-libris de a"
+        self.assertEqual(words, txt.split())
+
+
+class TestSinicaTreebank(unittest.TestCase):
+    def test_sents(self):
+        first_3_sents = sinica_treebank.sents()[:3]
+        self.assertEqual(
+            first_3_sents, [["一"], ["友情"], ["嘉珍", "和", "我", "住在", "同一條", "巷子"]]
+        )
+
+    def test_parsed_sents(self):
+        parsed_sents = sinica_treebank.parsed_sents()[25]
+        self.assertEqual(
+            parsed_sents,
+            Tree(
+                "S",
+                [
+                    Tree("NP", [Tree("Nba", ["嘉珍"])]),
+                    Tree("V‧地", [Tree("VA11", ["不停"]), Tree("DE", ["的"])]),
+                    Tree("VA4", ["哭泣"]),
+                ],
+            ),
+        )
+
+
+class TestCoNLL2007(unittest.TestCase):
+    # Reading the CoNLL 2007 Dependency Treebanks
+
+    def test_sents(self):
+        sents = conll2007.sents("esp.train")[0]
+        self.assertEqual(
+            sents[:6], ["El", "aumento", "del", "índice", "de", "desempleo"]
+        )
+
+    def test_parsed_sents(self):
+
+        parsed_sents = conll2007.parsed_sents("esp.train")[0]
+
+        self.assertEqual(
+            parsed_sents.tree(),
+            Tree(
+                "fortaleció",
+                [
+                    Tree(
+                        "aumento",
+                        [
+                            "El",
+                            Tree(
+                                "del",
+                                [
+                                    Tree(
+                                        "índice",
+                                        [
+                                            Tree(
+                                                "de",
+                                                [Tree("desempleo", ["estadounidense"])],
+                                            )
+                                        ],
+                                    )
+                                ],
+                            ),
+                        ],
+                    ),
+                    "hoy",
+                    "considerablemente",
+                    Tree(
+                        "al",
+                        [
+                            Tree(
+                                "euro",
+                                [
+                                    Tree(
+                                        "cotizaba",
+                                        [
+                                            ",",
+                                            "que",
+                                            Tree("a", [Tree("15.35", ["las", "GMT"])]),
+                                            "se",
+                                            Tree(
+                                                "en",
+                                                [
+                                                    Tree(
+                                                        "mercado",
+                                                        [
+                                                            "el",
+                                                            Tree("de", ["divisas"]),
+                                                            Tree("de", ["Fráncfort"]),
+                                                        ],
+                                                    )
+                                                ],
+                                            ),
+                                            Tree("a", ["0,9452_dólares"]),
+                                            Tree(
+                                                "frente_a",
+                                                [
+                                                    ",",
+                                                    Tree(
+                                                        "0,9349_dólares",
+                                                        [
+                                                            "los",
+                                                            Tree(
+                                                                "de",
+                                                                [
+                                                                    Tree(
+                                                                        "mañana",
+                                                                        ["esta"],
+                                                                    )
+                                                                ],
+                                                            ),
+                                                        ],
+                                                    ),
+                                                ],
+                                            ),
+                                        ],
+                                    )
+                                ],
+                            )
+                        ],
+                    ),
+                    ".",
+                ],
+            ),
+        )
+
+
+@pytest.mark.skipif(
+    not ptb.fileids(),
+    reason="A full installation of the Penn Treebank is not available",
+)
+class TestPTB(unittest.TestCase):
+    def test_fileids(self):
+        self.assertEqual(
+            ptb.fileids()[:4],
+            [
+                "BROWN/CF/CF01.MRG",
+                "BROWN/CF/CF02.MRG",
+                "BROWN/CF/CF03.MRG",
+                "BROWN/CF/CF04.MRG",
+            ],
+        )
+
+    def test_words(self):
+        self.assertEqual(
+            ptb.words("WSJ/00/WSJ_0003.MRG")[:7],
+            ["A", "form", "of", "asbestos", "once", "used", "*"],
+        )
+
+    def test_tagged_words(self):
+        self.assertEqual(
+            ptb.tagged_words("WSJ/00/WSJ_0003.MRG")[:3],
+            [("A", "DT"), ("form", "NN"), ("of", "IN")],
+        )
+
+    def test_categories(self):
+        self.assertEqual(
+            ptb.categories(),
+            [
+                "adventure",
+                "belles_lettres",
+                "fiction",
+                "humor",
+                "lore",
+                "mystery",
+                "news",
+                "romance",
+                "science_fiction",
+            ],
+        )
+
+    def test_news_fileids(self):
+        self.assertEqual(
+            ptb.fileids("news")[:3],
+            ["WSJ/00/WSJ_0001.MRG", "WSJ/00/WSJ_0002.MRG", "WSJ/00/WSJ_0003.MRG"],
+        )
+
+    def test_category_words(self):
+        self.assertEqual(
+            ptb.words(categories=["humor", "fiction"])[:6],
+            ["Thirty-three", "Scotty", "did", "not", "go", "back"],
+        )
+
+
+@pytest.mark.skip("Skipping test for mwa_ppdb.")
+class TestMWAPPDB(unittest.TestCase):
+    def test_fileids(self):
+        self.assertEqual(
+            mwa_ppdb.fileids(), ["ppdb-1.0-xxxl-lexical.extended.synonyms.uniquepairs"]
+        )
+
+    def test_entries(self):
+        self.assertEqual(
+            mwa_ppdb.entries()[:10],
+            [
+                ("10/17/01", "17/10/2001"),
+                ("102,70", "102.70"),
+                ("13,53", "13.53"),
+                ("3.2.5.3.2.1", "3.2.5.3.2.1."),
+                ("53,76", "53.76"),
+                ("6.9.5", "6.9.5."),
+                ("7.7.6.3", "7.7.6.3."),
+                ("76,20", "76.20"),
+                ("79,85", "79.85"),
+                ("93,65", "93.65"),
+            ],
+        )

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_data.py

@@ -0,0 +1,15 @@
+import pytest
+
+import nltk.data
+
+
+def test_find_raises_exception():
+    with pytest.raises(LookupError):
+        nltk.data.find("no_such_resource/foo")
+
+
+def test_find_raises_exception_with_full_resource_name():
+    no_such_thing = "no_such_thing/bar"
+    with pytest.raises(LookupError) as exc:
+        nltk.data.find(no_such_thing)
+        assert no_such_thing in str(exc)

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_disagreement.py

@@ -0,0 +1,144 @@
+import unittest
+
+from nltk.metrics.agreement import AnnotationTask
+
+
+class TestDisagreement(unittest.TestCase):
+
+    """
+    Class containing unit tests for nltk.metrics.agreement.Disagreement.
+    """
+
+    def test_easy(self):
+        """
+        Simple test, based on
+        https://github.com/foolswood/krippendorffs_alpha/raw/master/krippendorff.pdf.
+        """
+        data = [
+            ("coder1", "dress1", "YES"),
+            ("coder2", "dress1", "NO"),
+            ("coder3", "dress1", "NO"),
+            ("coder1", "dress2", "YES"),
+            ("coder2", "dress2", "NO"),
+            ("coder3", "dress3", "NO"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), -0.3333333)
+
+    def test_easy2(self):
+        """
+        Same simple test with 1 rating removed.
+        Removal of that rating should not matter: K-Apha ignores items with
+        only 1 rating.
+        """
+        data = [
+            ("coder1", "dress1", "YES"),
+            ("coder2", "dress1", "NO"),
+            ("coder3", "dress1", "NO"),
+            ("coder1", "dress2", "YES"),
+            ("coder2", "dress2", "NO"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), -0.3333333)
+
+    def test_advanced(self):
+        """
+        More advanced test, based on
+        http://www.agreestat.com/research_papers/onkrippendorffalpha.pdf
+        """
+        data = [
+            ("A", "1", "1"),
+            ("B", "1", "1"),
+            ("D", "1", "1"),
+            ("A", "2", "2"),
+            ("B", "2", "2"),
+            ("C", "2", "3"),
+            ("D", "2", "2"),
+            ("A", "3", "3"),
+            ("B", "3", "3"),
+            ("C", "3", "3"),
+            ("D", "3", "3"),
+            ("A", "4", "3"),
+            ("B", "4", "3"),
+            ("C", "4", "3"),
+            ("D", "4", "3"),
+            ("A", "5", "2"),
+            ("B", "5", "2"),
+            ("C", "5", "2"),
+            ("D", "5", "2"),
+            ("A", "6", "1"),
+            ("B", "6", "2"),
+            ("C", "6", "3"),
+            ("D", "6", "4"),
+            ("A", "7", "4"),
+            ("B", "7", "4"),
+            ("C", "7", "4"),
+            ("D", "7", "4"),
+            ("A", "8", "1"),
+            ("B", "8", "1"),
+            ("C", "8", "2"),
+            ("D", "8", "1"),
+            ("A", "9", "2"),
+            ("B", "9", "2"),
+            ("C", "9", "2"),
+            ("D", "9", "2"),
+            ("B", "10", "5"),
+            ("C", "10", "5"),
+            ("D", "10", "5"),
+            ("C", "11", "1"),
+            ("D", "11", "1"),
+            ("C", "12", "3"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), 0.743421052632)
+
+    def test_advanced2(self):
+        """
+        Same more advanced example, but with 1 rating removed.
+        Again, removal of that 1 rating should not matter.
+        """
+        data = [
+            ("A", "1", "1"),
+            ("B", "1", "1"),
+            ("D", "1", "1"),
+            ("A", "2", "2"),
+            ("B", "2", "2"),
+            ("C", "2", "3"),
+            ("D", "2", "2"),
+            ("A", "3", "3"),
+            ("B", "3", "3"),
+            ("C", "3", "3"),
+            ("D", "3", "3"),
+            ("A", "4", "3"),
+            ("B", "4", "3"),
+            ("C", "4", "3"),
+            ("D", "4", "3"),
+            ("A", "5", "2"),
+            ("B", "5", "2"),
+            ("C", "5", "2"),
+            ("D", "5", "2"),
+            ("A", "6", "1"),
+            ("B", "6", "2"),
+            ("C", "6", "3"),
+            ("D", "6", "4"),
+            ("A", "7", "4"),
+            ("B", "7", "4"),
+            ("C", "7", "4"),
+            ("D", "7", "4"),
+            ("A", "8", "1"),
+            ("B", "8", "1"),
+            ("C", "8", "2"),
+            ("D", "8", "1"),
+            ("A", "9", "2"),
+            ("B", "9", "2"),
+            ("C", "9", "2"),
+            ("D", "9", "2"),
+            ("B", "10", "5"),
+            ("C", "10", "5"),
+            ("D", "10", "5"),
+            ("C", "11", "1"),
+            ("D", "11", "1"),
+            ("C", "12", "3"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), 0.743421052632)

llmeval-env/lib/python3.10/site-packages/nltk/test/unit/test_distance.py

@@ -0,0 +1,129 @@
+from typing import Tuple
+
+import pytest
+
+from nltk.metrics.distance import edit_distance
+
+
+class TestEditDistance:
+    @pytest.mark.parametrize(
+        "left,right,substitution_cost,expecteds",
+        [
+            # Allowing transpositions reduces the number of edits required.
+            # with transpositions:
+            # e.g. "abc" -T-> "cba" -D-> "ca": 2 steps
+            #
+            # without transpositions:
+            # e.g. "abc" -D-> "ab" -D-> "a" -I-> "ca": 3 steps
+            ("abc", "ca", 1, (2, 3)),
+            ("abc", "ca", 5, (2, 3)),  # Doesn't *require* substitutions
+            # Note, a substition_cost of higher than 2 doesn't make much
+            # sense, as a deletion + insertion is identical, and always
+            # costs 2.
+            #
+            #
+            # Transpositions don't always reduce the number of edits required:
+            # with or without transpositions:
+            # e.g. "wants" -D-> "wats" -D-> "was" -I-> "wasp": 3 steps
+            ("wants", "wasp", 1, (3, 3)),
+            ("wants", "wasp", 5, (3, 3)),  # Doesn't *require* substitutions
+            #
+            #
+            # Ought to have the same results with and without transpositions
+            # with or without transpositions:
+            # e.g. "rain" -S-> "sain" -S-> "shin" -I-> "shine": 3 steps
+            # (but cost 5 if substitution_cost=2)
+            ("rain", "shine", 1, (3, 3)),
+            ("rain", "shine", 2, (5, 5)),  # Does *require* substitutions
+            #
+            #
+            # Several potentially interesting typos
+            # with transpositions:
+            # e.g. "acbdef" -T-> "abcdef": 1 step
+            #
+            # without transpositions:
+            # e.g. "acbdef" -D-> "abdef" -I-> "abcdef": 2 steps
+            ("acbdef", "abcdef", 1, (1, 2)),
+            ("acbdef", "abcdef", 2, (1, 2)),  # Doesn't *require* substitutions
+            #
+            #
+            # with transpositions:
+            # e.g. "lnaguaeg" -T-> "languaeg" -T-> "language": 2 steps
+            #
+            # without transpositions:
+            # e.g. "lnaguaeg" -D-> "laguaeg" -I-> "languaeg" -D-> "languag" -I-> "language": 4 steps
+            ("lnaguaeg", "language", 1, (2, 4)),
+            ("lnaguaeg", "language", 2, (2, 4)),  # Doesn't *require* substitutions
+            #
+            #
+            # with transpositions:
+            # e.g. "lnaugage" -T-> "lanugage" -T-> "language": 2 steps
+            #
+            # without transpositions:
+            # e.g. "lnaugage" -S-> "lnangage" -D-> "langage" -I-> "language": 3 steps
+            # (but one substitution, so a cost of 4 if substition_cost = 2)
+            ("lnaugage", "language", 1, (2, 3)),
+            ("lnaugage", "language", 2, (2, 4)),
+            # Does *require* substitutions if no transpositions
+            #
+            #
+            # with transpositions:
+            # e.g. "lngauage" -T-> "lnaguage" -T-> "language": 2 steps
+            # without transpositions:
+            # e.g. "lngauage" -I-> "lanaguage" -D-> "language": 2 steps
+            ("lngauage", "language", 1, (2, 2)),
+            ("lngauage", "language", 2, (2, 2)),  # Doesn't *require* substitutions
+            #
+            #
+            # with or without transpositions:
+            # e.g. "wants" -S-> "sants" -S-> "swnts" -S-> "swits" -S-> "swims" -D-> "swim": 5 steps
+            #
+            # with substitution_cost=2 and transpositions:
+            # e.g. "wants" -T-> "santw" -D-> "sntw" -D-> "stw" -D-> "sw"
+            # -I-> "swi" -I-> "swim": 6 steps
+            #
+            # with substitution_cost=2 and no transpositions:
+            # e.g. "wants" -I-> "swants" -D-> "swant" -D-> "swan" -D-> "swa" -D-> "sw"
+            # -I-> "swi" -I-> "swim": 7 steps
+            ("wants", "swim", 1, (5, 5)),
+            ("wants", "swim", 2, (6, 7)),
+            #
+            #
+            # with or without transpositions:
+            # e.g. "kitten" -S-> "sitten" -s-> "sittin" -I-> "sitting": 3 steps
+            # (but cost 5 if substitution_cost=2)
+            ("kitten", "sitting", 1, (3, 3)),
+            ("kitten", "sitting", 2, (5, 5)),
+            #
+            # duplicated letter
+            # e.g. "duplicated" -D-> "duplicated"
+            ("duplicated", "duuplicated", 1, (1, 1)),
+            ("duplicated", "duuplicated", 2, (1, 1)),
+            ("very duplicated", "very duuplicateed", 2, (2, 2)),
+        ],
+    )
+    def test_with_transpositions(
+        self, left: str, right: str, substitution_cost: int, expecteds: Tuple[int, int]
+    ):
+        """
+        Test `edit_distance` between two strings, given some `substitution_cost`,
+        and whether transpositions are allowed.
+
+        :param str left: First input string to `edit_distance`.
+        :param str right: Second input string to `edit_distance`.
+        :param int substitution_cost: The cost of a substitution action in `edit_distance`.
+        :param Tuple[int, int] expecteds: A tuple of expected outputs, such that `expecteds[0]` is
+            the expected output with `transpositions=True`, and `expecteds[1]` is
+            the expected output with `transpositions=False`.
+        """
+        # Test the input strings in both orderings
+        for s1, s2 in ((left, right), (right, left)):
+            # zip with [True, False] to get the transpositions value
+            for expected, transpositions in zip(expecteds, [True, False]):
+                predicted = edit_distance(
+                    s1,
+                    s2,
+                    substitution_cost=substitution_cost,
+                    transpositions=transpositions,
+                )
+                assert predicted == expected