Add files using upload-large-folder tool

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_freqdist.py

@@ -0,0 +1,7 @@
+import nltk
+
+
+def test_iterating_returns_an_iterator_ordered_by_frequency():
+    samples = ["one", "two", "two"]
+    distribution = nltk.FreqDist(samples)
+    assert list(distribution) == ["two", "one"]

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_metrics.py

@@ -0,0 +1,66 @@
+import unittest
+
+from nltk.metrics import (
+    BigramAssocMeasures,
+    QuadgramAssocMeasures,
+    TrigramAssocMeasures,
+)
+
+## Test the likelihood ratio metric
+
+_DELTA = 1e-8
+
+
+class TestLikelihoodRatio(unittest.TestCase):
+    def test_lr_bigram(self):
+        self.assertAlmostEqual(
+            BigramAssocMeasures.likelihood_ratio(2, (4, 4), 20),
+            2.4142743368419755,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            BigramAssocMeasures.likelihood_ratio(1, (1, 1), 1), 0.0, delta=_DELTA
+        )
+        self.assertRaises(
+            ValueError,
+            BigramAssocMeasures.likelihood_ratio,
+            *(0, (2, 2), 2),
+        )
+
+    def test_lr_trigram(self):
+        self.assertAlmostEqual(
+            TrigramAssocMeasures.likelihood_ratio(1, (1, 1, 1), (1, 1, 1), 2),
+            5.545177444479562,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            TrigramAssocMeasures.likelihood_ratio(1, (1, 1, 1), (1, 1, 1), 1),
+            0.0,
+            delta=_DELTA,
+        )
+        self.assertRaises(
+            ValueError,
+            TrigramAssocMeasures.likelihood_ratio,
+            *(1, (1, 1, 2), (1, 1, 2), 2),
+        )
+
+    def test_lr_quadgram(self):
+        self.assertAlmostEqual(
+            QuadgramAssocMeasures.likelihood_ratio(
+                1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 1), (1, 1, 1, 1), 2
+            ),
+            8.317766166719343,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            QuadgramAssocMeasures.likelihood_ratio(
+                1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 1), (1, 1, 1, 1), 1
+            ),
+            0.0,
+            delta=_DELTA,
+        )
+        self.assertRaises(
+            ValueError,
+            QuadgramAssocMeasures.likelihood_ratio,
+            *(1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 2), (1, 1, 1, 1), 1),
+        )

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_naivebayes.py

@@ -0,0 +1,21 @@
+import unittest
+
+from nltk.classify.naivebayes import NaiveBayesClassifier
+
+
+class NaiveBayesClassifierTest(unittest.TestCase):
+    def test_simple(self):
+        training_features = [
+            ({"nice": True, "good": True}, "positive"),
+            ({"bad": True, "mean": True}, "negative"),
+        ]
+
+        classifier = NaiveBayesClassifier.train(training_features)
+
+        result = classifier.prob_classify({"nice": True})
+        self.assertTrue(result.prob("positive") > result.prob("negative"))
+        self.assertEqual(result.max(), "positive")
+
+        result = classifier.prob_classify({"bad": True})
+        self.assertTrue(result.prob("positive") < result.prob("negative"))
+        self.assertEqual(result.max(), "negative")

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_nombank.py

@@ -0,0 +1,27 @@
+"""
+Unit tests for nltk.corpus.nombank
+"""
+
+import unittest
+
+from nltk.corpus import nombank
+
+# Load the nombank once.
+nombank.nouns()
+
+
+class NombankDemo(unittest.TestCase):
+    def test_numbers(self):
+        # No. of instances.
+        self.assertEqual(len(nombank.instances()), 114574)
+        # No. of rolesets
+        self.assertEqual(len(nombank.rolesets()), 5577)
+        # No. of nouns.
+        self.assertEqual(len(nombank.nouns()), 4704)
+
+    def test_instance(self):
+        self.assertEqual(nombank.instances()[0].roleset, "perc-sign.01")
+
+    def test_framefiles_fileids(self):
+        self.assertEqual(len(nombank.fileids()), 4705)
+        self.assertTrue(all(fileid.endswith(".xml") for fileid in nombank.fileids()))

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_pl196x.py

@@ -0,0 +1,13 @@
+import unittest
+
+import nltk
+from nltk.corpus.reader import pl196x
+
+
+class TestCorpusViews(unittest.TestCase):
+    def test_corpus_reader(self):
+        pl196x_dir = nltk.data.find("corpora/pl196x")
+        pl = pl196x.Pl196xCorpusReader(
+            pl196x_dir, r".*\.xml", textids="textids.txt", cat_file="cats.txt"
+        )
+        pl.tagged_words(fileids=pl.fileids(), categories="cats.txt")

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_pos_tag.py

@@ -0,0 +1,83 @@
+"""
+Tests for nltk.pos_tag
+"""
+
+
+import unittest
+
+from nltk import pos_tag, word_tokenize
+
+
+class TestPosTag(unittest.TestCase):
+    def test_pos_tag_eng(self):
+        text = "John's big idea isn't all that bad."
+        expected_tagged = [
+            ("John", "NNP"),
+            ("'s", "POS"),
+            ("big", "JJ"),
+            ("idea", "NN"),
+            ("is", "VBZ"),
+            ("n't", "RB"),
+            ("all", "PDT"),
+            ("that", "DT"),
+            ("bad", "JJ"),
+            (".", "."),
+        ]
+        assert pos_tag(word_tokenize(text)) == expected_tagged
+
+    def test_pos_tag_eng_universal(self):
+        text = "John's big idea isn't all that bad."
+        expected_tagged = [
+            ("John", "NOUN"),
+            ("'s", "PRT"),
+            ("big", "ADJ"),
+            ("idea", "NOUN"),
+            ("is", "VERB"),
+            ("n't", "ADV"),
+            ("all", "DET"),
+            ("that", "DET"),
+            ("bad", "ADJ"),
+            (".", "."),
+        ]
+        assert pos_tag(word_tokenize(text), tagset="universal") == expected_tagged
+
+    def test_pos_tag_rus(self):
+        text = "Илья оторопел и дважды перечитал бумажку."
+        expected_tagged = [
+            ("Илья", "S"),
+            ("оторопел", "V"),
+            ("и", "CONJ"),
+            ("дважды", "ADV"),
+            ("перечитал", "V"),
+            ("бумажку", "S"),
+            (".", "NONLEX"),
+        ]
+        assert pos_tag(word_tokenize(text), lang="rus") == expected_tagged
+
+    def test_pos_tag_rus_universal(self):
+        text = "Илья оторопел и дважды перечитал бумажку."
+        expected_tagged = [
+            ("Илья", "NOUN"),
+            ("оторопел", "VERB"),
+            ("и", "CONJ"),
+            ("дважды", "ADV"),
+            ("перечитал", "VERB"),
+            ("бумажку", "NOUN"),
+            (".", "."),
+        ]
+        assert (
+            pos_tag(word_tokenize(text), tagset="universal", lang="rus")
+            == expected_tagged
+        )
+
+    def test_pos_tag_unknown_lang(self):
+        text = "모르겠 습니 다"
+        self.assertRaises(NotImplementedError, pos_tag, word_tokenize(text), lang="kor")
+        # Test for default kwarg, `lang=None`
+        self.assertRaises(NotImplementedError, pos_tag, word_tokenize(text), lang=None)
+
+    def test_unspecified_lang(self):
+        # Tries to force the lang='eng' option.
+        text = "모르겠 습니 다"
+        expected_but_wrong = [("모르겠", "JJ"), ("습니", "NNP"), ("다", "NN")]
+        assert pos_tag(word_tokenize(text)) == expected_but_wrong

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_ribes.py

@@ -0,0 +1,246 @@
+from nltk.translate.ribes_score import corpus_ribes, word_rank_alignment
+
+
+def test_ribes_empty_worder():  # worder as in word order
+    # Verifies that these two sentences have no alignment,
+    # and hence have the lowest possible RIBES score.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's neat and all but the reference's different".split()
+
+    assert word_rank_alignment(ref, hyp) == []
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes_one_worder():
+    # Verifies that these two sentences have just one match,
+    # and the RIBES score for this sentence with very little
+    # correspondence is 0.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's nice and all but the reference's different".split()
+
+    assert word_rank_alignment(ref, hyp) == [3]
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes_two_worder():
+    # Verifies that these two sentences have two matches,
+    # but still get the lowest possible RIBES score due
+    # to the lack of similarity.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's nice and all but the reference is different".split()
+
+    assert word_rank_alignment(ref, hyp) == [9, 3]
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes():
+    # Based on the doctest of the corpus_ribes function
+    hyp1 = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "which",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "always",
+        "obeys",
+        "the",
+        "commands",
+        "of",
+        "the",
+        "party",
+    ]
+    ref1a = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "that",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "will",
+        "forever",
+        "heed",
+        "Party",
+        "commands",
+    ]
+    ref1b = [
+        "It",
+        "is",
+        "the",
+        "guiding",
+        "principle",
+        "which",
+        "guarantees",
+        "the",
+        "military",
+        "forces",
+        "always",
+        "being",
+        "under",
+        "the",
+        "command",
+        "of",
+        "the",
+        "Party",
+    ]
+    ref1c = [
+        "It",
+        "is",
+        "the",
+        "practical",
+        "guide",
+        "for",
+        "the",
+        "army",
+        "always",
+        "to",
+        "heed",
+        "the",
+        "directions",
+        "of",
+        "the",
+        "party",
+    ]
+
+    hyp2 = [
+        "he",
+        "read",
+        "the",
+        "book",
+        "because",
+        "he",
+        "was",
+        "interested",
+        "in",
+        "world",
+        "history",
+    ]
+    ref2a = [
+        "he",
+        "was",
+        "interested",
+        "in",
+        "world",
+        "history",
+        "because",
+        "he",
+        "read",
+        "the",
+        "book",
+    ]
+
+    list_of_refs = [[ref1a, ref1b, ref1c], [ref2a]]
+    hypotheses = [hyp1, hyp2]
+
+    score = corpus_ribes(list_of_refs, hypotheses)
+
+    assert round(score, 4) == 0.3597
+
+
+def test_no_zero_div():
+    # Regression test for Issue 2529, assure that no ZeroDivisionError is thrown.
+    hyp1 = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "which",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "always",
+        "obeys",
+        "the",
+        "commands",
+        "of",
+        "the",
+        "party",
+    ]
+    ref1a = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "that",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "will",
+        "forever",
+        "heed",
+        "Party",
+        "commands",
+    ]
+    ref1b = [
+        "It",
+        "is",
+        "the",
+        "guiding",
+        "principle",
+        "which",
+        "guarantees",
+        "the",
+        "military",
+        "forces",
+        "always",
+        "being",
+        "under",
+        "the",
+        "command",
+        "of",
+        "the",
+        "Party",
+    ]
+    ref1c = [
+        "It",
+        "is",
+        "the",
+        "practical",
+        "guide",
+        "for",
+        "the",
+        "army",
+        "always",
+        "to",
+        "heed",
+        "the",
+        "directions",
+        "of",
+        "the",
+        "party",
+    ]
+
+    hyp2 = ["he", "read", "the"]
+    ref2a = ["he", "was", "interested", "in", "world", "history", "because", "he"]
+
+    list_of_refs = [[ref1a, ref1b, ref1c], [ref2a]]
+    hypotheses = [hyp1, hyp2]
+
+    score = corpus_ribes(list_of_refs, hypotheses)
+
+    assert round(score, 4) == 0.1688

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_rte_classify.py

@@ -0,0 +1,94 @@
+import pytest
+
+from nltk import config_megam
+from nltk.classify.rte_classify import RTEFeatureExtractor, rte_classifier, rte_features
+from nltk.corpus import rte as rte_corpus
+
+expected_from_rte_feature_extration = """
+alwayson        => True
+ne_hyp_extra    => 0
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 3
+word_overlap    => 3
+
+alwayson        => True
+ne_hyp_extra    => 0
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 2
+word_overlap    => 1
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 1
+word_overlap    => 2
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 6
+word_overlap    => 2
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 4
+word_overlap    => 0
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 3
+word_overlap    => 1
+"""
+
+
+class TestRTEClassifier:
+    # Test the feature extraction method.
+    def test_rte_feature_extraction(self):
+        pairs = rte_corpus.pairs(["rte1_dev.xml"])[:6]
+        test_output = [
+            f"{key:<15} => {rte_features(pair)[key]}"
+            for pair in pairs
+            for key in sorted(rte_features(pair))
+        ]
+        expected_output = expected_from_rte_feature_extration.strip().split("\n")
+        # Remove null strings.
+        expected_output = list(filter(None, expected_output))
+        assert test_output == expected_output
+
+    # Test the RTEFeatureExtractor object.
+    def test_feature_extractor_object(self):
+        rtepair = rte_corpus.pairs(["rte3_dev.xml"])[33]
+        extractor = RTEFeatureExtractor(rtepair)
+
+        assert extractor.hyp_words == {"member", "China", "SCO."}
+        assert extractor.overlap("word") == set()
+        assert extractor.overlap("ne") == {"China"}
+        assert extractor.hyp_extra("word") == {"member"}
+
+    # Test the RTE classifier training.
+    def test_rte_classification_without_megam(self):
+        # Use a sample size for unit testing, since we
+        # don't need to fully train these classifiers
+        clf = rte_classifier("IIS", sample_N=100)
+        clf = rte_classifier("GIS", sample_N=100)
+
+    def test_rte_classification_with_megam(self):
+        try:
+            config_megam()
+        except (LookupError, AttributeError) as e:
+            pytest.skip("Skipping tests with dependencies on MEGAM")
+        clf = rte_classifier("megam", sample_N=100)

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_seekable_unicode_stream_reader.py

@@ -0,0 +1,86 @@
+import os
+from io import BytesIO
+
+import pytest
+
+from nltk.corpus.reader import SeekableUnicodeStreamReader
+
+
+def check_reader(unicode_string, encoding):
+    bytestr = unicode_string.encode(encoding)
+    stream = BytesIO(bytestr)
+    reader = SeekableUnicodeStreamReader(stream, encoding)
+
+    # Should open at the start of the file
+    assert reader.tell() == 0
+
+    # Compare original string to contents from `.readlines()`
+    assert unicode_string == "".join(reader.readlines())
+
+    # Should be at the end of the file now
+    stream.seek(0, os.SEEK_END)
+    assert reader.tell() == stream.tell()
+
+    reader.seek(0)  # go back to start
+
+    # Compare original string to contents from `.read()`
+    contents = ""
+    char = None
+    while char != "":
+        char = reader.read(1)
+        contents += char
+    assert unicode_string == contents
+
+
+# Call `check_reader` with a variety of input strings and encodings.
+ENCODINGS = ["ascii", "latin1", "greek", "hebrew", "utf-16", "utf-8"]
+
+STRINGS = [
+    """
+    This is a test file.
+    It is fairly short.
+    """,
+    "This file can be encoded with latin1. \x83",
+    """\
+    This is a test file.
+    Here's a blank line:
+
+    And here's some unicode: \xee \u0123 \uffe3
+    """,
+    """\
+    This is a test file.
+    Unicode characters: \xf3 \u2222 \u3333\u4444 \u5555
+    """,
+    """\
+    This is a larger file.  It has some lines that are longer \
+    than 72 characters.  It's got lots of repetition.  Here's \
+    some unicode chars: \xee \u0123 \uffe3 \ueeee \u2345
+
+    How fun!  Let's repeat it twenty times.
+    """
+    * 20,
+]
+
+
+@pytest.mark.parametrize("string", STRINGS)
+def test_reader(string):
+    for encoding in ENCODINGS:
+        # skip strings that can't be encoded with the current encoding
+        try:
+            string.encode(encoding)
+        except UnicodeEncodeError:
+            continue
+        check_reader(string, encoding)
+
+
+def test_reader_stream_closes_when_deleted():
+    reader = SeekableUnicodeStreamReader(BytesIO(b""), "ascii")
+    assert not reader.stream.closed
+    reader.__del__()
+    assert reader.stream.closed
+
+
+def teardown_module(module=None):
+    import gc
+
+    gc.collect()

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_senna.py

@@ -0,0 +1,112 @@
+"""
+Unit tests for Senna
+"""
+
+import unittest
+from os import environ, path, sep
+
+from nltk.classify import Senna
+from nltk.tag import SennaChunkTagger, SennaNERTagger, SennaTagger
+
+# Set Senna executable path for tests if it is not specified as an environment variable
+if "SENNA" in environ:
+    SENNA_EXECUTABLE_PATH = path.normpath(environ["SENNA"]) + sep
+else:
+    SENNA_EXECUTABLE_PATH = "/usr/share/senna-v3.0"
+
+senna_is_installed = path.exists(SENNA_EXECUTABLE_PATH)
+
+
+@unittest.skipUnless(senna_is_installed, "Requires Senna executable")
+class TestSennaPipeline(unittest.TestCase):
+    """Unittest for nltk.classify.senna"""
+
+    def test_senna_pipeline(self):
+        """Senna pipeline interface"""
+
+        pipeline = Senna(SENNA_EXECUTABLE_PATH, ["pos", "chk", "ner"])
+        sent = "Dusseldorf is an international business center".split()
+        result = [
+            (token["word"], token["chk"], token["ner"], token["pos"])
+            for token in pipeline.tag(sent)
+        ]
+        expected = [
+            ("Dusseldorf", "B-NP", "B-LOC", "NNP"),
+            ("is", "B-VP", "O", "VBZ"),
+            ("an", "B-NP", "O", "DT"),
+            ("international", "I-NP", "O", "JJ"),
+            ("business", "I-NP", "O", "NN"),
+            ("center", "I-NP", "O", "NN"),
+        ]
+        self.assertEqual(result, expected)
+
+
+@unittest.skipUnless(senna_is_installed, "Requires Senna executable")
+class TestSennaTagger(unittest.TestCase):
+    """Unittest for nltk.tag.senna"""
+
+    def test_senna_tagger(self):
+        tagger = SennaTagger(SENNA_EXECUTABLE_PATH)
+        result = tagger.tag("What is the airspeed of an unladen swallow ?".split())
+        expected = [
+            ("What", "WP"),
+            ("is", "VBZ"),
+            ("the", "DT"),
+            ("airspeed", "NN"),
+            ("of", "IN"),
+            ("an", "DT"),
+            ("unladen", "NN"),
+            ("swallow", "NN"),
+            ("?", "."),
+        ]
+        self.assertEqual(result, expected)
+
+    def test_senna_chunk_tagger(self):
+        chktagger = SennaChunkTagger(SENNA_EXECUTABLE_PATH)
+        result_1 = chktagger.tag("What is the airspeed of an unladen swallow ?".split())
+        expected_1 = [
+            ("What", "B-NP"),
+            ("is", "B-VP"),
+            ("the", "B-NP"),
+            ("airspeed", "I-NP"),
+            ("of", "B-PP"),
+            ("an", "B-NP"),
+            ("unladen", "I-NP"),
+            ("swallow", "I-NP"),
+            ("?", "O"),
+        ]
+
+        result_2 = list(chktagger.bio_to_chunks(result_1, chunk_type="NP"))
+        expected_2 = [
+            ("What", "0"),
+            ("the airspeed", "2-3"),
+            ("an unladen swallow", "5-6-7"),
+        ]
+        self.assertEqual(result_1, expected_1)
+        self.assertEqual(result_2, expected_2)
+
+    def test_senna_ner_tagger(self):
+        nertagger = SennaNERTagger(SENNA_EXECUTABLE_PATH)
+        result_1 = nertagger.tag("Shakespeare theatre was in London .".split())
+        expected_1 = [
+            ("Shakespeare", "B-PER"),
+            ("theatre", "O"),
+            ("was", "O"),
+            ("in", "O"),
+            ("London", "B-LOC"),
+            (".", "O"),
+        ]
+
+        result_2 = nertagger.tag("UN headquarters are in NY , USA .".split())
+        expected_2 = [
+            ("UN", "B-ORG"),
+            ("headquarters", "O"),
+            ("are", "O"),
+            ("in", "O"),
+            ("NY", "B-LOC"),
+            (",", "O"),
+            ("USA", "B-LOC"),
+            (".", "O"),
+        ]
+        self.assertEqual(result_1, expected_1)
+        self.assertEqual(result_2, expected_2)

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_stem.py

@@ -0,0 +1,157 @@
+import unittest
+from contextlib import closing
+
+from nltk import data
+from nltk.stem.porter import PorterStemmer
+from nltk.stem.snowball import SnowballStemmer
+
+
+class SnowballTest(unittest.TestCase):
+    def test_arabic(self):
+        """
+        this unit testing for test the snowball arabic light stemmer
+        this stemmer deals with prefixes and suffixes
+        """
+        # Test where the ignore_stopwords=True.
+        ar_stemmer = SnowballStemmer("arabic", True)
+        assert ar_stemmer.stem("الْعَرَبِــــــيَّة") == "عرب"
+        assert ar_stemmer.stem("العربية") == "عرب"
+        assert ar_stemmer.stem("فقالوا") == "قال"
+        assert ar_stemmer.stem("الطالبات") == "طالب"
+        assert ar_stemmer.stem("فالطالبات") == "طالب"
+        assert ar_stemmer.stem("والطالبات") == "طالب"
+        assert ar_stemmer.stem("الطالبون") == "طالب"
+        assert ar_stemmer.stem("اللذان") == "اللذان"
+        assert ar_stemmer.stem("من") == "من"
+        # Test where the ignore_stopwords=False.
+        ar_stemmer = SnowballStemmer("arabic", False)
+        assert ar_stemmer.stem("اللذان") == "اللذ"  # this is a stop word
+        assert ar_stemmer.stem("الطالبات") == "طالب"
+        assert ar_stemmer.stem("الكلمات") == "كلم"
+        # test where create the arabic stemmer without given init value to ignore_stopwords
+        ar_stemmer = SnowballStemmer("arabic")
+        assert ar_stemmer.stem("الْعَرَبِــــــيَّة") == "عرب"
+        assert ar_stemmer.stem("العربية") == "عرب"
+        assert ar_stemmer.stem("فقالوا") == "قال"
+        assert ar_stemmer.stem("الطالبات") == "طالب"
+        assert ar_stemmer.stem("الكلمات") == "كلم"
+
+    def test_russian(self):
+        stemmer_russian = SnowballStemmer("russian")
+        assert stemmer_russian.stem("авантненькая") == "авантненьк"
+
+    def test_german(self):
+        stemmer_german = SnowballStemmer("german")
+        stemmer_german2 = SnowballStemmer("german", ignore_stopwords=True)
+
+        assert stemmer_german.stem("Schr\xe4nke") == "schrank"
+        assert stemmer_german2.stem("Schr\xe4nke") == "schrank"
+
+        assert stemmer_german.stem("keinen") == "kein"
+        assert stemmer_german2.stem("keinen") == "keinen"
+
+    def test_spanish(self):
+        stemmer = SnowballStemmer("spanish")
+
+        assert stemmer.stem("Visionado") == "vision"
+
+        # The word 'algue' was raising an IndexError
+        assert stemmer.stem("algue") == "algu"
+
+    def test_short_strings_bug(self):
+        stemmer = SnowballStemmer("english")
+        assert stemmer.stem("y's") == "y"
+
+
+class PorterTest(unittest.TestCase):
+    def _vocabulary(self):
+        with closing(
+            data.find("stemmers/porter_test/porter_vocabulary.txt").open(
+                encoding="utf-8"
+            )
+        ) as fp:
+            return fp.read().splitlines()
+
+    def _test_against_expected_output(self, stemmer_mode, expected_stems):
+        stemmer = PorterStemmer(mode=stemmer_mode)
+        for word, true_stem in zip(self._vocabulary(), expected_stems):
+            our_stem = stemmer.stem(word)
+            assert (
+                our_stem == true_stem
+            ), "{} should stem to {} in {} mode but got {}".format(
+                word,
+                true_stem,
+                stemmer_mode,
+                our_stem,
+            )
+
+    def test_vocabulary_martin_mode(self):
+        """Tests all words from the test vocabulary provided by M Porter
+
+        The sample vocabulary and output were sourced from
+        https://tartarus.org/martin/PorterStemmer/voc.txt and
+        https://tartarus.org/martin/PorterStemmer/output.txt
+        and are linked to from the Porter Stemmer algorithm's homepage
+        at https://tartarus.org/martin/PorterStemmer/
+        """
+        with closing(
+            data.find("stemmers/porter_test/porter_martin_output.txt").open(
+                encoding="utf-8"
+            )
+        ) as fp:
+            self._test_against_expected_output(
+                PorterStemmer.MARTIN_EXTENSIONS, fp.read().splitlines()
+            )
+
+    def test_vocabulary_nltk_mode(self):
+        with closing(
+            data.find("stemmers/porter_test/porter_nltk_output.txt").open(
+                encoding="utf-8"
+            )
+        ) as fp:
+            self._test_against_expected_output(
+                PorterStemmer.NLTK_EXTENSIONS, fp.read().splitlines()
+            )
+
+    def test_vocabulary_original_mode(self):
+        # The list of stems for this test was generated by taking the
+        # Martin-blessed stemmer from
+        # https://tartarus.org/martin/PorterStemmer/c.txt
+        # and removing all the --DEPARTURE-- sections from it and
+        # running it against Martin's test vocabulary.
+
+        with closing(
+            data.find("stemmers/porter_test/porter_original_output.txt").open(
+                encoding="utf-8"
+            )
+        ) as fp:
+            self._test_against_expected_output(
+                PorterStemmer.ORIGINAL_ALGORITHM, fp.read().splitlines()
+            )
+
+        self._test_against_expected_output(
+            PorterStemmer.ORIGINAL_ALGORITHM,
+            data.find("stemmers/porter_test/porter_original_output.txt")
+            .open(encoding="utf-8")
+            .read()
+            .splitlines(),
+        )
+
+    def test_oed_bug(self):
+        """Test for bug https://github.com/nltk/nltk/issues/1581
+
+        Ensures that 'oed' can be stemmed without throwing an error.
+        """
+        assert PorterStemmer().stem("oed") == "o"
+
+    def test_lowercase_option(self):
+        """Test for improvement on https://github.com/nltk/nltk/issues/2507
+
+        Ensures that stems are lowercased when `to_lowercase=True`
+        """
+        porter = PorterStemmer()
+        assert porter.stem("On") == "on"
+        assert porter.stem("I") == "i"
+        assert porter.stem("I", to_lowercase=False) == "I"
+        assert porter.stem("Github") == "github"
+        assert porter.stem("Github", to_lowercase=False) == "Github"

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_tag.py

@@ -0,0 +1,23 @@
+def test_basic():
+    from nltk.tag import pos_tag
+    from nltk.tokenize import word_tokenize
+
+    result = pos_tag(word_tokenize("John's big idea isn't all that bad."))
+    assert result == [
+        ("John", "NNP"),
+        ("'s", "POS"),
+        ("big", "JJ"),
+        ("idea", "NN"),
+        ("is", "VBZ"),
+        ("n't", "RB"),
+        ("all", "PDT"),
+        ("that", "DT"),
+        ("bad", "JJ"),
+        (".", "."),
+    ]
+
+
+def setup_module(module):
+    import pytest
+
+    pytest.importorskip("numpy")

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_tgrep.py

@@ -0,0 +1,780 @@
+#!/usr/bin/env python
+#
+# Natural Language Toolkit: TGrep search
+#
+# Copyright (C) 2001-2022 NLTK Project
+# Author: Will Roberts <wildwilhelm@gmail.com>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Unit tests for nltk.tgrep.
+"""
+
+
+import unittest
+
+from nltk import tgrep
+from nltk.tree import ParentedTree
+
+
+class TestSequenceFunctions(unittest.TestCase):
+
+    """
+    Class containing unit tests for nltk.tgrep.
+    """
+
+    def test_tokenize_simple(self):
+        """
+        Simple test of tokenization.
+        """
+        tokens = tgrep.tgrep_tokenize("A .. (B !< C . D) | ![<< (E , F) $ G]")
+        self.assertEqual(
+            tokens,
+            [
+                "A",
+                "..",
+                "(",
+                "B",
+                "!",
+                "<",
+                "C",
+                ".",
+                "D",
+                ")",
+                "|",
+                "!",
+                "[",
+                "<<",
+                "(",
+                "E",
+                ",",
+                "F",
+                ")",
+                "$",
+                "G",
+                "]",
+            ],
+        )
+
+    def test_tokenize_encoding(self):
+        """
+        Test that tokenization handles bytes and strs the same way.
+        """
+        self.assertEqual(
+            tgrep.tgrep_tokenize(b"A .. (B !< C . D) | ![<< (E , F) $ G]"),
+            tgrep.tgrep_tokenize("A .. (B !< C . D) | ![<< (E , F) $ G]"),
+        )
+
+    def test_tokenize_link_types(self):
+        """
+        Test tokenization of basic link types.
+        """
+        self.assertEqual(tgrep.tgrep_tokenize("A<B"), ["A", "<", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>B"), ["A", ">", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<3B"), ["A", "<3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>3B"), ["A", ">3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<,B"), ["A", "<,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>,B"), ["A", ">,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<-3B"), ["A", "<-3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>-3B"), ["A", ">-3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<-B"), ["A", "<-", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>-B"), ["A", ">-", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<'B"), ["A", "<'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>'B"), ["A", ">'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<:B"), ["A", "<:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>:B"), ["A", ">:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<<B"), ["A", "<<", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>>B"), ["A", ">>", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<<,B"), ["A", "<<,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>>,B"), ["A", ">>,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<<'B"), ["A", "<<'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>>'B"), ["A", ">>'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A<<:B"), ["A", "<<:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A>>:B"), ["A", ">>:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A.B"), ["A", ".", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A,B"), ["A", ",", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A..B"), ["A", "..", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A,,B"), ["A", ",,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A$B"), ["A", "$", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A$.B"), ["A", "$.", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A$,B"), ["A", "$,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A$..B"), ["A", "$..", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A$,,B"), ["A", "$,,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<B"), ["A", "!", "<", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>B"), ["A", "!", ">", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<3B"), ["A", "!", "<3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>3B"), ["A", "!", ">3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<,B"), ["A", "!", "<,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>,B"), ["A", "!", ">,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<-3B"), ["A", "!", "<-3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>-3B"), ["A", "!", ">-3", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<-B"), ["A", "!", "<-", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>-B"), ["A", "!", ">-", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<'B"), ["A", "!", "<'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>'B"), ["A", "!", ">'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<:B"), ["A", "!", "<:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>:B"), ["A", "!", ">:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<<B"), ["A", "!", "<<", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>>B"), ["A", "!", ">>", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<<,B"), ["A", "!", "<<,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>>,B"), ["A", "!", ">>,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<<'B"), ["A", "!", "<<'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>>'B"), ["A", "!", ">>'", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!<<:B"), ["A", "!", "<<:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!>>:B"), ["A", "!", ">>:", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!.B"), ["A", "!", ".", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!,B"), ["A", "!", ",", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!..B"), ["A", "!", "..", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!,,B"), ["A", "!", ",,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!$B"), ["A", "!", "$", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!$.B"), ["A", "!", "$.", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!$,B"), ["A", "!", "$,", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!$..B"), ["A", "!", "$..", "B"])
+        self.assertEqual(tgrep.tgrep_tokenize("A!$,,B"), ["A", "!", "$,,", "B"])
+
+    def test_tokenize_examples(self):
+        """
+        Test tokenization of the TGrep2 manual example patterns.
+        """
+        self.assertEqual(tgrep.tgrep_tokenize("NP < PP"), ["NP", "<", "PP"])
+        self.assertEqual(tgrep.tgrep_tokenize("/^NP/"), ["/^NP/"])
+        self.assertEqual(
+            tgrep.tgrep_tokenize("NP << PP . VP"), ["NP", "<<", "PP", ".", "VP"]
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("NP << PP | . VP"), ["NP", "<<", "PP", "|", ".", "VP"]
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("NP !<< PP [> NP | >> VP]"),
+            ["NP", "!", "<<", "PP", "[", ">", "NP", "|", ">>", "VP", "]"],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("NP << (PP . VP)"),
+            ["NP", "<<", "(", "PP", ".", "VP", ")"],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("NP <' (PP <, (IN < on))"),
+            ["NP", "<'", "(", "PP", "<,", "(", "IN", "<", "on", ")", ")"],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < (A < B) < C"),
+            ["S", "<", "(", "A", "<", "B", ")", "<", "C"],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < ((A < B) < C)"),
+            ["S", "<", "(", "(", "A", "<", "B", ")", "<", "C", ")"],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < (A < B < C)"),
+            ["S", "<", "(", "A", "<", "B", "<", "C", ")"],
+        )
+        self.assertEqual(tgrep.tgrep_tokenize("A<B&.C"), ["A", "<", "B", "&", ".", "C"])
+
+    def test_tokenize_quoting(self):
+        """
+        Test tokenization of quoting.
+        """
+        self.assertEqual(
+            tgrep.tgrep_tokenize('"A<<:B"<<:"A $.. B"<"A>3B"<C'),
+            ['"A<<:B"', "<<:", '"A $.. B"', "<", '"A>3B"', "<", "C"],
+        )
+
+    def test_tokenize_nodenames(self):
+        """
+        Test tokenization of node names.
+        """
+        self.assertEqual(tgrep.tgrep_tokenize("Robert"), ["Robert"])
+        self.assertEqual(tgrep.tgrep_tokenize("/^[Bb]ob/"), ["/^[Bb]ob/"])
+        self.assertEqual(tgrep.tgrep_tokenize("*"), ["*"])
+        self.assertEqual(tgrep.tgrep_tokenize("__"), ["__"])
+        # test tokenization of NLTK tree position syntax
+        self.assertEqual(tgrep.tgrep_tokenize("N()"), ["N(", ")"])
+        self.assertEqual(tgrep.tgrep_tokenize("N(0,)"), ["N(", "0", ",", ")"])
+        self.assertEqual(tgrep.tgrep_tokenize("N(0,0)"), ["N(", "0", ",", "0", ")"])
+        self.assertEqual(
+            tgrep.tgrep_tokenize("N(0,0,)"), ["N(", "0", ",", "0", ",", ")"]
+        )
+
+    def test_tokenize_macros(self):
+        """
+        Test tokenization of macro definitions.
+        """
+        self.assertEqual(
+            tgrep.tgrep_tokenize(
+                "@ NP /^NP/;\n@ NN /^NN/;\n@NP [!< NP | < @NN] !$.. @NN"
+            ),
+            [
+                "@",
+                "NP",
+                "/^NP/",
+                ";",
+                "@",
+                "NN",
+                "/^NN/",
+                ";",
+                "@NP",
+                "[",
+                "!",
+                "<",
+                "NP",
+                "|",
+                "<",
+                "@NN",
+                "]",
+                "!",
+                "$..",
+                "@NN",
+            ],
+        )
+
+    def test_node_simple(self):
+        """
+        Test a simple use of tgrep for finding nodes matching a given
+        pattern.
+        """
+        tree = ParentedTree.fromstring(
+            "(S (NP (DT the) (JJ big) (NN dog)) " "(VP bit) (NP (DT a) (NN cat)))"
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("NN", [tree])), [[(0, 2), (2, 1)]])
+        self.assertEqual(
+            list(tgrep.tgrep_nodes("NN", [tree])), [[tree[0, 2], tree[2, 1]]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NN|JJ", [tree])), [[(0, 1), (0, 2), (2, 1)]]
+        )
+
+    def test_node_printing(self):
+        """Test that the tgrep print operator ' is properly ignored."""
+        tree = ParentedTree.fromstring("(S (n x) (N x))")
+        self.assertEqual(
+            list(tgrep.tgrep_positions("N", [tree])),
+            list(tgrep.tgrep_positions("'N", [tree])),
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("/[Nn]/", [tree])),
+            list(tgrep.tgrep_positions("'/[Nn]/", [tree])),
+        )
+
+    def test_node_encoding(self):
+        """
+        Test that tgrep search strings handles bytes and strs the same
+        way.
+        """
+        tree = ParentedTree.fromstring(
+            "(S (NP (DT the) (JJ big) (NN dog)) " "(VP bit) (NP (DT a) (NN cat)))"
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions(b"NN", [tree])),
+            list(tgrep.tgrep_positions(b"NN", [tree])),
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_nodes(b"NN", [tree])),
+            list(tgrep.tgrep_nodes("NN", [tree])),
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions(b"NN|JJ", [tree])),
+            list(tgrep.tgrep_positions("NN|JJ", [tree])),
+        )
+
+    def test_node_nocase(self):
+        """
+        Test selecting nodes using case insensitive node names.
+        """
+        tree = ParentedTree.fromstring("(S (n x) (N x))")
+        self.assertEqual(list(tgrep.tgrep_positions('"N"', [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions('i@"N"', [tree])), [[(0,), (1,)]])
+
+    def test_node_quoted(self):
+        """
+        Test selecting nodes using quoted node names.
+        """
+        tree = ParentedTree.fromstring('(N ("N" x) (N" x) ("\\" x))')
+        self.assertEqual(list(tgrep.tgrep_positions('"N"', [tree])), [[()]])
+        self.assertEqual(list(tgrep.tgrep_positions('"\\"N\\""', [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions('"N\\""', [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions('"\\"\\\\\\""', [tree])), [[(2,)]])
+
+    def test_node_regex(self):
+        """
+        Test regex matching on nodes.
+        """
+        tree = ParentedTree.fromstring("(S (NP-SBJ x) (NP x) (NNP x) (VP x))")
+        # This is a regular expression that matches any node whose
+        # name starts with NP, including NP-SBJ:
+        self.assertEqual(list(tgrep.tgrep_positions("/^NP/", [tree])), [[(0,), (1,)]])
+
+    def test_node_regex_2(self):
+        """
+        Test regex matching on nodes.
+        """
+        tree = ParentedTree.fromstring("(S (SBJ x) (SBJ1 x) (NP-SBJ x))")
+        self.assertEqual(list(tgrep.tgrep_positions("/^SBJ/", [tree])), [[(0,), (1,)]])
+        # This is a regular expression that matches any node whose
+        # name includes SBJ, including NP-SBJ:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("/SBJ/", [tree])), [[(0,), (1,), (2,)]]
+        )
+
+    def test_node_tree_position(self):
+        """
+        Test matching on nodes based on NLTK tree position.
+        """
+        tree = ParentedTree.fromstring("(S (NP-SBJ x) (NP x) (NNP x) (VP x))")
+        # test all tree positions that are not leaves
+        leaf_positions = {tree.leaf_treeposition(x) for x in range(len(tree.leaves()))}
+        tree_positions = [x for x in tree.treepositions() if x not in leaf_positions]
+        for position in tree_positions:
+            node_id = f"N{position}"
+            tgrep_positions = list(tgrep.tgrep_positions(node_id, [tree]))
+            self.assertEqual(len(tgrep_positions[0]), 1)
+            self.assertEqual(tgrep_positions[0][0], position)
+
+    def test_node_noleaves(self):
+        """
+        Test node name matching with the search_leaves flag set to False.
+        """
+        tree = ParentedTree.fromstring("(S (A (T x)) (B (N x)))")
+        self.assertEqual(
+            list(tgrep.tgrep_positions("x", [tree])), [[(0, 0, 0), (1, 0, 0)]]
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("x", [tree], False)), [[]])
+
+    def tests_rel_dominance(self):
+        """
+        Test matching nodes based on dominance relations.
+        """
+        tree = ParentedTree.fromstring("(S (A (T x)) (B (N x)))")
+        self.assertEqual(list(tgrep.tgrep_positions("* < T", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* < T > S", [tree])), [[(0,)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !< T", [tree])),
+            [[(), (0, 0), (0, 0, 0), (1,), (1, 0), (1, 0, 0)]],
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("* !< T > S", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* > A", [tree])), [[(0, 0)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* > B", [tree])), [[(1, 0)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !> B", [tree])),
+            [[(), (0,), (0, 0), (0, 0, 0), (1,), (1, 0, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !> B >> S", [tree])), [[(0,), (0, 0), (1,)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* >> S", [tree])),
+            [[(0,), (0, 0), (1,), (1, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* >>, S", [tree])), [[(0,), (0, 0)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* >>' S", [tree])), [[(1,), (1, 0)]]
+        )
+        # Known issue:
+        # self.assertEqual(list(tgrep.tgrep_positions('* !>> S', [tree])),
+        #                 [[()]])
+        self.assertEqual(list(tgrep.tgrep_positions("* << T", [tree])), [[(), (0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <<' T", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <<1 N", [tree])), [[(1,)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !<< T", [tree])),
+            [[(0, 0), (0, 0, 0), (1,), (1, 0), (1, 0, 0)]],
+        )
+        tree = ParentedTree.fromstring("(S (A (T x)) (B (T x) (N x )))")
+        self.assertEqual(list(tgrep.tgrep_positions("* <: T", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* < T", [tree])), [[(0,), (1,)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !<: T", [tree])),
+            [[(), (0, 0), (0, 0, 0), (1,), (1, 0), (1, 0, 0), (1, 1), (1, 1, 0)]],
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("* !<: T > S", [tree])), [[(1,)]])
+        tree = ParentedTree.fromstring("(S (T (A x) (B x)) (T (C x)))")
+        self.assertEqual(list(tgrep.tgrep_positions("* >: T", [tree])), [[(1, 0)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* !>: T", [tree])),
+            [[(), (0,), (0, 0), (0, 0, 0), (0, 1), (0, 1, 0), (1,), (1, 0, 0)]],
+        )
+        tree = ParentedTree.fromstring(
+            "(S (A (B (C (D (E (T x))))))" " (A (B (C (D (E (T x))) (N x)))))"
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* <<: T", [tree])),
+            [
+                [
+                    (0,),
+                    (0, 0),
+                    (0, 0, 0),
+                    (0, 0, 0, 0),
+                    (0, 0, 0, 0, 0),
+                    (1, 0, 0, 0),
+                    (1, 0, 0, 0, 0),
+                ]
+            ],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* >>: A", [tree])),
+            [
+                [
+                    (0, 0),
+                    (0, 0, 0),
+                    (0, 0, 0, 0),
+                    (0, 0, 0, 0, 0),
+                    (0, 0, 0, 0, 0, 0),
+                    (1, 0),
+                    (1, 0, 0),
+                ]
+            ],
+        )
+
+    def test_bad_operator(self):
+        """
+        Test error handling of undefined tgrep operators.
+        """
+        tree = ParentedTree.fromstring("(S (A (T x)) (B (N x)))")
+        self.assertRaises(
+            tgrep.TgrepException, list, tgrep.tgrep_positions("* >>> S", [tree])
+        )
+
+    def test_comments(self):
+        """
+        Test that comments are correctly filtered out of tgrep search
+        strings.
+        """
+        tree = ParentedTree.fromstring("(S (NN x) (NP x) (NN x))")
+        search1 = """
+        @ NP /^NP/;
+        @ NN /^NN/;
+        @NN
+        """
+        self.assertEqual(list(tgrep.tgrep_positions(search1, [tree])), [[(0,), (2,)]])
+        search2 = """
+        # macros
+        @ NP /^NP/;
+        @ NN /^NN/;
+
+        # search string
+        @NN
+        """
+        self.assertEqual(list(tgrep.tgrep_positions(search2, [tree])), [[(0,), (2,)]])
+
+    def test_rel_sister_nodes(self):
+        """
+        Test matching sister nodes in a tree.
+        """
+        tree = ParentedTree.fromstring("(S (A x) (B x) (C x))")
+        self.assertEqual(list(tgrep.tgrep_positions("* $. B", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* $.. B", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* $, B", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* $,, B", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* $ B", [tree])), [[(0,), (2,)]])
+
+    def tests_rel_indexed_children(self):
+        """
+        Test matching nodes based on their index in their parent node.
+        """
+        tree = ParentedTree.fromstring("(S (A x) (B x) (C x))")
+        self.assertEqual(list(tgrep.tgrep_positions("* >, S", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >1 S", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >2 S", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >3 S", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >' S", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >-1 S", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >-2 S", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* >-3 S", [tree])), [[(0,)]])
+        tree = ParentedTree.fromstring(
+            "(S (D (A x) (B x) (C x)) (E (B x) (C x) (A x)) " "(F (C x) (A x) (B x)))"
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("* <, A", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <1 A", [tree])), [[(0,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <2 A", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <3 A", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <' A", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <-1 A", [tree])), [[(1,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <-2 A", [tree])), [[(2,)]])
+        self.assertEqual(list(tgrep.tgrep_positions("* <-3 A", [tree])), [[(0,)]])
+
+    def test_rel_precedence(self):
+        """
+        Test matching nodes based on precedence relations.
+        """
+        tree = ParentedTree.fromstring(
+            "(S (NP (NP (PP x)) (NP (AP x)))"
+            " (VP (AP (X (PP x)) (Y (AP x))))"
+            " (NP (RC (NP (AP x)))))"
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* . X", [tree])), [[(0,), (0, 1), (0, 1, 0)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* . Y", [tree])), [[(1, 0, 0), (1, 0, 0, 0)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* .. X", [tree])),
+            [[(0,), (0, 0), (0, 0, 0), (0, 1), (0, 1, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* .. Y", [tree])),
+            [[(0,), (0, 0), (0, 0, 0), (0, 1), (0, 1, 0), (1, 0, 0), (1, 0, 0, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* , X", [tree])), [[(1, 0, 1), (1, 0, 1, 0)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* , Y", [tree])),
+            [[(2,), (2, 0), (2, 0, 0), (2, 0, 0, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* ,, X", [tree])),
+            [[(1, 0, 1), (1, 0, 1, 0), (2,), (2, 0), (2, 0, 0), (2, 0, 0, 0)]],
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("* ,, Y", [tree])),
+            [[(2,), (2, 0), (2, 0, 0), (2, 0, 0, 0)]],
+        )
+
+    def test_examples(self):
+        """
+        Test the Basic Examples from the TGrep2 manual.
+        """
+        tree = ParentedTree.fromstring("(S (NP (AP x)) (NP (PP x)))")
+        # This matches any NP node that immediately dominates a PP:
+        self.assertEqual(list(tgrep.tgrep_positions("NP < PP", [tree])), [[(1,)]])
+
+        tree = ParentedTree.fromstring("(S (NP x) (VP x) (NP (PP x)) (VP x))")
+        # This matches an NP that dominates a PP and is immediately
+        # followed by a VP:
+        self.assertEqual(list(tgrep.tgrep_positions("NP << PP . VP", [tree])), [[(2,)]])
+
+        tree = ParentedTree.fromstring(
+            "(S (NP (AP x)) (NP (PP x)) " "(NP (DET x) (NN x)) (VP x))"
+        )
+        # This matches an NP that dominates a PP or is immediately
+        # followed by a VP:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NP << PP | . VP", [tree])), [[(1,), (2,)]]
+        )
+
+        tree = ParentedTree.fromstring(
+            "(S (NP (NP (PP x)) (NP (AP x)))"
+            " (VP (AP (NP (PP x)) (NP (AP x))))"
+            " (NP (RC (NP (AP x)))))"
+        )
+        # This matches an NP that does not dominate a PP. Also, the NP
+        # must either have a parent that is an NP or be dominated by a
+        # VP:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NP !<< PP [> NP | >> VP]", [tree])),
+            [[(0, 1), (1, 0, 1)]],
+        )
+
+        tree = ParentedTree.fromstring(
+            "(S (NP (AP (PP x) (VP x))) " "(NP (AP (PP x) (NP x))) (NP x))"
+        )
+        # This matches an NP that dominates a PP which itself is
+        # immediately followed by a VP. Note the use of parentheses to
+        # group ". VP" with the PP rather than with the NP:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NP << (PP . VP)", [tree])), [[(0,)]]
+        )
+
+        tree = ParentedTree.fromstring(
+            "(S (NP (DET a) (NN cat) (PP (IN on) (NP x)))"
+            " (NP (DET a) (NN cat) (PP (IN on) (NP x)) (PP x))"
+            " (NP x))"
+        )
+        # This matches an NP whose last child is a PP that begins with
+        # the preposition "on":
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NP <' (PP <, (IN < on))", [tree])), [[(0,)]]
+        )
+
+        tree = ParentedTree.fromstring(
+            "(S (S (C x) (A (B x))) (S (C x) (A x)) " "(S (D x) (A (B x))))"
+        )
+        # The following pattern matches an S which has a child A and
+        # another child that is a C and that the A has a child B:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("S < (A < B) < C", [tree])), [[(0,)]]
+        )
+
+        tree = ParentedTree.fromstring(
+            "(S (S (A (B x) (C x))) (S (S (C x) (A (B x)))))"
+        )
+        # However, this pattern means that S has child A and that A
+        # has children B and C:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("S < ((A < B) < C)", [tree])), [[(0,)]]
+        )
+
+        # It is equivalent to this:
+        self.assertEqual(
+            list(tgrep.tgrep_positions("S < (A < B < C)", [tree])), [[(0,)]]
+        )
+
+    def test_use_macros(self):
+        """
+        Test defining and using tgrep2 macros.
+        """
+        tree = ParentedTree.fromstring(
+            "(VP (VB sold) (NP (DET the) "
+            "(NN heiress)) (NP (NN deed) (PREP to) "
+            "(NP (DET the) (NN school) (NN house))))"
+        )
+        self.assertEqual(
+            list(
+                tgrep.tgrep_positions(
+                    "@ NP /^NP/;\n@ NN /^NN/;\n@NP !< @NP !$.. @NN", [tree]
+                )
+            ),
+            [[(1,), (2, 2)]],
+        )
+        # use undefined macro @CNP
+        self.assertRaises(
+            tgrep.TgrepException,
+            list,
+            tgrep.tgrep_positions(
+                "@ NP /^NP/;\n@ NN /^NN/;\n@CNP !< @NP !$.. @NN", [tree]
+            ),
+        )
+
+    def test_tokenize_node_labels(self):
+        """Test tokenization of labeled nodes."""
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < @SBJ < (@VP < (@VB $.. @OBJ))"),
+            [
+                "S",
+                "<",
+                "@SBJ",
+                "<",
+                "(",
+                "@VP",
+                "<",
+                "(",
+                "@VB",
+                "$..",
+                "@OBJ",
+                ")",
+                ")",
+            ],
+        )
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < @SBJ=s < (@VP=v < (@VB $.. @OBJ))"),
+            [
+                "S",
+                "<",
+                "@SBJ",
+                "=",
+                "s",
+                "<",
+                "(",
+                "@VP",
+                "=",
+                "v",
+                "<",
+                "(",
+                "@VB",
+                "$..",
+                "@OBJ",
+                ")",
+                ")",
+            ],
+        )
+
+    def test_tokenize_segmented_patterns(self):
+        """Test tokenization of segmented patterns."""
+        self.assertEqual(
+            tgrep.tgrep_tokenize("S < @SBJ=s < (@VP=v < (@VB $.. @OBJ)) : =s .. =v"),
+            [
+                "S",
+                "<",
+                "@SBJ",
+                "=",
+                "s",
+                "<",
+                "(",
+                "@VP",
+                "=",
+                "v",
+                "<",
+                "(",
+                "@VB",
+                "$..",
+                "@OBJ",
+                ")",
+                ")",
+                ":",
+                "=s",
+                "..",
+                "=v",
+            ],
+        )
+
+    def test_labeled_nodes(self):
+        """
+        Test labeled nodes.
+
+        Test case from Emily M. Bender.
+        """
+        search = """
+            # macros
+            @ SBJ /SBJ/;
+            @ VP /VP/;
+            @ VB /VB/;
+            @ VPoB /V[PB]/;
+            @ OBJ /OBJ/;
+
+            # 1 svo
+            S < @SBJ=s < (@VP=v < (@VB $.. @OBJ)) : =s .. =v"""
+        sent1 = ParentedTree.fromstring(
+            "(S (NP-SBJ I) (VP (VB eat) (NP-OBJ (NNS apples))))"
+        )
+        sent2 = ParentedTree.fromstring(
+            "(S (VP (VB eat) (NP-OBJ (NNS apples))) (NP-SBJ I))"
+        )
+        search_firsthalf = search.split("\n\n")[0] + "S < @SBJ < (@VP < (@VB $.. @OBJ))"
+        search_rewrite = "S < (/.*SBJ/ $.. (/VP/ < (/VB/ $.. /.*OBJ/)))"
+
+        self.assertTrue(list(tgrep.tgrep_positions(search_firsthalf, [sent1]))[0])
+        self.assertTrue(list(tgrep.tgrep_positions(search, [sent1]))[0])
+        self.assertTrue(list(tgrep.tgrep_positions(search_rewrite, [sent1]))[0])
+        self.assertEqual(
+            list(tgrep.tgrep_positions(search, [sent1])),
+            list(tgrep.tgrep_positions(search_rewrite, [sent1])),
+        )
+        self.assertTrue(list(tgrep.tgrep_positions(search_firsthalf, [sent2]))[0])
+        self.assertFalse(list(tgrep.tgrep_positions(search, [sent2]))[0])
+        self.assertFalse(list(tgrep.tgrep_positions(search_rewrite, [sent2]))[0])
+        self.assertEqual(
+            list(tgrep.tgrep_positions(search, [sent2])),
+            list(tgrep.tgrep_positions(search_rewrite, [sent2])),
+        )
+
+    def test_multiple_conjs(self):
+        """
+        Test that multiple (3 or more) conjunctions of node relations are
+        handled properly.
+        """
+        sent = ParentedTree.fromstring("((A (B b) (C c)) (A (B b) (C c) (D d)))")
+        # search = '(A < B < C < D)'
+        # search_tworels = '(A < B < C)'
+        self.assertEqual(
+            list(tgrep.tgrep_positions("(A < B < C < D)", [sent])), [[(1,)]]
+        )
+        self.assertEqual(
+            list(tgrep.tgrep_positions("(A < B < C)", [sent])), [[(0,), (1,)]]
+        )
+
+    def test_trailing_semicolon(self):
+        """
+        Test that semicolons at the end of a tgrep2 search string won't
+        cause a parse failure.
+        """
+        tree = ParentedTree.fromstring(
+            "(S (NP (DT the) (JJ big) (NN dog)) " "(VP bit) (NP (DT a) (NN cat)))"
+        )
+        self.assertEqual(list(tgrep.tgrep_positions("NN", [tree])), [[(0, 2), (2, 1)]])
+        self.assertEqual(list(tgrep.tgrep_positions("NN;", [tree])), [[(0, 2), (2, 1)]])
+        self.assertEqual(
+            list(tgrep.tgrep_positions("NN;;", [tree])), [[(0, 2), (2, 1)]]
+        )

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_tokenize.py

@@ -0,0 +1,867 @@
+"""
+Unit tests for nltk.tokenize.
+See also nltk/test/tokenize.doctest
+"""
+from typing import List, Tuple
+
+import pytest
+
+from nltk.tokenize import (
+    LegalitySyllableTokenizer,
+    StanfordSegmenter,
+    SyllableTokenizer,
+    TreebankWordTokenizer,
+    TweetTokenizer,
+    punkt,
+    sent_tokenize,
+    word_tokenize,
+)
+
+
+def load_stanford_segmenter():
+    try:
+        seg = StanfordSegmenter()
+        seg.default_config("ar")
+        seg.default_config("zh")
+        return True
+    except LookupError:
+        return False
+
+
+check_stanford_segmenter = pytest.mark.skipif(
+    not load_stanford_segmenter(),
+    reason="NLTK was unable to find stanford-segmenter.jar.",
+)
+
+
+class TestTokenize:
+    def test_tweet_tokenizer(self):
+        """
+        Test TweetTokenizer using words with special and accented characters.
+        """
+
+        tokenizer = TweetTokenizer(strip_handles=True, reduce_len=True)
+        s9 = "@myke: Let's test these words: resumé España München français"
+        tokens = tokenizer.tokenize(s9)
+        expected = [
+            ":",
+            "Let's",
+            "test",
+            "these",
+            "words",
+            ":",
+            "resumé",
+            "España",
+            "München",
+            "français",
+        ]
+        assert tokens == expected
+
+    @pytest.mark.parametrize(
+        "test_input, expecteds",
+        [
+            (
+                "My text 0106404243030 is great text",
+                (
+                    ["My", "text", "01064042430", "30", "is", "great", "text"],
+                    ["My", "text", "0106404243030", "is", "great", "text"],
+                ),
+            ),
+            (
+                "My ticket id is 1234543124123",
+                (
+                    ["My", "ticket", "id", "is", "12345431241", "23"],
+                    ["My", "ticket", "id", "is", "1234543124123"],
+                ),
+            ),
+            (
+                "@remy: This is waaaaayyyy too much for you!!!!!! 01064042430",
+                (
+                    [
+                        ":",
+                        "This",
+                        "is",
+                        "waaayyy",
+                        "too",
+                        "much",
+                        "for",
+                        "you",
+                        "!",
+                        "!",
+                        "!",
+                        "01064042430",
+                    ],
+                    [
+                        ":",
+                        "This",
+                        "is",
+                        "waaayyy",
+                        "too",
+                        "much",
+                        "for",
+                        "you",
+                        "!",
+                        "!",
+                        "!",
+                        "01064042430",
+                    ],
+                ),
+            ),
+            # Further tests from https://github.com/nltk/nltk/pull/2798#issuecomment-922533085,
+            # showing the TweetTokenizer performance for `match_phone_numbers=True` and
+            # `match_phone_numbers=False`.
+            (
+                # Some phone numbers are always tokenized, even with `match_phone_numbers=`False`
+                "My number is 06-46124080, except it's not.",
+                (
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "06-46124080",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "06-46124080",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                ),
+            ),
+            (
+                # Phone number here is only tokenized correctly if `match_phone_numbers=True`
+                "My number is 601-984-4813, except it's not.",
+                (
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "601-984-4813",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "601-984-",
+                        "4813",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                ),
+            ),
+            (
+                # Phone number here is only tokenized correctly if `match_phone_numbers=True`
+                "My number is (393)  928 -3010, except it's not.",
+                (
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "(393)  928 -3010",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                    [
+                        "My",
+                        "number",
+                        "is",
+                        "(",
+                        "393",
+                        ")",
+                        "928",
+                        "-",
+                        "3010",
+                        ",",
+                        "except",
+                        "it's",
+                        "not",
+                        ".",
+                    ],
+                ),
+            ),
+            (
+                # A long number is tokenized correctly only if `match_phone_numbers=False`
+                "The product identification number is 48103284512.",
+                (
+                    [
+                        "The",
+                        "product",
+                        "identification",
+                        "number",
+                        "is",
+                        "4810328451",
+                        "2",
+                        ".",
+                    ],
+                    [
+                        "The",
+                        "product",
+                        "identification",
+                        "number",
+                        "is",
+                        "48103284512",
+                        ".",
+                    ],
+                ),
+            ),
+            (
+                # `match_phone_numbers=True` can have some unforeseen
+                "My favourite substraction is 240 - 1353.",
+                (
+                    ["My", "favourite", "substraction", "is", "240 - 1353", "."],
+                    ["My", "favourite", "substraction", "is", "240", "-", "1353", "."],
+                ),
+            ),
+        ],
+    )
+    def test_tweet_tokenizer_expanded(
+        self, test_input: str, expecteds: Tuple[List[str], List[str]]
+    ):
+        """
+        Test `match_phone_numbers` in TweetTokenizer.
+
+        Note that TweetTokenizer is also passed the following for these tests:
+            * strip_handles=True
+            * reduce_len=True
+
+        :param test_input: The input string to tokenize using TweetTokenizer.
+        :type test_input: str
+        :param expecteds: A 2-tuple of tokenized sentences. The first of the two
+            tokenized is the expected output of tokenization with `match_phone_numbers=True`.
+            The second of the two tokenized lists is the expected output of tokenization
+            with `match_phone_numbers=False`.
+        :type expecteds: Tuple[List[str], List[str]]
+        """
+        for match_phone_numbers, expected in zip([True, False], expecteds):
+            tokenizer = TweetTokenizer(
+                strip_handles=True,
+                reduce_len=True,
+                match_phone_numbers=match_phone_numbers,
+            )
+            predicted = tokenizer.tokenize(test_input)
+            assert predicted == expected
+
+    def test_sonority_sequencing_syllable_tokenizer(self):
+        """
+        Test SyllableTokenizer tokenizer.
+        """
+        tokenizer = SyllableTokenizer()
+        tokens = tokenizer.tokenize("justification")
+        assert tokens == ["jus", "ti", "fi", "ca", "tion"]
+
+    def test_syllable_tokenizer_numbers(self):
+        """
+        Test SyllableTokenizer tokenizer.
+        """
+        tokenizer = SyllableTokenizer()
+        text = "9" * 10000
+        tokens = tokenizer.tokenize(text)
+        assert tokens == [text]
+
+    def test_legality_principle_syllable_tokenizer(self):
+        """
+        Test LegalitySyllableTokenizer tokenizer.
+        """
+        from nltk.corpus import words
+
+        test_word = "wonderful"
+        tokenizer = LegalitySyllableTokenizer(words.words())
+        tokens = tokenizer.tokenize(test_word)
+        assert tokens == ["won", "der", "ful"]
+
+    @check_stanford_segmenter
+    def test_stanford_segmenter_arabic(self):
+        """
+        Test the Stanford Word Segmenter for Arabic (default config)
+        """
+        seg = StanfordSegmenter()
+        seg.default_config("ar")
+        sent = "يبحث علم الحاسوب استخدام الحوسبة بجميع اشكالها لحل المشكلات"
+        segmented_sent = seg.segment(sent.split())
+        assert segmented_sent.split() == [
+            "يبحث",
+            "علم",
+            "الحاسوب",
+            "استخدام",
+            "الحوسبة",
+            "ب",
+            "جميع",
+            "اشكال",
+            "ها",
+            "ل",
+            "حل",
+            "المشكلات",
+        ]
+
+    @check_stanford_segmenter
+    def test_stanford_segmenter_chinese(self):
+        """
+        Test the Stanford Word Segmenter for Chinese (default config)
+        """
+        seg = StanfordSegmenter()
+        seg.default_config("zh")
+        sent = "这是斯坦福中文分词器测试"
+        segmented_sent = seg.segment(sent.split())
+        assert segmented_sent.split() == ["这", "是", "斯坦福", "中文", "分词器", "测试"]
+
+    def test_phone_tokenizer(self):
+        """
+        Test a string that resembles a phone number but contains a newline
+        """
+
+        # Should be recognized as a phone number, albeit one with multiple spaces
+        tokenizer = TweetTokenizer()
+        test1 = "(393)  928 -3010"
+        expected = ["(393)  928 -3010"]
+        result = tokenizer.tokenize(test1)
+        assert result == expected
+
+        # Due to newline, first three elements aren't part of a phone number;
+        # fourth is
+        test2 = "(393)\n928 -3010"
+        expected = ["(", "393", ")", "928 -3010"]
+        result = tokenizer.tokenize(test2)
+        assert result == expected
+
+    def test_emoji_tokenizer(self):
+        """
+        Test a string that contains Emoji ZWJ Sequences and skin tone modifier
+        """
+        tokenizer = TweetTokenizer()
+
+        # A Emoji ZWJ Sequences, they together build as a single emoji, should not be split.
+        test1 = "👨‍👩‍👧‍👧"
+        expected = ["👨‍👩‍👧‍👧"]
+        result = tokenizer.tokenize(test1)
+        assert result == expected
+
+        # A Emoji with skin tone modifier, the two characters build a single emoji, should not be split.
+        test2 = "👨🏿"
+        expected = ["👨🏿"]
+        result = tokenizer.tokenize(test2)
+        assert result == expected
+
+        # A string containing both skin tone modifier and ZWJ Sequences
+        test3 = "🤔 🙈 me así, se😌 ds 💕👭👙 hello 👩🏾‍🎓 emoji hello 👨‍👩‍👦‍👦 how are 😊 you today🙅🏽🙅🏽"
+        expected = [
+            "🤔",
+            "🙈",
+            "me",
+            "así",
+            ",",
+            "se",
+            "😌",
+            "ds",
+            "💕",
+            "👭",
+            "👙",
+            "hello",
+            "👩🏾\u200d🎓",
+            "emoji",
+            "hello",
+            "👨\u200d👩\u200d👦\u200d👦",
+            "how",
+            "are",
+            "😊",
+            "you",
+            "today",
+            "🙅🏽",
+            "🙅🏽",
+        ]
+        result = tokenizer.tokenize(test3)
+        assert result == expected
+
+        # emoji flag sequences, including enclosed letter pairs
+        # Expected behavior from #3034
+        test4 = "🇦🇵🇵🇱🇪"
+        expected = ["🇦🇵", "🇵🇱", "🇪"]
+        result = tokenizer.tokenize(test4)
+        assert result == expected
+
+        test5 = "Hi 🇨🇦, 😍!!"
+        expected = ["Hi", "🇨🇦", ",", "😍", "!", "!"]
+        result = tokenizer.tokenize(test5)
+        assert result == expected
+
+        test6 = "<3 🇨🇦 🤝 🇵🇱 <3"
+        expected = ["<3", "🇨🇦", "🤝", "🇵🇱", "<3"]
+        result = tokenizer.tokenize(test6)
+        assert result == expected
+
+    def test_pad_asterisk(self):
+        """
+        Test padding of asterisk for word tokenization.
+        """
+        text = "This is a, *weird sentence with *asterisks in it."
+        expected = [
+            "This",
+            "is",
+            "a",
+            ",",
+            "*",
+            "weird",
+            "sentence",
+            "with",
+            "*",
+            "asterisks",
+            "in",
+            "it",
+            ".",
+        ]
+        assert word_tokenize(text) == expected
+
+    def test_pad_dotdot(self):
+        """
+        Test padding of dotdot* for word tokenization.
+        """
+        text = "Why did dotdot.. not get tokenized but dotdotdot... did? How about manydots....."
+        expected = [
+            "Why",
+            "did",
+            "dotdot",
+            "..",
+            "not",
+            "get",
+            "tokenized",
+            "but",
+            "dotdotdot",
+            "...",
+            "did",
+            "?",
+            "How",
+            "about",
+            "manydots",
+            ".....",
+        ]
+        assert word_tokenize(text) == expected
+
+    def test_remove_handle(self):
+        """
+        Test remove_handle() from casual.py with specially crafted edge cases
+        """
+
+        tokenizer = TweetTokenizer(strip_handles=True)
+
+        # Simple example. Handles with just numbers should be allowed
+        test1 = "@twitter hello @twi_tter_. hi @12345 @123news"
+        expected = ["hello", ".", "hi"]
+        result = tokenizer.tokenize(test1)
+        assert result == expected
+
+        # Handles are allowed to follow any of the following characters
+        test2 = "@n`@n~@n(@n)@n-@n=@n+@n\\@n|@n[@n]@n{@n}@n;@n:@n'@n\"@n/@n?@n.@n,@n<@n>@n @n\n@n ñ@n.ü@n.ç@n."
+        expected = [
+            "`",
+            "~",
+            "(",
+            ")",
+            "-",
+            "=",
+            "+",
+            "\\",
+            "|",
+            "[",
+            "]",
+            "{",
+            "}",
+            ";",
+            ":",
+            "'",
+            '"',
+            "/",
+            "?",
+            ".",
+            ",",
+            "<",
+            ">",
+            "ñ",
+            ".",
+            "ü",
+            ".",
+            "ç",
+            ".",
+        ]
+        result = tokenizer.tokenize(test2)
+        assert result == expected
+
+        # Handles are NOT allowed to follow any of the following characters
+        test3 = "a@n j@n z@n A@n L@n Z@n 1@n 4@n 7@n 9@n 0@n _@n !@n @@n #@n $@n %@n &@n *@n"
+        expected = [
+            "a",
+            "@n",
+            "j",
+            "@n",
+            "z",
+            "@n",
+            "A",
+            "@n",
+            "L",
+            "@n",
+            "Z",
+            "@n",
+            "1",
+            "@n",
+            "4",
+            "@n",
+            "7",
+            "@n",
+            "9",
+            "@n",
+            "0",
+            "@n",
+            "_",
+            "@n",
+            "!",
+            "@n",
+            "@",
+            "@n",
+            "#",
+            "@n",
+            "$",
+            "@n",
+            "%",
+            "@n",
+            "&",
+            "@n",
+            "*",
+            "@n",
+        ]
+        result = tokenizer.tokenize(test3)
+        assert result == expected
+
+        # Handles are allowed to precede the following characters
+        test4 = "@n!a @n#a @n$a @n%a @n&a @n*a"
+        expected = ["!", "a", "#", "a", "$", "a", "%", "a", "&", "a", "*", "a"]
+        result = tokenizer.tokenize(test4)
+        assert result == expected
+
+        # Tests interactions with special symbols and multiple @
+        test5 = "@n!@n @n#@n @n$@n @n%@n @n&@n @n*@n @n@n @@n @n@@n @n_@n @n7@n @nj@n"
+        expected = [
+            "!",
+            "@n",
+            "#",
+            "@n",
+            "$",
+            "@n",
+            "%",
+            "@n",
+            "&",
+            "@n",
+            "*",
+            "@n",
+            "@n",
+            "@n",
+            "@",
+            "@n",
+            "@n",
+            "@",
+            "@n",
+            "@n_",
+            "@n",
+            "@n7",
+            "@n",
+            "@nj",
+            "@n",
+        ]
+        result = tokenizer.tokenize(test5)
+        assert result == expected
+
+        # Tests that handles can have a max length of 15
+        test6 = "@abcdefghijklmnopqrstuvwxyz @abcdefghijklmno1234 @abcdefghijklmno_ @abcdefghijklmnoendofhandle"
+        expected = ["pqrstuvwxyz", "1234", "_", "endofhandle"]
+        result = tokenizer.tokenize(test6)
+        assert result == expected
+
+        # Edge case where an @ comes directly after a long handle
+        test7 = "@abcdefghijklmnop@abcde @abcdefghijklmno@abcde @abcdefghijklmno_@abcde @abcdefghijklmno5@abcde"
+        expected = [
+            "p",
+            "@abcde",
+            "@abcdefghijklmno",
+            "@abcde",
+            "_",
+            "@abcde",
+            "5",
+            "@abcde",
+        ]
+        result = tokenizer.tokenize(test7)
+        assert result == expected
+
+    def test_treebank_span_tokenizer(self):
+        """
+        Test TreebankWordTokenizer.span_tokenize function
+        """
+
+        tokenizer = TreebankWordTokenizer()
+
+        # Test case in the docstring
+        test1 = "Good muffins cost $3.88\nin New (York).  Please (buy) me\ntwo of them.\n(Thanks)."
+        expected = [
+            (0, 4),
+            (5, 12),
+            (13, 17),
+            (18, 19),
+            (19, 23),
+            (24, 26),
+            (27, 30),
+            (31, 32),
+            (32, 36),
+            (36, 37),
+            (37, 38),
+            (40, 46),
+            (47, 48),
+            (48, 51),
+            (51, 52),
+            (53, 55),
+            (56, 59),
+            (60, 62),
+            (63, 68),
+            (69, 70),
+            (70, 76),
+            (76, 77),
+            (77, 78),
+        ]
+        result = list(tokenizer.span_tokenize(test1))
+        assert result == expected
+
+        # Test case with double quotation
+        test2 = 'The DUP is similar to the "religious right" in the United States and takes a hardline stance on social issues'
+        expected = [
+            (0, 3),
+            (4, 7),
+            (8, 10),
+            (11, 18),
+            (19, 21),
+            (22, 25),
+            (26, 27),
+            (27, 36),
+            (37, 42),
+            (42, 43),
+            (44, 46),
+            (47, 50),
+            (51, 57),
+            (58, 64),
+            (65, 68),
+            (69, 74),
+            (75, 76),
+            (77, 85),
+            (86, 92),
+            (93, 95),
+            (96, 102),
+            (103, 109),
+        ]
+        result = list(tokenizer.span_tokenize(test2))
+        assert result == expected
+
+        # Test case with double qoutation as well as converted quotations
+        test3 = "The DUP is similar to the \"religious right\" in the United States and takes a ``hardline'' stance on social issues"
+        expected = [
+            (0, 3),
+            (4, 7),
+            (8, 10),
+            (11, 18),
+            (19, 21),
+            (22, 25),
+            (26, 27),
+            (27, 36),
+            (37, 42),
+            (42, 43),
+            (44, 46),
+            (47, 50),
+            (51, 57),
+            (58, 64),
+            (65, 68),
+            (69, 74),
+            (75, 76),
+            (77, 79),
+            (79, 87),
+            (87, 89),
+            (90, 96),
+            (97, 99),
+            (100, 106),
+            (107, 113),
+        ]
+        result = list(tokenizer.span_tokenize(test3))
+        assert result == expected
+
+    def test_word_tokenize(self):
+        """
+        Test word_tokenize function
+        """
+
+        sentence = "The 'v', I've been fooled but I'll seek revenge."
+        expected = [
+            "The",
+            "'",
+            "v",
+            "'",
+            ",",
+            "I",
+            "'ve",
+            "been",
+            "fooled",
+            "but",
+            "I",
+            "'ll",
+            "seek",
+            "revenge",
+            ".",
+        ]
+        assert word_tokenize(sentence) == expected
+
+        sentence = "'v' 're'"
+        expected = ["'", "v", "'", "'re", "'"]
+        assert word_tokenize(sentence) == expected
+
+    def test_punkt_pair_iter(self):
+
+        test_cases = [
+            ("12", [("1", "2"), ("2", None)]),
+            ("123", [("1", "2"), ("2", "3"), ("3", None)]),
+            ("1234", [("1", "2"), ("2", "3"), ("3", "4"), ("4", None)]),
+        ]
+
+        for (test_input, expected_output) in test_cases:
+            actual_output = [x for x in punkt._pair_iter(test_input)]
+
+            assert actual_output == expected_output
+
+    def test_punkt_pair_iter_handles_stop_iteration_exception(self):
+        # test input to trigger StopIteration from next()
+        it = iter([])
+        # call method under test and produce a generator
+        gen = punkt._pair_iter(it)
+        # unpack generator, ensure that no error is raised
+        list(gen)
+
+    def test_punkt_tokenize_words_handles_stop_iteration_exception(self):
+        obj = punkt.PunktBaseClass()
+
+        class TestPunktTokenizeWordsMock:
+            def word_tokenize(self, s):
+                return iter([])
+
+        obj._lang_vars = TestPunktTokenizeWordsMock()
+        # unpack generator, ensure that no error is raised
+        list(obj._tokenize_words("test"))
+
+    def test_punkt_tokenize_custom_lang_vars(self):
+
+        # Create LangVars including a full stop end character as used in Bengali
+        class BengaliLanguageVars(punkt.PunktLanguageVars):
+            sent_end_chars = (".", "?", "!", "\u0964")
+
+        obj = punkt.PunktSentenceTokenizer(lang_vars=BengaliLanguageVars())
+
+        # We now expect these sentences to be split up into the individual sentences
+        sentences = "উপরাষ্ট্রপতি শ্রী এম ভেঙ্কাইয়া নাইডু সোমবার আই আই টি দিল্লির হীরক জয়ন্তী উদযাপনের উদ্বোধন করেছেন। অনলাইনের মাধ্যমে এই অনুষ্ঠানে কেন্দ্রীয় মানব সম্পদ উন্নয়নমন্ত্রী শ্রী রমেশ পোখরিয়াল ‘নিশাঙ্ক’  উপস্থিত ছিলেন। এই উপলক্ষ্যে উপরাষ্ট্রপতি হীরকজয়ন্তীর লোগো এবং ২০৩০-এর জন্য প্রতিষ্ঠানের লক্ষ্য ও পরিকল্পনার নথি প্রকাশ করেছেন।"
+        expected = [
+            "উপরাষ্ট্রপতি শ্রী এম ভেঙ্কাইয়া নাইডু সোমবার আই আই টি দিল্লির হীরক জয়ন্তী উদযাপনের উদ্বোধন করেছেন।",
+            "অনলাইনের মাধ্যমে এই অনুষ্ঠানে কেন্দ্রীয় মানব সম্পদ উন্নয়নমন্ত্রী শ্রী রমেশ পোখরিয়াল ‘নিশাঙ্ক’  উপস্থিত ছিলেন।",
+            "এই উপলক্ষ্যে উপরাষ্ট্রপতি হীরকজয়ন্তীর লোগো এবং ২০৩০-এর জন্য প্রতিষ্ঠানের লক্ষ্য ও পরিকল্পনার নথি প্রকাশ করেছেন।",
+        ]
+
+        assert obj.tokenize(sentences) == expected
+
+    def test_punkt_tokenize_no_custom_lang_vars(self):
+
+        obj = punkt.PunktSentenceTokenizer()
+
+        # We expect these sentences to not be split properly, as the Bengali full stop '।' is not included in the default language vars
+        sentences = "উপরাষ্ট্রপতি শ্রী এম ভেঙ্কাইয়া নাইডু সোমবার আই আই টি দিল্লির হীরক জয়ন্তী উদযাপনের উদ্বোধন করেছেন। অনলাইনের মাধ্যমে এই অনুষ্ঠানে কেন্দ্রীয় মানব সম্পদ উন্নয়নমন্ত্রী শ্রী রমেশ পোখরিয়াল ‘নিশাঙ্ক’  উপস্থিত ছিলেন। এই উপলক্ষ্যে উপরাষ্ট্রপতি হীরকজয়ন্তীর লোগো এবং ২০৩০-এর জন্য প্রতিষ্ঠানের লক্ষ্য ও পরিকল্পনার নথি প্রকাশ করেছেন।"
+        expected = [
+            "উপরাষ্ট্রপতি শ্রী এম ভেঙ্কাইয়া নাইডু সোমবার আই আই টি দিল্লির হীরক জয়ন্তী উদযাপনের উদ্বোধন করেছেন। অনলাইনের মাধ্যমে এই অনুষ্ঠানে কেন্দ্রীয় মানব সম্পদ উন্নয়নমন্ত্রী শ্রী রমেশ পোখরিয়াল ‘নিশাঙ্ক’  উপস্থিত ছিলেন। এই উপলক্ষ্যে উপরাষ্ট্রপতি হীরকজয়ন্তীর লোগো এবং ২০৩০-এর জন্য প্রতিষ্ঠানের লক্ষ্য ও পরিকল্পনার নথি প্রকাশ করেছেন।"
+        ]
+
+        assert obj.tokenize(sentences) == expected
+
+    @pytest.mark.parametrize(
+        "input_text,n_sents,n_splits,lang_vars",
+        [
+            # Test debug_decisions on a text with two sentences, split by a dot.
+            ("Subject: Some subject. Attachments: Some attachments", 2, 1),
+            # The sentence should be split into two sections,
+            # with one split and hence one decision.
+            # Test debug_decisions on a text with two sentences, split by an exclamation mark.
+            ("Subject: Some subject! Attachments: Some attachments", 2, 1),
+            # The sentence should be split into two sections,
+            # with one split and hence one decision.
+            # Test debug_decisions on a text with one sentences,
+            # which is not split.
+            ("This is just a normal sentence, just like any other.", 1, 0)
+            # Hence just 1
+        ],
+    )
+    def punkt_debug_decisions(self, input_text, n_sents, n_splits, lang_vars=None):
+        tokenizer = punkt.PunktSentenceTokenizer()
+        if lang_vars != None:
+            tokenizer._lang_vars = lang_vars
+
+        assert len(tokenizer.tokenize(input_text)) == n_sents
+        assert len(list(tokenizer.debug_decisions(input_text))) == n_splits
+
+    def test_punkt_debug_decisions_custom_end(self):
+        # Test debug_decisions on a text with two sentences,
+        # split by a custom end character, based on Issue #2519
+        class ExtLangVars(punkt.PunktLanguageVars):
+            sent_end_chars = (".", "?", "!", "^")
+
+        self.punkt_debug_decisions(
+            "Subject: Some subject^ Attachments: Some attachments",
+            n_sents=2,
+            n_splits=1,
+            lang_vars=ExtLangVars(),
+        )
+        # The sentence should be split into two sections,
+        # with one split and hence one decision.
+
+    @pytest.mark.parametrize(
+        "sentences, expected",
+        [
+            (
+                "this is a test. . new sentence.",
+                ["this is a test.", ".", "new sentence."],
+            ),
+            ("This. . . That", ["This.", ".", ".", "That"]),
+            ("This..... That", ["This..... That"]),
+            ("This... That", ["This... That"]),
+            ("This.. . That", ["This.. .", "That"]),
+            ("This. .. That", ["This.", ".. That"]),
+            ("This. ,. That", ["This.", ",.", "That"]),
+            ("This!!! That", ["This!!!", "That"]),
+            ("This! That", ["This!", "That"]),
+            (
+                "1. This is R .\n2. This is A .\n3. That's all",
+                ["1.", "This is R .", "2.", "This is A .", "3.", "That's all"],
+            ),
+            (
+                "1. This is R .\t2. This is A .\t3. That's all",
+                ["1.", "This is R .", "2.", "This is A .", "3.", "That's all"],
+            ),
+            ("Hello.\tThere", ["Hello.", "There"]),
+        ],
+    )
+    def test_sent_tokenize(self, sentences: str, expected: List[str]):
+        assert sent_tokenize(sentences) == expected

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_twitter_auth.py

@@ -0,0 +1,77 @@
+"""
+Tests for static parts of Twitter package
+"""
+
+import os
+
+import pytest
+
+pytest.importorskip("twython")
+
+from nltk.twitter import Authenticate
+
+
+@pytest.fixture
+def auth():
+    return Authenticate()
+
+
+class TestCredentials:
+    """
+    Tests that Twitter credentials from a file are handled correctly.
+    """
+
+    @classmethod
+    def setup_class(self):
+        self.subdir = os.path.join(os.path.dirname(__file__), "files")
+        os.environ["TWITTER"] = "twitter-files"
+
+    def test_environment(self, auth):
+        """
+        Test that environment variable has been read correctly.
+        """
+        fn = os.path.basename(auth.creds_subdir)
+        assert fn == os.environ["TWITTER"]
+
+    @pytest.mark.parametrize(
+        "kwargs",
+        [
+            # Each of the following scenarios should raise an error:
+            # An empty subdir path
+            {"subdir": ""},
+            # A subdir path of None
+            {"subdir": None},
+            # A nonexistent directory
+            {"subdir": "/nosuchdir"},
+            # 'credentials.txt' is not in default subdir, as read from `os.environ['TWITTER']`
+            {},
+            # Nonexistent credentials file ('foobar')
+            {"creds_file": "foobar"},
+            # 'bad_oauth1-1.txt' is incomplete
+            {"creds_file": "bad_oauth1-1.txt"},
+            # The first key in credentials file 'bad_oauth1-2.txt' is ill-formed
+            {"creds_file": "bad_oauth1-2.txt"},
+            # The first two lines in 'bad_oauth1-3.txt' are collapsed
+            {"creds_file": "bad_oauth1-3.txt"},
+        ],
+    )
+    def test_scenarios_that_should_raise_errors(self, kwargs, auth):
+        """Various scenarios that should raise errors"""
+        try:
+            auth.load_creds(**kwargs)
+        # raises ValueError (zero length field name in format) for python 2.6
+        # OSError for the rest
+        except (OSError, ValueError):
+            pass
+        except Exception as e:
+            pytest.fail("Unexpected exception thrown: %s" % e)
+        else:
+            pytest.fail("OSError exception not thrown.")
+
+    def test_correct_file(self, auth):
+        """Test that a proper file succeeds and is read correctly"""
+        oauth = auth.load_creds(subdir=self.subdir)
+
+        assert auth.creds_fullpath == os.path.join(self.subdir, auth.creds_file)
+        assert auth.creds_file == "credentials.txt"
+        assert oauth["app_key"] == "a"

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_util.py

@@ -0,0 +1,82 @@
+import pytest
+
+from nltk.util import everygrams
+
+
+@pytest.fixture
+def everygram_input():
+    """Form test data for tests."""
+    return iter(["a", "b", "c"])
+
+
+def test_everygrams_without_padding(everygram_input):
+    expected_output = [
+        ("a",),
+        ("a", "b"),
+        ("a", "b", "c"),
+        ("b",),
+        ("b", "c"),
+        ("c",),
+    ]
+    output = list(everygrams(everygram_input))
+    assert output == expected_output
+
+
+def test_everygrams_max_len(everygram_input):
+    expected_output = [
+        ("a",),
+        ("a", "b"),
+        ("b",),
+        ("b", "c"),
+        ("c",),
+    ]
+    output = list(everygrams(everygram_input, max_len=2))
+    assert output == expected_output
+
+
+def test_everygrams_min_len(everygram_input):
+    expected_output = [
+        ("a", "b"),
+        ("a", "b", "c"),
+        ("b", "c"),
+    ]
+    output = list(everygrams(everygram_input, min_len=2))
+    assert output == expected_output
+
+
+def test_everygrams_pad_right(everygram_input):
+    expected_output = [
+        ("a",),
+        ("a", "b"),
+        ("a", "b", "c"),
+        ("b",),
+        ("b", "c"),
+        ("b", "c", None),
+        ("c",),
+        ("c", None),
+        ("c", None, None),
+        (None,),
+        (None, None),
+        (None,),
+    ]
+    output = list(everygrams(everygram_input, max_len=3, pad_right=True))
+    assert output == expected_output
+
+
+def test_everygrams_pad_left(everygram_input):
+    expected_output = [
+        (None,),
+        (None, None),
+        (None, None, "a"),
+        (None,),
+        (None, "a"),
+        (None, "a", "b"),
+        ("a",),
+        ("a", "b"),
+        ("a", "b", "c"),
+        ("b",),
+        ("b", "c"),
+        ("c",),
+    ]
+    output = list(everygrams(everygram_input, max_len=3, pad_left=True))
+    assert output == expected_output

.eggs/nltk-3.8-py3.10.egg/nltk/test/unit/test_wordnet.py

@@ -0,0 +1,240 @@
+"""
+Unit tests for nltk.corpus.wordnet
+See also nltk/test/wordnet.doctest
+"""
+import unittest
+
+from nltk.corpus import wordnet as wn
+from nltk.corpus import wordnet_ic as wnic
+
+wn.ensure_loaded()
+S = wn.synset
+L = wn.lemma
+
+
+class WordnNetDemo(unittest.TestCase):
+    def test_retrieve_synset(self):
+        move_synset = S("go.v.21")
+        self.assertEqual(move_synset.name(), "move.v.15")
+        self.assertEqual(move_synset.lemma_names(), ["move", "go"])
+        self.assertEqual(
+            move_synset.definition(), "have a turn; make one's move in a game"
+        )
+        self.assertEqual(move_synset.examples(), ["Can I go now?"])
+
+    def test_retrieve_synsets(self):
+        self.assertEqual(sorted(wn.synsets("zap", pos="n")), [S("zap.n.01")])
+        self.assertEqual(
+            sorted(wn.synsets("zap", pos="v")),
+            [S("microwave.v.01"), S("nuke.v.01"), S("zap.v.01"), S("zap.v.02")],
+        )
+
+    def test_hyperhyponyms(self):
+        # Not every synset as hypernyms()
+        self.assertEqual(S("travel.v.01").hypernyms(), [])
+        self.assertEqual(S("travel.v.02").hypernyms(), [S("travel.v.03")])
+        self.assertEqual(S("travel.v.03").hypernyms(), [])
+
+        # Test hyper-/hyponyms.
+        self.assertEqual(S("breakfast.n.1").hypernyms(), [S("meal.n.01")])
+        first_five_meal_hypo = [
+            S("banquet.n.02"),
+            S("bite.n.04"),
+            S("breakfast.n.01"),
+            S("brunch.n.01"),
+            S("buffet.n.02"),
+        ]
+        self.assertEqual(sorted(S("meal.n.1").hyponyms()[:5]), first_five_meal_hypo)
+        self.assertEqual(S("Austen.n.1").instance_hypernyms(), [S("writer.n.01")])
+        first_five_composer_hypo = [
+            S("ambrose.n.01"),
+            S("bach.n.01"),
+            S("barber.n.01"),
+            S("bartok.n.01"),
+            S("beethoven.n.01"),
+        ]
+        self.assertEqual(
+            S("composer.n.1").instance_hyponyms()[:5], first_five_composer_hypo
+        )
+
+        # Test root hyper-/hyponyms
+        self.assertEqual(S("person.n.01").root_hypernyms(), [S("entity.n.01")])
+        self.assertEqual(S("sail.v.01").root_hypernyms(), [S("travel.v.01")])
+        self.assertEqual(
+            S("fall.v.12").root_hypernyms(), [S("act.v.01"), S("fall.v.17")]
+        )
+
+    def test_derivationally_related_forms(self):
+        # Test `derivationally_related_forms()`
+        self.assertEqual(
+            L("zap.v.03.nuke").derivationally_related_forms(),
+            [L("atomic_warhead.n.01.nuke")],
+        )
+        self.assertEqual(
+            L("zap.v.03.atomize").derivationally_related_forms(),
+            [L("atomization.n.02.atomization")],
+        )
+        self.assertEqual(
+            L("zap.v.03.atomise").derivationally_related_forms(),
+            [L("atomization.n.02.atomisation")],
+        )
+        self.assertEqual(L("zap.v.03.zap").derivationally_related_forms(), [])
+
+    def test_meronyms_holonyms(self):
+        # Test meronyms, holonyms.
+        self.assertEqual(
+            S("dog.n.01").member_holonyms(), [S("canis.n.01"), S("pack.n.06")]
+        )
+        self.assertEqual(S("dog.n.01").part_meronyms(), [S("flag.n.07")])
+
+        self.assertEqual(S("faculty.n.2").member_meronyms(), [S("professor.n.01")])
+        self.assertEqual(S("copilot.n.1").member_holonyms(), [S("crew.n.01")])
+
+        self.assertEqual(
+            S("table.n.2").part_meronyms(),
+            [S("leg.n.03"), S("tabletop.n.01"), S("tableware.n.01")],
+        )
+        self.assertEqual(S("course.n.7").part_holonyms(), [S("meal.n.01")])
+
+        self.assertEqual(
+            S("water.n.1").substance_meronyms(), [S("hydrogen.n.01"), S("oxygen.n.01")]
+        )
+        self.assertEqual(
+            S("gin.n.1").substance_holonyms(),
+            [
+                S("gin_and_it.n.01"),
+                S("gin_and_tonic.n.01"),
+                S("martini.n.01"),
+                S("pink_lady.n.01"),
+            ],
+        )
+
+    def test_antonyms(self):
+        # Test antonyms.
+        self.assertEqual(
+            L("leader.n.1.leader").antonyms(), [L("follower.n.01.follower")]
+        )
+        self.assertEqual(
+            L("increase.v.1.increase").antonyms(), [L("decrease.v.01.decrease")]
+        )
+
+    def test_misc_relations(self):
+        # Test misc relations.
+        self.assertEqual(S("snore.v.1").entailments(), [S("sleep.v.01")])
+        self.assertEqual(
+            S("heavy.a.1").similar_tos(),
+            [
+                S("dense.s.03"),
+                S("doughy.s.01"),
+                S("heavier-than-air.s.01"),
+                S("hefty.s.02"),
+                S("massive.s.04"),
+                S("non-buoyant.s.01"),
+                S("ponderous.s.02"),
+            ],
+        )
+        self.assertEqual(S("light.a.1").attributes(), [S("weight.n.01")])
+        self.assertEqual(S("heavy.a.1").attributes(), [S("weight.n.01")])
+
+        # Test pertainyms.
+        self.assertEqual(
+            L("English.a.1.English").pertainyms(), [L("england.n.01.England")]
+        )
+
+    def test_lch(self):
+        # Test LCH.
+        self.assertEqual(
+            S("person.n.01").lowest_common_hypernyms(S("dog.n.01")),
+            [S("organism.n.01")],
+        )
+        self.assertEqual(
+            S("woman.n.01").lowest_common_hypernyms(S("girlfriend.n.02")),
+            [S("woman.n.01")],
+        )
+
+    def test_domains(self):
+        # Test domains.
+        self.assertEqual(S("code.n.03").topic_domains(), [S("computer_science.n.01")])
+        self.assertEqual(S("pukka.a.01").region_domains(), [S("india.n.01")])
+        self.assertEqual(S("freaky.a.01").usage_domains(), [S("slang.n.02")])
+
+    def test_in_topic_domains(self):
+        # Test in domains.
+        self.assertEqual(
+            S("computer_science.n.01").in_topic_domains()[0], S("access.n.05")
+        )
+        self.assertEqual(S("germany.n.01").in_region_domains()[23], S("trillion.n.02"))
+        self.assertEqual(S("slang.n.02").in_usage_domains()[1], S("airhead.n.01"))
+
+    def test_wordnet_similarities(self):
+        # Path based similarities.
+        self.assertAlmostEqual(S("cat.n.01").path_similarity(S("cat.n.01")), 1.0)
+        self.assertAlmostEqual(S("dog.n.01").path_similarity(S("cat.n.01")), 0.2)
+        self.assertAlmostEqual(
+            S("car.n.01").path_similarity(S("automobile.v.01")),
+            S("automobile.v.01").path_similarity(S("car.n.01")),
+        )
+        self.assertAlmostEqual(
+            S("big.a.01").path_similarity(S("dog.n.01")),
+            S("dog.n.01").path_similarity(S("big.a.01")),
+        )
+        self.assertAlmostEqual(
+            S("big.a.01").path_similarity(S("long.a.01")),
+            S("long.a.01").path_similarity(S("big.a.01")),
+        )
+        self.assertAlmostEqual(
+            S("dog.n.01").lch_similarity(S("cat.n.01")), 2.028, places=3
+        )
+        self.assertAlmostEqual(
+            S("dog.n.01").wup_similarity(S("cat.n.01")), 0.8571, places=3
+        )
+        self.assertAlmostEqual(
+            S("car.n.01").wup_similarity(S("automobile.v.01")),
+            S("automobile.v.01").wup_similarity(S("car.n.01")),
+        )
+        self.assertAlmostEqual(
+            S("big.a.01").wup_similarity(S("dog.n.01")),
+            S("dog.n.01").wup_similarity(S("big.a.01")),
+        )
+        self.assertAlmostEqual(
+            S("big.a.01").wup_similarity(S("long.a.01")),
+            S("long.a.01").wup_similarity(S("big.a.01")),
+        )
+        self.assertAlmostEqual(
+            S("big.a.01").lch_similarity(S("long.a.01")),
+            S("long.a.01").lch_similarity(S("big.a.01")),
+        )
+        # Information Content similarities.
+        brown_ic = wnic.ic("ic-brown.dat")
+        self.assertAlmostEqual(
+            S("dog.n.01").jcn_similarity(S("cat.n.01"), brown_ic), 0.4497, places=3
+        )
+        semcor_ic = wnic.ic("ic-semcor.dat")
+        self.assertAlmostEqual(
+            S("dog.n.01").lin_similarity(S("cat.n.01"), semcor_ic), 0.8863, places=3
+        )
+
+    def test_omw_lemma_no_trailing_underscore(self):
+        expected = sorted(
+            [
+                "popolna_sprememba_v_mišljenju",
+                "popoln_obrat",
+                "preobrat",
+                "preobrat_v_mišljenju",
+            ]
+        )
+        self.assertEqual(sorted(S("about-face.n.02").lemma_names(lang="slv")), expected)
+
+    def test_iterable_type_for_all_lemma_names(self):
+        # Duck-test for iterables.
+        # See https://stackoverflow.com/a/36230057/610569
+        cat_lemmas = wn.all_lemma_names(lang="cat")
+        eng_lemmas = wn.all_lemma_names(lang="eng")
+
+        self.assertTrue(hasattr(eng_lemmas, "__iter__"))
+        self.assertTrue(hasattr(eng_lemmas, "__next__") or hasattr(eng_lemmas, "next"))
+        self.assertTrue(eng_lemmas.__iter__() is eng_lemmas)
+
+        self.assertTrue(hasattr(cat_lemmas, "__iter__"))
+        self.assertTrue(hasattr(cat_lemmas, "__next__") or hasattr(eng_lemmas, "next"))
+        self.assertTrue(cat_lemmas.__iter__() is cat_lemmas)

build/lib/opencompass/configs/dataset_collections/chat_OC15.py

@@ -0,0 +1,22 @@
+from mmengine.config import read_base
+
+with read_base():
+    from opencompass.configs.datasets.mmlu.mmlu_gen_4d595a import mmlu_datasets
+    from opencompass.configs.datasets.cmmlu.cmmlu_gen_c13365 import cmmlu_datasets
+    from opencompass.configs.datasets.ceval.ceval_gen_5f30c7 import ceval_datasets
+    from opencompass.configs.datasets.GaokaoBench.GaokaoBench_no_subjective_gen_4c31db import GaokaoBench_datasets
+    from opencompass.configs.datasets.triviaqa.triviaqa_wiki_1shot_gen_bc5f21 import triviaqa_datasets
+    from opencompass.configs.datasets.nq.nq_open_1shot_gen_2e45e5 import nq_datasets
+    from opencompass.configs.datasets.race.race_gen_69ee4f import race_datasets
+    from opencompass.configs.datasets.winogrande.winogrande_5shot_gen_b36770 import winogrande_datasets
+    from opencompass.configs.datasets.hellaswag.hellaswag_10shot_gen_e42710 import hellaswag_datasets
+    from opencompass.configs.datasets.bbh.bbh_gen_2879b0 import bbh_datasets
+    from opencompass.configs.datasets.gsm8k.gsm8k_gen_1d7fe4 import gsm8k_datasets
+    from opencompass.configs.datasets.math.math_0shot_gen_393424 import math_datasets
+    from opencompass.configs.datasets.TheoremQA.TheoremQA_5shot_gen_6f0af8 import TheoremQA_datasets
+    from opencompass.configs.datasets.humaneval.humaneval_gen_8e312c import humaneval_datasets
+    from opencompass.configs.datasets.mbpp.sanitized_mbpp_gen_830460 import sanitized_mbpp_datasets
+    from opencompass.configs.datasets.gpqa.gpqa_gen_4baadb import gpqa_datasets
+    from opencompass.configs.datasets.IFEval.IFEval_gen_3321a3 import ifeval_datasets
+
+datasets = sum((v for k, v in locals().items() if k.endswith('_datasets')), [])

build/lib/opencompass/configs/datasets/FewCLUE_bustm/FewCLUE_bustm_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_bustm_gen_634f41 import bustm_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_chid/FewCLUE_chid_ppl_8f2872.py

@@ -0,0 +1,45 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import CHIDDataset
+
+chid_reader_cfg = dict(
+    input_columns=[f'content{i}' for i in range(7)], output_column='answer')
+
+chid_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            i: dict(
+                round=[
+                    dict(role='HUMAN', prompt=f'以下句子是否通顺？\n{{content{i}}}'),
+                    dict(role='BOT', prompt='这个句子是通顺的。'),
+                ], )
+            for i in range(7)
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+
+chid_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+chid_datasets = [
+    dict(
+        type=CHIDDataset,
+        path='json',
+        abbr='chid-dev',
+        data_files='./data/FewCLUE/chid/dev_few_all.json',
+        split='train',
+        reader_cfg=chid_reader_cfg,
+        infer_cfg=chid_infer_cfg,
+        eval_cfg=chid_eval_cfg),
+    dict(
+        type=CHIDDataset,
+        path='json',
+        abbr='chid-test',
+        data_files='./data/FewCLUE/chid/test_public.json',
+        split='train',
+        reader_cfg=chid_reader_cfg,
+        infer_cfg=chid_infer_cfg,
+        eval_cfg=chid_eval_cfg),
+]

build/lib/opencompass/configs/datasets/FewCLUE_cluewsc/FewCLUE_cluewsc_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_cluewsc_gen_c68933 import cluewsc_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_csl/FewCLUE_csl_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_csl_gen_28b223 import csl_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_csl/FewCLUE_csl_gen_87f4a8.py

@@ -0,0 +1,51 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import CslDatasetV2
+from opencompass.utils.text_postprocessors import first_capital_postprocess
+
+csl_reader_cfg = dict(
+    input_columns=['abst', 'keywords'],
+    output_column='label',
+)
+
+csl_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template=dict(round=[
+            dict(
+                role='HUMAN',
+                prompt=
+                '摘要：{abst}\n关键词：{keywords}\n上述关键词出现在学术期刊中是否恰当？\nA. 否\nB. 是\n请从”A“，”B“中进行选择。\n答：'
+            )
+        ]),
+    ),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=GenInferencer),
+)
+
+csl_eval_cfg = dict(
+    evaluator=dict(type=AccEvaluator),
+    pred_role='BOT',
+    pred_postprocessor=dict(type=first_capital_postprocess),
+)
+
+csl_datasets = [
+    dict(
+        abbr='csl_dev',
+        type=CslDatasetV2,
+        path='./data/FewCLUE/csl/dev_few_all.json',
+        reader_cfg=csl_reader_cfg,
+        infer_cfg=csl_infer_cfg,
+        eval_cfg=csl_eval_cfg,
+    ),
+    dict(
+        abbr='csl_test',
+        type=CslDatasetV2,
+        path='./data/FewCLUE/csl/test_public.json',
+        reader_cfg=csl_reader_cfg,
+        infer_cfg=csl_infer_cfg,
+        eval_cfg=csl_eval_cfg,
+    ),
+]

build/lib/opencompass/configs/datasets/FewCLUE_eprstmt/FewCLUE_eprstmt_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_eprstmt_gen_740ea0 import eprstmt_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_eprstmt/FewCLUE_eprstmt_gen_740ea0.py

@@ -0,0 +1,49 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import EprstmtDatasetV2
+from opencompass.utils.text_postprocessors import first_capital_postprocess
+
+eprstmt_reader_cfg = dict(
+    input_columns=['sentence'], output_column='label', test_split='train')
+
+eprstmt_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template=dict(round=[
+            dict(
+                role='HUMAN',
+                prompt=
+                '内容： "{sentence}"。请对上述内容进行情绪分类。\nA. 积极\nB. 消极\n请从”A“，”B“中进行选择。\n答：'
+            ),
+        ]),
+    ),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=GenInferencer),
+)
+
+eprstmt_eval_cfg = dict(
+    evaluator=dict(type=AccEvaluator),
+    pred_role='BOT',
+    pred_postprocessor=dict(type=first_capital_postprocess),
+)
+
+eprstmt_datasets = [
+    dict(
+        abbr='eprstmt-dev',
+        type=EprstmtDatasetV2,
+        path='./data/FewCLUE/eprstmt/dev_few_all.json',
+        reader_cfg=eprstmt_reader_cfg,
+        infer_cfg=eprstmt_infer_cfg,
+        eval_cfg=eprstmt_eval_cfg,
+    ),
+    dict(
+        abbr='eprstmt-test',
+        type=EprstmtDatasetV2,
+        path='./data/FewCLUE/eprstmt/test_public.json',
+        reader_cfg=eprstmt_reader_cfg,
+        infer_cfg=eprstmt_infer_cfg,
+        eval_cfg=eprstmt_eval_cfg,
+    ),
+]

build/lib/opencompass/configs/datasets/FewCLUE_eprstmt/FewCLUE_eprstmt_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_eprstmt_ppl_f1e631 import eprstmt_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_eprstmt/FewCLUE_eprstmt_ppl_f1e631.py

@@ -0,0 +1,49 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+eprstmt_reader_cfg = dict(
+    input_columns=['sentence'], output_column='label', test_split='train')
+
+eprstmt_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            'Negative':
+            dict(round=[
+                dict(role='HUMAN', prompt='内容： "{sentence}"。情绪分类：'),
+                dict(role='BOT', prompt='消极。')
+            ]),
+            'Positive':
+            dict(round=[
+                dict(role='HUMAN', prompt='内容： "{sentence}"。情绪分类：'),
+                dict(role='BOT', prompt='积极。')
+            ]),
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+
+eprstmt_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+eprstmt_datasets = [
+    dict(
+        type=HFDataset,
+        abbr='eprstmt-dev',
+        path='json',
+        data_files='./data/FewCLUE/eprstmt/dev_few_all.json',
+        split='train',
+        reader_cfg=eprstmt_reader_cfg,
+        infer_cfg=eprstmt_infer_cfg,
+        eval_cfg=eprstmt_eval_cfg),
+    dict(
+        type=HFDataset,
+        abbr='eprstmt-test',
+        path='json',
+        data_files='./data/FewCLUE/eprstmt/test_public.json',
+        split='train',
+        reader_cfg=eprstmt_reader_cfg,
+        infer_cfg=eprstmt_infer_cfg,
+        eval_cfg=eprstmt_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FewCLUE_ocnli_fc/FewCLUE_ocnli_fc_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_ocnli_fc_ppl_c08300 import ocnli_fc_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_ocnli_fc/FewCLUE_ocnli_fc_ppl_9e8b3d.py

@@ -0,0 +1,60 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+ocnli_fc_reader_cfg = dict(
+    input_columns=['sentence1', 'sentence2'],
+    output_column='label',
+    test_split='train')
+
+ocnli_fc_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            'contradiction':
+            dict(round=[
+                dict(
+                    role='HUMAN',
+                    prompt='阅读文章：{sentence1}\n根据上文，回答如下问题：{sentence2}？'),
+                dict(role='BOT', prompt='错')
+            ]),
+            'entailment':
+            dict(round=[
+                dict(
+                    role='HUMAN',
+                    prompt='阅读文章：{sentence1}\n根据上文，回答如下问题：{sentence2}？'),
+                dict(role='BOT', prompt='对')
+            ]),
+            'neutral':
+            dict(round=[
+                dict(
+                    role='HUMAN', prompt='如果{sentence1}为真，那么{sentence2}也为真吗？'),
+                dict(role='BOT', prompt='可能')
+            ]),
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+ocnli_fc_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+ocnli_fc_datasets = [
+    dict(
+        type=HFDataset,
+        abbr='ocnli_fc-dev',
+        path='json',
+        split='train',
+        data_files='./data/FewCLUE/ocnli/dev_few_all.json',
+        reader_cfg=ocnli_fc_reader_cfg,
+        infer_cfg=ocnli_fc_infer_cfg,
+        eval_cfg=ocnli_fc_eval_cfg),
+    dict(
+        type=HFDataset,
+        abbr='ocnli_fc-test',
+        path='json',
+        split='train',
+        data_files='./data/FewCLUE/ocnli/test_public.json',
+        reader_cfg=ocnli_fc_reader_cfg,
+        infer_cfg=ocnli_fc_infer_cfg,
+        eval_cfg=ocnli_fc_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FewCLUE_ocnli_fc/FewCLUE_ocnli_fc_ppl_c08300.py

@@ -0,0 +1,44 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+ocnli_fc_reader_cfg = dict(
+    input_columns=['sentence1', 'sentence2'],
+    output_column='label',
+    test_split='train')
+
+ocnli_fc_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            'contradiction':
+            '阅读文章：{sentence1}\n根据上文，回答如下问题： {sentence2}？\n答：错',
+            'entailment': '阅读文章：{sentence1}\n根据上文，回答如下问题： {sentence2}？\n答：对',
+            'neutral': '如果{sentence1}为真，那么{sentence2}也为真吗?可能'
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+ocnli_fc_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+ocnli_fc_datasets = [
+    dict(
+        type=HFDataset,
+        abbr='ocnli_fc-dev',
+        path='json',
+        split='train',
+        data_files='./data/FewCLUE/ocnli/dev_few_all.json',
+        reader_cfg=ocnli_fc_reader_cfg,
+        infer_cfg=ocnli_fc_infer_cfg,
+        eval_cfg=ocnli_fc_eval_cfg),
+    dict(
+        type=HFDataset,
+        abbr='ocnli_fc-test',
+        path='json',
+        split='train',
+        data_files='./data/FewCLUE/ocnli/test_public.json',
+        reader_cfg=ocnli_fc_reader_cfg,
+        infer_cfg=ocnli_fc_infer_cfg,
+        eval_cfg=ocnli_fc_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FewCLUE_tnews/FewCLUE_tnews_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_tnews_gen_b90e4a import tnews_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_tnews/FewCLUE_tnews_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FewCLUE_tnews_ppl_d10e8a import tnews_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FewCLUE_tnews/FewCLUE_tnews_ppl_7d1c07.py

@@ -0,0 +1,43 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import TNewsDataset
+
+tnews_reader_cfg = dict(input_columns='sentence', output_column='label_desc2')
+
+tnews_labels = [
+    '农业新闻', '旅游新闻', '游戏新闻', '科技类别公司新闻', '体育类别新闻', '初升高教育新闻', '娱乐圈新闻', '投资资讯',
+    '军事类别常识', '车辆新闻', '楼市新闻', '环球不含中国类别新闻', '书籍文化历史类别新闻', '故事类别新闻', '股票市场类别新闻'
+]
+
+tnews_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={lb: f'{{sentence}}这篇新闻属于：{lb}'
+                  for lb in tnews_labels}),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+
+tnews_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+tnews_datasets = [
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-dev',
+        data_files='./data/FewCLUE/tnews/dev_few_all.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg),
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-test',
+        data_files='./data/FewCLUE/tnews/test_public.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FewCLUE_tnews/FewCLUE_tnews_ppl_d10e8a.py

@@ -0,0 +1,48 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import TNewsDataset
+
+tnews_reader_cfg = dict(input_columns='sentence', output_column='label_desc2')
+
+tnews_labels = [
+    '农业新闻', '旅游新闻', '游戏新闻', '科技类别公司新闻', '体育类别新闻', '初升高教育新闻', '娱乐圈新闻', '投资资讯',
+    '军事类别常识', '车辆新闻', '楼市新闻', '环球不含中国类别新闻', '书籍文化历史类别新闻', '故事类别新闻', '股票市场类别新闻'
+]
+
+tnews_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            lb: dict(round=[
+                dict(role='HUMAN', prompt='{sentence}\n上述内容属于什么新闻？'),
+                dict(role='BOT', prompt=lb)
+            ])
+            for lb in tnews_labels
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+
+tnews_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+tnews_datasets = [
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-dev',
+        data_files='./data/FewCLUE/tnews/dev_few_all.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg),
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-test',
+        data_files='./data/FewCLUE/tnews/test_public.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FewCLUE_tnews/FewCLUE_tnews_ppl_fff486.py

@@ -0,0 +1,48 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import TNewsDataset
+
+tnews_reader_cfg = dict(input_columns='sentence', output_column='label_desc2')
+
+tnews_labels = [
+    '农业新闻', '旅游新闻', '游戏新闻', '科技类别公司新闻', '体育类别新闻', '初升高教育新闻', '娱乐圈新闻', '投资资讯',
+    '军事类别常识', '车辆新闻', '楼市新闻', '环球不含中国类别新闻', '书籍文化历史类别新闻', '故事类别新闻', '股票市场类别新闻'
+]
+
+tnews_infer_cfg = dict(
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            lb: dict(round=[
+                dict(role='HUMAN', prompt='以下内容属于什么新闻：{sentence}。'),
+                dict(role='BOT', prompt=lb)
+            ])
+            for lb in tnews_labels
+        }),
+    retriever=dict(type=ZeroRetriever),
+    inferencer=dict(type=PPLInferencer))
+
+tnews_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+tnews_datasets = [
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-dev',
+        data_files='./data/FewCLUE/tnews/dev_few_all.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg),
+    dict(
+        type=TNewsDataset,
+        path='json',
+        abbr='tnews-test',
+        data_files='./data/FewCLUE/tnews/test_public.json',
+        split='train',
+        reader_cfg=tnews_reader_cfg,
+        infer_cfg=tnews_infer_cfg,
+        eval_cfg=tnews_eval_cfg)
+]

build/lib/opencompass/configs/datasets/FinanceIQ/FinanceIQ_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FinanceIQ_gen_e0e6b5 import financeIQ_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FinanceIQ/FinanceIQ_gen_e0e6b5.py

@@ -0,0 +1,77 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import FixKRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import FinanceIQDataset
+from opencompass.utils.text_postprocessors import first_capital_postprocess
+
+financeIQ_subject_mapping_en = {
+    'certified_public_accountant': '注册会计师（CPA）',
+    'banking_qualification': '银行从业资格',
+    'securities_qualification': '证券从业资格',
+    'fund_qualification': '基金从业资格',
+    'insurance_qualification': '保险从业资格CICE',
+    'economic_analyst': '经济师',
+    'taxation_practitioner': '税务师',
+    'futures_qualification': '期货从业资格',
+    'certified_fin_planner': '理财规划师',
+    'actuary_fin_math': '精算师-金融数学',
+}
+
+financeIQ_subject_mapping = {
+    '注册会计师（CPA）': '注册会计师（CPA）',
+    '银行从业资格': '银行从业资格',
+    '证券从业资格': '证券从业资格',
+    '基金从业资格': '基金从业资格',
+    '保险从业资格CICE': '保险从业资格CICE',
+    '经济师': '经济师',
+    '税务师': '税务师',
+    '期货从业资格': '期货从业资格',
+    '理财规划师': '理财规划师',
+    '精算师-金融数学': '精算师-金融数学',
+}
+
+financeIQ_all_sets = list(financeIQ_subject_mapping.keys())
+
+financeIQ_datasets = []
+for _name in financeIQ_all_sets:
+    _ch_name = financeIQ_subject_mapping[_name]
+    financeIQ_infer_cfg = dict(
+        ice_template=dict(
+            type=PromptTemplate,
+            template=dict(
+                begin='</E>',
+                round=[
+                    dict(
+                        role='HUMAN',
+                        prompt=
+                        f'以下是关于{_ch_name}的单项选择题，请直接给出正确答案的选项。\n题目：{{question}}\nA. {{A}}\nB. {{B}}\nC. {{C}}\nD. {{D}}'
+                    ),
+                    dict(role='BOT', prompt='答案是: {answer}'),
+                ]),
+            ice_token='</E>',
+        ),
+        retriever=dict(type=FixKRetriever, fix_id_list=[0, 1, 2, 3, 4]),
+        inferencer=dict(type=GenInferencer),
+    )
+
+    financeIQ_eval_cfg = dict(
+        evaluator=dict(type=AccEvaluator),
+        pred_postprocessor=dict(type=first_capital_postprocess))
+
+    financeIQ_datasets.append(
+        dict(
+            type=FinanceIQDataset,
+            path='./data/FinanceIQ/',
+            name=_name,
+            abbr=f'FinanceIQ-{_name}',
+            reader_cfg=dict(
+                input_columns=['question', 'A', 'B', 'C', 'D'],
+                output_column='answer',
+                train_split='dev',
+                test_split='test'),
+            infer_cfg=financeIQ_infer_cfg,
+            eval_cfg=financeIQ_eval_cfg,
+        ))
+
+del _name, _ch_name

build/lib/opencompass/configs/datasets/FinanceIQ/FinanceIQ_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .FinanceIQ_ppl_42b9bd import financeIQ_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/FinanceIQ/FinanceIQ_ppl_42b9bd.py

@@ -0,0 +1,76 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import FixKRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import FinanceIQDataset
+
+financeIQ_subject_mapping_en = {
+    'certified_public_accountant': '注册会计师（CPA）',
+    'banking_qualification': '银行从业资格',
+    'securities_qualification': '证券从业资格',
+    'fund_qualification': '基金从业资格',
+    'insurance_qualification': '保险从业资格CICE',
+    'economic_analyst': '经济师',
+    'taxation_practitioner': '税务师',
+    'futures_qualification': '期货从业资格',
+    'certified_fin_planner': '理财规划师',
+    'actuary_fin_math': '精算师-金融数学',
+}
+
+financeIQ_subject_mapping = {
+    '注册会计师（CPA）': '注册会计师（CPA）',
+    '银行从业资格': '银行从业资格',
+    '证券从业资格': '证券从业资格',
+    '基金从业资格': '基金从业资格',
+    '保险从业资格CICE': '保险从业资格CICE',
+    '经济师': '经济师',
+    '税务师': '税务师',
+    '期货从业资格': '期货从业资格',
+    '理财规划师': '理财规划师',
+    '精算师-金融数学': '精算师-金融数学',
+}
+
+financeIQ_all_sets = list(financeIQ_subject_mapping.keys())
+
+financeIQ_datasets = []
+for _name in financeIQ_all_sets:
+    _ch_name = financeIQ_subject_mapping[_name]
+    financeIQ_infer_cfg = dict(
+        ice_template=dict(
+            type=PromptTemplate,
+            template={
+                answer: dict(
+                    begin='</E>',
+                    round=[
+                        dict(
+                            role='HUMAN',
+                            prompt=f'以下是关于{_ch_name}的单项选择题，请直接给出正确答案的选项。\n题目：{{question}}\nA. {{A}}\nB. {{B}}\nC. {{C}}\nD. {{D}}'
+                        ),
+                        dict(role='BOT', prompt=f'答案是: {answer}'),
+                    ])
+                for answer in ['A', 'B', 'C', 'D']
+            },
+            ice_token='</E>',
+        ),
+        retriever=dict(type=FixKRetriever, fix_id_list=[0, 1, 2, 3, 4]),
+        inferencer=dict(type=PPLInferencer),
+    )
+
+    financeIQ_eval_cfg = dict(evaluator=dict(type=AccEvaluator))
+
+    financeIQ_datasets.append(
+        dict(
+            type=FinanceIQDataset,
+            path='./data/FinanceIQ/',
+            name=_name,
+            abbr=f'FinanceIQ-{_name}',
+            reader_cfg=dict(
+                input_columns=['question', 'A', 'B', 'C', 'D'],
+                output_column='answer',
+                train_split='dev',
+                test_split='test'),
+            infer_cfg=financeIQ_infer_cfg,
+            eval_cfg=financeIQ_eval_cfg,
+        ))
+
+del _name, _ch_name

build/lib/opencompass/configs/datasets/GLUE_CoLA/GLUE_CoLA_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .GLUE_CoLA_ppl_77d0df import CoLA_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/GLUE_CoLA/GLUE_CoLA_ppl_77d0df.py

@@ -0,0 +1,50 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import FixKRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+
+_hint = 'The following are text classification questions. \n' \
+    'Please determine whether the following sentence is linguistically acceptable: ' \
+    '0 means unacceptable, 1 means acceptable.\n'
+
+CoLA_infer_cfg = dict(
+    ice_template=dict(
+        type=PromptTemplate,
+        template='Sentence: {sentence}\nResult: {label}',
+    ),
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            answer:
+            f'{_hint}</E>Sentence: {{sentence}}\nResult: {answer}'
+            for answer in [0, 1]
+        },
+        ice_token='</E>',
+    ),
+    retriever=dict(type=FixKRetriever, fix_id_list=[17, 18, 19, 20, 21]),
+    inferencer=dict(type=PPLInferencer))
+
+CoLA_eval_cfg = dict(evaluator=dict(type=AccEvaluator), )
+
+CoLA_datasets = []
+for _split in ['validation']:
+
+    CoLA_reader_cfg = dict(
+        input_columns=['sentence'],
+        output_column='label',
+        test_split=_split
+    )
+
+    CoLA_datasets.append(
+        dict(
+            abbr=f'CoLA-{_split}',
+            type=HFDataset,
+            path='glue',
+            name='cola',
+            reader_cfg=CoLA_reader_cfg,
+            infer_cfg=CoLA_infer_cfg,
+            eval_cfg=CoLA_eval_cfg
+        )
+    )

build/lib/opencompass/configs/datasets/GLUE_MRPC/GLUE_MRPC_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .GLUE_MRPC_ppl_96564c import MRPC_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/GLUE_MRPC/GLUE_MRPC_ppl_96564c.py

@@ -0,0 +1,51 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import FixKRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+
+_hint = 'The following are semantic matching questions. \n' \
+    'Please determine whether the following two sentences are semantically equivalent: ' \
+    '0 means not equivalent, 1 means equivalent.\n'
+MRPC_infer_cfg = dict(
+    ice_template=dict(
+        type=PromptTemplate,
+        template='Sentence one: {sentence1}\nSentence two: {sentence2}\nResult: {label}',
+    ),
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            answer:
+            f'{_hint}</E>Sentence one: {{sentence1}}\nSentence two: {{sentence2}}\nResult: {answer}'
+            for answer in [0, 1]
+        },
+        ice_token='</E>',
+    ),
+    retriever=dict(type=FixKRetriever, fix_id_list=[0, 1, 2, 3, 4]),
+    inferencer=dict(type=PPLInferencer))
+
+MRPC_eval_cfg = dict(evaluator=dict(type=AccEvaluator), )
+
+
+MRPC_datasets = []
+for _split in ['validation', 'test']:
+
+    MRPC_reader_cfg = dict(
+        input_columns=['sentence1', 'sentence2'],
+        output_column='label',
+        train_split='train',
+        test_split=_split
+    )
+
+    MRPC_datasets.append(
+        dict(
+            abbr=f'MRPC-{_split}',
+            type=HFDataset,
+            path='glue',
+            name='mrpc',
+            reader_cfg=MRPC_reader_cfg,
+            infer_cfg=MRPC_infer_cfg,
+            eval_cfg=MRPC_eval_cfg
+        )
+    )

build/lib/opencompass/configs/datasets/GLUE_QQP/GLUE_QQP_ppl.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .GLUE_QQP_ppl_250d00 import QQP_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/GLUE_QQP/GLUE_QQP_ppl_250d00.py

@@ -0,0 +1,51 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import FixKRetriever
+from opencompass.openicl.icl_inferencer import PPLInferencer
+from opencompass.openicl.icl_evaluator import AccEvaluator
+from opencompass.datasets import HFDataset
+
+
+_hint = 'The following are semantic matching questions. \n' \
+    'Please determine whether the following two sentences are semantically duplicate: ' \
+    '0 means not duplicate, 1 means duplicate.\n'
+QQP_infer_cfg = dict(
+    ice_template=dict(
+        type=PromptTemplate,
+        template='Sentence one: {question1}\nSentence two: {question2}\nResult: {label}',
+    ),
+    prompt_template=dict(
+        type=PromptTemplate,
+        template={
+            answer:
+            f'{_hint}</E>Sentence one: {{question1}}\nSentence two: {{question2}}\nResult: {answer}'
+            for answer in [0, 1]
+        },
+        ice_token='</E>',
+    ),
+    retriever=dict(type=FixKRetriever, fix_id_list=[0, 1, 2, 3, 4]),
+    inferencer=dict(type=PPLInferencer))
+
+QQP_eval_cfg = dict(evaluator=dict(type=AccEvaluator), )
+
+
+QQP_datasets = []
+for _split in ['validation', 'test']:
+
+    QQP_reader_cfg = dict(
+        input_columns=['question1', 'question2'],
+        output_column='label',
+        train_split='train',
+        test_split=_split
+    )
+
+    QQP_datasets.append(
+        dict(
+            abbr=f'QQP-{_split}',
+            type=HFDataset,
+            path='glue',
+            name='qqp',
+            reader_cfg=QQP_reader_cfg,
+            infer_cfg=QQP_infer_cfg,
+            eval_cfg=QQP_eval_cfg
+        )
+    )

build/lib/opencompass/configs/datasets/GaokaoBench/GaokaoBench_gen.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .GaokaoBench_gen_5cfe9e import GaokaoBench_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/GaokaoBench/GaokaoBench_gen_5cfe9e.py

@@ -0,0 +1,304 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer
+from opencompass.datasets import GaokaoBenchDataset
+
+
+_MCQ_prompts = [
+    {
+        'type': 'single_choice',
+        'keyword': '2010-2022_Math_II_MCQs',
+        'prefix_prompt':
+        '请你做一道数学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type': 'single_choice',
+        'keyword': '2010-2022_Math_I_MCQs',
+        'prefix_prompt':
+        '请你做一道数学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_History_MCQs',
+        'prefix_prompt':
+        '请你做一道历史选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Biology_MCQs',
+        'prefix_prompt':
+        '请你做一道生物选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Political_Science_MCQs',
+        'prefix_prompt':
+        '请你做一道政治选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'multi_choice',
+        'keyword':
+        '2010-2022_Physics_MCQs',
+        'prefix_prompt':
+        '请你做一道物理选择题。\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出所有符合题意的答案，并写在【答案】和<eoa>之间。\n例如：【答案】 AB <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】... <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Chemistry_MCQs',
+        'prefix_prompt':
+        '请你做一道化学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2013_English_MCQs',
+        'prefix_prompt':
+        '请你做一道英语选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Chinese_Modern_Lit',
+        'prefix_prompt':
+        '请你做一道语文阅读理解题，其中包含三个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_English_Fill_in_Blanks',
+        'prefix_prompt':
+        '请你做一道英语完形填空题,其中包含二十个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'five_out_of_seven',
+        'keyword':
+        '2012-2022_English_Cloze_Test',
+        'prefix_prompt':
+        '请回答下面的问题，将符合题意的五个选项的字母写在【答案】和<eoa>之间，例如“【答案】 A B C D E <eoa>\n请严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Geography_MCQs',
+        'prefix_prompt':
+        '请你做一道地理选择题，其中包含两到三个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_English_Reading_Comp',
+        'prefix_prompt':
+        '请你做一道英语阅读理解题，其中包含三到五个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Chinese_Lang_and_Usage_MCQs',
+        'prefix_prompt':
+        '请你做一道语文选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n（1）【解析】 ... <eoe>\n【答案】 ... <eoa>\n（2）【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答\n题目如下：'
+    },
+]
+_FBQ_prompts = [{
+    'type': 'cloze',
+    'keyword': '2010-2022_Math_I_Fill-in-the-Blank',
+    'prefix_prompt':
+    '请解答下面的数学填空题\n仔细阅读题目，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword': '2010-2022_Math_II_Fill-in-the-Blank',
+    'prefix_prompt':
+    '请解答下面的数学填空题\n仔细阅读题目，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword':
+    '2010-2022_Chinese_Language_Famous_Passages_and_Sentences_Dictation',
+    'prefix_prompt':
+    '请回答下面的语文填空题\n请你仔细阅读题目，先找到题目对应的中国名篇，再从名篇中找到合适的句子填写到题目的空白处。请你将思考过程写在【解析】和<eoe>之间，将最终答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n（1）【解析】 ...<eoe>\n【答案】...<eoa>\n（2）【解析】 ...<eoe>\n【答案】...<eoa>\n请严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword': '2014-2022_English_Language_Cloze_Passage',
+    'prefix_prompt':
+    '请回答下面的英语短文填词题\n仔细阅读题目，空白处请填入一个适当单词或者括号内单词的正确形式。请你一步步思考，将思考过程写在【解析】和<eoe>之间，将最终答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n（1）【解析】 ...<eoe>\n【答案】...<eoa>\n（2）【解析】 ...<eoe>\n【答案】...<eoa>\n请严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+    'comment': ''
+}]
+_OEQ_prompts = [
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Geography_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的地理解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。你的答案请写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果���止一道题，请分别作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chemistry_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的化学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Math_I_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的数学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间，答案需要有完整的解题步骤。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_History_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的历史解答题\n仔细阅读材料和题目，并充分结合你已有的知识，解答其中的问题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Biology_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的生物解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间,同一小题的答案用\t分隔开。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...\t...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...\t...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Math_II_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的数学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间，答案需要有完整的解题步骤。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Physics_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的物理解答题，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【解析】 ...<eoe>\n【答案】 ...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Political_Science_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的政治解答题\n仔细阅读材料和题目，并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'correction',
+        'keyword': '2012-2022_English_Language_Error_Correction',
+        'prefix_prompt':
+        '请解答下面的英语短文改错题，仔细阅读题目并充分结合你你已有的知识，找出其中10处需要改动的地方。请你一���步思考，把修改后的短文写在【答案】和<eoa>之间。\n完整的题目回答格式如下：【答案】 ...<eoa>\n 请你严格按照上述格式作答。\n题目如下:',
+        # "prefix_prompt": [
+        #     "请解答下面的英语短文改错题，仔细阅读题目并充分结合你你已有的知识，找出其中10处需要改动的地方。请你一步步思考，把修改后的短文写在【答案】和<eoa>之间。\n完整的题目回答格式如下：【答案】 ...<eoa>\n 请你严格按照上述格式作答。\n题目如下:",
+        #     "请比较下面两篇短文，找到第二篇和第一篇的10处不同，每处不同只涉及一个单词，请将结果写在【答案】和<eoa>之间。例如：【答案】1. 将play改为plays\n 2.增加了the\n ... <eoa>\n 完整的题目回答格式如下：【答案】(1) ... \n (2) ...\n ...(10) ...\n<eoa>\n请你严格按照上述格式作答。\n短文如下:"
+        # ],
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Ancient_Poetry_Reading',
+        'prefix_prompt':
+        '请解答下面的语文古代诗歌阅读题，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Practical_Text_Reading',
+        'prefix_prompt':
+        '请解答下面的语文实用类文本阅读，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Literary_Text_Reading',
+        'prefix_prompt':
+        '请解答下面的语文文学类文本阅读，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答,如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Classical_Chinese_Reading',
+        'prefix_prompt':
+        '请解答下面的语文文言文阅读，仔细阅读题目，前三题是单选题，最后一题要将文言文翻译为现代汉语。请你一步步思考并把最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。翻译题把翻译后的现代汉语句子写在【答案】后面，例如”【答案】今天天气很好 <eoa>”\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword':
+        '2010-2022_Chinese_Language_Language_and_Writing_Skills_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的语文解答题，仔细阅读题目，注意其中可能含有选择题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【解析】 ...<eoe>\n【答案】 ...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    }
+]
+
+GaokaoBench_datasets = []
+for _folder, _prompts in [
+    ('Multiple-choice_Questions', _MCQ_prompts),
+    ('Fill-in-the-blank_Questions', _FBQ_prompts),
+    ('Open-ended_Questions', _OEQ_prompts),
+]:
+    for _p in _prompts:
+        _reader_cfg = {
+            'input_columns': ['question'],
+            'output_column': 'answer',
+        }
+        _infer_cfg = {
+            'ice_template': {
+                'type': PromptTemplate,
+                'template': {
+                    'round': [{
+                        'role': 'HUMAN',
+                        'prompt': _p['prefix_prompt'] + '{question}'
+                    }]
+                },
+                'ice_token': '</E>'
+            },
+            'retriever': {
+                'type': ZeroRetriever
+            },
+            'inferencer': {
+                'type': GenInferencer,
+                'max_out_len': 1024,
+            }
+        }
+        _eval_cfg = {
+            'evaluator': {
+                'type': 'GaokaoBenchEvaluator' + '_' + _p['type'],
+            },
+            'pred_role': 'BOT',
+        }
+        _base_path = 'opencompass/GAOKAO-BENCH'
+        _dataset = {
+            'type': GaokaoBenchDataset,
+            'abbr': 'GaokaoBench_' + _p['keyword'],
+            'path': _base_path,
+            'filename': '/' + _folder + '/' + _p['keyword'] + '.json',
+            'name': _p['keyword'],
+            'reader_cfg': _reader_cfg,
+            'infer_cfg': _infer_cfg,
+            'eval_cfg': _eval_cfg,
+        }
+
+        GaokaoBench_datasets.append(_dataset)
+
+_temporary_variables = [k for k in globals() if k.startswith('_')]
+for _t in _temporary_variables:
+    del globals()[_t]
+del _temporary_variables, _t

build/lib/opencompass/configs/datasets/GaokaoBench/GaokaoBench_mixed.py

@@ -0,0 +1,4 @@
+from mmengine.config import read_base
+
+with read_base():
+    from .GaokaoBench_mixed_9af5ee import GaokaoBench_datasets  # noqa: F401, F403

build/lib/opencompass/configs/datasets/GaokaoBench/GaokaoBench_mixed_9af5ee.py

@@ -0,0 +1,356 @@
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer, PPLInferencer
+from opencompass.datasets import GaokaoBenchDataset
+_MCQ_prompts = [
+    {
+        'type': 'single_choice',
+        'keyword': '2010-2022_Math_II_MCQs',
+        'prefix_prompt':
+        '请你做一道数学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type': 'single_choice',
+        'keyword': '2010-2022_Math_I_MCQs',
+        'prefix_prompt':
+        '请你做一道数学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_History_MCQs',
+        'prefix_prompt':
+        '请你做一道历史选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Biology_MCQs',
+        'prefix_prompt':
+        '请你做一道生物选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Political_Science_MCQs',
+        'prefix_prompt':
+        '请你做一道政治选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'multi_choice',
+        'keyword':
+        '2010-2022_Physics_MCQs',
+        'prefix_prompt':
+        '请你做一道物理选择题。\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出所有符合题意的答案，并写在【答案】和<eoa>之间。\n例如：【答案】 AB <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】... <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2022_Chemistry_MCQs',
+        'prefix_prompt':
+        '请你做一道化学选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'single_choice',
+        'keyword':
+        '2010-2013_English_MCQs',
+        'prefix_prompt':
+        '请你做一道英语选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。\n题目如下：'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Chinese_Modern_Lit',
+        'prefix_prompt':
+        '请你做一道语文阅读理解题，其中包含三个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_English_Fill_in_Blanks',
+        'prefix_prompt':
+        '请你做一道英语完形填空题,其中包含二十个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'five_out_of_seven',
+        'keyword':
+        '2012-2022_English_Cloze_Test',
+        'prefix_prompt':
+        '请回答下面的问题，将符合题意的五个选项的字母写在【答案】和<eoa>之间，例如“【答案】 A B C D E <eoa>\n请严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Geography_MCQs',
+        'prefix_prompt':
+        '请你做一道地理选择题，其中包含两到三个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_English_Reading_Comp',
+        'prefix_prompt':
+        '请你做一道英语阅读理解题，其中包含三到五个小题。\n请你一步一步思考。每一题你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：（1）【答案】 A <eoa>\n（2）【答案】 B <eoa>\n请你严格按照上述格式作答。\n'
+    },
+    {
+        'type':
+        'multi_question_choice',
+        'keyword':
+        '2010-2022_Chinese_Lang_and_Usage_MCQs',
+        'prefix_prompt':
+        '请你做一道语文选择题\n请你一步一步思考并将思考过程写在【解析】和<eoe>之间。你将从A，B，C，D中选出正确的答案，并写在【答案】和<eoa>之间。\n例如：【答案】: A <eoa>\n完整的题目回答的格式如下：\n（1）【解析】 ... <eoe>\n【答案】 ... <eoa>\n（2）【解析】 ... <eoe>\n【答案】 ... <eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答\n题目如下：'
+    },
+]
+_FBQ_prompts = [{
+    'type': 'cloze',
+    'keyword': '2010-2022_Math_I_Fill-in-the-Blank',
+    'prefix_prompt':
+    '请解答下面的数学填空题\n仔细阅读题目，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword': '2010-2022_Math_II_Fill-in-the-Blank',
+    'prefix_prompt':
+    '请解答下面的数学填空题\n仔细阅读题目，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword':
+    '2010-2022_Chinese_Language_Famous_Passages_and_Sentences_Dictation',
+    'prefix_prompt':
+    '请回答下面的语文填空题\n请你仔细阅读题目，先找到题目对应的中国名篇，再从名篇中找到合适的句子填写到题目的空白处。请你将思考过程写在【解析】和<eoe>之间，将最终答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n（1）【解析】 ...<eoe>\n【答案】...<eoa>\n（2）【解析】 ...<eoe>\n【答案】...<eoa>\n请严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+    'comment': ''
+}, {
+    'type': 'cloze',
+    'keyword': '2014-2022_English_Language_Cloze_Passage',
+    'prefix_prompt':
+    '请回答下面的英语短文填词题\n仔细阅读题目，空白处请填入一个适当单词或者括号内单词的正确形式。请你一步步思考，将思考过程写在【解析】和<eoe>之间，将最终答案写在【答案】和<eoa>之间。\n完整的题目回答格式如下：\n（1）【解析】 ...<eoe>\n【答案】...<eoa>\n（2）【解析】 ...<eoe>\n【答案】...<eoa>\n请严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+    'comment': ''
+}]
+_OEQ_prompts = [
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Geography_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的地理解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。你的答案请写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作��，如果不止一道题，请分别作答。\n题目如下：',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chemistry_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的化学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Math_I_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的数学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间，答案需要有完整的解题步骤。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_History_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的历史解答题\n仔细阅读材料和题目，并充分结合你已有的知识，解答其中的问题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Biology_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的生物解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间,同一小题的答案用\t分隔开。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...\t...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...\t...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Math_II_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的数学解答题\n仔细阅读题目并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间，答案需要有完整的解题步骤。\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Physics_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的物理解答题，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【解析】 ...<eoe>\n【答案】 ...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Political_Science_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的政治解答题\n仔细阅读材料和题目，并充分结合你已有的知识，解答其中的问题，请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的答案写在【答案】和<eoa>之间\n完整的题目回答格式如下：\n(1)【解析】 ...<eoe>\n【答案】...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'correction',
+        'keyword': '2012-2022_English_Language_Error_Correction',
+        'prefix_prompt':
+        '请解答下面的英语短文改错题，仔细阅读题目并充分结合你你已有的知识，找出其中10处需要改动的地方��请你一步步思考，把修改后的短文写在【答案】和<eoa>之间。\n完整的题目回答格式如下：【答案】 ...<eoa>\n 请你严格按照上述格式作答。\n题目如下:',
+        # "prefix_prompt": [
+        #     "请解答下面的英语短文改错题，仔细阅读题目并充分结合你你已有的知识，找出其中10处需要改动的地方。请你一步步思考，把修改后的短文写在【答案】和<eoa>之间。\n完整的题目回答格式如下：【答案】 ...<eoa>\n 请你严格按照上述格式作答。\n题目如下:",
+        #     "请比较下面两篇短文，找到第二篇和第一篇的10处不同，每处不同只涉及一个单词，请将结果写在【答案】和<eoa>之间。例如：【答案】1. 将play改为plays\n 2.增加了the\n ... <eoa>\n 完整的题目回答格式如下：【答案】(1) ... \n (2) ...\n ...(10) ...\n<eoa>\n请你严格按照上述格式作答。\n短文如下:"
+        # ],
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Ancient_Poetry_Reading',
+        'prefix_prompt':
+        '请解答下面的语文古代诗歌阅读题，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Practical_Text_Reading',
+        'prefix_prompt':
+        '请解答下面的语文实用类文本阅读，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Literary_Text_Reading',
+        'prefix_prompt':
+        '请解答下面的语文文学类文本阅读，仔细阅读题目，注意其中可能含有单选题和多选题。请你一步步思考并将最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答,如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword': '2010-2022_Chinese_Language_Classical_Chinese_Reading',
+        'prefix_prompt':
+        '请解答下面的语文文言文阅读，仔细阅读题目，前三题是单选题，最后一题要将文言文翻译为现代汉语。请你一步步思考并把最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。翻译题把翻译后的现代汉语句子写在【答案】后面，例如”【答案】今天天气很好 <eoa>”\n完整的题目回答格式如下：（1）[答案】 ...<eoa>\n (2)【答案】...<eoa>\n请你严格按照上述格式作答，如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    },
+    {
+        'type': 'subjective',
+        'keyword':
+        '2010-2022_Chinese_Language_Language_and_Writing_Skills_Open-ended_Questions',
+        'prefix_prompt':
+        '请解答下面的语文解答题，仔细阅读题目，注意其中可能含有选择题。请你一步步思考并将思考过程写在【解析】和<eoe>之间。请把你的最终答案写在【答案】和<eoa>之间。选择题你要从选项中选出符合题意的答案，例如“【答案】A <eoa>”。\n完整的题目回答格式如下：（1）【解析】 ...<eoe>\n【答案】 ...<eoa>\n (2)【解析】 ...<eoe>\n【答案】...<eoa>\n请你严格按照上述格式作答。如果不止一道题，请分别作答。\n题目如下:',
+        'comment': ''
+    }
+]
+
+GaokaoBench_datasets = []
+for _folder, _prompts in [
+    ('Multiple-choice_Questions', _MCQ_prompts),
+    ('Fill-in-the-blank_Questions', _FBQ_prompts),
+    ('Open-ended_Questions', _OEQ_prompts),
+]:
+    for _p in _prompts:
+        if _p['type'] == 'single_choice':
+            continue
+        _reader_cfg = {
+            'input_columns': ['question'],
+            'output_column': 'answer',
+        }
+        _infer_cfg = {
+            'ice_template': {
+                'type': PromptTemplate,
+                'template': {
+                    'round': [{
+                        'role': 'HUMAN',
+                        'prompt': _p['prefix_prompt'] + '{question}'
+                    }]
+                },
+                'ice_token': '</E>'
+            },
+            'retriever': {
+                'type': ZeroRetriever
+            },
+            'inferencer': {
+                'type': GenInferencer,
+                'max_out_len': 1024,
+            }
+        }
+        _eval_cfg = {
+            'evaluator': {
+                'type': 'GaokaoBenchEvaluator' + '_' + _p['type'],
+            },
+            'pred_role': 'BOT',
+        }
+        _base_path = './data/GAOKAO-BENCH/data'
+        _dataset = {
+            'type': GaokaoBenchDataset,
+            'abbr': 'GaokaoBench_' + _p['keyword'],
+            'path': _base_path,
+            'filename': '/' + _folder + '/' + _p['keyword'] + '.json',
+            'name': _p['keyword'],
+            'reader_cfg': _reader_cfg,
+            'infer_cfg': _infer_cfg,
+            'eval_cfg': _eval_cfg,
+        }
+
+        GaokaoBench_datasets.append(_dataset)
+
+_folder = 'Multiple-choice_Questions'
+for _p in _MCQ_prompts:
+    if _p['type'] != 'single_choice':
+        continue
+    _reader_cfg = {
+        'input_columns': ['question'],
+        'output_column': 'answer',
+    }
+    _infer_cfg = {
+        'ice_template': {
+            'type': PromptTemplate,
+            'template': {
+                answer: {
+                    'round': [{
+                        'role': 'HUMAN',
+                        'prompt': _p['prefix_prompt'] + '{question}'
+                    }, {
+                        'role': 'BOT',
+                        'prompt': f'【答案】{answer} <eoa>'
+                    }]
+                }
+                for answer in ['A', 'B', 'C', 'D']
+            },
+            'ice_token': '</E>'
+        },
+        'retriever': {
+            'type': ZeroRetriever
+        },
+        'inferencer': {
+            'type': PPLInferencer
+        }
+    }
+    _eval_cfg = {
+        'evaluator': {
+            'type': 'GaokaoBenchEvaluator' + '_' + _p['type'],
+        },
+        'pred_role': 'BOT',
+    }
+    _base_path = 'opencompass/GAOKAO-BENCH'
+    _dataset = {
+        'type': GaokaoBenchDataset,
+        'abbr': 'GaokaoBench_' + _p['keyword'],
+        'path': _base_path,
+        'filename': '/' + _folder + '/' + _p['keyword'] + '.json',
+        'name': _p['keyword'],
+        'reader_cfg': _reader_cfg,
+        'infer_cfg': _infer_cfg,
+        'eval_cfg': _eval_cfg,
+    }
+
+    GaokaoBench_datasets.append(_dataset)
+
+_temporary_variables = [k for k in globals() if k.startswith('_')]
+for _t in _temporary_variables:
+    del globals()[_t]
+del _temporary_variables, _t

build/lib/opencompass/configs/datasets/GaokaoBench/GaokaoBench_no_subjective_gen_4c31db.py

@@ -0,0 +1,45 @@
+import os
+from opencompass.openicl.icl_prompt_template import PromptTemplate
+from opencompass.openicl.icl_retriever import ZeroRetriever
+from opencompass.openicl.icl_inferencer import GenInferencer
+from opencompass.datasets import GaokaoBenchDataset
+from mmengine.config import read_base
+
+with read_base():
+    from .GaokaoBench_prompts import MCQ_prompts, FBQ_prompts
+
+GaokaoBench_datasets = []
+for folder, prompts in [
+    ('Multiple-choice_Questions', MCQ_prompts),
+    ('Fill-in-the-blank_Questions', FBQ_prompts),
+]:
+    for p in prompts:
+        reader_cfg = {
+            'input_columns': ['question'],
+            'output_column': 'answer',
+        }
+        infer_cfg = {
+            'ice_template': {
+                'type': PromptTemplate,
+                'template': {'round': [{'role': 'HUMAN', 'prompt': p['prefix_prompt'] + '{question}'}]},
+                'ice_token': '</E>',
+            },
+            'retriever': {'type': ZeroRetriever},
+            'inferencer': {'type': GenInferencer, 'max_out_len': 1024},
+        }
+        eval_cfg = {
+            'evaluator': {'type': 'GaokaoBenchEvaluator' + '_' + p['type']},
+            'pred_role': 'BOT',
+        }
+        _base_path = 'opencompass/GAOKAO-BENCH'
+        dataset = {
+            'type': GaokaoBenchDataset,
+            'abbr': 'GaokaoBench_' + p['keyword'],
+            'path': _base_path,
+            'filename': '/' + folder + '/' + p['keyword'] + '.json',
+            'name': p['keyword'],
+            'reader_cfg': reader_cfg,
+            'infer_cfg': infer_cfg,
+            'eval_cfg': eval_cfg,
+        }
+        GaokaoBench_datasets.append(dataset)